Comment publier un serveur avec Docker et GitHub Actions

Déployer un serveur signifiait autrefois se connecter manuellement en SSH, tirer le code et redémarrer les processus. Aujourd'hui, avec Docker et GitHub Actions, vous pouvez entièrement automatiser ce flux — d'un git push à un conteneur en fonctionnement.

Prérequis

Avant de commencer, assurez-vous d'avoir :

• Un serveur (VPS, Raspberry Pi ou n'importe quelle machine Linux)
• Docker installé sur le serveur
• Un dépôt GitHub avec le code de votre application
• Un accès SSH à votre serveur

Étape 1 : Dockeriser votre application

D'abord, créez un Dockerfile à la racine de votre projet :

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
 
FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/index.js"]

Cela utilise une construction multi-étapes pour garder l'image finale légère — seuls les artefacts de production sont inclus dans l'étape runner.

Étape 2 : Configurer Docker Compose sur votre serveur

Sur votre serveur, créez un fichier docker-compose.yml :

version: "3.8"
services:
  app:
    image: ghcr.io/your-username/your-repo:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=${DATABASE_URL}

La politique restart: unless-stopped garantit que votre conteneur redémarre automatiquement après un redémarrage du serveur.

Étape 3 : Configurer les secrets GitHub

Dans votre dépôt GitHub, allez dans Settings → Secrets and variables → Actions et ajoutez :

• SERVER_HOST — l'IP ou le domaine de votre serveur
• SERVER_USER — le nom d'utilisateur SSH (ex: ubuntu)
• SERVER_SSH_KEY — votre clé SSH privée (celle dont la clé publique est sur le serveur)

Étape 4 : Créer le workflow GitHub Actions

Créez .github/workflows/deploy.yml :

name: Deploy to Server
 
on:
  push:
    branches:
      - main
 
jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
 
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
 
      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
 
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ghcr.io/${{ github.repository }}:latest
 
  deploy:
    runs-on: ubuntu-latest
    needs: build-and-push
 
    steps:
      - name: Deploy via SSH
        uses: appleboy/ssh-action@v1
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SERVER_SSH_KEY }}
          script: |
            cd /opt/your-app
            docker compose pull
            docker compose up -d

Le workflow est divisé en deux jobs :

1. build-and-push — construit l'image Docker et la pousse vers le GitHub Container Registry (GHCR)
2. deploy — se connecte en SSH à votre serveur, tire la nouvelle image et redémarre le conteneur

Étape 5 : Configuration initiale sur le serveur

Avant le premier déploiement, connectez-vous à votre serveur et tirez l'image manuellement :

docker login ghcr.io -u your-username --password-stdin
docker compose pull
docker compose up -d

Après cela, chaque push sur main va automatiquement construire, pousser et déployer votre application.

Points clés à retenir

• Les builds Docker multi-étapes réduisent significativement la taille de l'image
• GitHub Container Registry est gratuit pour les dépôts publics et intégré à GitHub Actions
• appleboy/ssh-action gère le déploiement SSH proprement sans avoir besoin d'un runner auto-hébergé
• La gestion des secrets garde les identifiants hors de votre code source
• Avec docker compose pull && docker compose up -d, les mises à jour quasi sans interruption sont simples pour des applications basiques

Ce modèle s'adapte bien d'un projet hobby à un service de production — ajoutez simplement des vérifications de santé, une logique de rollback et des notifications selon vos besoins.