How to Create a DynamoDB Table and Real World Application Using Serverless Framework Deployed on AWS

A practical guide to creating a DynamoDB table and real world application with the Serverless framework using Python.

Been curious about the Serverless framework and its various offerings? Wondering where to start and wanting a useful real-world tutorial?

If that’s you, then read on.

We are going to use the Serverless framework to do the following:

1. Create a DynamoDB with the correct policy to Put, Get, Update and Delete, etc.
2. Dynamic routing, so that the routes don’t have to be defined explicitly within the Serverless config, each time a function is created
3. Setup local development, that mimics the AWS resources well. To have a consistent local/production workflow.

The Serverless framework has many plugins available to make development easier. The ones we are going to use, to achieve the above goals are:

Plugins

serverless-python-requirements — https://github.com/serverless/serverless-python-requirements

This plugin automatically bundles dependencies in a requirements.txt file and makes them available in the PYTHONPATH and automatically adds those dependencies to the projects package.json

“The plugin works by hooking into the Framework on a deploy command. Before your package is zipped, it uses Docker to install the packages listed in your requirements.txt file and save them to a .requirements/ directory. It then symlinks the contents of .requirements/ into your top-level directory so that Python imports work as expected. After the deployment is finished, it cleans up the symlinks to keep your directory clean.” — https://www.serverless.com/blog/serverless-python-packaging/

serverless-wsgi — https://github.com/logandk/serverless-wsgi

WSGI (Web Server Gateway Interface) — is a specification on how a server communicates with a web app and means that the app can be deployed on any server that has a WSGI wrapper — see “Step back: WSGI “ section https://docs.python.org/2/howto/webservers.html — we are using it so the application code can handle the routing, instead of defining each function/route within the config.

serverless-dynamodb-local — https://github.com/99x/serverless-dynamodb-local

As the title suggests, it’s a local DynamoDB for testing/local development.

serverless-offline -https://github.com/dherault/serverless-offline

This plugin emulates the AWS API Gateway locally so that we can develop with confidence that it’ll work on AWS well.

Note

Before we get started, for many of the plugins to work, such as DynamoDB, local and Serverless, we have to configure our AWS credentials.

If we don’t do this, it won’t work and we will receive the following error

“Request must contain either a valid (registered) AWS access key ID or X.509 certificate.”

You can follow the guide here for more detail:

Serverless Framework - AWS Lambda Guide - Credentials

I generally do the following.

Credentials

serverless config credentials --provider aws --key 1234 --secret 5678 --profile development

This will add a profile with the aws secret/key in ~/.aws/credentials

We can then add this to the aws provider in the serverless.yaml file for those credentials to be used to authenticate.

Serverless Build

Okay, cool! so that’s the plugins and auth out of the way.

Moving on to the app.

1. Clone the Example Repository

GitHub - jjcallis/example-serverless-app-with-dynamodb

2. Virtual Environment

Why do we need a virtual environment? It allows us to create an isolated environment, which contains all of the executables that our project will need.

Firstly install the virtualenv:

pip install virtualenv

Create a virtual environment:

virtualenv venv --python=python3.8

We can then activate the virtual environment with:

source venv/bin/activate

Alternatively, if you ever wanted to deactivate the virtual environment run:

deactivate

Now in the virtual environment, we can install packages/plugins via npm (these are already in package.json). Without affecting or pulling any Python dependencies from our main operating system.

Such as I have Python dependencies for machine learning software, which would be pulled into the requirements file if it wasn’t done in a virtual environment.

npm install

We are using Flask as the WSGI supported framework so that our app can handle the routing, so install Flask and Boto3

pip install flask
---
pip install boto3

once you install new packages via pip update the requirements.txt file, this is used by the Python virtual environment.

pip freeze > requirements.txt

Install the serverless framework globally:

npm install -g serverless

Install DynamoDB locally:

sls dynamodb install

3. Local Development

Start DynamoDB:

sls dynamodb start

Serve the application with WSGI:

sls wsgi serve -p 8080

We can then hit the various endpoints.

4. Up and Running

curl -i -H "Content-Type: application/json" -X GET  http://localhost:8080

Browser

Create product

curl -i -H "Content-Type: application/json" -X POST -d '{"productId":"new", "productTitle": "amazing new product, wow"}' http://localhost:8080/product

Get product

curl -i -H "Content-Type: application/json" -X GET  http://localhost:8080/product/new

5. Deploy on AWS

Run the following command to deploy your Serverless application to aws. This will create the Dynamodb with the correct policy, lamdas, endpoints, etc.

sls deploy

6. Remove Deployment from AWS

serverless remove

This will remove the functions, Events, and Resources that were created. This will also delete the AWS resources provisioned by Serverless/CloudFormation.

7. The Code

Specified the organization/project and the plugins we require. Note serverless-dynamodb-local is above serverless-offline The order of plugins is important in Serverless, for example, we want DynamoDB to be available to the offline service.

Custom section. This is where we set our custom variables and settings. Such setting the service to use docker for the container. Setting that we are using python3, specifying this is the dev environment and to start the service under port 8000, migrate:true will atomically migrate the DynamoDB table, i.e create the productId for us to be used as the primary key.

Provider section. This is where we specify which provider to use. In this case, we are using AWS, setting run time to use python 3.8 (latest supported version, at time of writing for AWS Lambda) and a role, which permits DynamoDB to do CRUD options on the resource.

Functions. We are handling the routing within the app via Flask, as this framework supports WSGI. We set the routes with @app.route

We don’t need to define each function. We are using the handler as a proxy to pass any requests to the application.

Resources. This will create a DynamoDB table via CloudFormation. We get the table name from the custom section.

And there you have it. Thank you for reading.

More content at plainenglish.io