Performance et scalabilité : les rollbacks

Un rollback n'est pas un Ctrl+Z : c'est un déploiement complet, avec son coût en connexions, en cache froid et en compatibilité de schéma. La méthode pour le rendre réellement supportable.

Performance et scalabilité : les rollbacks

Un rollback qui prend douze minutes n'est pas un rollback, c'est un second incident. Sur un service Go que je suis en production, le retour arrière a pris quarante secondes et le pic d'erreurs 500 a duré onze minutes de plus. L'image précédente n'était pas en cause : le pool de connexions Postgres repartait de zéro.

La plupart des équipes mesurent leur temps de déploiement et jamais leur temps de retour arrière. C'est pourtant la seule métrique qui compte quand la prod brûle à 3 h du matin.

Un rollback est un déploiement, pas un Ctrl+Z

kubectl rollout undo ne restaure rien. La commande recrée un ReplicaSet à partir de la révision précédente et relance une stratégie de rolling update strictement identique à celle d'un déploiement normal.

Tu repasses donc par le scheduler, le pull d'image, les init containers, la readiness probe, puis la bascule des endpoints du Service. Aucune de ces étapes n'est instantanée, et aucune n'est gratuite en charge.

Test à faire sur ton cluster cette semaine : kubectl rollout undo deployment/api --to-revision=3 suivi de kubectl rollout status deployment/api --timeout=120s. Si le status dépasse deux minutes sur un service qui sert du trafic, ton rollback n'est pas un plan de secours, c'est un espoir.

Les trois familles de rollback et leur coût réel

Tous les retours arrière ne se valent pas. La confusion entre ces trois familles explique la majorité des incidents prolongés que j'ai observés.

TypeCe que tu restauresTemps typiqueRisque principal
ArtefactUne révision de code (image, binaire)30 s à 3 minCache froid, connexions, contrat d'API
ConfigurationUn comportement (ConfigMap, feature flag)Moins de 10 s en flag, 1 à 2 min en podLe code doit encore savoir lire l'ancien chemin
DonnéesUn état de base ou de schéma10 min à plusieurs heuresIrréversible si destructif, verrous de table

La troisième ligne est celle qui tue. Un rollback d'image ne défait jamais un DROP COLUMN appliqué deux minutes plus tôt, et aucune révision de Deployment ne contient la donnée perdue. J'ai détaillé ces angles morts dans les limites des rollbacks trop souvent ignorées.

Kubernetes : ce que le rollback natif ne fait pas

Un Deployment conserve dix révisions par défaut via revisionHistoryLimit. Passé ce quota, les vieux ReplicaSets sont élagués et --to-revision échoue sur les plus anciennes.

Sur un service déployé huit fois par jour, dix révisions représentent à peine une journée d'historique. Monte à 20 ou 30 sur les services critiques et garde tes images taguées par digest dans le registre pendant au moins 90 jours.

kubectl rollout history deployment/api
kubectl rollout undo deployment/api --to-revision=12
kubectl rollout status deployment/api --timeout=180s

Le comportement exact est documenté dans la référence Deployment de Kubernetes. Retiens surtout que undo crée un nouveau ReplicaSet, il ne ressuscite pas l'ancien.

La fenêtre où deux versions tournent

Pendant un rolling update, anciens et nouveaux pods servent du trafic simultanément. Un rollback rouvre exactement cette fenêtre, mais dans l'autre sens.

Si la version N+1 a écrit un champ que la version N ne sait pas lire, une partie des requêtes casse à la relecture. C'est le scénario classique du renommage de colonne sans période de double écriture.

Règle simple : tout changement de contrat passe par une phase où les deux versions coexistent volontairement. Le rollback ne devient sûr que si cette coexistence a été prévue avant le déploiement, pas après l'incident.

Helm : --atomic ne fait pas tout

helm upgrade --atomic déclenche un rollback automatique si la release échoue dans le timeout imparti. C'est utile, mais ça ne couvre que les échecs visibles par Helm : pods non prêts, jobs en erreur, dépassement de délai.

Un service qui répond 200 avec des données fausses passe le --wait sans broncher. Il te faut une sonde applicative qui vérifie un vrai cas métier, pas un /healthz qui renvoie ok parce que le process est vivant.

helm upgrade --install api ./charts/api \
  --namespace prod \
  --atomic --wait --timeout 5m

helm rollback api 12 --namespace prod --wait --timeout 5m

Deux détails surprennent toujours en incident : les CRDs ne sont pas rollbackés, et un hook pre-rollback mal écrit peut bloquer la restauration entière. La documentation de helm rollback précise les options, mais seule une répétition en staging te dira si ta release passe réellement.

Migrations : la règle expand/contract, non négociable

Une migration compatible avec N et N+1 rend le rollback possible. Une migration qui casse N le rend théorique, même si le pipeline affiche un beau bouton vert.

Le déroulé en trois temps tient en trois déploiements séparés, jamais un seul :

-- Déploiement 1 : on ajoute, on ne retire rien
ALTER TABLE orders ADD COLUMN status_v2 text;

