Building a serverless REST API with AWS SAM and Fauna

Pre-requisites

Optional - deploy from GitHub

Configuring a database in Fauna

Storing secrets in Parameter Store

Creating a serverless application on AWS

Retrieving secrets from Parameter Store

const { SSM } = require('aws-sdk');
const ssm = new SSM();

const init = async () => {
    // Get the Fauna Server Key from AWS Systems Manager Parameter Store at runtime.
    const { Parameter: { Value } } = await ssm.getParameter({ Name: process.env.FAUNA_SECRET_PARAMETER, WithDecryption: true }).promise();
    // Now 'Value' has the decrypted value of your server key
    ...
}

// This starts our initialization before a handler is invoked by calling the `init` function above
const initComplete = init();

exports.list = async () => {
    await initComplete;

Adding routes

List stores

ListStores:
    Type: AWS::Serverless::Function
    Properties:
        Handler: src/handlers/stores.list
        Events:
            HttpGetRequest:
                Type: HttpApi
                Properties:
                    Method: get
                    Path: /stores
        Policies: 
            # Needed for logging 
            - AWSLambdaBasicExecutionRole 
            # Needed to retrieve our database key 
            - SSMParameterReadPolicy:
                ParameterName: !Ref FaunaSecretParameter

exports.list = async () => {
    await initComplete;

    let results = await client.query(
        q.Map(
            q.Paginate(q.Documents(q.Collection('stores'))),
            q.Lambda(product => q.Get(product))
        )
    );

    const response = {
        statusCode: 200,
        body: JSON.stringify(results)
    };

    return response;
}

curl ${ListStoresURL}

Create store

CreateStore:
    Type: AWS::Serverless::Function
    Properties:
        Handler: src/handlers/stores.create
        Events:
            HttpPostRequest:
                Type: HttpApi
                Properties:
                    Method: post
                    Path: /stores
        ...

exports.create = async (event) => {
    await initComplete;

    let result = await client.query(
        q.Create(q.Collection('stores'), { data: JSON.parse(event.body) })
    );

curl --request POST \
  --header "Content-Type: application/json" \
  --data @events/create-store.json \
  ${CreateStoresURL}

Update store

UpdateStore:
    Type: AWS::Serverless::Function
    Properties:
        Handler: src/handlers/stores.update
        Events:
            HttpPutRequest:
                Type: HttpApi
                Properties:
                    Method: put
                    Path: /stores/{id}
        ...

exports.update = async (event) => {
    await initComplete;

    let result = await client.query(
        q.Update(
            q.Ref(q.Collection('stores'), event.pathParameters.id),
            { data: JSON.parse(event.body) }
        )
    );

curl --request PUT \
  --header "Content-Type: application/json" \
  --data @events/update-store.json \
  ${UpdateStoresURL}

curl --request PUT \
  --header "Content-Type: application/json" \
  --data '{ "address": null }' \
  ${UpdateStoresURL}

Delete store

DeleteStore:
    Type: AWS::Serverless::Function
        Properties:
            Handler: src/handlers/stores.delete
            Events:
                HttpDeleteRequest:
                    Type: HttpApi
                    Properties:
                        Method: delete
                        Path: /stores/{id}
            ...

exports.delete = async (event) => {
    await initComplete;

    let result = await client.query(
        q.Delete(q.Ref(q.Collection('stores'), event.pathParameters.id)));

curl --request DELETE ${DeleteStoresURL}

Next steps

Cleaning up resources

1. Open the CloudFormation console, select the Fauna-HTTP-API stack, and choose Delete. Confirm that you want to delete the stack and all resources by choosing Delete stack. CloudFormation initiates the delete process, which should take less than one minute to complete.
2. Open the Parameter Store console, select the fauna-secret parameter, and choose Delete. Confirm that you want to delete the parameter by choosing Delete parameters.
3. Open the CloudWatch console, select Log groups in the Logs section, and select any log groups created by your application that you wish to remove. Open the Actions dropdown menu and choose Delete log group(s). Confirm that you want to delete the selected log groups by choosing Delete.
4. Open the Fauna dashboard and choose the aws-http-api database from the list of databases. Choose Settings to open the Database Settings screen, then choose Delete. Confirm that you want to delete the database by choosing Delete.

Conclusion