DEV Community: Sachin Lubana

Cloudformation: Lambda with HTTP API Gateway

Sachin Lubana — Tue, 14 Sep 2021 21:15:43 +0000

Hey, Welcome!

In this post I am going to share how you can quickly setup a cloudformation stack with HTTP API Gateway proxying requests to serverless lambda function.

You can read in my previous post on setting up an HTTP API gateway with custom domain.

To make it simpler, I will break it down into multiple steps.

If you are just interested in the yaml template simply scroll down to the end.

Step 1: Create serverless lambda function

  DemoFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: "nodejs12.x"
      InlineCode: |
        exports.handler = function(event, context, callback) {
            console.log(event);
            const response = {
                statusCode: 200,
                body: JSON.stringify('Hello Node rule 1')
            };
            callback(null, response);
        };

The above code creates serverless lambda function.

This lambda function basically uses

nodejs12.x as runtime
inline source code which can be CodeUri property that reference the source code from file

Step 2: Enable lambda invoke permission

  DemoLambdaInvokePermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref DemoFunction
      Action: "lambda:InvokeFunction"
      Principal: apigateway.amazonaws.com

The above code enables the lambda invoke from an api gateway You can read more about the lambda invoke permission.

Step 3: Create lambda proxy integration

  DemoIntegration:
    Type: AWS::ApiGatewayV2::Integration
    Properties:
      ApiId: !Ref DemoHttpApi
      Description: Lambda proxy integration
      IntegrationType: AWS_PROXY
      IntegrationMethod: GET
      PayloadFormatVersion: "2.0"
      IntegrationUri: !Sub 'arn:${AWS::Partition}:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${DemoFunction.Arn}/invocations'

The above code integrates the lambda function with an HTTP api gateway.
You can read more about the lambda proxy integration here

Step 4: Create api route

  DemoApiRoute:
    Type: AWS::ApiGatewayV2::Route
    Properties:
      ApiId: !Ref DemoHttpApi
      RouteKey: "GET /demo"
      AuthorizationType: AWS_IAM
      Target: !Join
        - /
        - - integrations
          - !Ref DemoIntegration

The above code creates an api route with requests targeted to the lambda proxy integration.

I have configured authorization type as AWS_IAM which means the calling client (IAM role) must have permission to execute API gateway.

I use this API gateway for internal service communication where the calling site is another lambda function.

It implies that my lambda function X requests data from api gateway which proxies the requests to lambda function Y and this request is authenticated using AWS_IAM mechanism.

Step 5: Call site lambda function

  DemoCallFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: nodejs12.x
      CodeUri: dist/lambda/demoCall/
      Policies:
        - AmazonAPIGatewayInvokeFullAccess

That is all you need to integrate lambda function with an HTTP api gateway.

You can use the below template to create cloudformation stack with all the above resources we talked about.

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Lambda with HTTP API gateway demo stack

Resources:
  ##########################################
  ##  create your API gateway resources   ##
  ##  as described in my previous post    ##
  ##########################################

  DemoFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: "nodejs12.x"
      InlineCode: |
        exports.handler = function(event, context, callback) {
            console.log(event);
            const response = {
                statusCode: 200,
                body: JSON.stringify('Hello Node rule 1')
            };
            callback(null, response);
        };

  DemoLambdaInvokePermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref DemoFunction
      Action: "lambda:InvokeFunction"
      Principal: apigateway.amazonaws.com

  DemoIntegration:
    Type: AWS::ApiGatewayV2::Integration
    Properties:
      ApiId: !Ref DemoHttpApi
      Description: Lambda proxy integration
      IntegrationType: AWS_PROXY
      IntegrationMethod: POST
      PayloadFormatVersion: "2.0"
      IntegrationUri: !Sub 'arn:${AWS::Partition}:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${DemoFunction.Arn}/invocations'

  DemoApiRoute:
    Type: AWS::ApiGatewayV2::Route
    Properties:
      ApiId: !Ref DemoHttpApi
      RouteKey: "GET /demo"
      AuthorizationType: AWS_IAM
      Target: !Join
        - /
        - - integrations
          - !Ref DemoIntegration

In my next post, I will be sharing how we can connect a lambda function to an application load balancer.

