Hackforge Academy

Explanation

Microservices is an architectural approach where a large application is divided into small, independent services. Each service is responsible for a specific business capability and can be developed, deployed, and scaled independently. Python is commonly used to build microservices using frameworks such as FastAPI, Flask, and Django. For example, an e-commerce application can have separate services for users, products, orders, and payments. Each service can have its own codebase and database and communicate with other services through APIs such as REST.

Code:

# Example: Simple Python Microservice
# user_service.py

from fastapi import FastAPI

app = FastAPI()

@app.get('/users')
def get_users():
    return {
        'service': 'User Service',
        'users': ['John', 'Alice', 'David']
    }

# Run with:
# uvicorn user_service:app --reload

Explanation

In a monolithic application, all business functionality is typically contained within a single application. A change to one part may require rebuilding and redeploying the entire application. In a microservices architecture, functionality is divided into independent services. For example, an e-commerce system can separate User Service, Product Service, Order Service, and Payment Service. Each service can be developed and deployed independently. Microservices can improve scalability and team independence, but they also introduce additional complexity such as service communication, monitoring, deployment, and distributed data management.

Code:

# Monolithic application
#
# ecommerce.py
# ├── users
# ├── products
# ├── orders
# └── payments


# Microservices architecture
#
# user-service/
# product-service/
# order-service/
# payment-service/

Explanation

FastAPI is a modern Python web framework commonly used to build REST APIs and microservices. A FastAPI application can expose endpoints that other services or frontend applications can consume. Each microservice can have its own API endpoints and business logic. FastAPI also provides automatic API documentation and supports asynchronous programming, making it a good choice for high-performance Python services.

Code:

from fastapi import FastAPI

app = FastAPI(title='Product Service')

products = [
    {'id': 1, 'name': 'Laptop', 'price': 65000},
    {'id': 2, 'name': 'Mouse', 'price': 750}
]


@app.get('/products')
def get_products():
    return products


@app.get('/products/{product_id}')
def get_product(product_id: int):
    for product in products:
        if product['id'] == product_id:
            return product

    return {'message': 'Product not found'}


# Run:
# uvicorn product_service:app --reload

Explanation

Microservices need to communicate with each other to complete business operations. REST APIs over HTTP are one of the most common communication mechanisms. For example, an Order Service may call a Product Service to retrieve product information before creating an order. Python applications can use libraries such as requests or httpx to make HTTP calls. In production systems, service communication should also consider timeouts, retries, authentication, error handling, and service discovery.

Code:

# order_service.py

import httpx
from fastapi import FastAPI

app = FastAPI()

PRODUCT_SERVICE = 'http://localhost:8001'


@app.get('/orders/{product_id}')
async def create_order(product_id: int):
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f'{PRODUCT_SERVICE}/products/{product_id}',
            timeout=5.0
        )

    if response.status_code != 200:
        return {'message': 'Product Service unavailable'}

    product = response.json()

    return {
        'message': 'Order created',
        'product': product
    }

Explanation

Python microservices provide several benefits including independent deployment, independent scaling, technology flexibility, smaller codebases, and better team ownership. However, microservices are more complex than a simple monolithic application. Developers need to handle network failures, service discovery, distributed logging, monitoring, authentication, API versioning, data consistency, and deployment. Microservices are most useful when an application or organization has enough complexity to justify the additional operational overhead.

Code:

# Example Microservices Architecture
#
#                  API Gateway
#                       |
#       +---------------+---------------+
#       |               |               |
#  User Service   Product Service   Order Service
#       |               |               |
#   PostgreSQL       PostgreSQL       PostgreSQL
#
# Typical technologies:
# FastAPI       -> REST APIs
# PostgreSQL    -> Database
# Docker        -> Containerization
# Redis         -> Caching
# RabbitMQ/Kafka-> Messaging
# Nginx         -> Reverse Proxy
# Kubernetes    -> Container Orchestration