Microservices Fundamentals（微服務基礎）

// Monolith: 所有邏輯在同一個專案
public class OrderService
{
    private readonly OrderDbContext _db;
    private readonly PaymentService _payment;
    private readonly InventoryService _inventory;
    private readonly NotificationService _notification;
 
    public async Task<Order> PlaceOrder(OrderRequest request)
    {
        // 所有操作在同一個 transaction
        using var tx = await _db.Database.BeginTransactionAsync();
        var order = await CreateOrder(request);
        await _payment.Charge(order);       // 直接呼叫
        await _inventory.Reserve(order);    // 直接呼叫
        await _notification.Send(order);    // 直接呼叫
        await tx.CommitAsync();
        return order;
    }
}
 
// Microservices: 每個服務獨立，透過 HTTP/Message Queue 溝通
public class OrderService  // 訂單服務
{
    private readonly HttpClient _paymentClient;
    private readonly IMessageBus _bus;
 
    public async Task<Order> PlaceOrder(OrderRequest request)
    {
        var order = await CreateOrder(request);
        // 透過 HTTP 呼叫支付服務
        await _paymentClient.PostAsJsonAsync("/api/payments", new
        {
            OrderId = order.Id,
            Amount = order.Total
        });
        // 透過 Message Queue 通知庫存和通知服務
        await _bus.PublishAsync(new OrderPlacedEvent(order.Id));
        return order;
    }
}

// Monolith: Express app 包含所有 routes
const app = express();
app.use("/api/orders", orderRoutes);
app.use("/api/payments", paymentRoutes);
app.use("/api/inventory", inventoryRoutes);
// 全部跑在同一個 process
 
// Microservices: 每個服務是獨立的 Express app
// order-service/index.ts
const orderApp = express();
orderApp.post("/api/orders", async (req, res) => {
  const order = await createOrder(req.body);
  // 發送事件通知其他服務
  await messageBus.publish("order.placed", {
    orderId: order.id,
    items: order.items,
  });
  res.json(order);
});
orderApp.listen(3001);
 
// payment-service/index.ts（獨立 process）
const paymentApp = express();
messageBus.subscribe("order.placed", async (event) => {
  await processPayment(event.orderId);
});
paymentApp.listen(3002);

# Monolith: Django 或 Flask 的所有模組在一起
# 優點：簡單、一個 DB transaction 搞定
class OrderView:
    def post(self, request):
        with transaction.atomic():
            order = Order.objects.create(**request.data)
            Payment.objects.charge(order)
            Inventory.objects.reserve(order)
            Notification.objects.send(order)
        return Response(order)
 
# Microservices: 每個服務獨立部署
# order_service/main.py
from fastapi import FastAPI
import httpx
import aio_pika
 
app = FastAPI()
 
@app.post("/api/orders")
async def place_order(request: OrderRequest):
    order = await create_order(request)
    # HTTP 呼叫支付服務
    async with httpx.AsyncClient() as client:
        await client.post(
            "http://payment-service/api/payments",
            json={"order_id": order.id, "amount": order.total}
        )
    # 發布事件
    await publish_event("order.placed", {"order_id": order.id})
    return order