Déploiement automatisé

Rolling / blue-green / canary · Docker registry · SSH deploy · Compose prod

Bootcode IWA-S04 — DevOps, Semaine 3, Jour 4

Objectifs de la leçon

1. Stratégies de déploiement

Rolling, blue-green, canary — avantages et inconvénients

2. Docker registry (GHCR)

Push/pull d'images versionnées depuis GitHub Container Registry

3. SSH deploy depuis le CI

GitHub Actions se connecte au VPS et relance les conteneurs

4. Compose en production

restart, healthcheck, env_file, limites de ressources

5. Secrets de production

GitHub Secrets pour le CI, .env sur le serveur — jamais dans Git

Plan du cours

1

Rappel : CI + cloud

J1-J2 le CI, J3 le cloud — aujourd'hui le CD : déployer automatiquement

2

Stratégies de déploiement

Rolling update, blue-green, canary

3

Docker registries

Docker Hub vs GHCR — push/pull d'images versionnées

4

Live coding

Pipeline complet : build → push GHCR → SSH → compose up

5

Compose prod + gestion des secrets

Restart, healthchecks, .env sur le serveur

Trois stratégies de déploiement

Rolling update

Remplacer les instances progressivement, les unes après les autres.

  • ✅ Pas de downtime
  • ✅ Pas d'infra en double
  • ❌ Deux versions cohabitent temporairement
  • ❌ Rollback lent (re-roll)

Blue-green

Deux environnements identiques : on déploie sur blue, on teste, on bascule le trafic.

  • ✅ Rollback instantané (switch back)
  • ✅ Zéro cohabitation
  • ❌ Double l'infrastructure = le coût

Canary

Nouvelle version à un petit % des users d'abord, montée en charge graduelle.

  • ✅ Risque minimal en prod
  • ✅ Détection de bugs en conditions réelles
  • ❌ Nécessite un load balancer/routeur
  • ❌ Plus complexe à orchestrer

Aujourd'hui : rolling simple via docker compose — le blue-green et le canary demandent des outils (LB, Kubernetes) au-delà d'un VPS unique.

Docker registry : l'image est l'artefact

Le CI build l'image, la pousse sur le registry, le serveur la pull. Pas de rebuild côté prod — l'image testée EST l'image déployée.

GHCR (ghcr.io)

Gratuit pour les repos publics, intégré nativement à GitHub Actions — le GITHUB_TOKEN suffit pour s'authentifier.

🏷️ Tag = SHA du commit

ghcr.io/org/app:abc1234 — chaque image est immuable et liée à un commit précis. C'est ce qui rend le rollback possible.

# tagger par le SHA, pas que :latest

- uses: docker/build-push-action@v5

  with:

    push: true

    tags: |

      ghcr.io/${{ github.repository }}:${{ github.sha }}

      ghcr.io/${{ github.repository }}:latest

# côté serveur

docker compose pull

docker compose up -d

Le job de déploiement SSH

deploy:

  needs: docker

  runs-on: ubuntu-latest

  steps:

    - name: Deploy via SSH

      env:

        SSH_KEY: ${{ secrets.VPS_SSH_KEY }}

        HOST: ${{ secrets.VPS_HOST }}

        USER: ${{ secrets.VPS_USER }}

      run: |

        echo "$SSH_KEY" > key && chmod 600 key

        ssh -i key -o StrictHostKeyChecking=no $USER@$HOST '

          cd /opt/app &&

          docker compose pull &&

          docker compose up -d &&

          docker image prune -f'

🔑 Clé dédiée

Une clé ed25519 créée pour le CI (deploy@github-actions) — révocable sans toucher aux accès humains.

⬇️ pull avant up

Sans pull, compose réutilise l'image en cache — on déploie l'ancienne version !

🧹 image prune

Nettoyer les vieilles images — sinon le disque du VPS se remplit de tags obsolètes.

docker-compose.prod.yml

