MONOLITHE                    MICROSERVICES
┌─────────────────┐         ┌──────┐ ┌──────┐ ┌──────┐
│                 │         │ User │ │Order │ │ Pay  │
│  Application    │  ──→    │Service│ │Service│ │Service│
│  Complète       │         └──────┘ └──────┘ └──────┘
│                 │              │       │       │
└─────────────────┘         ┌──────────────────────┐
         │                  │   Database par       │
    ┌─────────┐             │      Service         │
    │Database │             └──────────────────────┘
    └─────────┘

# docker-compose.yml - Scaling indépendant
version: '3.8'
services:
  user-service:
    image: myapp/user-service
    deploy:
      replicas: 2  # Service peu sollicité

  order-service:
    image: myapp/order-service
    deploy:
      replicas: 5  # Service critique avec forte charge

  payment-service:
    image: myapp/payment-service
    deploy:
      replicas: 3  # Service modérément sollicité
    resources:
      limits:
        memory: 512M  # Ressources spécifiques

// User Service - Node.js pour rapidité
// user-service/src/app.js
const express = require('express');
const app = express();

app.get('/users/:id', async (req, res) => {
  const user = await userCache.get(req.params.id);
  res.json(user);
});

// Optimisé pour les lectures rapides
app.listen(3001);

# Analytics Service - Python pour traitement de données
# analytics-service/app.py
from flask import Flask
import pandas as pd
import numpy as np

app = Flask(__name__)

@app.route('/analytics/user-behavior')
def analyze_user_behavior():
    # Traitement complexe de données
    data = pd.read_sql(query, connection)
    analysis = data.groupby('user_id').agg({
        'events': 'count',
        'revenue': 'sum'
    })
    return analysis.to_json()

// Payment Service - Go pour performance
// payment-service/main.go
package main

import (
    "encoding/json"
    "net/http"
    "time"
)

type PaymentRequest struct {
    Amount   float64 `json:"amount"`
    Currency string  `json:"currency"`
    CardToken string `json:"card_token"`
}

func processPayment(w http.ResponseWriter, r *http.Request) {
    var payment PaymentRequest
    json.NewDecoder(r.Body).Decode(&payment)

    // Traitement haute performance
    result := processCreditCard(payment)

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(result)
}

func main() {
    http.HandleFunc("/payment/process", processPayment)
    http.ListenAndServe(":8080", nil)
}

# .github/workflows/deploy-user-service.yml
name: Deploy User Service

on:
  push:
    paths:
      - 'services/user-service/**'
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Build User Service
        run: |
          cd services/user-service
          docker build -t user-service:${{ github.sha }} .

      - name: Deploy to Kubernetes
        run: |
          kubectl set image deployment/user-service \
            user-service=user-service:${{ github.sha }}
          kubectl rollout status deployment/user-service

// order-service/src/services/userService.js
const axios = require('axios');

class UserService {
  async getUser(userId) {
    try {
      const response = await axios.get(`${USER_SERVICE_URL}/users/${userId}`, {
        timeout: 5000,
        headers: {
          'Authorization': `Bearer ${this.getServiceToken()}`,
          'X-Correlation-ID': this.correlationId
        }
      });
      return response.data;
    } catch (error) {
      if (error.code === 'ECONNREFUSED') {
        throw new ServiceUnavailableError('User service is down');
      }
      throw error;
    }
  }

  async validateUser(userId) {
    const user = await this.getUser(userId);
    return user && user.isActive;
  }
}

// order-service/src/events/orderEvents.js
const amqp = require('amqplib');

class OrderEventPublisher {
  constructor() {
    this.connection = null;
    this.channel = null;
  }

  async connect() {
    this.connection = await amqp.connect(process.env.RABBITMQ_URL);
    this.channel = await this.connection.createChannel();

    // Déclaration des échanges
    await this.channel.assertExchange('orders', 'topic', { durable: true });
  }

  async publishOrderCreated(order) {
    const event = {
      eventId: generateUuid(),
      timestamp: new Date().toISOString(),
      type: 'order.created',
      version: '1.0',
      data: {
        orderId: order.id,
        customerId: order.customerId,
        amount: order.total,
        items: order.items
      }
    };

    await this.channel.publish(
      'orders',
      'order.created',
      Buffer.from(JSON.stringify(event)),
      { persistent: true }
    );
  }
}

// inventory-service/src/handlers/orderHandler.js
class OrderHandler {
  async handleOrderCreated(event) {
    const { orderId, items } = event.data;

    try {
      // Réserver le stock
      for (const item of items) {
        await this.inventoryService.reserveStock(item.productId, item.quantity);
      }

      // Confirmer la réservation
      await this.publishStockReserved(orderId, items);

    } catch (error) {
      // Publier un événement d'échec
      await this.publishStockReservationFailed(orderId, error.message);
    }
  }
}

