How to Deploy Flask on AWS EC2, Hetzner, Digital Ocean

Flask is a micro web framework. It is minimalistic and gives developers the flexibility to choose additional libraries. Flask shines for smaller projects or where you don't need batteries-included approach and would rather have smaller codebase, less dependencies, and pick a component for every small task yourself.

If you are looking for other deployment tutorials checkout out one of these:

• Deploy Django on Hetzner Cloud
• Deploy Django to Digital Ocean Droplet
• Deploy Django to AWS Lightsail
• Deploy Django to AWS EC2
• Deploy Django on Linode
• Deploy Django to Google Cloud Platform

In this post:

Create a Flask App¶

Here is the link to the demo repository: https://github.com/appliku/flask_demo

Setup the environment 1. First create an app directory

mkdir flask_demo
cd flask_demo

1. Create virtual environment and install packages

python3 -m venv env
source env/bin/activate
pip install Flask SQLAlchemy Flask-SQLAlchemy psycopg2-binary gunicorn

Create a requirements.txt file with all these dependencies from the current virtual env:

pip freeze > requirements.txt

1. Create a new file app.py . First, import required libraries and create a Flask app:

import os  
from flask import Flask, request  
from sqlalchemy import Column, Integer, String, create_engine  
from sqlalchemy.ext.declarative import declarative_base  
from sqlalchemy.orm import sessionmaker  

app = Flask(__name__)

1. Set up the database connection. It will grab DATABASE_URL environment variable for DB connection string.

DATABASE_URL = os.environ['DATABASE_URL']  
engine = create_engine(DATABASE_URL)  
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)  
Base = declarative_base()

1. Create the model for the database table "Messages"

class Message(Base):  
    __tablename__ = "messages"  
    id = Column(Integer, primary_key=True, index=True)  
    name = Column(String, index=True)  
    email = Column(String, index=True)  
    message = Column(String, index=True)  

1. Initialise the database

# Create the table in the database  
Base.metadata.create_all(bind=engine)

1. A POST endpoint for submitting our messages

@app.route('/messages', methods=['POST'])
def add_message():
    data = request.get_json()

    name = data['name']
    email = data['email']
    message = data['message']

    new_message = Message(name=name, email=email, message=message)

    db = SessionLocal()
    db.add(new_message)
    db.commit()
    db.refresh(new_message)
    db.close()
    return {
        "name": new_message.name,
        "email": new_message.email,
        "message": new_message.message,
        "id": new_message.id
    }

2. Run the app:

if __name__ == '__main__':  
    app.run(host='0.0.0.0')

This is the whole file app.py:

import os
from flask import Flask, request, jsonify
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

app = Flask(__name__)

DATABASE_URL = os.environ['DATABASE_URL']
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()


class Message(Base):
    __tablename__ = "messages"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    email = Column(String, index=True)
    message = Column(String, index=True)


# Create the table in the database
Base.metadata.create_all(bind=engine)


@app.route('/messages', methods=['POST'])
def add_message():
    data = request.get_json()

    name = data['name']
    email = data['email']
    message = data['message']

    new_message = Message(name=name, email=email, message=message)

    db = SessionLocal()
    db.add(new_message)
    db.commit()
    db.refresh(new_message)
    db.close()
    return {
        "name": new_message.name,
        "email": new_message.email,
        "message": new_message.message,
        "id": new_message.id
    }


if __name__ == '__main__':
    app.run(host='0.0.0.0')

Now create the Procfile next to your app.py. It will be used to specify how to run your app when deployed with Appliku:

web: gunicorn app:app --log-file -

Also create the .gitgnore file. Main thing to include in this file is python cache files, virtual env and your editor of choice dot directory. Extend the following list for your own setup.

env/
.idea/
__pycache__/
*.py[cod]
*$py.class
.vscode/
.DS_Store  
.AppleDouble  
.LSOverride

Now we need to initialize a git repository and push it.

git init
git add .
git commit -m'Initial commit'

Create a GitHub or GitLab repository, add the remote and let's deploy it with Appliku.

Deploy Flask App¶

In order to deploy Flask App you need two things: - Appliku Account - Cloud Provider account

From cloud provider you get a server that will run your apps and databases.

