Building Microservices with Python, Flask, and Docker

Introduction
Prerequisites
Setup
Creating a Flask Application
Building Microservices
Containerizing with Docker
Conclusion

Introduction

In this tutorial, we will learn how to build microservices using Python, Flask, and Docker. Microservices architecture is a design pattern that focuses on developing small, independent services that work together to form a larger application. This approach allows for more flexibility, scalability, and easier maintenance.

By the end of this tutorial, you will have a clear understanding of microservices concepts, and you will be able to build and deploy microservices using Python, Flask, and Docker.

Prerequisites

To follow along with this tutorial, you should have the following:

Basic knowledge of Python programming language
Familiarity with Flask framework
Understanding of RESTful APIs
Docker installed on your system

Setup

Before we dive into building microservices, let’s set up our development environment.

Python and Flask: Start by installing Python on your system. You can download the latest version from the official Python website. Once installed, open your terminal and install Flask using the following command:
```
$ pip install flask
```
Docker: Next, install Docker by following the instructions provided on the official Docker website. Docker will be used to containerize our microservices.

Now that we have our development environment set up, let’s move on to building our microservices.

Creating a Flask Application

We’ll start by creating a basic Flask application that will serve as our microservice template. Open your preferred code editor and create a new Python file called app.py. ```python from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, World!"

if __name__ == '__main__':
    app.run()
``` In the above code, we import the Flask module and create an instance of the Flask class. We define a single route that responds with "Hello, World!" when the root URL is accessed. Finally, we run the application if it's directly executed, rather than imported as a module.

To run the application, execute the following command in the terminal: bash $ python app.py Open your web browser and visit http://localhost:5000. You should see the “Hello, World!” message displayed.

Building Microservices

Now that we have a basic Flask application, let’s break it down into separate microservices.

Service 1: Create a new file called service1.py and copy the following code into it:
```
from flask import Flask

app = Flask(__name__)

@app.route('/service1')
def service1():
    return "This is Service 1!"

if __name__ == '__main__':
    app.run(port=5001)
```
In this code, we define a new route that responds with “This is Service 1!” when /service1 is accessed. We also change the port to 5001 to avoid conflicts with the main application.
Service 2: Similarly, create a new file called service2.py and add the following code:
```
from flask import Flask

app = Flask(__name__)

@app.route('/service2')
def service2():
    return "This is Service 2!"

if __name__ == '__main__':
    app.run(port=5002)
```
This code defines a new route that responds with “This is Service 2!” when /service2 is accessed. The port is set to 5002.

At this point, we have two separate microservices within our application. Each service can have its own logic and data access, making it easier to scale and update individually.

Containerizing with Docker

To make our microservices more portable and easy to deploy, we’ll containerize them using Docker. Follow these steps to containerize each microservice:

Define Dockerfile: Create a new file in the root of your project called Dockerfile. Open it in a text editor and add the following content:
```
# Base image
FROM python:3.9

# Set working directory
WORKDIR /app

# Copy requirements file
COPY requirements.txt .

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy application files
COPY . .

# Expose port
EXPOSE 5000

# Run application
CMD python app.py
```
This Dockerfile specifies a base image, sets the working directory, copies the requirements file, installs dependencies, copies the application files, exposes the port, and runs the application using CMD.
Build and Run Docker Image: Open a terminal and navigate to the root of your project. Build the Docker image by running the following command:
```
$ docker build -t my-flask-app .
```
This command instructs Docker to build an image using the Dockerfile and tag it as my-flask-app. The dot (.) at the end of the command refers to the current directory.
Run Container: Once the image is built, we can create and run a container based on it. Execute the following command:
```
$ docker run -p 5000:5000 my-flask-app
```
This command maps the container’s port 5000 to the host machine’s port 5000 and runs the my-flask-app image.
Access Microservices: Open your web browser and visit http://localhost:5000 to access the main application. Similarly, you can access each microservice by replacing the port number with the respective microservice’s port (5001 for service 1 and 5002 for service 2).

Congratulations! You have successfully built and containerized microservices using Python, Flask, and Docker. This approach provides a scalable and maintainable architecture for developing complex applications.

Conclusion

In this tutorial, we learned how to build microservices using Python, Flask, and Docker. We started by creating a basic Flask application and then broke it down into separate microservices. Finally, we containerized our microservices using Docker, allowing for easy deployment and scalability.

Microservices architecture offers numerous benefits such as flexibility, scalability, and easier maintenance. By leveraging Python, Flask, and Docker, we can efficiently develop and deploy microservices-based applications.

Feel free to explore further and experiment with additional microservices, inter-service communication, and orchestration tools to enhance your microservices architecture.

Published: 2 September 2021