Maintenir les déploiements automatisés sur le long terme

Quatre horloges périment à des vitesses différentes dans un pipeline. Voici la maintenance trimestrielle qui évite les pannes surprises.

Maintenir les déploiements automatisés sur le long terme

Le pipeline qui marchait en 2023 ne tourne plus en 2026

Un workflow GitHub Actions écrit en 2023 pour un front Next.js est tombé en panne trois fois en dix-huit mois. Aucune ligne de mon code n'avait changé : l'image de runner avait été retirée, le runtime Node embarqué par les actions avait été mis à jour, et le service de cache utilisé par actions/cache avait été coupé côté plateforme.

Le déploiement automatisé n'est pas un projet, c'est une installation. Il vieillit, comme une chaudière. Et il vieillit d'autant plus vite que la chaîne dépend de services que tu ne contrôles pas : runners hébergés, registres d'images, dépôts d'actions tierces, APIs de cloud.

Ce guide donne la méthode que j'applique sur mes propres projets pour tenir trois ans sans réécrire la chaîne. Elle tient en quatre habitudes de maintenance et un runbook trimestriel de 45 minutes.

Un pipeline, quatre horloges qui n'avancent pas au même rythme

La première erreur consiste à traiter « maintenir le pipeline » comme une tâche unique. En réalité, quatre composants périment à des vitesses très différentes, et c'est ce décalage qui produit les pannes surprises.

ComposantDurée de vie typiqueSymptôme quand il périme
Image de runner (ubuntu-22.04)3 à 4 ansLe job reste en queued puis échoue sur un label introuvable
Runtime embarqué des actions (Node 20 → 24)18 à 24 moisWarnings de dépréciation pendant six mois, puis échec net
Version majeure d'une action tierce12 à 18 moisParamètre renommé, sortie supprimée, comportement différent
Secret, token, clé d'API6 à 24 mois401 soudain dans les logs, souvent un lundi matin
Dépendances applicatives2 à 8 semainesBuild qui casse après un npm ci sans verrou à jour

Tu remarques le piège : la ligne la plus lente (le runner) est aussi celle dont l'échéance est annoncée le plus discrètement. GitHub prévient par une note de blog et un warning dans les logs, pas par une alerte qui casse ta nuit.

La conséquence pratique : tu ne peux pas traiter ces quatre horloges avec la même procédure. Dépendances par automatisation continue, runners et actions par revue trimestrielle, secrets par calendrier de rotation fixe.

Épingler par SHA, monter par pull request

La règle de base tient en une ligne : une action se référence par un commit SHA complet, jamais par un tag mutable. Un tag comme @v4 peut être redéplacé par son mainteneur, volontairement ou à la suite d'une compromission de compte. Un SHA de 40 caractères, non.

# fragile : le tag peut bouger sous tes pieds
- uses: actions/checkout@v4

# stable : le commit est figé, et lisible
- uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

Le commentaire de version n'est pas décoratif. C'est lui qui permet, dans six mois, de savoir ce que tu regardes quand Renovate ouvre une PR sur cette ligne. Sans lui, un SHA nu devient du bruit incompréhensible et personne n'ose plus y toucher.

La documentation GitHub sur l'usage sécurisé des workflows recommande exactement cette pratique pour les actions tierces. Elle rappelle au passage que les secrets d'un dépôt sont lisibles par toute personne ayant un accès en écriture. Épingler protège la chaîne d'approvisionnement, pas les secrets.

Reste la question du coût de maintenance : épingler 22 actions dans 9 workflows, c'est 22 lignes à faire évoluer. À la main, personne ne le fait. C'est le rôle de l'étape suivante.

Automatiser les montées de version, pas les urgences

Renovate et Dependabot lisent tes manifestes et ouvrent des PR de mise à jour. Sur un pipeline, l'intérêt est double : ils gèrent aussi les uses: des workflows, ce que la plupart des équipes oublient de configurer.

Le preset helpers:pinGitHubActionDigests de Renovate existe précisément pour ça : il convertit les références d'actions en digests épinglés et maintient les montées ensuite. Un renovate.json5 minimal mais solide ressemble à ceci.

{
  extends: [
    "config:recommended",
    "helpers:pinGitHubActionDigests",
    ":semanticCommits"
  ],
  minimumReleaseAge: "7 days",
  prConcurrentLimit: 4,
  packageRules: [
    {
      // groupes pour éviter 30 PR par semaine
      groupName: "github-actions",
      matchManagers: ["github-actions"],
      automerge: false
    },
    {
      // les majeures ne partent jamais seules en prod
      matchUpdateTypes: ["major"],
      dependencyDashboardApproval: true
    }
  ]
}

Trois réglages méritent un commentaire. minimumReleaseAge: "7 days" impose une semaine de décantation après la publication, le temps qu'une version mal publiée soit retirée par son auteur. C'est la parade la plus efficace contre le scénario « le paquet est cassé pendant 36 heures ».