Cloudformation: HTTP API Gateway with DNS

Sachin Lubana — Wed, 08 Sep 2021 16:23:05 +0000

Hey, Welcome!

In this post I am going to share how you can quickly setup a cloudformation stack with an HTTP API Gateway listening behind a custom domain.

To make it simpler, I will break it down into multiple steps.

If you are just interested in the yaml template simply scroll down to the end.

Step 1: Create an HTTP api gateway resource

  DemoApiGateway:
    Type: AWS::ApiGatewayV2::Api
    Properties:
      Name: Get started HTTP API
      ProtocolType: HTTP

The above code creates an api gateway resource.
I chose HTTP API over REST because of the following reasons:

low latency
cost effective

You can read more about the comparison here

Step 2: Create an api gateway stage

  DemoApiStage:
    Type: AWS::ApiGatewayV2::Stage
    Properties:
      ApiId: !Ref DemoApiGateway
      StageName: Live
      Description: Live Stage
      AutoDeploy: true

The above code creates an api stage called Live and it is set to auto deploy.

Step 3: Create custom domain

  DemoDomainName:
    Type: AWS::ApiGatewayV2::DomainName
    Properties:
      DomainName: [YOUR-DOMAIN-NAME]
      DomainNameConfigurations:
        - EndpointType: REGIONAL
          CertificateArn: [YOUR-ACM-CERT-ARN]

The above code creates a custom domain resource that will be attached to the API Gateway.

Please note, you need to create an ACM certificate which is available in the same region since the endpoint type is REGIONAL

Step 4: Create domain mapping

  DemoApiMapping:
    Type: AWS::ApiGatewayV2::ApiMapping
    Properties:
      DomainName: [YOUR-DOMAIN-NAME]
      ApiId: DemoApiGateway
      Stage: DemoApiStage

The above code creates domain mapping resource that connects the domain to the api gateway on a given stage name.

Step 5: Create DNS alias record

  DemoRecordSetGroup:
    Type: AWS::Route53::RecordSetGroup
    Properties:
      HostedZoneId: [YOUR-HOSTED-ZONE-ID]
      RecordSets:
        - Name: [YOUR-DOMAIN-NAME]
          Type: A
          AliasTarget:
            DNSName: !GetAtt DemoDomainName.RegionalDomainName
            HostedZoneId: !GetAtt DemoDomainName.RegionalHostedZoneId

The above code creates an alias target of type A in route53 for the given hosted zone ID and given domain name.

That is all you need to create an HTTP api gateway with custom domain.

You can use the below template to create cloudformation stack with all the above resources we talked about.

AWSTemplateFormatVersion: "2010-09-09"
Description: HTTP API Gateway stack

Resources:
  DemoApiGateway:
    Type: AWS::ApiGatewayV2::Api
    Properties:
      Name: Demo API Gateway
      ProtocolType: HTTP

  DemoApiStage:
    Type: AWS::ApiGatewayV2::Stage
    Properties:
      ApiId: !Ref DemoApiGateway
      StageName: live
      Description: Live Stage
      AutoDeploy: true

  DemoApiDomainName:
    Type: AWS::ApiGatewayV2::DomainName
    Properties:
      DomainName: [YOUR-DOMAIN-NAME]
      DomainNameConfigurations:
        - EndpointType: REGIONAL
          CertificateArn: [YOUR-ACM-CERTIFICATE-ARN]

  DemoApiBasePathMapping:
    Type: AWS::ApiGatewayV2::ApiMapping
    Properties:
      DomainName: [YOUR-DOMAIN-NAME]
      ApiId: !Ref DemoApiGateway
      Stage: !Ref DemoApiStage

  DemoRecordSetGroup:
    Type: AWS::Route53::RecordSetGroup
    Properties:
      HostedZoneId: [YOUR-HOSTED-ZONE-ID]
      RecordSets:
        - Name: [YOUR-DOMAIN-NAME]
          Type: A
          AliasTarget:
            DNSName: !GetAtt DemoApiDomainName.RegionalDomainName
            HostedZoneId: !GetAtt DemoApiDomainName.RegionalHostedZoneId

In my next post, I will be sharing how we can connect a lambda function to our DemoApiGateway