Kubernetes

Orchestration de conteneurs avec Kubernetes — pods, services, deployments, mise à l'échelle automatique et health checks.

Qu’est-ce que Kubernetes ?

Kubernetes (K8s) est une plateforme d’orchestration de conteneurs qui automatise le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Créé par Google, il constitue aujourd’hui le standard de facto pour exécuter des workloads en production.

Kubernetes résout des problèmes que Docker seul ne peut pas gérer à grande échelle :

• Comment répartir mes conteneurs sur plusieurs machines ?
• Comment monter automatiquement en charge lorsque le trafic augmente ?
• Que se passe-t-il si un conteneur échoue — qui le redémarre ?
• Comment réaliser des rolling updates sans downtime ?

Concepts fondamentaux

Pod

Un Pod est l’unité de déploiement minimale dans Kubernetes. Il contient un ou plusieurs conteneurs qui partagent le réseau et le stockage. En pratique, la plupart des pods n’ont qu’un seul conteneur.

apiVersion: v1
kind: Pod
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  containers:
    - name: my-app
      image: my-app:1.0.0
      ports:
        - containerPort: 3000

Service

Un Service expose un ensemble de pods comme un service réseau stable. Les pods sont éphémères (ils peuvent mourir et être recréés), mais le Service conserve une IP et un DNS fixes.

Types de Service :

• ClusterIP (par défaut) : accessible uniquement à l’intérieur du cluster
• NodePort : expose le service sur un port de chaque nœud
• LoadBalancer : crée un répartiteur de charge externe (chez les cloud providers)

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 3000
  type: ClusterIP

Deployment

Un Deployment gère le cycle de vie des pods : combien de réplicas exécuter, comment les mettre à jour et comment effectuer un rollback si quelque chose échoue.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: my-app:1.0.0
          ports:
            - containerPort: 3000
          resources:
            requests:
              memory: "128Mi"
              cpu: "250m"
            limits:
              memory: "256Mi"
              cpu: "500m"

Health checks

Kubernetes utilise des probes pour vérifier l’état des conteneurs :

Liveness probe

Vérifie si le conteneur est vivant. En cas d’échec, Kubernetes redémarre le conteneur.

livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 10
  periodSeconds: 15
  failureThreshold: 3

Readiness probe

Vérifie si le conteneur est prêt à recevoir du trafic. En cas d’échec, Kubernetes cesse de lui envoyer des requests (mais ne le redémarre pas).

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 5
  periodSeconds: 10

Startup probe

Pour les applications dont le démarrage est lent. Tant que le startup probe n’est pas validé, les autres probes ne s’exécutent pas.

startupProbe:
  httpGet:
    path: /health
    port: 3000
  failureThreshold: 30
  periodSeconds: 5

Mise à l’échelle

Mise à l’échelle manuelle

kubectl scale deployment my-app --replicas=5

Horizontal Pod Autoscaler (HPA)

Ajuste automatiquement le nombre de pods en fonction de métriques comme le CPU ou la mémoire :

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

ConfigMaps et Secrets

ConfigMap

Pour la configuration non sensible :

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-config
data:
  LOG_LEVEL: "info"
  API_TIMEOUT: "30s"

Secret

Pour les données sensibles (encodées en base64) :

apiVersion: v1
kind: Secret
metadata:
  name: my-app-secrets
type: Opaque
data:
  DATABASE_PASSWORD: cGFzc3dvcmQxMjM=

Namespaces

Les namespaces permettent de diviser un cluster en environnements logiques isolés :

kubectl create namespace staging
kubectl create namespace production

Chaque namespace peut avoir ses propres ressources, limites et politiques d’accès.

Résumé

Kubernetes est la plateforme standard pour orchestrer des conteneurs en production. Ses abstractions clés — Pods, Services, Deployments — combinées aux health checks, à l’auto-scaling et à la gestion de la configuration, fournissent tout le nécessaire pour exécuter des applications distribuées de manière fiable et scalable.