名称: 微服务模式描述: 设计微服务架构，包括服务边界、事件驱动通信和弹性模式。用于构建分布式系统、分解单体应用或实施微服务。

微服务模式

掌握微服务架构模式，包括服务边界、服务间通信、数据管理和弹性模式，用于构建分布式系统。

何时使用此技能

分解单体应用到微服务
设计服务边界和合同
实施服务间通信
管理分布式数据和事务
构建弹性分布式系统
实施服务发现和负载均衡
设计事件驱动架构

核心概念

1. 服务分解策略

按业务能力分解

围绕业务功能组织服务
每个服务拥有其域
示例：订单服务、支付服务、库存服务

按子域分解（DDD）

核心域、支持子域
有界上下文映射到服务
清晰的拥有和责任

绞杀者模式

从单体逐步提取
新功能作为微服务
代理路由到旧/新系统

参见详细指南：服务分解

2. 通信模式

同步（请求/响应）

REST API
gRPC
GraphQL

异步（事件/消息）

事件流（Kafka）
消息队列（RabbitMQ, SQS）
发布/订阅模式

参见详细模式：通信模式

3. 数据管理

每个服务独立数据库

每个服务拥有其数据
无共享数据库
松耦合

Saga模式

分布式事务
补偿操作
最终一致性

参见详细模式：数据管理

4. 弹性模式

断路器

在重复错误上快速失败
防止级联故障

退避重试

瞬态故障处理
指数退避

舱壁隔离

隔离资源
限制故障影响

参见详细实现：弹性模式

快速入门

基本服务结构

from fastapi import FastAPI

app = FastAPI()

class OrderService:
    """处理订单生命周期。"""

    async def create_order(self, order_data: dict) -> Order:
        order = Order.create(order_data)

        # 为其他服务发布事件
        await self.event_bus.publish(
            OrderCreatedEvent(
                order_id=order.id,
                customer_id=order.customer_id,
                items=order.items,
                total=order.total
            )
        )

        return order

@app.post("/orders")
async def create_order(order_data: dict):
    service = OrderService()
    return await service.create_order(order_data)

API网关模式

class APIGateway:
    """所有客户端请求的中央入口点。"""

    async def call_order_service(self, path: str, method: str = "GET", **kwargs):
        response = await self.http_client.request(
            method,
            f"{self.order_service_url}{path}",
            **kwargs
        )
        return response.json()

    async def create_order_aggregate(self, order_id: str) -> dict:
        """从多个服务聚合数据。"""
        order, payment, inventory = await asyncio.gather(
            self.call_order_service(f"/orders/{order_id}"),
            self.call_payment_service(f"/payments/order/{order_id}"),
            self.call_inventory_service(f"/reservations/order/{order_id}"),
            return_exceptions=True
        )

        return {"order": order, "payment": payment, "inventory": inventory}

参见详细模式：API网关

服务分解模式

使用业务能力和DDD原则将单体分解为微服务。

参见详细指南：服务分解

通信模式

同步通信

带重试逻辑和超时的REST API。

from tenacity import retry, stop_after_attempt, wait_exponential

class ServiceClient:
    @retry(
        stop=stop_after_attempt(3),
        wait=wait_exponential(multiplier=1, min=2, max=10)
    )
    async def get(self, path: str, **kwargs):
        response = await self.client.get(f"{self.base_url}{path}", **kwargs)
        response.raise_for_status()
        return response.json()

参见详细模式：通信模式

异步事件驱动

使用Kafka的事件总线实现解耦通信。

async def publish_event(event: DomainEvent):
    await event_bus.publish(event)

async def subscribe_to_events(topic: str, handler: callable):
    await event_bus.subscribe(topic, handler)

参见详细实现：事件驱动架构

数据管理模式

Saga模式

通过补偿操作管理分布式事务。

class OrderFulfillmentSaga:
    """订单履行的编排式Saga。"""

    async def execute(self, order_data: dict) -> SagaResult:
        try:
            for step in self.steps:
                result = await step.action(context)
                if not result.success:
                    await self.compensate(completed_steps, context)
                    return SagaResult(status=SagaStatus.FAILED)

                completed_steps.append(step)

            return SagaResult(status=SagaStatus.COMPLETED)
        except Exception:
            await self.compensate(completed_steps, context)

参见详细实现：Saga模式

弹性模式

断路器

通过快速失败防止级联故障。

class CircuitBreaker:
    async def call(self, func: Callable, *args, **kwargs) -> Any:
        if self.state == CircuitState.OPEN:
            raise CircuitBreakerOpenError("断路器已打开")

        try:
            result = await func(*args, **kwargs)
            self._on_success()
            return result
        except Exception:
            self._on_failure()
            raise