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.
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.
| Type | Ce que tu restaures | Temps typique | Risque principal |
|---|---|---|---|
| Artefact | Une révision de code (image, binaire) | 30 s à 3 min | Cache froid, connexions, contrat d'API |
| Configuration | Un comportement (ConfigMap, feature flag) | Moins de 10 s en flag, 1 à 2 min en pod | Le code doit encore savoir lire l'ancien chemin |
| Données | Un état de base ou de schéma | 10 min à plusieurs heures | Irré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=180sLe 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 5mDeux 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.
preStopavec unsleep 10pour laisser le kube-proxy retirer l'endpoint avant l'arrêt du process.maxUnavailable: 0etmaxSurge: 1pour 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: 2La 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étrique | Définition | Cible raisonnable |
|---|---|---|
| Time to rollback | De la décision au trafic 100 % sur N-1 | Moins de 3 min |
| Taux de rollback réussi | Part des rollbacks sans intervention manuelle | Plus de 95 % |
| Fenêtre de double version | Durée où N et N-1 servent du trafic | Moins de 2 min |
| Rollbacks testés | Part des services avec un rollback exercé dans le trimestre | 100 % |
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.