-- Backfill par lots, hors transaction longue
UPDATE orders SET status_v2 = status
WHERE status_v2 IS NULL AND id BETWEEN 1 AND 50000;

-- Déploiement 2 : le code lit status_v2 et écrit les deux colonnes
-- Déploiement 3, une semaine plus tard :
ALTER TABLE orders DROP COLUMN status;

En Postgres 11 et au-delà, un ADD COLUMN sans DEFAULT volatile ne réécrit pas la table : l'opération est quasi instantanée. En revanche, SET NOT NULL prend un verrou exclusif et scanne tout, donc passe par CHECK (...) NOT VALID puis VALIDATE CONSTRAINT pour éviter de bloquer les écritures.

La règle que j'applique : aucune migration destructive dans le même déploiement que le code qui cesse de l'utiliser. La séparation coûte une semaine de colonne morte, elle évite une restauration de backup.

Ce qui casse la scalabilité au moment du rollback

Le rollback multiplie les connexions : les nouveaux pods ouvrent leur pool avant que les anciens aient fini de drainer. Trente pods avec un pool de vingt, c'est six cents connexions Postgres sur une base déjà sous stress.

  • preStop avec un sleep 10 pour laisser le kube-proxy retirer l'endpoint avant l'arrêt du process.
  • maxUnavailable: 0 et maxSurge: 1 pour ne jamais réduire la capacité pendant la bascule.
  • Un pooler côté base, PgBouncer en mode transaction, pour absorber le doublement temporaire.

Le HPA n'aide pas dans cette fenêtre. Il réagit sur quinze à soixante secondes de métriques alors que le pic de connexions dure quelques secondes, et le temps qu'il scaler, la décision est déjà prise par le pool.

Ce dimensionnement rejoint directement le choix de stratégie de déploiement : un canary à 5 % de trafic rend un rollback presque invisible côté charge, un big bang le rend brutal. J'ai comparé les arbitrages dans comment bien choisir sa stratégie de déploiement.

Le manifeste qui rend le rollback supportable

Trois réglages suffisent à diviser par deux le pic de charge pendant un retour arrière. Ils tiennent dans le Deployment, pas dans une procédure interne que personne ne relit.

spec:
  strategy:
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1
  template:
    spec:
      terminationGracePeriodSeconds: 30
      containers:
        - name: api
          lifecycle:
            preStop:
              exec:
                command: ["sleep", "10"]
          readinessProbe:
            httpGet: { path: /ready, port: 8080 }
            periodSeconds: 3
            failureThreshold: 2

La sonde /ready doit vérifier la connexion à la base et au cache, pas seulement l'existence du process. Avec periodSeconds: 3, un pod cassé sort du Service en six secondes au lieu de trente.

Ajoute un PodDisruptionBudget à minAvailable: 80% et un rollback ne pourra plus vider le service par accident, même lancé par un script trop pressé.

Mesurer le rollback comme un SLO

Un rollback non mesuré est une croyance. Quatre indicateurs suffisent à objectiver la capacité réelle de ton équipe.

MétriqueDéfinitionCible raisonnable
Time to rollbackDe la décision au trafic 100 % sur N-1Moins de 3 min
Taux de rollback réussiPart des rollbacks sans intervention manuellePlus de 95 %
Fenêtre de double versionDurée où N et N-1 servent du traficMoins de 2 min
Rollbacks testésPart des services avec un rollback exercé dans le trimestre100 %

La dernière ligne est la plus discriminante, et c'est aussi celle que personne ne suit. Une procédure de rollback jamais exercée n'est pas une procédure, c'est une hypothèse.

Le cadre DORA appelle ça le failed deployment recovery time, et le place au même niveau que la fréquence de déploiement. Une équipe qui déploie dix fois par jour mais qui met vingt minutes à revenir en arrière n'est pas rapide, elle est exposée.

FAQ

Faut-il garder plus de dix révisions ?

Oui dès que tu déploies plus de deux fois par jour sur un service critique. Vingt à trente révisions coûtent quelques ReplicaSets vides et te donnent plusieurs jours d'historique exploitable.

Un rollback d'image corrige-t-il une migration destructrice ?

Non. Le code revient, la donnée non. Si la colonne est supprimée, il faut restaurer un backup et accepter la perte entre le dernier dump et l'incident.

Blue/green ou canary pour rollback ?

Blue/green pour la vitesse, canary pour la finesse. Le premier bascule le trafic en secondes, le second limite l'exposition mais demande une gestion de version plus longue dans le temps.

Combien de temps garder les images précédentes ?

Quatre-vingt-dix jours minimum, en digest, avec une politique de rétention qui ne supprime jamais la dernière version stable. Un rollback vers une image élaguée échoue au pull, pas au déploiement, et tu le découvres au pire moment.

Faut-il automatiser le rollback ?

Automatise la détection et la proposition, garde la décision humaine sur la bascule. Un rollback automatique sur une métrique mal calibrée peut provoquer une boucle de ping-pong entre deux versions.

Le vrai test reste simple : prends un service au hasard dans ton inventaire et demande à l'équipe de le rollbacker sur staging, sans documentation, en moins de cinq minutes. Le résultat t'en dira plus que n'importe quel tableau de bord.