Appliku automates the setup of the server, build the app and deploy it whenever you push new changes to git. Appliku will also issue an SSL certificate for your custom domain, make backups and help you setup scheduled tasks (CRON).

Get your account here: https://app.appliku.com/

Deploy Flask App on AWS EC2¶

AWS is a massive cloud provider that offers hundreds of different types of services for running your apps and additional tools.

Get your account here: https://portal.aws.amazon.com/billing/signup#/start/email

In this section we'll create an EC2 Instance and deploy your Flask app on it.

In Appliku dashboard go to the Servers tab.

If you haven't set up AWS connection then follow instructions to generate required credentials and add them to your team.

When it is done you will be able to create an AWS EC2 Instance.

Select AWS provider.

Select the region, instance type and the disk size. To fit in AWS Free Tier make sure the disk size to be <30GB.

Click "Create EC2 Instance".

You will be taken to the server page where you will see the setup process. When it is finished, go to Applications tab and create a new app from GitHub (or GitLab if you hosted your repository there)

Deploy Flask App on Digital Ocean¶

If you choose to go with Digital Ocean first make sure to create a DO account.

You will need to generate a token here https://cloud.digitalocean.com/account/api/tokens/new

Make sure to select scopes both "Read" and "Write". We recommend to setup expiration to "Never" or "1 Year" to avoid service interruptions.

In Appliku dashboard go to Servers tab and click "Setup Credentials" for Digital Ocean. Paste and save the token and go back to Servers tab. You will be able to select Digital Ocean provider now.

Select the region and Droplet Type. For Droplet Size we strongly recommend to pick at least 1GB RAM instance so your server can build and run your app and the database.

Click "Create Droplet".

Appliku will call Digital Ocean API and create a server for you and begin setup.

When that is finished you will be able to create the app and the database.

Deploy Flask App on Hetzner server¶

Hetzner is an old, cheap and very reliable hosting company and it is our favorite one!

Create an account here: Hetzner Sign Up

When it is setup up - go to Appliku Dashboard -> Servers. Select "Custom"

Copy the SSH Public Key

Now go to Hetzner Cloud https://www.hetzner.com/cloud and create a project. Within the project click on Add Server.

We recommend picking Falkenstein datacenter because there they offer new ARM Ampere servers, which are most cost efficient and way more powerful.

For the Image select Ubuntu 22.04 (selected by default)

For Type select Arm64 (Ampere) and go with the smallest server. Please note how much power and resource you get for the price of roughly $4/mo compared to Digital Ocean or AWS. Same similar amount of resources in Digital Ocean would cost you $24/mo!

Scroll down and click "Add SSH key" and paste the public key you copied from the Appliku Dashboard. When key is added make sure it is selected for the server.

Now you can click "Create & Buy Now".

Creation doesn't take much time, usually server is ready in under 5-10 seconds.

Copy the Public IP address of the server and go back to Appliku dashboard and paste it to the IP address field.

Click Check credentials and add server

You will be brought to the server page. You will see that setup process is started. You can see Setup Logs for details of the process or errors if setup fails.

Server setup is complete:

Deploy Flask App Application with Appliku¶

Click on the "Applications" menu link

If you haven't setup connection to will need to do that by clicking Setup Credentials.

When you are done you will be able to select the service you prefer. For this tutorial we'll go with GitHub

Give your app a name, select repository, branch and the server you have just created and click "Create Application".

Click on "Manage" in the databases block and add a database "Postgres 15" on the server we have just created.

Wait for it to get to "Deployed" status.

Now go back to the application overview and click Deploy Now.

It might take a while during the first deployment as it needs to pull docker images on the fresh server and install dependencies from requirements.txt.

Next deployments will usually take under 10 seconds if you haven't changed the requirements.txt

Now go to terminal and run a CURL command to save a message.

Make sure to replace the hostname to match your apps name.

curl --request POST \
  --url https://flaskdemo.applikuapp.com/messages \
  --header 'Content-Type: application/json' \
  --data '{
"name" : "john Snow",
"email": "123@example.com",
"message": "hello"
}'

In the response you will get back the whole data that was sent and the ID

You can now go back to the database and copy the credentials.

Using a PostgreSQL client of your choosing connect to the DB.

I will do it from terminal:

You can see that table is created and there is a record with our message.

Congratulations! You have deployed a fully functional Flask app with a PostgreSQL database!