Comment Monitorer la Liveness et Readiness des Pods Kubernetes

Les probes Kubernetes sont essentielles pour maintenir des applications saines. Les probes liveness redémarrent les pods unhealthy, tandis que les probes readiness contrôlent le routage du trafic. Voici comment les configurer correctement.

Comprendre les Probes Kubernetes

Trois Types de Probes

Probe	Objectif	Action en cas d'échec
Liveness	Le conteneur est-il vivant ?	Redémarrer le conteneur
Readiness	Peut-il gérer le trafic ?	Retirer du service
Startup	A-t-il démarré ?	Bloquer les autres probes

Quand Utiliser Chacune

Liveness : Détecter les deadlocks, boucles infinies, processus bloqués
Readiness : Attendre les dépendances, gérer la dégradation gracieuse
Startup : Permettre aux applications lentes de s'initialiser

Configurer les Probes Liveness

Probe Liveness HTTP

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: app
    image: my-app:latest
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 15
      periodSeconds: 10
      timeoutSeconds: 5
      failureThreshold: 3
      successThreshold: 1

Probe Liveness TCP

Pour les services sans endpoints HTTP :

livenessProbe:
  tcpSocket:
    port: 3306
  initialDelaySeconds: 30
  periodSeconds: 10

Probe Liveness par Commande

Pour des health checks personnalisés :

livenessProbe:
  exec:
    command:
    - cat
    - /tmp/healthy
  initialDelaySeconds: 5
  periodSeconds: 5

Configurer les Probes Readiness

Probe Readiness HTTP

readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5
  timeoutSeconds: 3
  failureThreshold: 3

Endpoints Différents pour Probes Différentes

spec:
  containers:
  - name: app
    ports:
    - containerPort: 8080
    livenessProbe:
      httpGet:
        path: /healthz  # Vérification basique de vie
        port: 8080
    readinessProbe:
      httpGet:
        path: /ready    # Vérification complète des dépendances
        port: 8080

Probes Startup pour Applications Lentes

startupProbe:
  httpGet:
    path: /healthz
    port: 8080
  failureThreshold: 30
  periodSeconds: 10
  # Permet jusqu'à 5 minutes (30 * 10s) pour le démarrage

Implémenter les Endpoints de Santé

Endpoint Liveness (Simple)

// Go
func livenessHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("OK"))
}

Endpoint Readiness (Avec Vérification des Dépendances)

func readinessHandler(w http.ResponseWriter, r *http.Request) {
    // Vérifier la connexion base de données
    if err := db.Ping(); err != nil {
        w.WriteHeader(http.StatusServiceUnavailable)
        return
    }

    // Vérifier la connexion Redis
    if err := redis.Ping().Err(); err != nil {
        w.WriteHeader(http.StatusServiceUnavailable)
        return
    }

    w.WriteHeader(http.StatusOK)
}

Exemple Python Flask

from flask import Flask
import psycopg2

app = Flask(__name__)

@app.route('/healthz')
def liveness():
    return 'OK', 200

@app.route('/ready')
def readiness():
    try:
        conn = psycopg2.connect(DATABASE_URL)
        conn.close()
        return 'Ready', 200
    except:
        return 'Not Ready', 503

Paramètres des Probes Expliqués

Paramètre	Description	Recommandé
`initialDelaySeconds`	Attente avant première probe	Temps de démarrage app
`periodSeconds`	Temps entre les probes	10s
`timeoutSeconds`	Durée max de la probe	3-5s
`successThreshold`	Succès pour être healthy	1
`failureThreshold`	Échecs pour être unhealthy	3

Erreurs Courantes à Éviter

1. Probes Trop Agressives

# MAUVAIS : Tuera les pods pendant les pics de charge normaux
livenessProbe:
  timeoutSeconds: 1
  failureThreshold: 1
  periodSeconds: 1

2. Vérifier les Dépendances Externes dans Liveness

// MAUVAIS : Ne pas vérifier les services externes dans liveness
func livenessHandler(w http.ResponseWriter, r *http.Request) {
    if err := externalAPI.Ping(); err != nil {
        w.WriteHeader(503)  // Cela va redémarrer le pod !
        return
    }
}

3. Même Endpoint pour les Deux Probes

L'endpoint liveness devrait être plus simple que readiness.

Monitoring Externe

Monitorer les Services Kubernetes

En plus des probes, monitorez vos services exposés :

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080

Configurez le monitoring externe pour :

Endpoint load balancer
Endpoints ingress
Routes API critiques

Checklist Configuration des Probes

Probe liveness configurée
Probe readiness configurée
Probe startup pour apps lentes
Timeouts appropriés définis
Seuils d'échec ajustés
Endpoints de santé implémentés
Dépendances externes absentes de liveness
Monitoring externe configuré
Alerting configuré pour redémarrages de pods
Dashboards montrant la santé des pods

WizStatus monitore vos endpoints de services Kubernetes de l'extérieur. Combiné aux probes internes, vous obtenez une visibilité complète sur la santé de votre cluster.