In this guide, you will build a Python application using the Flask microframework on Ubuntu 20.04. The bulk of this article will be about how to set up the Gunicorn application server and how to launch the application and configure Nginx to act as a front-end reverse proxy.
Before starting this guide, you should have:
- A server with Ubuntu 20.04 installed and a non-root user with sudo privileges. Follow our initial server setup guide for guidance.
- Nginx installed, following Steps 1 and 2 of How To Install Nginx on Ubuntu 20.04.
- A domain name configured to point to your server. You can purchase one on Namecheap or get one for free on Freenom. You can learn how to point domains to DigitalOcean by following the relevant documentation on domains and DNS. Be sure to create the following DNS records:
- An A record with
your_domainpointing to your server’s public IP address.
- An A record with
www.your_domainpointing to your server’s public IP address.
- An A record with
- Familiarity with the WSGI specification, which the Gunicorn server will use to communicate with your Flask application. This discussion covers WSGI in more detail.
Step 1 — Installing the Components from the Ubuntu Repositories
Our first step will be to install all of the pieces we need from the Ubuntu repositories. This includes
pip, the Python package manager, which will manage our Python components. We will also get the Python development files necessary to build some of the Gunicorn components.
First, let’s update the local package index and install the packages that will allow us to build our Python environment. These will include
python3-pip, along with a few more packages and development tools necessary for a robust programming environment:
$ sudo apt update
$ sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools
With these packages in place, let’s move on to creating a virtual environment for our project.
Step 2 — Creating a Python Virtual Environment
Next, we’ll set up a virtual environment in order to isolate our Flask application from the other Python files on the system.
Start by installing the
python3-venv package, which will install the
$ sudo apt install python3-venv
Next, let’s make a parent directory for our Flask project. Move into the directory after you create it:
$ mkdir ~/myproject
$ cd ~/myproject
Create a virtual environment to store your Flask project’s Python requirements by typing:
$ source myprojectenv/bin/activate
Your prompt will change to indicate that you are now operating within the virtual environment. It will look something like this:
Step 3 — Setting Up a Flask Application
Now that you are in your virtual environment, you can install Flask and Gunicorn and get started on designing your application.
First, let’s install
wheel with the local instance of
pip to ensure that our packages will install even if they are missing wheel archives:
$ pip install wheel
Regardless of which version of Python you are using, when the virtual environment is activated, you should use the
pip command (not
Next, let’s install Flask and Gunicorn:
$ pip install gunicorn flask
Creating a Sample App
Now that you have Flask available, you can create a simple application. Flask is a microframework. It does not include many of the tools that more full-featured frameworks might, and exists mainly as a module that you can import into your projects to assist you in initializing a web application.
While your application might be more complex, we’ll create our Flask app in a single file, called
$ nano ~/myproject/myproject.py
The application code will live in this file. It will import Flask and instantiate a Flask object. You can use this to define the functions that should be run when a specific route is requested:
from flask import Flask
app = Flask(__name__)
return “<h1 style=’color:blue’>Hello There!</h1>”
if __name__ == “__main__”:
This basically defines what content to present when the root domain is accessed. Save and close the file when you’re finished.
If you followed the initial server setup guide, you should have a UFW firewall enabled. To test the application, you need to allow access to port
$ sudo ufw allow 5000
Now you can test your Flask app by typing:
$ python myproject.py
You will see output like the following, including a helpful warning reminding you not to use this server setup in production:
* Serving Flask app "myproject" (lazy loading) * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead. * Debug mode: off * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
Visit your server’s IP address followed by
:5000 in your web browser:
You should see something like this:
When you are finished, hit
CTRL-C in your terminal window to stop the Flask development server.
Creating the WSGI Entry Point
Next, let’s create a file that will serve as the entry point for our application. This will tell our Gunicorn server how to interact with the application.
Let’s call the file