services:

  app:

    image: ghcr.io/org/app:${APP_TAG}

    # image, PAS build — on pull le registry

    restart: unless-stopped

    env_file: .env

    ports: ["80:3000"]

    healthcheck:

      test: curl -f http://localhost:3000/health

      interval: 30s

      retries: 3

    deploy:

      resources:

        limits:

          memory: 512M

restart: unless-stopped

Le conteneur redémarre s'il crash ou si le VPS reboot. La prod ne tolère pas les processus morts.

healthcheck

Sans healthcheck, Docker croit le conteneur healthy alors que l'app a crashé — indispensable pour monitoring et restart.

env_file: .env

Le .env vit sur le serveur à /opt/app/.env — jamais commité. Secrets injectés au runtime.

Deux mondes de secrets

GitHub Secrets → le CI

Ce dont le workflow a besoin :

  • VPS_HOST — IP du serveur
  • VPS_USER — compte SSH
  • VPS_SSH_KEY — clé privée de deploy

Injectés comme env vars dans le job, jamais affichés dans les logs (masqués automatiquement).

.env sur le serveur → l'app

Ce dont l'application a besoin :

  • DATABASE_URL
  • JWT_SECRET
  • POSTGRES_PASSWORD

Créé une fois à la main sur le VPS, chmod 600. Le CI ne le touche pas — compose le lit via env_file.

❌ Le .env de prod dans Git = fuite de credentials. La regle : Git contient du code, pas des secrets.

Le rollback : tag SHA = machine à remonter le temps

Chaque image est taggée par le SHA du commit. Revenir en arrière = changer le tag et relancer.

Testé avant d'en avoir besoin

Un rollback jamais testé est un rollback qui ne marche pas. Faire un déploiement qui casse, vérifier qu'on sait revenir.

❌ Toujours :latest = impossible

Si seul :latest est poussé, l'ancienne image a été écrasée — rien à quoi revenir.

# rollback.sh sur le VPS

#!/bin/bash

TAG=$1

cd /opt/app

export APP_TAG=$TAG

docker compose pull app

docker compose up -d app

sleep 10

curl -f http://localhost/health || exit 1

# usage :

./rollback.sh abc1234

Pièges courants

❌ Tagger seulement :latest

Sans tag SHA, impossible de revenir à une version précise — le rollback devient de la devinette.

❌ .env de prod dans Git

Fuite de secrets — l'historique Git garde tout, même après suppression du fichier.

❌ up sans pull

docker compose up -d réutilise l'image en cache local — le déploiement « réussit » avec l'ancienne version.

❌ Pas de healthcheck

Docker voit le conteneur "running" alors que l'app a crashé au boot — silence radio en prod.

Exercice E3.4 — ~4h

Déploiement automatisé complet

Node.js + PostgreSQL : build image → push GHCR → SSH deploy → compose up.

Étapes

  • 1️⃣ /opt/app/.env de prod sur le VPS
  • 2️⃣ Clé SSH dédiée + ssh-copy-id
  • 3️⃣ Secrets VPS_HOST/USER/SSH_KEY
  • 4️⃣ docker-compose.prod.yml
  • 5️⃣ .github/workflows/deploy.yml
  • 6️⃣ Push → workflow → vérif en prod
  • 7️⃣ Test du rollback avec un SHA

Checklist

  • ✅ Image taggée SHA + latest
  • ✅ compose pull avant up
  • ✅ image, restart, healthcheck, env_file
  • ✅ .env sur le serveur, pas dans Git
  • ✅ Rollback fonctionnel
  • ✅ docker image prune au deploy

À retenir !

🚀 L'image est l'unité de déploiement

Buildée par le CI, poussée au registry, pullée par la prod — jamais de rebuild côté serveur.

🏷️ Tag SHA = rollback possible

Chaque image liée à un commit. Revenir en arrière = changer de tag.

🔐 Secrets : 2 mondes

GitHub Secrets pour le workflow, .env sur le serveur pour l'app. Jamais dans Git.

♻️ Compose prod = discipline

restart, healthcheck, pull avant up — sinon la prod ment.