Les mythes autour des déploiements

Déployer moins souvent pour réduire le risque est l'idée reçue la plus coûteuse du métier. Cinq mythes passés au crible, chiffres DORA et cas concrets à l'appui.

Les mythes autour des déploiements

Trois cent quarante-deux commits. C'est ce qu'une équipe que j'ai auditée en 2024 avait accumulés avant sa « grosse release » de fin de trimestre. Deux jours plus tard, la production tombait, et il a fallu onze heures pour découvrir qu'un seul de ces commits avait renommé une variable d'environnement.

Cette histoire n'illustre pas une équipe qui déploie trop. Elle illustre une équipe qui déploie trop rarement, en gros paquets, sans moyen d'isoler la cause. Voici les mythes qui entretiennent cette mécanique, et ce que dit vraiment la donnée.

Mythe 1 : espacer les déploiements réduit le risque

C'est le mythe le plus coûteux, et le plus répandu chez ceux qui ont eu peur une fois. La logique semble tenir debout : moins on touche au système, moins on risque de le casser. Les rapports DORA mesurent l'inverse depuis dix ans. Les équipes dites « Elite » déploient à la demande, avec un délai de livraison inférieur à un jour et un taux d'échec de changement autour de 5 %, quand les plus lentes dépassent les 20 %.

Le mécanisme est simple. Un lot de 342 commits rend le git bisect inutilisable : chaque itération coûte quarante minutes de build et vingt minutes de vérification, personne ne peut se permettre vingt étapes. Un lot de trois commits se relit, se rejoue et s'annule en dix minutes.

La cible n'est d'ailleurs pas « déployer vite ». La cible, c'est réduire la taille du lot. La fréquence n'est qu'une conséquence mesurable de cette réduction.

Mythe 2 : déployer et mettre en production, c'est la même chose

Confondre les deux est ce qui transforme chaque release en événement à risque. Le déploiement installe du code dans l'infrastructure ; la mise en production expose ce code aux utilisateurs. Entre les deux, il y a un interrupteur, et cet interrupteur s'appelle un feature flag.

Concrètement, sur un tunnel de paiement, je livre le nouveau parcours derrière un flag désactivé. Le déploiement est un non-événement : zéro utilisateur touché. Puis j'expose 1 %, j'observe le taux de conversion et les erreurs 5xx pendant une heure, je monte à 10 %, 50 %, 100 %. Si quelque chose dérape, je coupe le flag en cinq secondes.

Sans flag, la seule façon d'arrêter une fonctionnalité est de redéployer l'ancienne version. Douze minutes pendant lesquelles la base a déjà reçu des écritures au nouveau format. Tu ne reviens pas en arrière, tu improvises.

Mythe 3 : le rollback suffit à te protéger

Un rollback applicatif restaure une image, pas un état de données. Dès qu'une release touche au schéma, la promesse « on rollback si ça casse » devient un pari non vérifié, et c'est exactement le scénario que décrit l'article d'AWS sur la sécurité du rollback : la procédure testée sur l'application ne couvre pas la migration.

La seule méthode qui tienne en production, c'est le schéma en trois temps. D'abord ALTER TABLE orders ADD COLUMN paid_at timestamptz NULL, déployé seul, sans code qui le lit. Ensuite le backfill par lots de 5 000 lignes, avec une pause entre chaque lot. Enfin la bascule de lecture, puis le DROP COLUMN dans une release ultérieure, une fois que plus rien ne lit l'ancienne colonne.

Trois déploiements au lieu d'un, et un retour arrière réellement possible à chaque étape. Un DROP COLUMN dans la même release que le code, c'est un rollback qui restaure l'application face à une base amputée.

Mythe 4 : Kubernetes est le prérequis d'un déploiement sérieux

Kubernetes apporte la reprise automatique, l'autoscaling et la gestion de secrets à l'échelle. Il n'apporte pas la capacité à déployer proprement, et il ne t'en dispense pas. J'ai vu des clusters impeccablement configurés casser la prod à chaque helm upgrade parce que personne n'avait défini de readiness probe correcte.

À l'inverse, un montage à trois VPS, Docker Compose et Traefik fait très bien le travail jusqu'à quelques dizaines de requêtes par seconde. Deux services api-blue et api-green, un healthcheck sur /healthz, et une bascule de label Traefik pour envoyer le trafic sur la nouvelle couleur. Quarante lignes de compose, aucune dépendance à un orchestrateur.

Le test comparatif de Coolify, Dokploy et Kamal va dans le même sens : la question utile n'est pas « quel orchestrateur », c'est « quel niveau de reprise automatique mon trafic justifie ».

Mythe 5 : un canary remplace les tests

Un canary ne détecte que ce que tu mesures. Tu peux router 5 % du trafic vers la nouvelle version avec un p95 de latence et un taux de 5xx parfaits, et laisser passer une régression qui casse le bouton d'achat sur Safari. Les métriques techniques sont vertes, la métrique métier est à zéro, et personne ne regarde la seconde.

C'est le point que Martin Fowler souligne dans sa description du canary release : le mécanisme ne vaut que par les signaux qui déclenchent l'arrêt. Un canary sans métrique métier est un rituel de plus.

Même remarque pour le staging « identique à la prod » : données différentes, volume différent, un millième du trafic. Le canary ne remplace pas les tests, il observe ce que les tests ne peuvent pas simuler. Les deux couches se complètent, aucune ne se substitue à l'autre.

Le contre-argument que je prends au sérieux

Il existe des contextes où la prudence lente est rationnelle, et je ne les balaie pas. Un dispositif médical, un système de compensation interbancaire, un firmware embarqué : le coût d'un retour arrière ne se mesure pas en minutes mais en journées de réconciliation comptable ou en matériel rappelé. Dans ces cas, la fréquence élevée n'aide pas.

Mais la conclusion qu'on en tire habituellement — « donc on livre tous les trois mois » — est un saut logique. Ces équipes déploient en continu vers un environnement de préproduction et n'exposent qu'à la fin. C'est précisément la séparation déploiement/exposition du mythe 2, pas un argument contre la fréquence.

Ma concession réelle est ailleurs : la fréquence n'est pas une vertu en soi. Déployer quarante fois par jour sans observabilité, c'est juste casser plus vite et plus souvent. Ce qui compte, c'est le trio petite taille de lot, métriques fiables, retour arrière testé. Les stratégies blue-green et canary ne valent que si ce trio existe déjà.

Ce que je mesure chaque semaine

Quatre chiffres, pas plus : durée du build, temps de restauration après incident, taux de déploiements annulés après exposition, et nombre de rollbacks réellement exécutés. Le dernier est le plus révélateur. Une équipe qui n'a jamais rollbacké depuis six mois n'a pas un système stable, elle a une procédure de secours non testée.

Le garde-fou technique tient en quelques lignes, et il est exécutable tel quel :

deploy: build test
	ssh prod 'docker compose pull && docker compose up -d --no-deps api'
	sleep 30
	curl -fsS https://api.exemple.tld/healthz || $(MAKE) rollback

Si le healthcheck échoue, le rollback part sans intervention humaine. C'est mécanique, donc ça marche à trois heures du matin quand plus personne n'est lucide.

Le mythe le plus tenace

« Notre système est trop critique pour qu'on déploie souvent. » C'est l'exact inverse. Plus un système est critique, plus il faut réduire la taille de chaque changement et répéter la procédure de retour arrière.

Un système critique qui ne change que quatre fois par an est un système dont le rollback n'a jamais été exercé. Le jour où il faut l'utiliser, l'équipe découvre la procédure en même temps que l'incident.