Orchestration avec Kubernetes

Kubernetes est la solution standard pour l’orchestration des conteneurs. Nous allons voir comment déployer et gérer nos microservices sur un cluster Kubernetes.

1. Configuration de Base

1.1 Déploiement des Services

# product-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      containers:
      - name: product-service
        image: product-service:latest
        ports:
        - containerPort: 8081
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "prod"
        - name: EUREKA_CLIENT_SERVICEURL_DEFAULTZONE
          value: "http://eureka-server:8761/eureka/"
        - name: SPRING_CLOUD_CONFIG_URI
          value: "http://config-server:8888"
        resources:
          requests:
            memory: "512Mi"
            cpu: "200m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8081
          initialDelaySeconds: 30
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8081
          initialDelaySeconds: 60
          periodSeconds: 20

1.2 Services Kubernetes

# product-service-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  selector:
    app: product-service
  ports:
  - port: 8081
    targetPort: 8081
  type: ClusterIP

2. Configuration des ConfigMaps et Secrets

2.1 ConfigMap

# application-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: application-config
data:
  application.yml: |
    spring:
      application:
        name: product-service
      cloud:
        config:
          uri: http://config-server:8888
    eureka:
      client:
        service-url:
          defaultZone: http://eureka-server:8761/eureka/

2.2 Secret

# database-secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: database-secret
type: Opaque
data:
  DB_USERNAME: cHJvZHVjdF91c2Vy  # product_user en base64
  DB_PASSWORD: cHJvZHVjdF9wYXNzd29yZA==  # product_password en base64

3. Ingress et Load Balancing

3.1 Ingress Controller

# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: microservices-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /products
        pathType: Prefix
        backend:
          service:
            name: product-service
            port:
              number: 8081
      - path: /orders
        pathType: Prefix
        backend:
          service:
            name: order-service
            port:
              number: 8082

4. Gestion des Volumes

4.1 PersistentVolume

# postgres-pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: postgres-pv
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/data/postgres"

4.2 PersistentVolumeClaim

# postgres-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi

5. Monitoring et Logging

5.1 Prometheus Configuration

# prometheus-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    scrape_configs:
      - job_name: 'spring-actuator'
        metrics_path: '/actuator/prometheus'
        static_configs:
          - targets: ['product-service:8081', 'order-service:8082']

5.2 Grafana Dashboard

# grafana-dashboard.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: grafana-dashboard
data:
  microservices-dashboard.json: |
    {
      "dashboard": {
        "title": "Microservices Dashboard",
        "panels": [
          {
            "title": "Request Rate",
            "type": "graph",
            "datasource": "Prometheus",
            "targets": [
              {
                "expr": "rate(http_requests_total[5m])",
                "legendFormat": "{{service}}"
              }
            ]
          }
        ]
      }
    }

6. Auto-scaling

6.1 HorizontalPodAutoscaler

# product-service-hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: product-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: product-service
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

7. Tests

7.1 Test d’Intégration Kubernetes

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class KubernetesIntegrationTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void whenGetProduct_thenProductIsReturned() {
        ResponseEntity<Product> response = restTemplate.getForEntity(
            "/api/products/1", Product.class);
        assertEquals(HttpStatus.OK, response.getStatusCode());
        assertNotNull(response.getBody());
    }
}

7.2 Test de Charge

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class KubernetesLoadTest {
    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void whenHighLoad_thenAutoScalingWorks() {
        ExecutorService executor = Executors.newFixedThreadPool(50);
        List<Future<ResponseEntity<Product>>> futures = new ArrayList<>();

        for (int i = 0; i < 1000; i++) {
            futures.add(executor.submit(() ->
                restTemplate.getForEntity("/api/products/1", Product.class)));
        }

        int successCount = 0;
        for (Future<ResponseEntity<Product>> future : futures) {
            try {
                if (future.get().getStatusCode() == HttpStatus.OK) {
                    successCount++;
                }
            } catch (Exception e) {
                fail("Request failed: " + e.getMessage());
            }
        }

        assertTrue(successCount > 950); // 95% de succès minimum
        executor.shutdown();
    }
}

Conclusion

L’orchestration avec Kubernetes offre plusieurs avantages :

• Gestion automatique des conteneurs
• Auto-scaling basé sur la charge
• Haute disponibilité et résilience
• Gestion centralisée des configurations
• Monitoring et logging avancés
• Déploiement sans interruption

Cette série de tutoriels vous a permis de maîtriser les concepts essentiels des microservices avec Spring Cloud. Vous êtes maintenant prêt à développer et déployer vos propres applications microservices.