Serving Flask Applications with uSWGI on Ubuntu

By Kunal Relan, Alibaba Cloud MVP


In this tutorial, we’ll build a sample Python application using Flask and deploy the application using uWSGI and Nginx. Flask is a popular micro framework widely used in web development using Python. It is called a microframework as it doesn’t required any other tools or library to create a web application, and all other resources needed in the process are imported as third party libraries including database abstraction layer.

To start with the basics, we’ll create a hello world application using Flask. We’ll use uWSGI application server and Nginx to act as front end reverse proxy server.

To learn more detailed operations with your Flask installation, such as updating Python with Pyenv and daemonizing the log process, check out this tutorial.


To complete this tutorial, you will need:

  • Alibaba Cloud Elastic Compute Service (ECS) Ubuntu server with a non-root user with sudo privileges.
  • Basic working knowledge of Nginx and uWSGI.

Step 1 — Setting Up Required Components and Tools

In the first step we’ll install all the dependencies needed to setup the application from Ubuntu repositories and we’ll start with installing which is a package manager for Python, which contains the header files needed to compile python extensions and which will work as a front end reverse proxy server for us.

sudo apt-get update
sudo apt-get install python-pip python-dev nginx

After this step completes, we should have pip, python-dev tools and nginx installed in the system. Now lets setup a python virtual environment to create our flask application. Python virtual environments are useful to have a self-contained directory tree that contains a specific version of python and required components ensuring that we don’t install them globally as other apps in the same system might need another version of the same library.

So new we’ll install package using pip to be able to create a virtual environment.

sudo pip install virtualenv

Now we shall have package installed in our system.

After this we can go ahead and create the project directory and activate our virtual environment.

mkdir ~/samepleapp
cd ~/sampleapp

Next we’ll create a virtual environment to store our python modules using the following command.

user@instance:~/samepleapp $ virtualenv venv

This command will install a local copy of python and pip in a directory called within directory which we just created.

Before we install any more components in our virtual environment we need to activate the environment so that pip install the components in our virtual environment. To do so enter the following command.

user@instance:~/samepleapp $ source venv/bin/activate

After this command is successfully executed, your terminal prompt will indicate that you are now inside the virtual environment and it will look something like .

Step 2 — Creating a Sample Flask Application

Now that we have our virtual environment activated, lets install and and get started on creating our Hello World Application.

Use the local version of pip in your virtual instance to install and using the following command.

(venv) user@instance:~/samepleapp $ pip install flask uwsgi

After install and we can start creating our Flask Application, for the sake of this tutorial we'll just create one route which will return Hello World in the response and thus we'll just create a single file called .

We’ll keep our sample application in this file, now add the following code to import and initiate the Object to create an instance of .

(venv) user@instance:~/samepleapp $ nano

Now edit the following code using the nano code editor, save the file and exit.

from flask import Flask
app = Flask(__name__)
def hello():
return "It Works!"
if __name__ == "__main__":'',port=3000)

The above code basiically, imports the local library and initiates an object called and then defines the root route which will execute the function when the root domain is accessed and in our case it'll return Hello World and then we run the Object on all the network adapters of the instance using address.

Note: Make sure your port 3000 is open over the Internet.

Now, if everything went well you can start the Python server using the following command and then access the web server on PORT 3000 using your browser or terminal.

(venv) user@instance:~/samepleapp $ python

The above command should start the Python server and you can now access the application by visiting in your browser or terminal.

After you have tested the same, exit the Python server by pressing .

Next we’ll create that will serve as the entry point to our application which directs the server on how to interact with the python application.

Step 3 — Configuring uWSGI

So now that we have our application ready to be deployed, we’ll move on to uWSGI and configure uWSGI to serve our application. To start with we’ll check if uWSGI is able to start our application using the command line.

Now edit the following code in file in your app directory, save and exit.

from app import app
if __name__ == "__main__":

The above code imports the object from our and runs the application, will serve as entry point to our application.

Now lets test if our entry point starts the application, enter the following code in your terminal.

(venv) user@instance:~/samepleapp $ uwsgi --socket --protocol=http -w wsgi:app

This command will try to call object in and run the application.

Now visit the server’s IP on port 5000 and you should be able to see the same output and once it’s working properly you can exit the application by pressing .

Once we have tested that uWSGI is working for us, we’ll start with creating a WSGI configuration file and provide it the options we need.

Create another file in the same directory and name it and edit the file to put the following configurations to run our application.

#python module to import
module = wsgi:app
#enable the master process
master = true
#spawn number of workers
processes = 5
#socket file's location
socket = sampleflask.sock
#permissions for the socket file
chmod-socket = 660

When finished, save and exit the file.

Step 4 — Creating systemd unit file

Once we have the configuration file, next we need to create a systemd unit file which will make ubuntu’s init system to start our application everytime the server boots.

Now we need to create file inside where all the ubuntu init files exist.

Edit the following code in the file

#Metadata and dependencies section
Description=Sampleflask service
#Define users and app working directory
ExecStart=/home/<your_user>/sampleflask/venv/bin/uwsgi --ini sampleflask.ini
#Link the service to start on multi-user system up

Next, save the file and exit.

After this, we can now start our uWSGI service we just created using command, let's enable our service to start at boot using the following command:

(venv) user@instance:~/samepleapp $ sudo systemctl start sampleflask
(venv) user@instance:~/samepleapp $ sudo systemctl enable sampleflask

Step 5 — Configuring Nginx to Proxy requests

Our uWSGI service should now be up and running on port 3000, next we need to configure Nginx to proxy the requests on port 80. To do so we’ll need to configure Nginx to pass the web requests to the socket using protocol. Nginx comes with native support for passing uwsgi protocol traffic and works out of the box with uwsgi.

Let’s begin by adding a new server block in a new file called and put the following code in it.

server {
# the port your site will be served on
listen 80;
# the IP Address your site will be served on
server_name <your_ip>;
# Proxy connections to application server
location / {
include uwsgi_params;
uwsgi_pass unix:/home/<your_user>/sampleflask/sampleflask.sock;

So that’s all we need to pass Nginx requests to our uWSGI server, next we need to enable the newly created server block using the following command.

(venv) user@instance:~/samepleapp $ sudo ln -s /etc/nginx/sites-available/sampleflask /etc/nginx/sites-enabled

The above command links our newly created server file to the enabled websites directory, now lets test if everything went well with our latest change using Nginx Test Configuration.

(venv) user@instance:~/samepleapp $ sudo ngnix -t

If everything went well, you should see the following output ini your terminal.

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

After this, we are all set to get everything to work and as the last step we need to restart our Nginx server in order for it to load our new changes.

(venv) user@instance:~/samepleapp $ sudo systemctl restart nginx

Now if you open the browser with your IP on port 80, you should be able to see the response from our flask server.


In this tutorial, we created a simple flask application which runs on uWSGI and is reverse proxied through Nginx, Flask is a simple yet powerful micro framework which can enable you to create complex web application and services. uWSGI and Nginx are again powerful tools which enables you to deploy and manage your Flask application for your users as they grow.


Follow me to keep abreast with the latest technology news, industry insights, and developer trends.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store