How To Serve Flask Applications with Gunicorn and Nginx on Ubuntu 22.04

How To Serve Flask Applications with Gunicorn and Nginx on Ubuntu 22.04
Not using Ubuntu 22.04?Choose a different version or distribution.
Ubuntu 22.04

A previous version of this tutorial was written by Kathleen Juell.


In this guide, you will build a Python application using the Flask microframework on Ubuntu 22.04. The majority of this tutorial 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 22.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 22.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_domain pointing to your server’s public IP address.
    • An A record with www.your_domain pointing to your server’s public IP address.
  • 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

The first step will be to install all of required pieces from the Ubuntu repositories. This includes pip, the Python package manager, which will manage the Python components. You will also get the Python development files necessary to build some of the Gunicorn components.

First,update the local package index and install the packages that will allow you to build your Python environment. These will include python3-pip, along with a few more packages and development tools necessary for a robust programming environment:

  1. sudo apt update
  2. sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools

With these packages in place, the next step is to create a virtual environment for your project.

Step 2 — Creating a Python Virtual Environment

Next, you’ll set up a virtual environment in order to isolate the Flask application from the other Python files on your system.

Start by installing the python3-venv package, which will install the venv module:

  1. sudo apt install python3-venv

Next, make a parent directory for your Flask project. Move into the directory with the cd command after you create it:

  1. mkdir ~/myproject
  2. cd ~/myproject

Create a virtual environment to store your Flask project’s Python requirements by typing:

  1. python3 -m venv myprojectenv

This will install a local copy of Python and pip into a directory called myprojectenv within your project directory.

Before installing applications within the virtual environment, you need to activate it. Do so by typing:

  1. 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: (myprojectenv)user@host:~/myproject$.

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, install wheel with the local instance of pip to ensure that your packages will install even if they are missing wheel archives:

  1. 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 pip3).

Next, install Flask and Gunicorn:

  1. 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 myproject.py:

  1. 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__)

def hello():
    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 5000:

  1. sudo ufw allow 5000

Now you can test your Flask app by typing:

  1. 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 (Press CTRL+C to quit)

Visit your server’s IP address followed by :5000 in your web browser:


You should see something like this:

Flask sample app

When you are finished, hit CTRL-C in your terminal window to stop the Flask development server.

Creating the WSGI Entry Point

Next, create a file that will serve as the entry point for your application. This will tell the Gunicorn server how to interact with the application.

Call the file wsgi.py:

  1. nano ~/myproject/wsgi.py

In this file, import the Flask instance from our application and then run it:

from myproject import app

if __name__ == "__main__":

Save and close the file when you are finished.

Step 4 — Configuring Gunicorn

Your application is now written with an entry point established. You can now move on to configuring Gunicorn.

Before moving on, check that Gunicorn can serve the application correctly.

You can do this by passing it the name of the application’s entry point. This is constructed as the name of the module (minus the .py extension), plus the name of the callable within the application. In this case, it is wsgi:app.

Also specify the interface and port to bind to using the argument so that the application will be started on a publicly available interface:

  1. cd ~/myproject
  2. gunicorn --bind wsgi:app

You should see output like the following:

[2020-05-20 14:13:00 +0000] [46419] [INFO] Starting gunicorn 20.0.4 [2020-05-20 14:13:00 +0000] [46419] [INFO] Listening at: (46419) [2020-05-20 14:13:00 +0000] [46419] [INFO] Using worker: sync [2020-05-20 14:13:00 +0000] [46421] [INFO] Booting worker with pid: 46421

Visit your server’s IP address with :5000 appended to the end in your web browser again:


You should see your application’s output:

Flask sample app

When you have confirmed that it’s functioning properly, press CTRL-C in your terminal window.

When you are done using the virtual environment, you can deactivate it:

  1. deactivate

Any Python commands will now use the system’s Python environment again.

Next, create the systemd service unit file. Creating a systemd unit file will allow Ubuntu’s init system to automatically start Gunicorn and serve the Flask application whenever the server boots.

Create a unit file ending in .service within the /etc/systemd/system directory to begin:

  1. sudo nano /etc/systemd/system/myproject.service

Inside, you’ll start with the [Unit] section, which is used to specify metadata and dependencies. Add a description of your service here and tell the init system to only start this after the networking target has been reached:

Description=Gunicorn instance to serve myproject

Next, add a [Service] section. This will specify the user and group that you want the process to run under. Give your regular user account ownership of the process since it owns all of the relevant files. Also give group ownership to the www-data group so that Nginx can communicate easily with the Gunicorn processes. Remember to replace the username here with your username:

Description=Gunicorn instance to serve myproject


