Writing PowerShell Core AWS Lambda Functions – Part III

Overview

In this third blog, we’ll be setting up the initial configuration of the Lex ‘bot that is going to be the intermediary between the Facebook page we setup earlier and our forthcoming PowerShell Lambda function. After a brief overview of what’s going to be needed, we’ll setup a Slot Type (with a bit of help from PowerShell), Slot, Intent, and Facebook Channel. With this done, we’ll do a basic test of the ‘bot which to give some insight into the event data format that our function will be receiving and processing.

The Story So Far…

At this point, we have a Facebook app and page setup, our development environment in place with all the prerequisites for writing & publishing PowerShell Lambda packages and taken a trip through the (currently) four cmdlets offered by the AWSLambdaPSCore module.

About Lex

Lex is an AWS service geared towards allowing the use of natural language, written or spoken, as a mechanism for driving other applications and services. It allows you to connect social media services like Facebook, a device such as an Alexa Dot, or your own application to Lex and process the input before providing a response back to the source.

Your Lex bot consists of one or more :

  • Intents – An objective, performed via a combination of the items below.
  • Utterances – Sequence of words which activate a specific Intent
  • Slots – Sets of values, akin to parameters, that are utilized in order for the objective to be achieved. The value of a slot can be filtered from an Utterance, or prompted for separately. Also akin to typical parameter behavior, the values provided to Slots can be restricted to a given format or list of values, using what are known as Slot types.
  • Prompts – Requests for additional information or confirmation of details already given.
  • Fulfilments – The steps that will be taken with all the previous provided that allows the Intent to be completed. In our case this will involve the invoking of a Lambda function and receipt of its output.
  • Channels – Communications services (currently Facebook, Kik, Slack, and Twilio SMS) that Lex can by interact with.

What’s Required

For our ‘bot, with the above in mind, we’re going to go for the following:

Intent Name GetPowerShellHelp
Utterances I want help with {command}

What does {command} do

I want help with an AWS cmdlet

Slot Type PSCommand (custom)
Slot Type Values Every command in the AWSLambdaPSCore module(!)
Slot Name command
Fulfillment Our Lambda function
Channel Facebook

Let’s set about getting these setup. 🙂

Creating the ‘bot

    • Login to the AWS console
    • Click Services, Amazon Lex
  • With Bot selected on the left hand side, click Create

  • In the Create your bot window, click Custom bot
    • Bot name : MyPowerShellHelpBot
    • Language : Leave as default English (US)
    • Output voice: None. This is a text based application
    • Session timeout : 1 min
    • IAM Role : This is created for you automatically
    • COPPA : No
  • Click Create

A few more seconds should see our bot created. Before we start creating the Intent though, we’re going to create a file that will be used by the Intent, the Slot type PSCommand, mentioned above.

About Slot Types and Slots

Initially, Lex receives a set of words, the Utterance, which acts as a trigger to a specific Intent. In the simplest of Intents, no specifics are required other than the a fixed set of words.

e.g. “play a song for me”.

More often though, additional details will be required. After all, if we want to hear a song, sometimes you might want to hear music by a specific artist. However, creating an Utterance for every single artist would be an impossible task.

This is where Slots come into play. In the example above, the artist is your slot. Defining a Slot tells Lex that it needs specific information to process the request. Each Slot has an associated Slot type.

A Slot type really is just an enumeration that consist of a specific input value (or values), and the underlying value. A Slot type can have more than input value, known as a synonym.

e.g. In the Amazon.Number Slot type, an input value of “four” has an underlying value of 4.

Slot types help not only to translate input data into a more suitable format for processing, but also to restrict the input values that can be given. They can be used to prevent invalid data from being given BEFORE any processing is done. Whilst it also is possible to do pre-processing of input data, In our case, we don’t want our Lambda to run if it’s being provided with an invalid cmdlet name.

Creating the Slot Type File

