Create an API Gateway API as an AWS Lambda Proxy

To create API resources for Lambda functions

1. In the API Gateway console, create an API named LambdaGate. You can create child resources to represent different Lambda functions; in the following, you will create a single child resource of the API root.

2. For the simple calculator function you created, create the /calc resource off the API's root. You will expose the GET and POST methods on this resource for the client to invoke the back-end Lambda function, supplying the required input as query string parameters (to be declared as ?operand1=...&operand2=...&operator=...) in the GET request and as a JSON payload in the POST request, respectively.

   You will also create the /calc/{operand1}/{operand2}/{operator} to expose the GET method to invoke the Lambda function and to supply the required input as the three path parameters (operand1, operand2, and operator).

   We will show how to apply API Gateway request and response data mapping to normalize the input to the back end Lambda function.

   

To set up the GET method with query strings to invoke the Lambda function

1. Choose Create Method in the API Gateway console to create a GET method for the API's /calc resource.

   In the method's Set up pane, configure the method with the following settings.

   

   You must use the POST method for the integration request when calling a Lambda function, although you can use any other HTTP verbs for the method request.

   The Path override value must the URL path of the Lambda Invoke action. The path is of the following format:

   
   /2015-03-31/functions/FunctionName/invocations?Qualifier=version                     
                   

   where FunctionName is the ARN of the Lambda function to be invoked. The optional Qualifier query string can be used to select a version of the function. If it not specified, the $LATEST version will be used.

   You can also add the X-Amz-Invocation-Type: Event | RequestReponse | DryRun header to have the action invoked asynchronously, as request and response, or as a test run, respectively. If the header is not specified, the action will be invoked as request and response. For the example shown here, this header has the default value.

   We will come back to setting up Mapping Templates after setting up the query string parameters to hold the input data for the Lambda function.

2. In Method Request for the GET method on /calc, expand the URL Query String Parameters section. Choose Add query string to add the operand1, operand2, and operator query string parameters.

   

3. Go back to Integration Request. Expand the Mapping Templates section. If necessary, in Content-Type, under application/json, choose Add mapping template. Type the following in the Mapping template editor:

   
   {
       "a":  "$input.params('operand1')",
       "b":  "$input.params('operand2')", 
       "op": "$input.params('operator')"   
   }                    
                   

   

   This template maps the three query string parameters declared in Method Request into designated property values of the JSON object as the input to the back-end Lambda function. The transformed JSON object will be included as the integration request payload.

4. You can now choose Test to verify that the GET method on the /calc resource has been properly set up to invoke the Lambda function.

To set up the POST method with a JSON payload to invoke a Lambda function

1. Choose Create Method in the API Gateway console to create a POST method for the LambdaGate API's /calc resource.

   In the method's Set Up panel, configure the POST method with the following settings.

   

   Using a POST request with a JSON payload is the simplest way to invoke a Lambda function, because no mappings are needed.

2. You can now choose Test to verify the POST method works as expected. The following input:

   
   {
       "a": 1,
       "b": 2,
       "op": "+"
   }
                   

   should produce the following output:

   
   {
     "a": 1,
     "b": 2,
     "op": "+",
     "c": 3
   }                    
                   

To set up the GET method with URL path parameters to invoke the Lambda function

1. Choose Create Method in the API Gateway console to create a GET method for the API's /calc/{operand1}/{operand2}/{operator} resource.

   In the method's Set up pane, configure this GET method with the following settings.

   

   Next, we will set up Mapping Templates to translate the URL path parameters into the integration request JSON payload as the input to the Lambda function.

2. In Method Request for the GET method on /calc/{operand1}/{operand2}/{operator}, expand the Request Paths section to verify that the path parameters are there.

   

3. Go back to Integration Request. Expand the Mapping Templates section. If necessary, in Content-Type, under application/json, choose Add mapping template.

   

   Type the following in the Mapping Template editor:

   
   {
      "a": "$input.params('operand1')",
      "b": "$input.params('operand2')",
      "op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
      
   }                   
                   

   This template maps the three URL path parameters, declared when the /calc/{operand1}/{operand2}/{operator} resource was created, into designated property values of the JSON object. Because URL paths must be URL-encoded, the division operator must be specified as %2F instead of /. This template maps these translations as well. The transformed JSON object will be included as the integration request payload.

4. As another exercise, we demonstrate how to translate the JSON returned from the Lambda function to show the output as a plain text string to the caller. This involves resetting the method request's Content-Type header to "text/plain" and providing a mapping template to translate the JSON output into a plain string.

   First, make sure that Content-Type header is included in the Response Headers for 200 section in Method Response.

   

5. In Integration Response, expand the 200 method response entry. Expand the Header Mappings section. In Mapping value for Content-Type, type 'text/plain'. This header mapping expression overrides the Content-Type header with a literal string, which must be enclosed within a pair of single quotes.

   

   Next, expand the Mapping Templates section, highlight the application/json entry under the Content-Type header (of integration response), open the Mapping template editor, enter and save the following mapping script:

   $input.path('$.a') $input.path('$.op') $input.path('$.b') = $input.path('$.c')

6. Choose Test to verify the GET method on the /calc/{operand1}/{operand2}/{operator} works as expected. The following request URL:

   /calc/1/2/%2F

   should produce the following plain text output:

   1 / 2 = 0.5

   Note

   As part of a URL, the division operator (/) is URL-encoded (%2F).

7. After testing the API using the Test Invoke in the API Gateway console, you must deploy the API to make it public available. If you update the API, such as adding, modifying or deleting a resource or method, updating any data mapping, you must redeploy the API to make the new features or updates available.