// saga/orderSaga.js
class OrderSaga {
  constructor() {
    this.steps = [];
    this.compensations = [];
  }

  async executeOrder(orderData) {
    try {
      // Étape 1: Créer la commande
      const order = await this.createOrder(orderData);
      this.addCompensation(() => this.cancelOrder(order.id));

      // Étape 2: Réserver le stock
      await this.reserveInventory(order);
      this.addCompensation(() => this.releaseInventory(order));

      // Étape 3: Traiter le paiement
      const payment = await this.processPayment(order);
      this.addCompensation(() => this.refundPayment(payment.id));

      // Étape 4: Confirmer la commande
      await this.confirmOrder(order.id);

      return { success: true, orderId: order.id };

    } catch (error) {
      // Compensation en cas d'échec
      await this.executeCompensations();
      throw error;
    }
  }

  addCompensation(compensationFn) {
    this.compensations.unshift(compensationFn); // LIFO
  }

  async executeCompensations() {
    for (const compensation of this.compensations) {
      try {
        await compensation();
      } catch (error) {
        console.error('Compensation failed:', error);
      }
    }
  }
}

// shared/middleware/tracing.js
const opentracing = require('opentracing');
const jaeger = require('jaeger-client');

// Configuration Jaeger
const config = {
  serviceName: process.env.SERVICE_NAME,
  sampler: {
    type: 'const',
    param: 1,
  },
  reporter: {
    logSpans: true,
    agentHost: process.env.JAEGER_HOST,
    agentPort: process.env.JAEGER_PORT,
  },
};

const tracer = jaeger.initTracer(config);

// Middleware Express pour tracing
function tracingMiddleware(req, res, next) {
  const parentSpanContext = tracer.extract(
    opentracing.FORMAT_HTTP_HEADERS,
    req.headers
  );

  const span = tracer.startSpan(
    `${req.method} ${req.path}`,
    { childOf: parentSpanContext }
  );

  span.setTag('http.method', req.method);
  span.setTag('http.url', req.url);
  span.setTag('user.id', req.user?.id);

  req.span = span;

  res.on('finish', () => {
    span.setTag('http.status_code', res.statusCode);
    if (res.statusCode >= 400) {
      span.setTag('error', true);
    }
    span.finish();
  });

  next();
}

// Service call avec propagation du contexte
async function callUserService(userId, parentSpan) {
  const span = tracer.startSpan('call_user_service', { childOf: parentSpan });

  const headers = {};
  tracer.inject(span, opentracing.FORMAT_HTTP_HEADERS, headers);

  try {
    const response = await axios.get(`/users/${userId}`, { headers });
    span.setTag('user.found', true);
    return response.data;
  } catch (error) {
    span.setTag('error', true);
    span.log({ event: 'error', message: error.message });
    throw error;
  } finally {
    span.finish();
  }
}

// api-gateway/src/gateway.js
const express = require('express');
const httpProxy = require('http-proxy-middleware');
const rateLimit = require('express-rate-limit');
const jwt = require('jsonwebtoken');

const app = express();

// Rate limiting global
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 1000, // Limite par IP
});
app.use(limiter);

// Authentification centralisée
const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];

  if (!token) {
    return res.status(401).json({ error: 'Token manquant' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Token invalide' });
  }
};

// Routes protégées
const protectedRoutes = ['/api/orders', '/api/users/profile'];

app.use(protectedRoutes, authenticate);

// Proxy vers les microservices
const serviceRoutes = {
  '/api/users': 'http://user-service:3001',
  '/api/orders': 'http://order-service:3002',
  '/api/products': 'http://product-service:3003',
  '/api/payments': 'http://payment-service:3004'
};

Object.entries(serviceRoutes).forEach(([route, target]) => {
  app.use(route, httpProxy({
    target,
    changeOrigin: true,
    pathRewrite: {
      [`^${route}`]: '',
    },
    onError: (err, req, res) => {
      res.status(503).json({
        error: 'Service temporairement indisponible',
        service: target
      });
    },
    timeout: 10000,
  }));
});

app.listen(3000, () => {
  console.log('API Gateway running on port 3000');
});

// shared/patterns/circuitBreaker.js
class CircuitBreaker {
  constructor(options = {}) {
    this.failureThreshold = options.failureThreshold || 5;
    this.timeout = options.timeout || 60000; // 1 minute
    this.resetTimeout = options.resetTimeout || 30000; // 30 secondes

    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
    this.failureCount = 0;
    this.lastFailureTime = null;
  }

  async execute(operation) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = 'HALF_OPEN';
        this.failureCount = 0;
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }

    try {
      const result = await Promise.race([
        operation(),
        new Promise((_, reject) => 
          setTimeout(() => reject(new Error('Operation timeout')), this.timeout)
        )
      ]);

      // Succès
      if (this.state === 'HALF_OPEN') {
        this.state = 'CLOSED';
      }
      this.failureCount = 0;

      return result;

    } catch (error) {
      this.failureCount++;
      this.lastFailureTime = Date.now();

      if (this.failureCount >= this.failureThreshold) {
        this.state = 'OPEN';
      }

      throw error;
    }
  }
}