Next, map out the working directory and set the PATH environmental variable so that the init system knows that the executables for the process are located within our virtual environment. Also specify the command to start the service. This command will do the following:

  • Start 3 worker processes (though you should adjust this as necessary)
  • Create and bind to a Unix socket file, myproject.sock, within our project directory. We’ll set an umask value of 007 so that the socket file is created giving access to the owner and group, while restricting other access
  • Specify the WSGI entry point file name, along with the Python callable within that file (wsgi:app)

Systemd requires that you give the full path to the Gunicorn executable, which is installed within your virtual environment.

Remember to replace the username and project paths with your own information:

Description=Gunicorn instance to serve myproject

ExecStart=/home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app

Finally, add an [Install] section. This will tell systemd what to link this service to if you enable it to start at boot. You’ll want this service to start when the regular multi-user system is up and running:

Description=Gunicorn instance to serve myproject

ExecStart=/home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app


With that, your systemd service file is complete. Save and close it now.

You can now start the Gunicorn service that you created and enable it so that it starts at boot:

  1. sudo systemctl start myproject
  2. sudo systemctl enable myproject

Let’s check the status:

  1. sudo systemctl status myproject

You should see output like this:

● myproject.service - Gunicorn instance to serve myproject Loaded: loaded (/etc/systemd/system/myproject.service; enabled; vendor preset: enabled) Active: active (running) since Tue 2022-05-10 19:40:41 UTC; 9s ago Main PID: 17300 (gunicorn) Tasks: 4 (limit: 2327) Memory: 56.0M CPU: 514ms CGroup: /system.slice/myproject.service ├─17300 /home/sammy/myproject/myprojectenv/bin/python3 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app ├─17301 /home/sammy/myproject/myprojectenv/bin/python3 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app ├─17302 /home/sammy/myproject/myprojectenv/bin/python3 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app └─17303 /home/sammy/myproject/myprojectenv/bin/python3 /home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi:app May 10 19:40:41 r systemd[1]: Started Gunicorn instance to serve myproject. . . .

If you see any errors, be sure to resolve them before continuing with the tutorial.

Step 5 — Configuring Nginx to Proxy Requests

Your Gunicorn application server should now be up and running, waiting for requests on the socket file in the project directory. Now you can configure Nginx to pass web requests to that socket by making some small additions to its configuration file.

Begin by creating a new server block configuration file in Nginx’s sites-available directory. Call this myproject to keep in line with the rest of the guide:

  1. sudo nano /etc/nginx/sites-available/myproject

Open up a server block and tell Nginx to listen on the default port 80. Also tell it to use this block for requests for our server’s domain name:

