Приведи пример использования микросервисной архитектуры

Микросервисная архитектура: практический пример

Микросервисная архитектура предполагает разделение приложения на независимые, слабо связанные сервисы, каждый из которых решает свою бизнес-задачу. Покажу реальный пример e-commerce системы.

Архитектура системы

Представьте платформу покупок с 4 основными микросервисами:

1. Users Service — управление профилями и авторизацией
2. Products Service — каталог товаров
3. Orders Service — обработка заказов
4. Payments Service — обработка платежей

Как они взаимодействуют

// Users Service: @/services/users/api.ts
export const userRouter = Router();

userRouter.post("/register", async (req, res) => {
  const { email, password } = req.body;
  const user = await db.users.create({ email, password });
  
  // Публикуем событие в RabbitMQ
  await queue.publish("user.registered", { userId: user.id });
  
  res.json({ userId: user.id });
});

// Products Service: @/services/products/api.ts
export const productsRouter = Router();

productsRouter.get("/products/:id", async (req, res) => {
  const product = await db.products.findOne({ id: req.params.id });
  res.json(product);
});

// Orders Service: @/services/orders/api.ts
export const ordersRouter = Router();

ordersRouter.post("/orders", async (req, res) => {
  const { userId, items } = req.body;
  
  // 1. Валидируем товары через HTTP запрос к Products Service
  const products = await fetch(
    "http://products-service:3002/products/validate",
    { 
      method: "POST",
      body: JSON.stringify(items)
    }
  ).then(r => r.json());
  
  // 2. Создаем заказ
  const order = await db.orders.create({
    userId,
    items,
    status: "pending"
  });
  
  // 3. Публикуем событие для сервиса платежей
  await queue.publish("order.created", { 
    orderId: order.id,
    totalPrice: order.totalPrice
  });
  
  res.json({ orderId: order.id });
});

// Payments Service: @/services/payments/consumer.ts
// Слушает событие order.created
queue.subscribe("order.created", async (message) => {
  const { orderId, totalPrice } = message;
  
  try {
    // Обращаемся к платежной системе
    const payment = await stripe.charges.create({
      amount: totalPrice,
      currency: "usd"
    });
    
    // Публикуем успех платежа
    await queue.publish("payment.succeeded", {
      orderId,
      paymentId: payment.id
    });
  } catch (error) {
    // Публикуем ошибку платежа
    await queue.publish("payment.failed", { orderId });
  }
});

Развертывание с Docker Compose

version: "3.8"

services:
  users-service:
    build: ./services/users
    ports: ["3001:3001"]
    depends_on:
      - postgres
      - rabbitmq

  products-service:
    build: ./services/products
    ports: ["3002:3002"]
    depends_on:
      - postgres
      - rabbitmq

  orders-service:
    build: ./services/orders
    ports: ["3003:3003"]
    depends_on:
      - postgres
      - rabbitmq

  payments-service:
    build: ./services/payments
    ports: ["3004:3004"]
    depends_on:
      - rabbitmq

  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: ecommerce

  rabbitmq:
    image: rabbitmq:3.12-management
    ports: ["5672:5672", "15672:15672"]

  api-gateway:
    build: ./gateway
    ports: ["8000:8000"]
    depends_on:
      - users-service
      - products-service
      - orders-service

API Gateway для маршрутизации

// @/gateway/index.ts
import express from "express";

const app = express();

app.use("/api/users", httpProxy.createProxyMiddleware({
  target: "http://users-service:3001",
  changeOrigin: true,
}));

app.use("/api/products", httpProxy.createProxyMiddleware({
  target: "http://products-service:3002",
  changeOrigin: true,
}));

app.use("/api/orders", httpProxy.createProxyMiddleware({
  target: "http://orders-service:3003",
  changeOrigin: true,
}));

app.listen(8000);

Ключевые преимущества этого подхода

• Независимость: каждый сервис может быть развернут отдельно
• Масштабируемость: можем масштабировать только Payments Service если нужно
• Отказоустойчивость: падение одного сервиса не сломает весь system
• Технологическая гибкость: каждый микросервис может использовать свой stack (Node.js, Go, Python)