Passer aux déploiements automatisés sans douleur
Automatiser un déploiement cassé, c'est automatiser la panne. Les cinq étapes qui rendent un déploiement rejouable, réversible et rapide.
Ton vrai problème n'est pas le pipeline
Un déploiement automatisé qui échoue une fois sur trois ne remplace pas un déploiement manuel : il ajoute une couche d'incertitude. La cause est presque toujours la même, et elle n'est pas dans le YAML du pipeline. Le serveur cible n'est pas reproductible : un paquet installé à la main en septembre, une variable d'environnement éditée directement en prod, un cron ajouté sans ticket.
Automâtiser cet état, c'est automatiser la panne. Tu vas gagner en vitesse ce que tu perdras en compréhension.
Le test qui tranche en cinq minutes : tu montes une VM neuve, tu lances ton script de déploiement, et l'application répond. Si tu as besoin d'un SSH manuel pour finir le travail, tu n'as pas un déploiement automatisé, tu as un script qui prépare le terrain à une intervention humaine.
J'ai vu cette blague coûter trois heures de restauration sur un projet Django de quatre conteneurs, parce qu'une seule variable SMTP vivait dans /etc/environment et nulle part ailleurs.
La douleur du déploiement automatisé ne vient pas de l'outil. Elle vient du fait que tu automatises une procédure que personne n'a jamais écrite.
Étape 1 — Un script idempotent avant tout pipeline
Avant de toucher à GitLab CI, GitHub Actions ou Jenkins, écris deploy.sh. Un seul fichier, exécutable en local comme en CI, que tu peux lancer trois fois de suite sans casser la production. C'est le contrat de base : si le script n'est pas rejouable, aucun orchestreur ne te sauvera.
#!/usr/bin/env bash
set -euo pipefail
APP_DIR=/srv/app
RELEASE_SHA="${1:?usage: deploy.sh <sha>}"
LOCK=/var/lock/deploy.lock
exec 9>"$LOCK"
flock -n 9 || { echo "déploiement déjà en cours"; exit 1; }
mkdir -p "$APP_DIR/releases"
git -C "$APP_DIR/repo" fetch --quiet origin
git -C "$APP_DIR/repo" checkout --quiet "$RELEASE_SHA"
tar -C "$APP_DIR/repo" -czf "/tmp/release-$RELEASE_SHA.tgz" .
mkdir -p "$APP_DIR/releases/$RELEASE_SHA"
tar -C "$APP_DIR/releases/$RELEASE_SHA" -xzf "/tmp/release-$RELEASE_SHA.tgz"
ln -sfn "$APP_DIR/releases/$RELEASE_SHA" "$APP_DIR/current"
systemctl reload app.service
curl -fsS --retry 5 --retry-delay 2 http://127.0.0.1:8080/healthz >/dev/null
echo "release $RELEASE_SHA en ligne"Trois détails font toute la différence dans ce script. Le flock empêche deux déploiements concurrents de se marcher dessus — c'est exactement le bug qui laisse un serveur dans un état impossible à décrire. Le répertoire horodaté par SHA garde les dernières releases pour un retour arrière instantané. Le curl de fin de script transforme un déploiement « probablement réussi » en déploiement vérifié.
Une fois ce script stable, le pipeline ne fait plus qu'une chose : l'appeler avec le SHA du commit. Ton CI devient un déclencheur, pas un second système à maintenir.
Étape 2 — Le build produit un artefact immuable
Un tag latest est un mensonge : la même étiquette désigne une image différente selon le jour. Tu perds la capacité de dire « la prod tourne avec le commit 4f2a1c ». Tague par SHA, promeus cet artefact, et ne reconstruis jamais entre deux environnements.
build:
stage: build
script:
- docker build -t "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA" .
- docker push "$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA"
rules:
- if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCHLa promotion en préprod puis en prod se fait alors sans rebuild, par un simple retag côté registry :
docker buildx imagetools create \
-t registry.example.com/app:staging \
registry.example.com/app:4f2a1c9Cette discipline règle un problème que tout le monde sous-estime : les faux bugs d'environnement. Si l'image de préprod et celle de prod sont identiques au bit près, une différence de comportement vient forcément de la configuration ou des données — jamais d'un npm install qui a résolu une dépendance différente.
| Pratique | Ce que tu perds | Ce que tu gagnes |
|---|---|---|
Tag latest | Traçabilité commit vers prod | Rien |
| Tag par SHA | 30 secondes de configuration | Rollback exact, audit, cache de couches stable |
| Rebuild par environnement | — | Des écarts impossibles à reproduire |
Étape 3 — Un pipeline qui échoue en 90 secondes
Un pipeline lent est un pipeline contourné. Personne n'attend douze minutes pour savoir qu'une virgule manque. L'ordre des étapes doit suivre le coût croissant : lint et vérification de types d'abord, tests unitaires ensuite, build après, déploiement en dernier.
stages: [check, test, build, deploy]
lint:
stage: check
script: [ruff check ., mypy src]
interruptible: true
unit:
stage: test
script: [pytest -q -x]
needs: [lint]
interruptible: true
timeout: 10m
deploy:
stage: deploy
script: [./deploy.sh "$CI_COMMIT_SHORT_SHA"]
needs: [unit, build]
environment: production
when: manualDeux options changent la vie au quotidien. interruptible: true annule le job en cours quand tu pousses un nouveau commit : plus de file d'attente de six pipelines obsolètes après trois corrections de typo. Et when: manual sur le déploiement de production te donne une porte de sortie les jours où tu sais que la base est en migration.
Ajoute un timeout explicite partout. Un job bloqué doit mourir, pas immobiliser un runner pendant une heure.
Étape 4 — Découpler déploiement et mise en service
Déployer, c'est mettre du code sur les serveurs. Livrer, c'est exposer ce code aux utilisateurs. Les deux actions n'ont aucune raison d'être simultanées, et les confondre est la première cause de déploiements stressants.
Concrètement : tu déploies une nouvelle version du tunnel de paiement, mais la route reste éteinte derrière un flag. Tu l'allumes pour 5 % des sessions, tu regardes le taux de conversion et les logs d'erreur pendant une heure, puis tu passes à 100 %. Si quelque chose casse, tu éteins le flag — le retour arrière prend deux secondes au lieu de quinze minutes.
# feature flag minimaliste, lu à chaque requête
import os, hashlib
def checkout_v2_enabled(user_id: str) -> bool:
pct = int(os.environ.get("CHECKOUT_V2_PCT", "0"))
bucket = int(hashlib.sha1(user_id.encode()).hexdigest()[:8], 16) % 100
return bucket < pctCe découplage est aussi ce qui rend les stratégies de déploiement progressif réellement utiles. Un canary sans flag te dit qu'une instance plante, pas si la fonctionnalité convainc. J'ai détaillé le mécanisme dans du blue-green au canary, et l'intérêt devient évident dès que tu peux séparer les deux signaux.
Étape 5 — Un rollback en une commande, testé tous les mois
La règle est simple : si revenir en arrière demande une réunion, tu ne déploieras jamais le vendredi à 17 h. Un déploiement que tu n'oses pas faire est un déploiement qui grossit jusqu'à devenir dangereux.
# Kubernetes : retour à la révision précédente
kubectl rollout undo deployment/api -n prod
kubectl rollout status deployment/api -n prod --timeout=120s
# ou vers une révision précise
kubectl rollout history deployment/api -n prod
kubectl rollout undo deployment/api -n prod --to-revision=7Avec un script de type Capistrano, le rollback consiste à repointer le lien symbolique vers la release précédente et recharger le service : deux secondes d'indisponibilité, zéro build.
Le point que presque tout le monde oublie : teste le rollback. Une fois par mois, en préprod, déploie une version, puis annule-la, et chronomètre. Le jour où la prod casse à 22 h, tu ne découvriras pas que ta procédure de retour arrière référence une image supprimée du registry.
La seule étape vraiment risquée : les migrations de base
Le code se remplace, la base se transforme. Un ALTER TABLE mal placé rend le rollback impossible, et c'est là que la plupart des équipes perdent leur promesse de déploiement sans douleur.
La règle de survie : une migration ne doit jamais casser la version N-1 du code. Applique le schéma expand / migrate / contract sur trois déploiements distincts.
-- Déploiement 1 (expand) : colonne nullable, l'ancien code continue de fonctionner
ALTER TABLE orders ADD COLUMN total_cents BIGINT NULL;
-- Backfill par lots, hors du chemin critique
UPDATE orders SET total_cents = ROUND(total * 100)
WHERE total_cents IS NULL AND id BETWEEN 1 AND 10000;
-- Déploiement 2 (migrate) : le code écrit dans les deux colonnes
-- Déploiement 3 (contract) : contrainte puis suppression de l'ancienne colonne
ALTER TABLE orders ALTER COLUMN total_cents SET NOT NULL;
ALTER TABLE orders DROP COLUMN total;Cette séquence a un coût : trois déploiements au lieu d'un. Elle a un bénéfice décisif : à aucun moment tu ne te retrouves avec une base incompatible avec le code qui tourne. Sur un cluster où plusieurs replicas se relaient pendant un rolling update, c'est la seule approche qui tient debout. Le même raisonnement s'applique à la configuration de tes workloads, décrite dans déploiement de Kubernetes en production.
Les six erreurs qui reviennent tout le temps
| Erreur | Symptôme observable | Correctif |
|---|---|---|
| Secrets en clair dans le YAML | Rotation impossible, fuite au premier fork | Coffre + injection à l'exécution |
| Pas de health check | Déploiement « réussi » sur une app morte | Endpoint dédié + vérification post-déploiement |
| Build non reproductible | « Ça marche en préprod » | Artefact immuable promu, pas reconstruit |
| Migrations dans le même job | Rollback applicatif impossible | Expand / contract, migration séparée |
| Pipeline de 15 minutes | Contournement manuel, déploiements groupés | Étapes parallèles, cache, fail fast |
| Aucun test de rollback | Découverte en pleine incident | Exercice mensuel chronométré |
Combien de temps ça coûte vraiment
Les chiffres qui circulent sur l'automatisation sont souvent des promesses commerciales. Voici des ordres de grandeur réalistes pour une application de taille moyenne, trois à six services, une équipe de deux à quatre développeurs.
| Chantier | Effort initial | Gain observé |
|---|---|---|
| Script idempotent + health check | 1 à 2 jours | Déploiement rejouable, fin des états bâtards |
| Artefact immuable par SHA | 1 jour | Rollback exact, fin des faux bugs d'environnement |
| Pipeline ordonné et rapide | 2 à 3 jours | Feedback en moins de 3 minutes au lieu de 15 |
| Feature flags | 3 à 5 jours | Mise en service progressive, découplage deploy/release |
| Procédure de rollback testée | 1 jour + 1 h par mois | Retour arrière en minutes au lieu d'heures |
Le gain se mesure moins en temps de déploiement qu'en fréquence et en sérénité. Le rapport DORA sur les performances de livraison logicielle documente depuis des années le lien entre fréquence de déploiement, délai de restauration et fiabilité. Ce sont les mêmes leviers qui reviennent, quelle que soit la stack.
FAQ
Faut-il Kubernetes pour automatiser ses déploiements ?
Non. Un script idempotent, un artefact tagué par SHA et un rollback en une commande couvrent l'essentiel du besoin sur une application monoligne. Kubernetes ajoute de la valeur quand tu as plusieurs services à orchestrer et des contraintes de mise à l'échelle, pas avant.
Quel outil choisir entre GitLab CI, GitHub Actions et Jenkins ?
Celui qui est déjà dans ton forge. La différence de fonctionnalités est marginale pour un pipeline build-test-deploy standard. Jenkins reste pertinent si tu as des agents spécifiques ou des contraintes réseau fortes — la documentation GitLab CI et celle de GitHub Actions suffisent à couvrir 95 % des cas.
Combien de temps avant un premier pipeline utile ?
Une semaine pour un pipeline build + test + déploiement manuel sur un service existant. Les trois premières semaines servent surtout à écrire ce qui était jusqu'ici dans la tête de la personne qui déployait.
Comment gérer les secrets dans le pipeline ?
Jamais dans le dépôt, jamais dans l'image. Variables protégées du CI pour les environnements non sensibles, coffre externe (Vault, Bitwarden Secrets Manager, SSM) pour le reste, avec une rotation scriptée. Un secret qui ne peut pas être tourné en cinq minutes finira par ne plus être tourné du tout.
Et les déploiements le vendredi ?
Ils deviennent acceptables dès que le rollback est testé et le flag prêt. Le vrai indicateur n'est pas le jour de la semaine, c'est le temps nécessaire pour revenir à l'état sain précédent.