prConcurrentLimit: 4 évite le mur de PR : au-delà de quatre, l'équipe arrête de lire et clique sur merge sans regarder. Une automatisation qu'on ne relit plus est pire qu'une absence d'automatisation, parce qu'elle donne l'illusion d'une veille.

Et le regroupement par manager transforme 14 PR d'actions en une seule. Celle-là, tu la lis vraiment.

Dependabot fait le même travail avec un dependabot.yml, si tu préfères rester dans l'outillage GitHub natif. Le point important n'est pas l'outil, c'est que la montée de version soit une PR revue, jamais un tag qui change tout seul.

Tester le déploiement, pas seulement le code

La plupart des pipelines testent le code avant de déployer, puis s'arrêtent à l'étape « deploy succeeded ». Si le serveur a déployé une image correcte mais que l'application refuse de démarrer faute d'une variable d'environnement, le pipeline est vert et la prod est morte.

Le smoke test post-déploiement coûte quinze lignes et attrape cette classe entière d'incidents. Le voici dans sa version que j'utilise sur un VPS Deploy, où trois sites partagent un reverse proxy Caddy.

#!/usr/bin/env bash
# deploy-smoke.sh — à lancer juste après le déploiement
set -euo pipefail
BASE="${1:?usage: deploy-smoke.sh https://exemple.fr}"
for i in $(seq 1 10); do
  code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 5 "$BASE/healthz" || true)
  if [ "$code" = "200" ]; then
    echo "OK après ${i} tentative(s)"
    exit 0
  fi
  sleep 3
done
echo "ÉCHEC: /healthz ne répond pas 200 (dernier code: ${code:-000})"
exit 1

Le principe derrière cette étape est celui de la séparation build, release, run : la mise en service est une phase distincte du build, donc elle mérite ses propres vérifications.

Deux détails comptent. L'endpoint /healthz doit vérifier que l'application peut réellement servir une requête, pas seulement que le processus est vivant. Et la boucle de dix tentatives existe parce qu'un conteneur qui démarre en 8 secondes échoue systématiquement à un test lancé immédiatement.

Le corollaire, souvent négligé : le rollback doit être une étape du pipeline, pas une procédure wiki. Un rollback jamais exécuté depuis six mois n'existe pas. Je force une exécution par trimestre, sur un environnement de préprod, pour vérifier que l'image précédente est encore disponible dans le registre.

Cette vérification rejoint ce que je décrivais dans passer aux déploiements automatisés sans douleur : la valeur d'un pipeline se mesure à la confiance qu'il donne pour déployer un vendredi à 17 h.

Le coût qui dérive sans qu'on le voie

Un pipeline qui double de durée ne fait pas de bruit. Il ne casse rien, il ralentit. Et sur un dépôt privé, il coûte de l'argent réel : les minutes de runner hébergé sont facturées au-delà du quota mensuel du plan.

Mesure réelle sur un projet Next.js + tests Playwright : 3 min 40 en janvier 2024, 9 min 10 en juillet 2025. Personne n'avait rien dégradé volontairement. La cause était cumulative — cache qui ne touchait plus (clé trop précise), matrice de tests passée de Node 20 à Node 20 + 22, et un job de lint dupliqué dans deux workflows.

Poste de coûtSignal à surveillerCorrectif typique
Cache inefficaceTaux de miss > 30 %, téléchargement complet à chaque runClé de cache basée sur le hash du lockfile seul
Matrice trop largeN jobs utiles sur N×M combinaisonsMatrice complète en nightly, version unique sur PR
Étapes dupliquéesDeux workflows lancent npm testUn workflow réutilisable (workflow_call)
Artefacts jamais purgésStockage qui grimpe linéairementretention-days explicite (7 au lieu de 90)

Le plus simple est de sortir la donnée plutôt que de l'estimer. Une requête sur l'API suffit à sortir la durée médiane des vingt derniers runs.

gh run list --workflow=deploy.yml --limit=20 \
  --json createdAt,updatedAt,conclusion \
  --jq '[.[] | {s: ((.updatedAt|fromdate) - (.createdAt|fromdate))}] | map(.s) | add/length/60'

Si la médiane dépasse huit minutes sur un projet de cette taille, il y a de la marge gratuite à récupérer avant de payer des runners plus gros.

Les secrets pourrissent plus vite que le code

Un secret oublié n'échoue pas tout de suite. Il échoue le jour où le fournisseur change sa politique d'expiration, ou le jour où la personne qui l'a créé quitte le projet.

Deux règles suffisent à supprimer 80 % du problème. D'abord, un secret par environnement : le token de staging ne doit jamais pouvoir écrire en prod. Ensuite, une date de péremption écrite dans le runbook, pas dans la tête de quelqu'un.