We’re going to create a Slot type, called PScommand. This will consist of a list of commands from the current revision of the AWSPowerShell.NetCore module we have installed. Our Slot, command, is the parameter that we will be using within our PowerShell Lambda function. Slot types can be imported as a zip compressed JSON file.

We’ll write a PowerShell script to make this JSON and zip file for us. Jump to your development environment of choice, paste the code below, and save it as a .ps1 file.

The here-string that you see is the core template format for slot type we’ll be using. The changes to be made here will involve filling the enumerationValues array with a list of the AWSPowerShell.NetCore modules cmdlets.

The script itself, after converting the JSON to a PSObject, enumerates through each command in the above module and appends an array consisting of a value element, set to the name of the command, and an empty array value for the synonyms attribute. Note that if we wanted to get really detailed, we could use the PowerShell aliases that exist for the commands in this module, placing them in the appropriate entries synonym value, but I’m going to keep it simple. Once this is complete, the PSObject is converted to a JSON file, before being zipped up.

Run the script to create both of these files.

Should you so want, you can take a look at psCommand.json.

Import the Slot Type File

Let’s import our new file:

    • Go back to the main Amazon Lex screen
    • Click Slot types
    • Click Actions, Import
    • On the Import slot type popup, click Browse
    • Navigate to the directory containing your script and the psCommand.zip, select the file and click Open
    • Click Import


Soon after, our Slot type, PScommand should be visible.

Create the Intent

Follow the steps below to create the intent. Similar to Slot types, it is possible to create a zipped JSON file with the Intent, but we’ll do this through the console for now to make it a bit clearer what is happening.

  • On the main Amazon Lex screen, click Bots
  • Click MyPowerShellHelpBot
  • Click +Create Intent
  • In the Add intent window, click Create intent

  • In the Create intent window, call the type getAWSPowerShellHelp for the Intents name.
  • Click Add

Next, we configure the intent. Set to the following.

  • Sample utterances :
    • What does {command} do
    • I want help with {command}
    • I want help with an AWS cmdlet
  • Lambda initialization and validation
    • Do not set
  • Slots
    • Required : Checked
    • Name: command
    • Slot typePScommand
    • Prompt: What cmdlet?
    • Click the blue + button to add the slot
  • Confirmation prompt
    • Leave unchecked
  • Fullfillment
    • Return parameters to client


Now, scroll down to the bottom of the screen and click Save Intent

Build and Publish the ‘Bot
Before we begin configuration of the Channel, we need to build and publish the ‘bot.

Click Build and wait for the build to finish. On completion, you should find the Test bot window has expanded.

  • Click Publish
  • Next, we are prompted to create an alias by providing it with a name. An alias is simply a reference to a version of a build.
  • Enter Prod for the alias name
  • Click Publish

Once the bot is published, a confirmation screen will appear.

  • Click Close

Create the Facebook Channel

The next step involves us setting up a Channel, in our case for Facebook. Successful configuration of a Channel allows the creation of an endpoint through which Facebook will communicate with Lex.

At this point, grab the Page Access Token and App Secret Key you recorded in Part I of this series.

  • Click the Channels tab
  • Click Facebook on the left hand side
  • Configure as follows:
    • Channel Name: MyFBChannel
    • Channel Description: AWS PowerShell Help Channel
    • KMS Key : Select aws/lex from the drop down list
    • Alias: Select Prod from the drop down list
    • Verify Token: MyVerifyToken
    • Page Access Token : Use the one you have from Part I
    • App Secret Key: Use the one you have from Part I
  • Click Activate

Activation results in a Callback URL, an endpoint that will be used by the Facebook app to communicate with Lex, being created.

Click Copy to copy into the clipboard.

Configure the Facebook Page and App

With the above configured in AWS, we now move on to configuring Facebook to use the Lex ‘bot.

