In this post, we will see how to deploy flask applications using gunicorn WSGI server and nginx as a reverse proxy and static files server.
Follow the steps below:
<h2>Step 1 - Install required packages</h2>
<pre class="language-bash"><code>sudo apt update</code></pre>
Now let's install python3, python3-pip, and Nginx using the commands below:
<pre class="language-bash"><code>sudo apt install python3-pip python3-dev nginx</code></pre>
<img src="https://api.codewithharry.com/media/blogFiles/flask-app-deploy-using-gunicorn-nginx/pythonInstall.PNG" width="600" height="66" />
<h2>Step 2 - Creating a directory (for our flask app) and virtual environment</h2>
Let's install virtualenv
<pre class="language-bash"><code>sudo pip3 install virtualenv</code></pre>
Lets now create a directory to host our flask application
<pre class="language-bash"><code>mkdir myFlaskApp &amp;&amp; cd myFlaskApp</code></pre>
run the following command to create a virtual environment named env
<pre class="language-bash"><code>virtualenv env</code></pre>
Finally activate the virtual environment
<pre class="language-bash"><code>source env/bin/activate</code></pre>
Lets now install flask and gunicorn using pip
<pre class="language-bash"><code>pip3 install flask gunicorn</code></pre>
<h2>Step 3 - Creating a sample project and wsgi entry point</h2>
Let us now create a sample project by entering the command below:
<pre class="language-bash"><code>vim app.py</code></pre>
Paste the contents below to app.py file
<pre class="language-python"><code>from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
 return "Hello World!"
if __name__ == '__main__':
 app.run(debug=True,host='0.0.0.0')</code></pre>
Next, we&rsquo;ll 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.
<pre class="language-bash"><code>vim wsgi.py</code></pre>
copy the contents below to wsgi.py
<pre class="language-bash"><code>from app import app

if __name__ == "__main__":
 app.run()</code></pre>
We can test gunicorn's ability to serve our project by running the command below:
<pre class="language-bash"><code>gunicorn --bind 0.0.0.0:5000 wsgi:app</code></pre>
<img src="https://api.codewithharry.com/media/blogFiles/flask-app-deploy-using-gunicorn-nginx/gunicorn_output.PNG" />
Folder structure so far:
<pre class="language-markup"><code>myFlaskApp
 |____ app.py
 |____ wsgi.py
 |____ env</code></pre>
Lets deactivate our virtual environment now:
<pre class="language-bash"><code>deactivate</code></pre>
<h2>Step 4 - Creating a systemd service</h2>
Lets now create a systemd service using the following commands:
<pre class="language-bash"><code>vim /etc/systemd/system/app.service</code></pre>
Now paste the contents below to this file:
<pre class="language-markup"><code>[Unit]
# specifies metadata and dependencies
Description=Gunicorn instance to serve myproject
After=network.target
# tells the init system to only start this after the networking target has been reached
# We will give our regular user account ownership of the process since it owns all of the relevant files
[Service]
# Service specify the user and group under which our process will run.
User=harry
# give group ownership to the www-data group so that Nginx can communicate easily with the Gunicorn processes.
Group=www-data
# We'll then map out the working directory and set the PATH environmental variable so that the init system knows where our the executables for the process are located (within our virtual environment).
WorkingDirectory=/home/harry/myFlaskApp/
Environment="PATH=/home/harry/myFlaskApp/env/bin"
# We'll then specify the commanded to start the service
ExecStart=/home/harry/myFlaskApp/env/bin/gunicorn --workers 3 --bind unix:app.sock -m 007 wsgi:app
# This will tell systemd what to link this service to if we enable it to start at boot. We want this service to start when the regular multi-user system is up and running:
[Install]
WantedBy=multi-user.target</code></pre>
Activate this service by typing:
<pre class="language-bash"><code>sudo systemctl start app
sudo systemctl enable app</code></pre>
A file named app.sock will be automatically created. Folder structure so far:
<pre class="language-markup"><code>myFlaskApp
 |____ app.py
 |____ wsgi.py
 |____ env
 |____ app.sock</code></pre>
&nbsp;
<h2>Step 5 - Configuring Nginx</h2>
Create a file named app inside /etc/nginx/sites-available
<pre class="language-bash"><code>vim /etc/nginx/sites-available/app</code></pre>
Now copy the below contents to this file:
<pre class="language-bash"><code>server {
listen 80;
server_name 165.232.177.116;

location / {
 include proxy_params;
 proxy_pass http://unix:/home/harry/myFlaskApp/app.sock;
 }
} </code></pre>
Important: I have used my server IP, you should use yours!
Activate this configuration by executing this:
<pre class="language-bash"><code>sudo ln -s /etc/nginx/sites-available/app /etc/nginx/sites-enabled</code></pre>
Restart nginx and your website should work fine!
<pre class="language-bash"><code>sudo systemctl restart nginx</code></pre>
Visiting http://165.232.177.116/ on browser shows a page like this
<img src="https://api.codewithharry.com/media/blogFiles/flask-app-deploy-using-gunicorn-nginx/site.PNG" width="657" height="411" />
If you are using a firewall (for eg. ufw), don't forget to allow nginx to receive incoming traffic on port 80
<pre class="language-bash"><code>sudo ufw allow 'Nginx Full'</code></pre>
Happy coding!

How to deploy flask app on Ubuntu VPS using Nginx and gunicorn

Comments ()