APIs are the backbone of modern applications, enabling communication between different services efficiently. Flask, a lightweight and flexible Python framework, is an excellent choice for building RESTful APIs. When combined with Docker, we can ensure consistency and scalability across different environments. In this guide, we’ll walk through building a simple RESTful API using Flask, containerizing it with Docker, and deploying it in a Dockerized environment.

Why Flask for RESTful APIs?

Flask is popular among developers because of its simplicity and flexibility. Unlike heavier frameworks like Django, Flask provides just the essentials, allowing developers to build APIs quickly with minimal setup. Some advantages include:

Lightweight and minimalistic
Built-in development server and debugger
Extensible with various plugins (Flask-SQLAlchemy, Flask-RESTful, etc.)
Easy to integrate with databases and authentication mechanisms

Setting Up the Flask API

Let’s start by setting up a simple Flask API that exposes basic CRUD (Create, Read, Update, Delete) operations.

1. Install Dependencies

First, ensure you have Python installed. Then, create a virtual environment and install Flask:

mkdir flask_docker_api && cd flask_docker_api
python3 -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
pip install flask flask-restful flasgger

2. Create the Flask App

Inside your project folder, create an app.py file and add the following code:

from flask import Flask, request, jsonify
from flask_restful import Resource, Api
from flasgger import Swagger

app = Flask(__name__)
api = Api(app)
swagger = Swagger(app)

items = []

class Item(Resource):
    def get(self, name):
        for item in items:
            if item['name'] == name:
                return item, 200
        return {"message": "Item not found"}, 404

    def post(self, name):
        data = request.get_json()
        new_item = {"name": name, "price": data["price"]}
        items.append(new_item)
        return new_item, 201

    def delete(self, name):
        global items
        items = [item for item in items if item['name'] != name]
        return {"message": "Item deleted"}, 200

api.add_resource(Item, "/item/<string:name>")

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

This defines a basic API that allows adding, retrieving, and deleting items.

Testing the API Locally

Run the application using:

python app.py

Visit http://127.0.0.1:5000/item/sample_item in your browser or use Postman to test your API.

Containerizing with Docker

1. Create a Dockerfile

In the project root, create a file named Dockerfile:

FROM python:3.9
WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt
EXPOSE 5000
CMD ["python", "app.py"]

2. Create a requirements file

Generate a requirements.txt file:

pip freeze > requirements.txt

3. Build and Run the Docker Container

Run the following commands:

docker build -t flask-api .
docker run -p 5000:5000 flask-api

Your API is now running inside a Docker container!

Using Docker Compose

To simplify container orchestration, create a docker-compose.yml file:

version: '3.8'
services:
  flask_api:
    build: .
    ports:
      - "5000:5000"

Run it using:

docker-compose up --build

Adding Swagger for API Documentation

Swagger provides interactive documentation for APIs. The flasgger package enables this easily.

Modify app.py to include:

swagger = Swagger(app)

Now, visit http://127.0.0.1:5000/apidocs to access the API documentation.

Conclusion

We successfully built a RESTful API using Flask, containerized it with Docker, and used Docker Compose for orchestration. With Swagger, we also provided interactive documentation. This setup is a strong foundation for deploying scalable microservices.

For further improvements, consider integrating a database like PostgreSQL or MongoDB, adding authentication, and deploying to a cloud provider.

Building a RESTful API with Flask and Docker

Table of contents