Making the Application Live
In order to allow our application talk to Lex, the Facebook application (AWS PowerShell Help in my case) needs to go live. This requires, however, that the application is configured to provide a link to a privacy policy for users the app.

  • Click Settings, Basic.
  • Configure Privacy Policy URL with any valid web address. There does not need to be any policy a the address given.

    • At the top of the screen, click the slider to make the app live.
    • Set the category to Messaging
  • Click Confirm when prompted if you wish to make the application public.

Shortly afterwards, the slider will go green and indicate ‘ON’

Configure a Webhook and Subscription
Now we’re going to setup the app to use the Callback URL from earlier.

  • Click Messenger on the left side of the screen
  • Click Settings directly below
  • Scroll down to Webhooks
  • Click Setup Webhooks
  • On the New Page Subscription window that opens, use the following settings:
    • Callback URL : Paste the text that was copied into your clipboard from the AWS console
    • Verify Token : MyVerifyToken
    • Subscription Fields: messages, messaging_postbacks, messaging_options
  • Click Verify and Save

Your subscription will be created.

  • Go to the App Review for Messenger section further down the screen
  • Click pages_messaging
  • Click Add to Submission

  • Click the Page Settings hyperlink in the text Looking for pages_messaging_subscripts? It’s moved to Page Settings.
  • This will take you to the Messenger Platform Settings

Because we are using Messenger as our communication method with our Lex ‘bot, some additional configuration needs to be carried out.

We don’t want the app to require manual intervention, so we need to tell Facebook this.

  • Go to the General Settings section
  • Set Response Method to Responses are all automated

Additionally, we want our app to be the one first notified if a message is received by our Facebook page.

  • Go to the Subscribed Apps section
  • Set Primary Receiver to AWS PowerShell Help 
  • Ensure Secondary Receiver is now set to Page Inbox

Testing Interaction With Lex ‘bot

Now let’s perform some basic checks of our apps interoperability with Lex.

  • Scroll to the Your Messenger Link section
  • Click Copy link to place the address in your clipboard

  • Paste the URL into the address bar of a new tab in your browser
  • Enter the following text into the message bar:
    • What does Get-EC2Host do?
    • Press return
    • I want help with Get-EC2Host
    • Press return

For each of the text entries above, you should receive a message back.

Remember that at this point we have set Fulfillment to Return parameters to client in the bot’s Intent configuration. This is why you should be seeing the name of Intent being invoked and the Slot provided. Our Lambda still needs to be created.

We’ve verified connectivity between Facebook and Lex, that the messages we have sent are triggering the right Intent and the parameter (slot) is properly parsed.

Let’s jump back to Lex so we can take a look at how this information is natively output.

Viewing the JSON Output

Note that the response that you saw in the Messenger window was a modified version of the actual event data that is raised. This was handled by the Channel.

Let’s take a look at the pre-formatted data.

  • Go back to the Amazon Lex screen
  • Click Bots
  • Click MyPowerShellHelpBot
  • Expand the Test bot window on the right hand side of the screen
  • In Chat with your bot… type I want help with Get-EC2Host
  • In the Indirect response section below, click Detail

You Test bot window should resemble the below:

The text in the Indirect response window is the exact JSON data that our Lambda will receive once it’s up and running.

Conclusion

In this slightly longer than usual blog, we’ve covered the basics of a Lex ‘bot and components that are used with it, created a Slot type consisting of the AWS PowerShell commands, configured an Intent and Channel and setup interoperability between Lex (via the Channel) to the Facebook app. We then performed testing both from Facebook Messenger and also using the Test ‘bot in the AWS console. Lastly, we’ve had an introduction to the format of the event data that is going to be passed to our forthcoming PowerShell Lambda function.

This leads us nicely up to the next blog, in which we’ll create our PowerShell Lambda function, upload it to AWS, and configure it to be activated by our Lex ‘bot.

Thanks for reading! Feedback welcome!

 

Recommended Further Reading

Create and Edit Custom Slot Types – https://developer.amazon.com/docs/custom-skills/create-and-edit-custom-slot-types.html

 

Share

Leave a Reply

Your email address will not be published. Required fields are marked *