Become AWS Certified Developer with Alexa

Being an AWS Certified can boost your career (increasing your salary, finding better job or getting a promotion) and make your expertise and skills relevant. Hence, there’s no better way to prepare for your AWS Certified Developer Associate exam than getting your hands dirty and build a Serverless Quiz game with Alexa Skill and AWS Lambda.

Note: all the code is available in my GitHub.

1 – DynamoDB

To get started, create a DynamoDB Table using the AWS CLI:

1
2
3
4
5

aws dynamodb create-table --table-name Questions
    --attribute-definitions AttributeName=ID,AttributeType=S
    --key-schema AttributeName=ID,KeyType=HASH
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
    --region AWS_REGION

I prepared in advance a list of questions for the following AWS services:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[
    {
        "category" : "S3",
        "questions" : [
            {
                "question": "In S3 what can be used to delete a large number of objects",
                "answers" : {
                   "A" : "QuickDelete",
                   "B" : "Multi-Object Delete",
                   "C" : "Multi-S3 Delete",
                   "D" : "There is no such option available"   
                },
                "correct" : "B"
            },
            {
                "question": "S3 buckets can contain both encrypted and non-encrypted objects",
                "answers" : {
                   "A" : "False",
                   "B" : "True"
                },
                "correct" : "B"
            }
        ]
    }
]

Next, import the JSON file to the DynamoDB table:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

func main() {
	cfg, err := external.LoadDefaultAWSConfig()
	if err != nil {
		log.Fatal(err)
	}

	raw, err := ioutil.ReadFile("questions.json")
	if err != nil {
		log.Fatal(err)
	}

	services := make([]Service, 0)
	json.Unmarshal(raw, &services)

	for _, service := range services {
		fmt.Printf("AWS Service: %s\n", service.Category)
		fmt.Printf("\tQuestions: %d\n", len(service.Questions))
		for _, question := range service.Questions {
			err = insertToDynamoDB(cfg, service.Category, question)
			if err != nil {
				log.Fatal(err)
			}
		}
	}

}

The insertToDynamoDB function uses the AWS DynamoDB SDK and PutItemRequest method to insert an item into the table:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

func insertToDynamoDB(cfg aws.Config, category string, question Question) error {
	tableName := os.Getenv("TABLE_NAME")

	item := DBItem{
		ID:       xid.New().String(),
		Category: category,
		Question: question.Question,
		Answers:  question.Answers,
		Correct:  question.Correct,
	}

	av, err := dynamodbattribute.MarshalMap(item)
	if err != nil {
		fmt.Println(err)
		return err
	}

	svc := dynamodb.New(cfg)
	req := svc.PutItemRequest(&dynamodb.PutItemInput{
		TableName: &tableName,
		Item:      av,
	})
	_, err = req.Send()
	if err != nil {
		return err
	}

	return nil
}

Run the main.go file by issuing the following command:

If you navigate to DynamoDB Dashboard, you should see that the list of questions has been successfully inserted:

2 – Alexa Skill

This is what ties it all together, by linking the phrases the user says to interact with the quiz to the intents.

For people who are not familiar with NLP. Alexa is based on an NLP Engine which is a system that analyses phrases (users messages) and returns an intent. Intents describe what a user want or want to do. It is the intention behind his message. Alexa can learn new intents by attributing examples of messages to an intent. Behind the scenes, the Engine will be able to predict the intent even if he had never seen it before.

So, sign up to Amazon Developer Console, and create a new custom Alexa Skill. Set an invocation name as follows:

Create a new Intent for starting the Quiz:

Add a new type “Slot” to store user choice:

Then, create another intent for AWS service choice:

And for user’s answer choice:

Save your interaction model. Then, you’re ready to configure your Alexa Skill.

3 – Lambda Function

The Lambda handler function is self explanatory, it maps each intent to a code snippet. To keep track of the user’s score. We use Alexa sessionAttributes property of the JSON response. The session attributes will then be passed back to you with the next request JSON inside the session’s object. The list of questions is retrieved from DynamoDB using AWS SDK and SSML (Speech Synthesis Markup Language) is used to make Alexa speaks a sentence ending in a question mark as a question or add pause in the speech:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

package main

import (
	"context"
	"fmt"
	"log"
	"strings"

	"github.com/aws/aws-lambda-go/lambda"
)

func HandleRequest(ctx context.Context, r AlexaRequest) (AlexaResponse, error) {
	resp := CreateResponse()

	switch r.Request.Intent.Name {
	case "Begin":
		resp.Say(`<speak>
			Choose the AWS service you want to be tested on <break time="1s"/>
			A <break time="1s"/> EC2 <break time="1s"/>
			B <break time="1s"/> VPC <break time="1s"/>
			C <break time="1s"/> DynamoDB <break time="1s"/>
			D <break time="1s"/> S3 <break time="1s"/>
			E <break time="1s"/> SQS
		</speak>`, false, "SSML")
	case "ServiceChoice":
		number := strings.TrimSuffix(r.Request.Intent.Slots["choice"].Value, ".")

		questions, _ := getQuestions(services[number])

		resp.SessionAttributes = make(map[string]interface{}, 1)
		resp.SessionAttributes["score"] = 0
		resp.SessionAttributes["correct"] = questions[0].Correct

		resp.Say(text, false, "SSML")
	case "AnswerChoice":
		resp.SessionAttributes = make(map[string]interface{}, 1)
		score := int(r.Session.Attributes["score"].(float64))
		correctChoice := r.Session.Attributes["correct"]
		userChoice := strings.TrimSuffix(r.Request.Intent.Slots["choice"].Value, ".")

		text := "<speak>"
		if correctChoice == userChoice {
			text += "Correct</speak>"
			score++
		} else {
			text += "Incorrect</speak>"
		}

		resp.Say(text, false, "SSML")

	case "AMAZON.HelpIntent":
		resp.Say(welcomeMessage, false, "PlainText")
	case "AMAZON.StopIntent":
		resp.Say(exitMessage, true, "PlainText")
	case "AMAZON.CancelIntent":
		resp.Say(exitMessage, true, "PlainText")
	default:
		resp.Say(welcomeMessage, false, "PlainText")
	}
	return *resp, nil
}

func main() {
	lambda.Start(HandleRequest)
}

Note: Full code is available in my GitHub.

Sign in to AWS Management Console, and create a new Lambda function in Go from scratch:

Assign the following IAM role to the function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "1",
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:CreateLogGroup",
                "logs:PutLogEvents"
            ],
            "Resource": "*"
        },
        {
            "Sid": "2",
            "Effect": "Allow",
            "Action": "dynamodb:Scan",
            "Resource": [
                "arn:aws:dynamodb:us-east-1:ACCOUNT_ID:table/Questions/index/ID",
                "arn:aws:dynamodb:us-east-1:ACCOUNT_ID:table/Questions"
            ]
        }
    ]
}

Generate the deployment package, and upload it to the Lambda Console and set the TABLE_NAME environment variable to the table name:

4 – Testing

Now that you have created the function and put its code in place, it’s time to specify how it gets called. We’ll do this by linking the Lambda ARN to Alexa Skill:

Once the information is in place, click Save Endpoints. You’re ready to start testing your new Alexa Skill !

To test, you need to login to Alexa Developer Console, and enable the “Test” switch on your skill from the “Test” Tab:

Or use an Alexa enabled device like Amazon Echo, by saying “Alexa, Open AWS Developer Quiz” :

Drop your comments, feedback, or suggestions below — or connect with me directly on Twitter @mlabouardy.