Creating a Flask App with Python
This is a quick setup guide for creating a basic Flask/Python web application. We'll be running this locally, but it will be ready to deploy on Amazon Web Services (AWS) with Flightcontrol.
We'll start by setting up a new project locally, and then we will push the Python code to a GitHub repository.
Flask (opens in a new tab) is a lightweight Python web framework. If you are looking to build a simple web application or API, Flask is a great choice. For more complicated applications, you might want to consider using the Django framework. Both run great with Flightcontrol!
Before you begin, you will need to have the following installed on your computer:
- Python 3.8 or higher
If you don't know what version of Python you have installed, or you don't have Python installed, you can check by running the following command from the command line:
Your python installation might also be
python3 instead of
python. If you get a version number of 2.7 or an error when running
python --version, try running
python3 --version instead.
If you don't have Python installed, you can download it from the Python Downloads (opens in a new tab) page. Choose the most recent version. If you're on a Mac, you can also install Python using Homebrew (opens in a new tab).
Let's get started by setting up a Python virtual environment. We want to install all of our Python dependencies in a virtual environment so that they don't conflict with other Python projects we might be running locally.
Create a new folder for your project. We'll call our project folder
Open up a command line terminal, and change directories into the
We can create a virtual environment using the
venv module that comes with Python. We'll call our virtual environment
venv. The commands differ slightly depending on your operating system.
For Linux or Mac (could be the
python command instead of
python3 -m venv venv
py -m venv venv
After creating the Python virtual environment, we need to activate the virtual environment. If we don't do this step, we'll inadvertently install our Python dependencies into the global Python installation instead of the virtual environment.
Again the commands differ somewhat based on your operating system:
For Linux or Mac:
In either case, your command line will change to show that the virtual environment is active. It will look something like this:
Now that we've got the Python virtual environment activated, we can use the virtual environment for our Flask web application.
Python includes a package manager,
pip. We can use
pip to install Flask and Gunicorn. Gunicorn is a Python web server that we will use to serve our Flask application.
pip install flask gunicorn
Several Python packages will be installed.
You will need to freeze the Python packages into a
requirements.txt file that can be used to recreate the environment if you run this application elsewhere. You can do this by running the following command:
pip freeze > requirements.txt
requirements.txt will be a list of your Python dependencies with their version numbers.
Now that we have Flask setup, we need to write a couple of Python files. We aren't going to do anything very fancy in our Flask application, just enough to get it running on AWS with Flightcontrol.
Both of these files will go into the root directory of our project.
The first Python file we create will be named
app.py and will contain the following code:
from flask import Flask
app = Flask(__name__)
return "Books Index Page"
if __name__ == "__main__":
Most of this code is required for any Flask application. We do have one route,
/, which will return the string
Books Index Page when the route is visited.
We also have a line that tells Flask to run the application on port
3000, and to listen on all IP addresses. This is important for when we deploy our application on AWS Fargate and make it generally available.
The second Python file we create will be named
wsgi.py and will contain the following code:
from app import app
if __name__ == "__main__":
We need this
wsgi.py file because the Gunicorn web server uses it to determine which Python code to run. In our case, it's pointing to the code in our
Now you've got a small Flask application ready to run locally with Gunicorn. On Mac or Linux, we can test it by running the following command from the command line:
gunicorn --bind 0.0.0.0:3000 wsgi:app
On Windows, you will need to be using the Windows Subsystem for Linux (WSL) to run the
gunicorn command. If you're running this on a normal Windows Command Prompt, you can run just the Flask application by running the following command:
If you're having trouble running
gunicorn, try running it with the path to the
gunicorn binary in your virtual environment, for instance:
venv/bin/gunicorn --bind 0.0.0.0:3000 wsgi:app
http://localhost:3000/ in your web browser, and you should see the "Books Index Page" text.
Now that we know what command to use to run our application, we need to configure Flightcontrol to use the same one.
We can do this in one of two ways - adding a custom start command for our environment, or by creating a
Procfile in the root directory of our project.
We'll use the
Procfile method in this guide. A
Procfile is a simple file that contains a one line command, along with the name of the service to use. In our case, we'll use the
web service, and the command will be
gunicorn --bind 0.0.0.0:3000 wsgi:app.
The contents of the
Procfile will be:
web: gunicorn --bind 0.0.0.0:3000 wsgi:app
Flightcontrol uses GitHub repositories to deploy your code base. If you don't have a GitHub account, you can create one at https://github.com (opens in a new tab).
Create a new, empty repository on your GitHub account and then push your Flask project to GitHub.
You can push your code from the command line with the following commands:
git add *.py requirements.txt Procfile
git commit -m "Initial commit"
git remote add origin YOUR_GITHUB_REPO_URL
git push -u origin main
Flightcontrol can work with either public or private GitHub repositories. If you authorize the Flightcontrol Ops GitHub application to access your repository, Flightcontrol listens for changes on that repository to automatically deploy environments.
To run this application on AWS, see our Getting Started with Flask guide.