Building Microservices with Python and Flask

Python is a versatile and powerful programming language, while Flask is a lightweight web framework that allows us to create web applications quickly. Together, they form a robust combination for developing microservices. In this article, we will guide you through the process of building microservices step by step, providing code snippets and explanations along the way.

In this tutorial, we will start by introducing the concept of microservices and their benefits. Then, we will set up a development environment and create a simple Flask application. After that, we will dive into the process of splitting the application into microservices, each serving a specific purpose. We will explore how to communicate between these microservices using HTTP requests and RESTful APIs.

Introduction to Microservices

Microservices architecture is an approach to building applications by breaking them down into smaller, loosely coupled services. Each service focuses on a specific task and can be developed, deployed, and scaled independently. This architecture promotes flexibility, maintainability, and scalability. To get started, let's set up our development environment.

Step 1: Install Python and Flask

First, ensure that Python is installed on your machine. You can download the latest version from the official Python website. Once Python is installed, open your terminal or command prompt and install Flask using pip, the Python package manager ?

pip install flask

Step 2: Create a Flask Application

Now that Flask is installed, let's create a basic Flask application. Create a new Python file and import the Flask module. Then, create a Flask object and define a route that will handle incoming requests ?

from flask import Flask

app = Flask(__name__)

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

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

In this code snippet, we import the Flask module and create a Flask object named app. We define a route decorator on the root URL ("/") and associate it with the hello() function. When a request is made to the root URL, Flask will invoke this function and return the response.

Splitting the Application into Microservices

Now that we have a basic Flask application, let's split it into microservices. We will create two microservices: one for handling user authentication and another for managing product data.

User Authentication Microservice

Create a new Python file named auth_service.py for the user authentication microservice. This service will handle user registration and login operations ?

from flask import Flask, request, jsonify

app = Flask(__name__)

# In-memory storage for demo purposes
users = []

@app.route('/register', methods=['POST'])
def register():
    user_data = request.json
    
    # Basic validation
    if not user_data or 'username' not in user_data or 'password' not in user_data:
        return jsonify({'error': 'Username and password required'}), 400
    
    # Check if user already exists
    if any(user['username'] == user_data['username'] for user in users):
        return jsonify({'error': 'User already exists'}), 409
    
    # Store user data
    users.append(user_data)
    return jsonify({'message': 'User registered successfully'}), 201

@app.route('/login', methods=['POST'])
def login():
    credentials = request.json
    
    # Find user
    user = next((user for user in users if user['username'] == credentials['username'] 
                and user['password'] == credentials['password']), None)
    
    if user:
        return jsonify({'message': 'Login successful'}), 200
    else:
        return jsonify({'error': 'Invalid credentials'}), 401

if __name__ == '__main__':
    app.run(port=5001, debug=True)

Product Management Microservice

Create another Python file named product_service.py for managing product operations. This service will handle CRUD operations for products ?

from flask import Flask, request, jsonify

app = Flask(__name__)

# In-memory storage for demo purposes
products = []
product_counter = 1

@app.route('/products', methods=['POST'])
def create_product():
    global product_counter
    product_data = request.json
    
    # Basic validation
    if not product_data or 'name' not in product_data:
        return jsonify({'error': 'Product name required'}), 400
    
    # Create product with ID
    product = {
        'id': product_counter,
        'name': product_data['name'],
        'price': product_data.get('price', 0)
    }
    products.append(product)
    product_counter += 1
    
    return jsonify({'message': 'Product created successfully', 'product': product}), 201

@app.route('/products/<int:product_id>', methods=['GET'])
def get_product(product_id):
    product = next((p for p in products if p['id'] == product_id), None)
    
    if product:
        return jsonify(product), 200
    else:
        return jsonify({'error': 'Product not found'}), 404

@app.route('/products/<int:product_id>', methods=['PUT'])
def update_product(product_id):
    product = next((p for p in products if p['id'] == product_id), None)
    
    if not product:
        return jsonify({'error': 'Product not found'}), 404
    
    update_data = request.json
    product.update(update_data)
    
    return jsonify({'message': 'Product updated successfully', 'product': product}), 200

@app.route('/products/<int:product_id>', methods=['DELETE'])
def delete_product(product_id):
    global products
    products = [p for p in products if p['id'] != product_id]
    return jsonify({'message': f'Product {product_id} deleted successfully'}), 200

if __name__ == '__main__':
    app.run(port=5002, debug=True)

Communicating Between Microservices

Now that we have two microservices, let's see how they can communicate with each other using HTTP requests and RESTful APIs.

Installing the Requests Library

To send HTTP requests between microservices, we need the requests library ?

pip install requests

API Gateway Example

Let's create an API gateway that coordinates between our microservices. Create a file named gateway.py ?

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

# Microservice URLs
AUTH_SERVICE = 'http://localhost:5001'
PRODUCT_SERVICE = 'http://localhost:5002'

@app.route('/api/register', methods=['POST'])
def register_user():
    try:
        response = requests.post(f'{AUTH_SERVICE}/register', json=request.json)
        return jsonify(response.json()), response.status_code
    except requests.RequestException as e:
        return jsonify({'error': 'Auth service unavailable'}), 503

@app.route('/api/products', methods=['POST'])
def create_product_with_auth():
    # First authenticate user
    auth_response = requests.post(f'{AUTH_SERVICE}/login', json={
        'username': request.json.get('username'),
        'password': request.json.get('password')
    })
    
    if auth_response.status_code != 200:
        return jsonify({'error': 'Authentication failed'}), 401
    
    # Create product if authenticated
    product_data = {
        'name': request.json.get('name'),
        'price': request.json.get('price')
    }
    
    try:
        response = requests.post(f'{PRODUCT_SERVICE}/products', json=product_data)
        return jsonify(response.json()), response.status_code
    except requests.RequestException as e:
        return jsonify({'error': 'Product service unavailable'}), 503

if __name__ == '__main__':
    app.run(port=5000, debug=True)

Running the Microservices

To test our microservices architecture, run each service in separate terminal windows:

1. Start the authentication service: python auth_service.py
2. Start the product service: python product_service.py
3. Start the API gateway: python gateway.py

Best Practices

Conclusion

In this tutorial, we explored how to build microservices using Python and Flask. We demonstrated splitting applications into independent services and enabling communication through HTTP requests. This architecture provides scalability, maintainability, and flexibility for modern applications.