Flask is known as a web micro-framework because it does not require any specific plugins to run, and it is built on Python. The Flask framework is very flexible and lightweight.

In this tutorial, we will create a Flask application then deploy it with Docker.

Setting up a Flask Application:

• First, create a directory structure for the Flask Application. Run the below command to create a “DemoApp” directory in “/var/www/”.

sudo mkdir /var/www/DemoApp

• Switch to the newly created directory:

cd /var/www/DemoApp

• Create the basic folder structure:

sudo mkdir -p app/static app/temp

• Create a file, required to run the Flask application:

sudo nano app/__init__.py

• The above file indicates the python interpreter that the app directory is a package.
• Add the following code to the above file, which will create a Flask instance and will import the logic from the views.py file (which we will create further).

from flask import Flask

app = Flask(__name__)

from app import views

/var/www/DemoApp/__init__.py

Save and close the file.

• Create the “views.py” file, which will contain application logic.

sudo nano app/views.py

• Add the code into views.py, which will return the “Hello Zehntech!” when we visit the web page.

from app import app

@app.route(‘/’)

def home():

return “Hello Zehntech!”

/var/www/DemoApp/app/views.py

The “@app.route” in the code block called “Decorator,” from where we define on which URL the home() method trigger.

Now, you’re ready to create the uwsgi.ini file with views.py file, which will contain the uWSGI configurations for our application. uWSGI is an application server and a protocol of deployment for the Nginx. There are multiple application servers available that can serve FastCGI, uWSGI, and HTTP protocols.

• To create the uwsgi.ini file:

sudo nano uwsgi.ini

• Add the below configuration into uwsgi.ini file:

[uwsgi]

module = main

callable = app

master = true

/var/www/DemoApp/uwsgi.ini

The main referred to as main.py, which instructs uWSGI to use the app instance exported by the main application. The application will keep running with the “master” option.

• Next, create the entry point to the application, which is the “main.py” file. It will instruct uWSGI how to interact with the application.

sudo nano main.py

• Import the previously create package named as “app” into the main.py:

from app import app

/var/www/DemoApp/main.py

• Create a file named “requirement.txt” which contains the dependencies installed by pip package manager:

sudo nano requirements.txt

• Write below line into the newly created file “requirement.txt” to specify the Flask version to be installed:

Flask==1.0.2

/var/www/DemoApp/app/requirement.txt

Save and close the file.
We have successfully set up our Flask application.

Creating a Dockerfile and Setting up Docker

First, we will create a Dockerfile which contains the commands used to assemble the image and create the docker deployment.

• To create a Dockerfile:

sudo nano Dockerfile

• Add the configuration commands into the Dockerfile which will specify the requirements and how the image will be built.

  NOTE: There are many tags available in Docker, but we are using the tag with alpine version e.g., FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7.
  As the flask is based on WSGI, therefore we use the Docker image with uWSGI and Nginx for creating Flask web applications in Python 3.6 version using Alpine Linux in a single container. It is the most common way to deploy web applications in Python for decent performance.
  

FROM tiangolo/uwsgi-nginx-flask:python3.6-alpine3.7

RUN apk –update add bash nano

ENV STATIC_URL /static

ENV STATIC_PATH /var/www/app/static

COPY ./requirement.txt /var/www/requirements.txt

RUN pip3 install -r /var/www/requirements.txt

/var/www/DemoApp/Dockerfile

• Save and close the configuration file.

• Create a “start.sh” script which builds the Docker container with below command:

sudo nano start.sh

This is a shell script that builds an image from the Dockerfile and creates a container from the docker image. Add your commands into the “start.sh” script like below:

#!/bin/bash

app=”zehntech.test”

docker build -t ${app} .

docker run –name=${app} \ -v $PWD:/app ${app}

/var/www/DemoApp/start.sh

This will create an image named “zehntech.test” which is saved as a variable named “app”.

• Execute the script “start.sh” for creating the Docker image and then build a container from the image:

sudo bash start.sh

• After executing the above script, run the command to list all the running containers:

sudo dokcer ps

CONTAINER ID IMAGE COMMAND PORTS NAMES
58b05508f4dd zehntech.test “/entrypoint.sh /sta…” 0.0.0.0:5000->80/tcp zehntech.test

Output

• To check that the docker container is running or not, visit the IP address with the specified port e.g. 5000 in your browser like below:

http://ip_address:5000

• You will see the output as shown below:

Great! We have successfully deployed our Flask application on Docker.