amplify_api_template.yml

AWSTemplateFormatVersion: 2010-09-09
Parameters:
  CognitoUserPoolArn:
    Type: String

Resources:
  AppTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: Rides
      AttributeDefinitions:
        -
          AttributeName: "RideId"
          AttributeType: "S"
      KeySchema:
        -
          AttributeName: "RideId"
          KeyType: "HASH"
      ProvisionedThroughput:
        ReadCapacityUnits: 5
        WriteCapacityUnits: 5

  AppLambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DynamoDBWriteAccess
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
              - Effect: Allow
                Action: 'dynamodb:PutItem'
                Resource: !GetAtt AppTable.Arn

  AppLambda:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: nodejs12.x
      Role: !GetAtt AppLambdaExecutionRole.Arn
      Handler: index.handler
      Code:
        ZipFile: |
            // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
            // SPDX-License-Identifier: MIT-0

            const randomBytes = require('crypto').randomBytes;

            const AWS = require('aws-sdk');

            const ddb = new AWS.DynamoDB.DocumentClient();

            const fleet = [
                {
                    Name: 'Bucephalus',
                    Color: 'Golden',
                    Gender: 'Male',
                },
                {
                    Name: 'Shadowfax',
                    Color: 'White',
                    Gender: 'Male',
                },
                {
                    Name: 'Rocinante',
                    Color: 'Yellow',
                    Gender: 'Female',
                },
            ];

            exports.handler = (event, context, callback) => {
                if (!event.requestContext.authorizer) {
                  errorResponse('Authorization not configured', context.awsRequestId, callback);
                  return;
                }

                const rideId = toUrlString(randomBytes(16));
                console.log('Received event (', rideId, '): ', event);

                // Because we're using a Cognito User Pools authorizer, all of the claims
                // included in the authentication token are provided in the request context.
                // This includes the username as well as other attributes.
                const username = event.requestContext.authorizer.claims['cognito:username'];

                // The body field of the event in a proxy integration is a raw string.
                // In order to extract meaningful values, we need to first parse this string
                // into an object. A more robust implementation might inspect the Content-Type
                // header first and use a different parsing strategy based on that value.
                const requestBody = JSON.parse(event.body);

                const pickupLocation = requestBody.PickupLocation;

                const unicorn = findUnicorn(pickupLocation);

                recordRide(rideId, username, unicorn).then(() => {
                    // You can use the callback function to provide a return value from your Node.js
                    // Lambda functions. The first parameter is used for failed invocations. The
                    // second parameter specifies the result data of the invocation.

                    // Because this Lambda function is called by an API Gateway proxy integration
                    // the result object must use the following structure.
                    callback(null, {
                        statusCode: 201,
                        body: JSON.stringify({
                            RideId: rideId,
                            Unicorn: unicorn,
                            UnicornName: unicorn.Name,
                            Eta: '30 seconds',
                            Rider: username,
                        }),
                        headers: {
                            'Access-Control-Allow-Origin': '*',
                        },
                    });
                }).catch((err) => {
                    console.error(err);

                    // If there is an error during processing, catch it and return
                    // from the Lambda function successfully. Specify a 500 HTTP status
                    // code and provide an error message in the body. This will provide a
                    // more meaningful error response to the end client.
                    errorResponse(err.message, context.awsRequestId, callback)
                });
            };

            // This is where you would implement logic to find the optimal unicorn for
            // this ride (possibly invoking another Lambda function as a microservice.)
            // For simplicity, we'll just pick a unicorn at random.
            function findUnicorn(pickupLocation) {
                console.log('Finding unicorn for ', pickupLocation.Latitude, ', ', pickupLocation.Longitude);
                return fleet[Math.floor(Math.random() * fleet.length)];
            }

            function recordRide(rideId, username, unicorn) {
                return ddb.put({
                    TableName: 'Rides',
                    Item: {
                        RideId: rideId,
                        User: username,
                        Unicorn: unicorn,
                        UnicornName: unicorn.Name,
                        RequestTime: new Date().toISOString(),
                    },
                }).promise();
            }

            function toUrlString(buffer) {
                return buffer.toString('base64')
                    .replace(/\+/g, '-')
                    .replace(/\//g, '_')
                    .replace(/=/g, '');
            }

            function errorResponse(errorMessage, awsRequestId, callback) {
              callback(null, {
                statusCode: 500,
                body: JSON.stringify({
                  Error: errorMessage,
                  Reference: awsRequestId,
                }),
                headers: {
                  'Access-Control-Allow-Origin': '*',
                },
              });
            }
      Description: Invoke a function during stack creation.

  ApplambdaApiGatewayInvoke:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !GetAtt AppLambda.Arn
      Principal: apigateway.amazonaws.com
      SourceArn: !Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${AppRestApi}/*/POST/ride

  AppRestApi:
    Type: AWS::ApiGateway::RestApi
    Properties:
      EndpointConfiguration:
        Types:
          - REGIONAL
      Name: "WildRydes"

  AppRestApiAuthorizer:
    Type: 'AWS::ApiGateway::Authorizer'
    Properties:
      Type: COGNITO_USER_POOLS
      ProviderARNs: [ !Ref CognitoUserPoolArn ]
      IdentitySource: method.request.header.Authorization
      Name: "WildRydes"
      RestApiId: !Ref AppRestApi

  AppRestApiRideResource:
    Type: 'AWS::ApiGateway::Resource'
    Properties:
      RestApiId: !Ref AppRestApi
      ParentId: !GetAtt
        - AppRestApi
        - RootResourceId
      PathPart: ride

  AppRestApiRidePostMethod:
    Type: 'AWS::ApiGateway::Method'
    Properties:
      RestApiId: !Ref AppRestApi
      ResourceId: !Ref AppRestApiRideResource
      HttpMethod: POST
      AuthorizationType: COGNITO_USER_POOLS
      AuthorizerId: !Ref AppRestApiAuthorizer
      Integration:
        Type: AWS_PROXY
        IntegrationHttpMethod: POST
        Uri: !Sub >-
          arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${AppLambda.Arn}/invocations
        IntegrationResponses:
          - ResponseParameters:
              method.response.header.Access-Control-Allow-Headers: "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'"
              method.response.header.Access-Control-Allow-Origin: "'*'"
              method.response.header.Access-Control-Allow-Methods: "'OPTIONS,GET,PUT,POST,DELETE,PATCH,HEAD'"
            StatusCode: '204'
        RequestTemplates:
          application/json: '{ statusCode: 200 }'
      MethodResponses:
        - ResponseParameters:
            method.response.header.Access-Control-Allow-Headers: true
            method.response.header.Access-Control-Allow-Origin: true
            method.response.header.Access-Control-Allow-Methods: true
          StatusCode: '204'
          ResponseModels:
            application/json: Empty

  #Added OPTIONS method that can respond to the OPTIONS preflight request
  AppRestApiOPTIONSMethod:
    Type: 'AWS::ApiGateway::Method'
    Properties:
      RestApiId: !Ref AppRestApi
      ResourceId: !Ref AppRestApiRideResource
      HttpMethod: OPTIONS #added
      AuthorizationType: NONE
      Integration:
        IntegrationResponses:
          - ResponseParameters:
              method.response.header.Access-Control-Allow-Headers: "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'"
              method.response.header.Access-Control-Allow-Origin: "'*'"
              method.response.header.Access-Control-Allow-Methods: "'OPTIONS,GET,PUT,POST,DELETE,PATCH,HEAD'"
            StatusCode: '204'
        RequestTemplates:
          application/json: '{ statusCode: 200 }'
        Type: MOCK
      MethodResponses:
        - ResponseParameters:
            method.response.header.Access-Control-Allow-Headers: true
            method.response.header.Access-Control-Allow-Origin: true
            method.response.header.Access-Control-Allow-Methods: true
          StatusCode: '204'

  AppRestApiDeployment:
    Type: AWS::ApiGateway::Deployment
    DependsOn:
      - AppRestApiRidePostMethod
      - AppRestApiOPTIONSMethod
    Properties:
      RestApiId: !Ref AppRestApi
      StageName: prod

Outputs:
  ApiEndpoint:
    Value: !Sub 'https://${AppRestApi}.execute-api.${AWS::Region}.amazonaws.com/prod'