Flask is a popular web framework for building web applications in Python. It is considered a microframework because it provides only the bare essentials for web development, focusing on simplicity and extensibility.
Flask is one of the most popular frameworks for developing REST applications in Python. Flask also has a server to do local deployments and test the application, but no one would go with it to production. So we need another server to deploy the application in production, and one option is to use a WSGI (Web Server Gateway Interface) server like Gunicorn.
In this tutorial, you will learn how to create a Flask application, configure it to Gunicorn, and containerize it.
The application
Let's create a simple Hello World application using Flask as a web framework.
You’ll need to install Python 3 and pip.
Setup
Create a new file with the name requirements.txt with the dependencies required for the project:
Flask
Gunicorn
Then update the pip dependencies and install the dependencies by running the following command:
pip3 install --upgrade pip
pip3 install -r requirements.txt
Application
Create a new file named app.py containing the Flask REST endpoint:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
Running
Let's test the application locally:
flask --app app run
The output will be similar to the following:
* Serving Flask app 'app' * Debug mode: off WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:5000 Press CTRL+C to quit
If you send a request to the defined endpoint, you'll get the predefined output:
curl localhost:5000/ Hello, World!
So far, so good, but as the log message says, we need another way to use a WSGI server for going to production. So, let's do it.
WSGI
WSGI stands for Web Server Gateway Interface. It is a specification for a standardized interface between web servers and web applications or frameworks written in Python. WSGI defines a contract that allows web servers to communicate with Python web applications, enabling them to work together seamlessly.
This separation of concerns allows web servers to focus on handling low-level networking tasks, such as accepting incoming requests and managing connections. In contrast, web applications can focus on handling the application logic and generating responses.
You can switch between server implementations with minimal application changes. In this case, we'll use Gunicorn.
First, we configure the Gunicorn server by creating a new file named gunicorn_config.py, where we'll configure things like the number of workers and threads and open port or timeout.
import os
workers = int(os.environ.get('GUNICORN_PROCESSES', '2'))
threads = int(os.environ.get('GUNICORN_THREADS', '4'))
# timeout = int(os.environ.get('GUNICORN_TIMEOUT', '120'))
bind = os.environ.get('GUNICORN_BIND', '0.0.0.0:8080')
forwarded_allow_ips = '*'
secure_scheme_headers = { 'X-Forwarded-Proto': 'https' }
Now, the last thing to do is start the Gunicorn server with the application deployed.
Let's run the following command in the terminal:
gunicorn --config gunicorn_config.py app:app
The first app is the name of the Python file containing the Flask application.
The output shows the application up and running in Gunicorn:
[2023-07-17 22:55:05 +0200] [15903] [INFO] Starting gunicorn 20.1.0 [2023-07-17 22:55:05 +0200] [15903] [INFO] Listening at: http://0.0.0.0:8080 (15903) [2023-07-17 22:55:05 +0200] [15903] [INFO] Using worker: gthread [2023-07-17 22:55:05 +0200] [15904] [INFO] Booting worker with pid: 15904 [2023-07-17 22:55:05 +0200] [15905] [INFO] Booting worker with pid: 15905
If you re-access the service using port 8080, you'll get the Hello World again.
curl localhost:8080/
Hello, World!
Now, with the application up and running locally, it's time to containerize it.
Containerization
Generally speaking, to containerize an application, you create a Dockerfile with all the instructions and dependencies required to run the application.
Dockerfile
The base image contains Python, so we only copy the application files, install the requirements to run the application, and use Gunicorn to start it.
FROM python:3.7.3-slim
COPY requirements.txt /
RUN pip3 install --upgrade pip
RUN pip3 install -r /requirements.txt
COPY . /app
WORKDIR /app
EXPOSE 8080
CMD ["gunicorn","--config", "gunicorn_config.py", "app:app"]
Building the container
We are going to use Podman Desktop to build the container. With Podman (or Docker) running, let's build the container running the following command:
podman build -t hello-flask:1.0.0 .
The output shows the building steps executed:
STEP 1/8: FROM python:3.7.3-slim STEP 2/8: COPY requirements.txt / --> 7721820f5f2e STEP 3/8: RUN pip3 install --upgrade pip … STEP 8/8: CMD ["gunicorn","--config", "gunicorn_config.py", "app:app"] COMMIT hello-flask:1.0.0 --> 7bf50a7a7936 Successfully tagged localhost/hello-flask:1.0.0 7bf50a7a7936d9b87af74b7d49a94c69d217712901d78ba170acb1f28f800d51
[ Learn more: What is Podman Desktop? A developer's introduction ]
Running the container
To run the container, use Podman (or Docker):
podman run -it --rm -p 8080:8080 hello-flask:1.0.0
[2023-07-18 07:35:29 +0000] [1] [INFO] Starting gunicorn 21.0.1
[2023-07-18 07:35:29 +0000] [1] [INFO] Listening at: http://0.0.0.0:8080 (1)
[2023-07-18 07:35:29 +0000] [1] [INFO] Using worker: gthread
[2023-07-18 07:35:29 +0000] [4] [INFO] Booting worker with pid: 4
[2023-07-18 07:35:29 +0000] [5] [INFO] Booting worker with pid: 5
Kubernetes
If you want to try the application in Kubernetes, use the following YAML file:
apiVersion: apps/v1
kind: Deployment
metadata:
labels:
app: hello-service
name: hello-service
spec:
replicas: 1
selector:
matchLabels:
app: hello-service
template:
metadata:
labels:
app: hello-service
spec:
containers:
- name: hello-service
image: quay.io/lordofthejars/hello-flask:1.0.0
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-service
labels:
app: hello-service
spec:
ports:
- name: http
port: 8080
selector:
app: hello-service
type: LoadBalancer
Use any Kubernetes cluster (minikube, kind, etc.) or a cloud Kubernetes implementation like OpenShift for free in the Developer Sandbox for Red Hat OpenShift.
Conclusion
Flask is one of the most popular frameworks in Python to develop web applications, but when it comes to moving to production, you need a server like Gunicorn to deploy it.
Containerizing the application is a simple process of putting these steps into a Dockerfile and choosing the right base image.
Last updated: September 19, 2023