Developing a Flask API in a Docker container with uWSGI and NGINX
Flask is a very lightweight framework for developing APIs in Python. However, it does not come with a production-level server by default — it comes with Werkzeug, which isn’t suited for production (e.g. can only handle one request at a time).
For preparing an application for production-level serving the API, uWSGI and NGINX can be used. Docker makes it easy to have everything put together in the same container and prevents you from having to install everything from scratch every time that you would put your application to run.
NGINX is the web server and reverse proxy, that passes requests on to uWSGI.
uWSGI is an application server, which can communicate with the web server for receiving requests and forwards them to Flask via the WSGI protocol.
The set up shown here is very minimal, and not suited for handling large amounts of simultaneous requests. However, this architecture is able to scale, and for this, it would only require tweaking the configuration files.
On this tutorial, the Web and the App servers are running inside the same container. However, it could have been developed putting them into different containers.
The code that supports the steps described in this tutorial are available at this repo: https://github.com/gabimelo/flask-boilerplate
This repo is a boilerplate for Flask applications. It uses MongoDB as an example DB, to exemplify how a Flask web app would connect to Mongo.
This is the full Dockerfile for the web and app server container:
Supervisor is what makes sure NGINX and uWSGI start running on container startup.
First of all, we start off from a Python container. This is an Ubuntu container with Python 3.5 and pip installed.
NGINX and Supervisor are installed through apt-get and uWSGI is installed with pip. Following that, we are able to install all of our project requirements.
The next lines create a new user called nginx , remove some default configuration files, and add some new ones (for nginx, uwsgiand supervisor). The last step will be to copy our actual project files into the container, and the command that will be run when the container starts is supervisord — this is what makes everything start running on container startup.
Now we'll have a look at these config files.
Firstly we have our nginx.conf file. I won't embed it here, as it is quite long, but there are comments on it explaining each line. This file defines how NGINX will work on this container.
Next, we have the flask-site-nginx.conf file. This describes the configuration for NGINX for our specific Flask project.
This specifies that all requests are going to be redirected to @yourapplication , and then describes that @yourapplication works with the uWSGI protocol, using a unix socket for the communication.
Next is the uwsgi.ini file. This ones — as one can probably guess from its name, configures uWSGI.
module is the file where your Flask app is located, and callable is the name of the Flask app object in this file. It then sets up to use the nginx user and group, and sets up the socket with which uWSGI and NGINX will communicate. Lastly, cheaper configures the amount of workers, and processes, the amount of processes, that uWSGI will be able to use.
The last file is the supervisord.conf:
This one is also pretty simple. It configures supervisor to run on the foreground, sets up the command to get uWSGI and NGINX started, and configures where they will write their log files to.
Having this set up, you just need to build and run your container, to get everything working. You'll need to specify which port the container will expose for receiving the requests (I did this using a docker-compose.yml file), and then you can test it by sending requests at <your-ip>:<the-exposed-port>(e.g. localhost:5000/hello-world).
One important detail is that uWSGI `fork`s your app’s process , which causes the Mongo client some trouble. A simple fix for this, as suggested in this answer is to instantiate your MongoClient as follows: pymongo.MongoClient(connect=False) (with the connect=False flag).
That's it for now! This tutorial is very simple, with very basic configuration for uWSGI, NGINX, Docker, etc, but presents an architecture that can scale with your application. I'll enjoy reading comments as to how I could improve it, and thanks for reading!
