Framework Comparison

Have you found it difficult to choose a Python Web framework? I also hesitated between FastAPI, Flask, and Django. After working on multiple projects, I discovered that each framework has its unique advantages. Let's analyze them in depth.

FastAPI has become one of the most popular Python Web frameworks in recent years. Its asynchronous features and type hint support really impressed me. Take a look at this code and you'll understand why:

from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {"user_id": user_id, "name": "John Doe"}

This simple example demonstrates the elegance of FastAPI. Type hints not only provide automatic documentation generation but also help us catch issues early during development. Have you noticed how its route definition is more intuitive than Flask?

Communication Methods

In microservice architecture, service-to-service communication is a key topic. We typically have two main choices: REST API and message queues.

Let's start with REST API, which has a straightforward implementation:

import requests

def call_user_service(user_id):
    response = requests.get(f"http://user-service/users/{user_id}")
    return response.json()

However, in real projects, I found that relying solely on REST API isn't enough. Message queues become particularly important when handling asynchronous tasks. Here's an example using RabbitMQ:

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

def publish_message(message):
    channel.basic_publish(exchange='',
                         routing_key='task_queue',
                         body=message)

Service Governance

Speaking of service governance, do you know what's most important? I believe it's service registration and discovery. Using Consul is perfect for implementing this functionality:

import consul

c = consul.Consul()


c.agent.service.register(
    "user-service",
    port=8080,
    tags=['python', 'web']
)

Configuration management is also a significant challenge. I recommend using environment variables to manage configurations, making it easy to separate development and production environments:

import os
from dotenv import load_dotenv

load_dotenv()

DATABASE_URL = os.getenv("DATABASE_URL")
API_KEY = os.getenv("API_KEY")

Observability

Observability is particularly important in microservice architecture. We need the three pillars: monitoring, logging, and tracing.

For monitoring, Prometheus is a great choice:

from prometheus_client import Counter, start_http_server

request_count = Counter('request_count', 'Number of requests received')

@app.get("/")
def handle_request():
    request_count.inc()
    return {"status": "ok"}

As for logging, I suggest using Python's standard library logging:

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

logger.info("Service started")
logger.error("Database connection failed")

Testing Strategy

How do you think microservice testing should be done? My suggestion is to perform both unit tests and integration tests.

Unit tests focus on business logic:

import pytest
from app.services import UserService

def test_get_user():
    service = UserService()
    user = service.get_user(1)
    assert user["name"] == "John Doe"

Integration tests ensure the entire service functions properly:

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_user():
    response = client.get("/users/1")
    assert response.status_code == 200
    assert response.json()["name"] == "John Doe"

These are some experiences I've accumulated in Python microservice development. Which of these practices do you think would best suit your project? Or do you have any other good ideas?