server {
    listen 80;
    server_name your_domain www.your_domain;

Next, add a location block that matches every request. Within this block, you’ll include the proxy_params file that specifies some general proxying parameters that need to be set. You’ll then pass the requests to the socket you defined using the proxy_pass directive:

server {
    listen 80;
    server_name your_domain www.your_domain;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/sammy/myproject/myproject.sock;

Save and close the file when you’re finished.

To enable the Nginx server block configuration you’ve just created, link the file to the sites-enabled directory:

  1. sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

With the file in that directory, you can test for syntax errors:

  1. sudo nginx -t

If this returns without indicating any issues, restart the Nginx process to read the new configuration:

  1. sudo systemctl restart nginx

Finally, adjust the firewall again. You no longer need access through port 5000, so you can remove that rule. You can then allow full access to the Nginx server:

  1. sudo ufw delete allow 5000
  2. sudo ufw allow 'Nginx Full'

You should now be able to navigate to your server’s domain name in your web browser:


You should see your application’s output:

Flask sample app

Note: You will receive an HTTP 502 gateway error if Nginx cannot access gunicorn’s socket file. Usually this is because the user’s home directory does not allow other users to access files inside it.

If your socket file is called /home/sammy/myproject/myproject.sock, ensure that /home/sammy has a minimum of 0755 permissions. You can use a tool like chmod to change the permissions like this:

  1. sudo chmod 755 /home/sammy

Then reload the page to see if the HTTP 502 error goes away.

If you encounter any errors, trying checking the following:

  • sudo less /var/log/nginx/error.log: checks the Nginx error logs.
  • sudo less /var/log/nginx/access.log: checks the Nginx access logs.
  • sudo journalctl -u nginx: checks the Nginx process logs.
  • sudo journalctl -u myproject: checks your Flask app’s Gunicorn logs.

Step 6 — Securing the Application

To ensure that traffic to your server remains secure, let’s get an SSL certificate for your domain. There are multiple ways to do this, including getting a free certificate from Let’s Encrypt, generating a self-signed certificate, or buying one from another provider and configuring Nginx to use it by following Steps 2 through 6 of How to Create a Self-signed SSL Certificate for Nginx in Ubuntu 22.04. We will use with option one (Let’s Encrypt) for the sake of expediency.

Install Certbot’s Nginx package with apt:

  1. sudo apt install python3-certbot-nginx

Certbot provides a variety of ways to obtain SSL certificates through plugins. The Nginx plugin will take care of reconfiguring Nginx and reloading the config whenever necessary. To use this plugin, type the following:

  1. sudo certbot --nginx -d your_domain -d www.your_domain

This runs certbot with the --nginx plugin, using -d to specify the names we’d like the certificate to be valid for.

If this is your first time running certbot, you will be prompted to enter an email address and agree to the terms of service. After doing so, certbot will communicate with the Let’s Encrypt server, then run a challenge to verify that you control the domain you’re requesting a certificate for.

If that’s successful, certbot will ask how you’d like to configure your HTTPS settings:

Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access. ------------------------------------------------------------------------------- 1: No redirect - Make no further changes to the webserver configuration. 2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for new sites, or if you're confident your site works on HTTPS. You can undo this change by editing your web server's configuration. ------------------------------------------------------------------------------- Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

Select your choice then hit ENTER. The configuration will be updated, and Nginx will reload to pick up the new settings. certbot will wrap up with a message telling you the process was successful and where your certificates are stored:

IMPORTANT NOTES: - Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/your_domain/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/your_domain/privkey.pem Your cert will expire on 2020-08-18. To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option. To non-interactively renew *all* of your certificates, run "certbot renew" - Your account credentials have been saved in your Certbot configuration directory at /etc/letsencrypt. You should make a secure backup of this folder now. This configuration directory will also contain certificates and private keys obtained by Certbot so making regular backups of this folder is ideal. - If you like Certbot, please consider supporting our work by: Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

If you followed the Nginx installation instructions in the prerequisites, you will no longer need the redundant HTTP profile allowance:

  1. sudo ufw delete allow 'Nginx HTTP'

To verify the configuration, navigate once again to your domain, using https://:


You should see your application output once again, along with your browser’s security indicator, which should indicate that the site is secured.


In this guide, you created and secured a simple Flask application within a Python virtual environment. You created a WSGI entry point so that any WSGI-capable application server can interface with it, and then configured the Gunicorn app server to provide this function. Afterwards, you created a systemd service file to automatically launch the application server on boot. You also created an Nginx server block that passes web client traffic to the application server, relaying external requests, and secured traffic to your server with Let’s Encrypt.

Flask is a very simple, but extremely flexible framework meant to provide your applications with functionality without being too restrictive about structure and design. You can use the general stack described in this guide to serve the flask applications that you design.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

About the authors

Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?

This textbox defaults to using Markdown to format your answer.

You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!

@jamonation thanks for this detailed tutorial. I spent the last 48 hours looking for a working one, and this tutorial with a bit of help from ChatGPT made my deployment work. Keep the great work.

This comment has been deleted

    If you followed all the steps and still experience the 502 error, you must modify nginx.conf

    sudo chown youruser:yourgroup etc/nginx/nginx.conf


    sudo nano etc/nginx/nginx.conf 
    user youruser; 

    QQ, we have # Gunicorn then why do we need Nginx?

    As I’m using pyenv instead of venv I had to use a slightly different path for the WorkingDirectory and Environment paths:

    ExecStart=/home/my_name/.pyenv/versions/my_pyenv_virtualenv/bin/gunicorn --workers 3 --bind unix:hello-app.sock -m 007 wsgi:app


    If you face the 502 Gateway error

    Try changing the following line in /etc/systemd/system/myproject.service file

    ExecStart=/home/sammy/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/sammy/myproject/myproject.sock -m 007 wsgi:app

    After this, you need to reload systemctl using the command sudo systemctl daemon-reload

    I can never get this to work through sock file.

    I can get it to work like so without sock file:

    server {
        listen 3080;
        server_name _;
        location / {
            include proxy_params;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

    I followed your steps and successfully deployed my application on AWS EC2. The app was working fine initially, but after about 22-24 hours, my app stopped working. Additionally, I’m unable to open my terminal as it displays a ‘Network error: Connection timed out’ message. I discussed this issue with our senior developer, and he mentioned that he checked the server’s EC2 status (1/2) and determined that the cause might be related to Nginx. I have the same configuration as the one you provided in your tutorial. I’m unsure whether this information is accurate or not. Could you please assist me?

    Is it possible to setup this at a domain like api.project.example.com or does this require more work?

    Tried this more times than I can count following the steps exactly. Always fails to create the .sock file.

    Try DigitalOcean for free

    Click below to sign up and get $200 of credit to try our products over 60 days!

    Sign up

    Join the Tech Talk
    Success! Thank you! Please check your email for further details.

    Please complete your information!

    Featured on Community

    Get our biweekly newsletter

    Sign up for Infrastructure as a Newsletter.

    Hollie's Hub for Good

    Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

    Become a contributor

    Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

    Welcome to the developer cloud

    DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

    Learn more
    DigitalOcean Cloud Control Panel