Microservices

// 마이크로서비스 예제 - 상품 서비스 (Product Service)
const express = require('express');
const axios = require('axios');
const { v4: uuidv4 } = require('uuid');

const app = express();
app.use(express.json());

// 서비스 레지스트리 (실제로는 Consul, Eureka 등 사용)
const SERVICE_REGISTRY = {
    inventory: 'http://inventory-service:8004',
    pricing: 'http://pricing-service:8005'
};

// 인메모리 데이터 (실제로는 각 서비스별 DB 사용)
const products = new Map();

/**
 * 상품 등록 API
 */
app.post('/products', async (req, res) => {
    try {
        const { name, description, category, basePrice } = req.body;

        const product = {
            id: uuidv4(),
            name,
            description,
            category,
            basePrice,
            createdAt: new Date().toISOString()
        };

        products.set(product.id, product);

        // 이벤트 발행 (다른 서비스에 알림)
        await publishEvent('product.created', product);

        res.status(201).json(product);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

/**
 * 상품 조회 API - 여러 서비스 데이터 조합
 */
app.get('/products/:id', async (req, res) => {
    try {
        const product = products.get(req.params.id);
        if (!product) {
            return res.status(404).json({ error: 'Product not found' });
        }

        // 여러 서비스에서 데이터 병렬 조회 (API Composition)
        const [inventory, pricing] = await Promise.all([
            callService(`${SERVICE_REGISTRY.inventory}/stock/${product.id}`),
            callService(`${SERVICE_REGISTRY.pricing}/price/${product.id}`)
        ]);

        // 데이터 조합하여 반환
        res.json({
            ...product,
            stock: inventory?.quantity || 0,
            price: pricing?.currentPrice || product.basePrice,
            discount: pricing?.discount || 0
        });
    } catch (error) {
        // Fallback: 기본 상품 정보만 반환
        const product = products.get(req.params.id);
        res.json({ ...product, stock: 'unavailable', price: product?.basePrice });
    }
});

/**
 * 서비스 간 HTTP 통신 (타임아웃 및 재시도 포함)
 */
async function callService(url, options = {}) {
    const { retries = 3, timeout = 3000 } = options;

    for (let i = 0; i < retries; i++) {
        try {
            const response = await axios.get(url, { timeout });
            return response.data;
        } catch (error) {
            if (i === retries - 1) throw error;
            // 지수 백오프 (Exponential Backoff)
            await new Promise(r => setTimeout(r, Math.pow(2, i) * 100));
        }
    }
}

/**
 * 이벤트 발행 (메시지 큐로 전송)
 */
async function publishEvent(eventType, data) {
    // 실제로는 Kafka, RabbitMQ 등 사용
    console.log(`[Event Published] ${eventType}:`, data);
    // await kafkaProducer.send({ topic: eventType, messages: [{ value: JSON.stringify(data) }] });
}

/**
 * 헬스 체크 엔드포인트
 */
app.get('/health', (req, res) => {
    res.json({
        status: 'healthy',
        service: 'product-service',
        timestamp: new Date().toISOString(),
        uptime: process.uptime()
    });
});

/**
 * Readiness 체크 (의존 서비스 확인)
 */
app.get('/ready', async (req, res) => {
    try {
        // 의존 서비스 헬스 체크
        await Promise.all([
            axios.get(`${SERVICE_REGISTRY.inventory}/health`, { timeout: 1000 }),
            axios.get(`${SERVICE_REGISTRY.pricing}/health`, { timeout: 1000 })
        ]);
        res.json({ status: 'ready' });
    } catch (error) {
        res.status(503).json({ status: 'not ready', error: error.message });
    }
});

const PORT = process.env.PORT || 8002;
app.listen(PORT, () => {
    console.log(`Product Service running on port ${PORT}`);
});

┌─────────────────────────────────────────────────────────────────────────┐
│                        Microservices Architecture                        │
└─────────────────────────────────────────────────────────────────────────┘

                              ┌─────────────┐
                              │   Client    │
                              │  (Web/App)  │
                              └──────┬──────┘
                                     │
                              ┌──────▼──────┐
                              │ API Gateway │  ← 인증, 라우팅, 속도제한
                              │ (Kong/Zuul) │
                              └──────┬──────┘
                                     │
           ┌─────────────────────────┼─────────────────────────┐
           │                         │                         │
    ┌──────▼──────┐          ┌──────▼──────┐          ┌──────▼──────┐
    │   User      │          │   Order     │          │  Product    │
    │  Service    │◄────────►│  Service    │◄────────►│  Service    │
    └──────┬──────┘   REST   └──────┬──────┘   REST   └──────┬──────┘
           │                        │                         │
    ┌──────▼──────┐          ┌──────▼──────┐          ┌──────▼──────┐
    │  User DB    │          │  Order DB   │          │ Product DB  │
    │ (PostgreSQL)│          │ (PostgreSQL)│          │  (MongoDB)  │
    └─────────────┘          └─────────────┘          └─────────────┘
                                    │
                                    │ Events (Kafka)
                                    ▼
           ┌─────────────────────────────────────────────────────┐
           │                   Message Queue                      │
           │                  (Apache Kafka)                      │
           └──────────┬────────────────────────────┬─────────────┘
                      │                            │
               ┌──────▼──────┐              ┌──────▼──────┐
               │  Payment    │              │ Notification│
               │  Service    │              │   Service   │
               └──────┬──────┘              └──────┬──────┘
                      │                            │
               ┌──────▼──────┐              ┌──────▼──────┐
               │ Payment DB  │              │   Redis     │
               └─────────────┘              │  (Cache)    │
                                            └─────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│ Infrastructure Layer                                                     │
├─────────────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │ Kubernetes  │  │   Istio     │  │ Prometheus  │  │   Jaeger    │    │
│  │ (Container  │  │  (Service   │  │ (Metrics)   │  │ (Tracing)   │    │
│  │  Orchestr.) │  │   Mesh)     │  │             │  │             │    │
│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────────────────────┘

핵심 패턴:
• API Gateway: 단일 진입점, 횡단 관심사 처리
• Database per Service: 서비스별 독립 데이터베이스
• Event-Driven: 비동기 통신으로 느슨한 결합
• Circuit Breaker: 장애 전파 방지
• Service Discovery: 동적 서비스 위치 탐색
• Distributed Tracing: 요청 흐름 추적