Serverless Templates for AWS and Python
Tags: aws, serverless, python, devops
Published: 2020-05-29 18:02:53

Serverless development supposed to abstract underlying infrastructure and lets you focus on business logic.
AWS Lambda revolutionized the way we build software today.

# AWS Lambda

AWS Lambda is an event-driven, supposed to be the smallest compute unit in the category of **Compute** in the AWS-universe. Most of the time when speaking of Serverless many people think about AWS Lambda or on a function. Lambda is the FaaS of AWS which was introduced in 2014.

Currently, there are runtimes for Node.js, Python which is btw the most popular one, Java, Go, and C#. If your favorite programming language is not on the list, you can create a custom runtime e.g. for PHP or Rust.

# Frameworks

Even if serverless abstracts the OS-management for you, it might be overwhelming in deploying a Serverless function.

When working with AWS Lambda, the deployment process can be tedious and long. By using a framework, we have a standardized, simplified building process that agrees on common knowledge. Frameworks are mostly built by a large open-source community which helps in finding common debugging tools and use cases.

## Serverless Framework

![The Serverless Framework](https://s3.amazonaws.com/assets.github.serverless/readme-serverless-framework.gif)

Don't get confused by the name but it's the actual name of the framework.
It is with 36k stars on Github (May 2020) the most popular serverless framework and there a plenty of examples and plugins. You configure all the resources and functions within a `serverless.yml` and it will take of dependencies, deployment to the cloud, and events.

However, the **Serverless** Framework is written in NodeJS which is an extra layer when developing with Python. That means you should remove all the node dependencies or its related files:

```yaml
# in serverless.yml
package:
  exclude:
    - node_modules/**
    - package.json
    - package-lock.json
```

As a Python developer, you probably want to install packages and you have your `requirements.txt` ready. You definitely will require the [Serverless Requirements-Plugin](https://github.com/UnitedIncome/serverless-python-requirements)

```yaml
# in serverless.yml
plugins:
  - serverless-python-requirements
```

The good thing about having it written in node, you don't need to install it globally because [npx](https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b) could handle it.

Puh... it lot to take into consideration...

## Creating A Flask App

I hope your head is not spinning. Now you might think, *Wait, I have a [Flask](https://palletsprojects.com/p/flask/) or my [Django](https://www.djangoproject.com/) app where the framework is taking care of the endpoints in my python code. Do I need to recreate several lambdas?*
A valid question. Luckily, there is also an awesome [Plugin](https://github.com/logandk/serverless-wsgi) for that.

```yaml
plugins:
  - serverless-python-requirements
  - serverless-wsgi # This is needed when developing with Flask or Django
```

## Using a Serverless Template

Stay with me, I got this. I have created a template that you can use for your Flask app.

{% github jolo-dev/serverless-flask %}

```bash
# sls works as well
npx serverless install --url https://github.com/jolo-dev/serverless-flask --name my-flask-app

cd my-flask-app && npm run setup
# answer prompt

# Ready for deployment
npx serverless deploy
# Don't forget to remove the deployment
npx sls remove
```

By using that template, you have a *ready-for-deployment* configured `serverless.yml`- file 😉
In the future, I will create a similar one for Django.

## Zappa Framework

![Zappa](https://camo.githubusercontent.com/7bdd37b656c15786839d868e1075cdf1926d4272/687474703a2f2f692e696d6775722e636f6d2f6f65506e484a6e2e6a7067)

Another alternative is [Zappa](https://github.com/Miserlou/Zappa) which is built-in Python Serverless Framework and it's serving only that runtime on AWS.

The cool thing is that you can easily migrate your [WSGI- application](https://en.wikipedia.org/wiki/Web_Server_Gateway_Interface) such as Flask, Django, or [Gunicorn](https://github.com/benoitc/gunicorn) to AWS.

```bash
pip install zappa
zappa init
zappa deploy
```
Eh, seriously? That's all, yep!😄

The configuration (default is JSON but I prefer YAML) is much smaller than of Serverless Framework

```yaml
---
dev:
  app_function: app.app # Your handler code
  s3_bucket: aws_bucket_name # Where the Code will be deployed
```

3(!!) lines of code 😱
That's really promising.
If you have a Django-app then you need to point to its settings:

```yaml
---
dev:
  django_settings: my_django_app.settings # For Django
  s3_bucket: aws_bucket_name
```

If you want to get started, I created a template where you can choose Flask or Django as your engine. That template is powered by [Cookiecutter](https://cookiecutter.readthedocs.io/en/1.7.2/) which is a pre-requisite for using my template.

{% github jolo-dev/zappa-template %}

However, the documentation is kind of difficult to read if you want to customize it.

# Comparison

Even though it looks so less in order to use Zappa, I made a comparison.

|Serverless Framework|Zappa Framework|
|---|---|
|+ Multi-vendor|+/- Python Only|
|+ Easy and Fast to setup|+ Super fast|
|+ Many Plugins|+ Easy Migration of WSGI Applications|
|+ Cloudformation in YAML|+/- AWS Only|
|+ Support of Many Programming Languages|- Documentation is overwhelming (personally, I don't like it)|
|- Written in NodeJS and not Python-Only|- No Plugins|
|- Many Configurations to make it Python-Ready|

# Conclusion

Clearly, as always it depends on what you're needs are.
However, there is a new shift towards Serverless Architecture and there are an ecosystem and many solutions in making serverless development frictionless. For sure there is a solution for you.
Thanks for readying and Happy Coding!