// Usage dans un service
const userServiceBreaker = new CircuitBreaker({
  failureThreshold: 3,
  timeout: 5000,
  resetTimeout: 30000
});

async function getUserWithCircuitBreaker(userId) {
  try {
    return await userServiceBreaker.execute(async () => {
      return await axios.get(`${USER_SERVICE_URL}/users/${userId}`);
    });
  } catch (error) {
    // Fallback ou cache
    return await getUserFromCache(userId);
  }
}

// service-registry/src/registry.js
class ServiceRegistry {
  constructor() {
    this.services = new Map();
    this.healthCheckInterval = 30000; // 30 secondes
    this.startHealthCheck();
  }

  register(serviceName, instance) {
    if (!this.services.has(serviceName)) {
      this.services.set(serviceName, []);
    }

    const service = {
      ...instance,
      registeredAt: new Date(),
      lastHealthCheck: new Date(),
      healthy: true
    };

    this.services.get(serviceName).push(service);
    console.log(`Service ${serviceName} registered:`, instance);
  }

  unregister(serviceName, instanceId) {
    const instances = this.services.get(serviceName);
    if (instances) {
      const filtered = instances.filter(i => i.id !== instanceId);
      this.services.set(serviceName, filtered);
    }
  }

  discover(serviceName) {
    const instances = this.services.get(serviceName);
    if (!instances) return [];

    // Retourner seulement les instances saines
    return instances.filter(instance => instance.healthy);
  }

  async startHealthCheck() {
    setInterval(async () => {
      for (const [serviceName, instances] of this.services) {
        for (const instance of instances) {
          try {
            await axios.get(`${instance.url}/health`, { timeout: 5000 });
            instance.healthy = true;
            instance.lastHealthCheck = new Date();
          } catch (error) {
            instance.healthy = false;
            console.warn(`Health check failed for ${serviceName}:`, instance.id);
          }
        }
      }
    }, this.healthCheckInterval);
  }
}

// Client de découverte de service
class ServiceClient {
  constructor(registry) {
    this.registry = registry;
    this.cache = new Map();
    this.cacheTimeout = 10000; // 10 secondes
  }

  async getService(serviceName) {
    const cached = this.cache.get(serviceName);
    if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
      return cached.instances;
    }

    const instances = this.registry.discover(serviceName);
    this.cache.set(serviceName, {
      instances,
      timestamp: Date.now()
    });

    return instances;
  }

  async callService(serviceName, path, options = {}) {
    const instances = await this.getService(serviceName);

    if (instances.length === 0) {
      throw new Error(`No healthy instances found for ${serviceName}`);
    }

    // Load balancing simple (round-robin)
    const instance = this.selectInstance(instances);

    return await axios({
      url: `${instance.url}${path}`,
      ...options
    });
  }

  selectInstance(instances) {
    // Round-robin simple
    if (!this.roundRobinIndex) this.roundRobinIndex = 0;
    const instance = instances[this.roundRobinIndex % instances.length];
    this.roundRobinIndex++;
    return instance;
  }
}

# k8s/user-service.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myapp/user-service:latest
        ports:
        - containerPort: 3001
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-secret
              key: user-db-url
        - name: REDIS_URL
          value: "redis://redis-service:6379"
        livenessProbe:
          httpGet:
            path: /health
            port: 3001
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3001
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"

---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 3001
    targetPort: 3001
  type: ClusterIP

# istio/virtual-service.yaml
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service-routing
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        version:
          exact: v2
    route:
    - destination:
        host: user-service
        subset: v2
      weight: 100
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 80
    - destination:
        host: user-service
        subset: v2
      weight: 20

---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: user-service-destination
spec:
  host: user-service
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2
  trafficPolicy:
    circuitBreaker:
      consecutiveErrors: 3
      interval: 30s
      baseEjectionTime: 30s

// 1. Intercepter les requêtes
app.use('/api/users', (req, res, next) => {
  // Feature flag pour migration progressive
  if (shouldUseNewService(req.user)) {
    return proxy('http://user-microservice')(req, res, next);
  }
  next(); // Continuer vers l'ancien système
});

// 2. Ancien système (temporaire)
app.use('/api/users', legacyUserRoutes);

// 3. Fonction de décision
function shouldUseNewService(user) {
  // Migration par pourcentage
  if (Math.random() < 0.1) return true; // 10% des utilisateurs

  // Migration par utilisateur test
  if (user && user.isTestUser) return true;

  // Migration par feature flag
  return featureFlags.isEnabled('new-user-service', user);
}