Type de secretRotationRemarque
Clé de déploiement SSH12 moisUne clé par projet, jamais une clé partagée entre 5 dépôts
Token d'API tiers6 à 12 moisPréférer un token à portée limitée par service
Clé cloud (AWS, GCP, OVH)Remplacer par OIDCUne fédération OIDC supprime le secret longue durée
Certificat TLS90 jours, automatiqueAlerte si le renouvellement n'a pas tourné depuis 60 jours

Un détail de la documentation GitHub mérite d'être connu : ne jamais stocker un secret sous forme de JSON ou de YAML dans une seule variable. La rédaction automatique des logs cherche une correspondance exacte de la valeur, et un bloc structuré passe très mal le filtre. Un secret par valeur, toujours.

Si ton fournisseur cloud supporte OIDC, l'effort est d'une heure et il supprime définitivement la question de la rotation des clés longues durées. C'est le meilleur rapport effort/risque de toute cette liste.

Le runbook trimestriel, 45 minutes

Le reste se joue dans une revue trimestrielle, calendrier bloqué, pas « quand on aura le temps ». Voici l'ordre que je suis, du plus urgent au plus confortable.

  1. Lister les actions non épinglées et les épingler.
  2. Lire les warnings de dépréciation dans les trois derniers runs verts.
  3. Vérifier la date de retrait de l'image de runner utilisée.
  4. Comparer la durée médiane du pipeline au trimestre précédent.
  5. Lister les secrets dont la date de rotation est dépassée.
  6. Exécuter un rollback complet sur la préprod.

Le premier point se fait en une commande, qui liste chaque uses: dont la référence n'est pas un SHA de 40 caractères.

grep -rhoE 'uses:[[:space:]]*[^[:space:]]+' .github/workflows \
  | sed -E 's/uses:[[:space:]]*//' \
  | grep -vE '@[0-9a-f]{40}$' \
  | grep -v '^\./' \
  | sort -u

Sur un dépôt de taille moyenne, la sortie tient en dix lignes et se traite en un quart d'heure. Si elle dépasse la page, c'est que le pipeline n'a jamais été maintenu et qu'il faut prévoir une demi-journée, pas 45 minutes.

Le point 6 est celui qu'on saute en premier et qui coûte le plus cher. J'ai vu un projet où le rollback était documenté, testé une fois, puis cassé silencieusement par un changement de politique de rétention du registre d'images : les anciennes images étaient supprimées au bout de sept jours. Le rollback existait sur le papier et n'avait plus de cible.

Quand la chaîne devient trop lourde à maintenir, la bonne réponse n'est pas toujours plus de discipline. Parfois c'est de changer d'outil, et j'ai comparé ce que valent réellement les alternatives dans mon test de Coolify, Dokploy et Kamal : un PaaS auto-hébergé déplace la maintenance vers un projet open source qui la fait à ta place.

Les quatre chiffres à relever chaque mois

Une chaîne de déploiement se pilote avec quatre métriques, pas avec une impression. Elles viennent des travaux DORA et elles restent les meilleurs indicateurs disponibles.

MétriqueCe qu'elle révèleSeuil d'alerte
Fréquence de déploiementLa confiance réelle dans la chaîneMoins d'une fois par semaine
Délai du commit à la prodLe poids des étapes manuellesPlus de 24 h
Taux d'échec du changementLa qualité du smoke test et du rollbackPlus de 15 %
Temps de restaurationLa vitesse réelle du retour arrièrePlus de 1 h

Le troisième chiffre est le plus utile pour arbitrer : s'il monte alors que la fréquence monte aussi, tu déploies plus vite sans mieux tester. C'est le signal qu'il faut investir dans le smoke test, pas dans la vélocité.

Questions fréquentes

Faut-il épingler aussi les actions officielles de GitHub ?

Oui, pour la même raison qu'une action tierce : le tag @v4 reste un pointeur mobile. L'épinglage par SHA ne t'empêche pas de monter, puisque Renovate ouvre la PR à ta place. Le seul coût est la lisibilité, et le commentaire de version le règle.

Combien de temps un pipeline maison reste-t-il raisonnable ?

Tant que la maintenance trimestrielle tient sous une heure, garde-le : tu contrôles chaque étape. Au-delà de deux heures par trimestre, le coût de possession dépasse le gain, et un PaaS auto-hébergé devient le choix rationnel.

Comment savoir qu'un runner va être retiré ?

Trois signaux arrivent dans cet ordre : un warning de dépréciation dans les logs du job, une note dans le changelog des images de runners, puis la disparition du label. Si tu lis les warnings des runs verts une fois par trimestre, tu as toujours plusieurs mois d'avance.

Un pipeline qui échoue une fois par mois, c'est grave ?

Tout dépend de ce qui échoue. Un test instable (flaky) qui échoue une fois par mois coûte surtout de l'attention et finit par être ignoré, là où un déploiement raté sans rollback automatique coûte de la disponibilité. Le second cas mérite un correctif immédiat, le premier un ticket.