CI/CD, Docker & Kubernetes — Déploiement Spring Boot en Production

Docker multi-stage, images optimisées, pipelines CI/CD, health checks, readiness, autoscaling, configuration sécurisée, observabilité et bonnes pratiques de déploiement en production.

Introduction

Déployer une application Spring Boot en production implique de maîtriser plusieurs briques : containerisation, pipelines CI/CD, Kubernetes, résilience et observabilité.

Ce chapitre vous guide dans la conception d’un déploiement robuste, sécurisé, performant et industrialisé avec Docker, GitHub Actions/GitLab CI, Kubernetes, readiness/liveness probes, scaling horizontal et bonnes pratiques de production.

Lexique essentiel

Multi-stage build
Technique Docker qui produit des images minimalistes.

Readiness Probe
Vérifie si l’application est prête à recevoir du trafic.

Liveness Probe
Vérifie si l’application est vivante (redémarrage automatique).

HPA
Horizontal Pod Autoscaler : scaling dynamique.

ConfigMap / Secret
Configuration externalisée et sécurisée dans Kubernetes.

Rolling Update
Déploiement progressif sans downtime.

1. Docker — Image optimisée (multi-stage)

Construire une image Docker Spring Boot nécessite un build multi-stage pour obtenir une image minimale, rapide à démarrer et sécurisée.

Dockerfile optimisé


# Stage 1 : Build
FROM maven:3.9.6-eclipse-temurin-21 AS build
WORKDIR /app
COPY . .
RUN mvn -B -DskipTests clean package

# Stage 2 : Runtime minimal
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=build /app/target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Bonnes pratiques Docker :

Images JRE allégées (Temurin Alpine).
Aucun outil inutile dans l’image finale.
Ne jamais copier le repo git ou les tests.
Scanner l’image avec Trivy ou Snyk.

2. CI/CD — Pipeline complet (GitHub Actions ou GitLab)

Une pipeline CI/CD doit automatiser l’intégralité du cycle : build, tests, analyse, image Docker, push registry puis déploiement Kubernetes.

Pipeline GitHub Actions minimal


name: CI-CD

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3

    - name: JDK 21
      uses: actions/setup-java@v3
      with:
        java-version: '21'

    - name: Build
      run: mvn -B -DskipTests package

    - name: Docker Build
      run: docker build -t registry/app:latest .

    - name: Push Image
      run: docker push registry/app:latest

Ajoutez ensuite un job pour déployer automatiquement sur Kubernetes.

3. Kubernetes — Déploiement professionnel

Deployment.yaml


apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-app
  template:
    metadata:
      labels:
        app: spring-app
    spec:
      containers:
        - name: app
          image: registry/app:latest
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
          envFrom:
            - configMapRef:
                name: app-config
            - secretRef:
                name: app-secret

Service.yaml


apiVersion: v1
kind: Service
metadata:
  name: spring-app
spec:
  type: ClusterIP
  selector:
    app: spring-app
  ports:
    - port: 80
      targetPort: 8080

Bonnes pratiques Kubernetes :

Readiness probe obligatoire avant routage.
Liveness probe pour auto-healing.
autoscaling → HPA via CPU/RAM ou métriques personnalisées.
Image immutable : tag précis (pas latest).

4. Autoscaling & résilience

Horizontal Pod Autoscaler (HPA)


apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: spring-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: spring-app
  minReplicas: 3
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

Le scaling automatique garantit performance & résilience face aux pics de charge.

5. Configuration & sécurité

ConfigMap (config non sensible)


apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  SPRING_PROFILES_ACTIVE: prod

Secret (valeurs sensibles)


apiVersion: v1
kind: Secret
metadata:
  name: app-secret
type: Opaque
data:
  DB_PASSWORD: cGFzc3dvcmQ=

Encodage Base64 obligatoire (non sécurisé → utiliser Vault en prod).

6. Observabilité & monitoring

Impossible d’exploiter un cluster sans observabilité :

Spring Boot Actuator
Micrometer + Prometheus
Grafana dashboards
Logs JSON structurés (ELK, Loki)
Traces distribuées (OpenTelemetry)

Actuator


management.endpoints.web.exposure.include=health,metrics,info,prometheus

Quiz : CI/CD & Déploiement Spring Boot

Q1. Quel élément permet d’éviter les downtime ?
- A. Delete + recreate
- B. Rolling Update ✔
- C. CronJob
Q2. Quelle sonde vérifie que l’app doit être redémarrée ?
- A. Readiness
- B. Liveness ✔
- C. HealthCheck SQL

Exercice d’application

Construisez un pipeline complet :
— Docker multi-stage
— Build + tests automatisés
— Image publiée dans un registry
— Deployment + Service + HPA
— Readiness & Liveness
— Dashboard Grafana personnalisé

Résumé

Docker, CI/CD et Kubernetes constituent la chaîne de production moderne. Grâce à un pipeline fiable, des images optimisées, un déploiement Kubernetes structuré, une observabilité complète et un autoscaling intelligent, vous obtenez une plateforme résiliente, performante et prête pour les environnements critiques.

Navigation de la Formation

Performance & Cache → Formation Kafka →