Proposition : Systeme CI/CD Auto-Deploy GitLab

Date : 15/01/2026 Status : IMPLEMENTEE Priorite : HAUTE Effort : 2-3h

Objectif

Deployer automatiquement les projets Docker lors d'un push sur GitLab :

• Push sur develop → deploy sur DEV (dev-portainer, 192.168.1.51)
• Push sur main → deploy sur PROD (prod-portainer, 192.168.1.12)

Architecture proposee

┌─────────────────────────────────────────────────────────────────────────────┐
│                           WORKFLOW CI/CD                                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│   DEVELOPPEUR                 GITLAB                    PORTAINER            │
│   ───────────                 ──────                    ─────────            │
│                                                                              │
│   git push develop ─────────► Webhook ─────────────────► dev-portainer      │
│                                  │                       └── docker build   │
│                                  │                       └── docker up      │
│                                  │                                          │
│   git push main ────────────► Webhook ─────────────────► prod-portainer     │
│                                  │                       └── docker build   │
│                                  │                       └── docker up      │
│                                  │                                          │
│                                  ▼                                          │
│                          conf.{env}.gouroubleu.yml                          │
│                          └── port, domain, env vars                         │
│                                                                              │
└─────────────────────────────────────────────────────────────────────────────┘

Composants a creer

1. Webhook Receiver (sur chaque Portainer)

Script PHP ou bash qui recoit les webhooks GitLab et declenche le build :

# /opt/deploy-webhook/deploy.sh
#!/bin/bash
PROJECT=$1
BRANCH=$2
ENV=$3  # dev ou prod

# Cloner/pull le projet
cd /home/gouroubleu/apps/$PROJECT
git fetch origin $BRANCH
git checkout $BRANCH
git pull origin $BRANCH

# Lire la config
CONFIG="conf.${ENV}.gouroubleu.yml"
if [ -f "$CONFIG" ]; then
    # Build et deploy
    docker compose -f docker-compose.yml build
    docker compose -f docker-compose.yml up -d

    # Notifier
    curl -X POST "http://192.168.1.12:5300/api/notify/push" \
         -H "Content-Type: application/json" \
         -d "{\"title\":\"Deploy $PROJECT\",\"body\":\"$BRANCH deploye sur $ENV\"}"
fi

2. Format conf.{env}.gouroubleu.yml

# conf.dev.gouroubleu.yml
version: '1.0'

project:
  name: needfinder
  description: Detecteur de besoins web

services:
  collector:
    port: 5200
    shortcut: bun              # Template Dockerfile (bun, node, rust, etc.)
    dockerfile: Dockerfile     # Ou custom
    env:
      - NEEDFINDER_DB_URL=@NEEDFINDER_DB_URL   # @ = depuis secrets
      - NEEDFINDER_PORT=5200
      - TZ=Europe/Paris

domains:
  - needfinder-api-dev.33800.nowhere84.com

deploy:
  auto: true                   # Active le deploy auto
  branch: develop              # Branche qui declenche
  target: dev-portainer        # Machine cible

3. GitLab Webhook Configuration

Pour chaque projet GitLab :

• URL : https://deploy-dev.33800.nowhere84.com/webhook (ou deploy-prod)
• Secret Token : genere et stocke dans secrets/
• Events : Push events uniquement
• Branches : develop OU main selon l'env

4. Endpoint nginx pour webhooks

# /etc/nginx/sites-available/deploy-webhook.conf
server {
    listen 443 ssl;
    server_name deploy-dev.33800.nowhere84.com;

    ssl_certificate /etc/letsencrypt/live/33800.nowhere84.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/33800.nowhere84.com/privkey.pem;

    location /webhook {
        proxy_pass http://192.168.1.51:5500;
        proxy_set_header X-GitLab-Token $http_x_gitlab_token;
    }
}

Plan d'implementation

Phase 1 : Webhook Receiver (1h)

1. Creer script deploy-webhook.sh sur dev-portainer et prod-portainer
2. Creer service systemd ou container pour ecouter les webhooks
3. Configurer nginx pour router les webhooks

Phase 2 : Configuration GitLab (30min)

1. Configurer webhooks sur les projets existants :
   • needfinder (develop → dev, main → prod)
   • connectors-api
   • browser-connector
   • notif-logger

Phase 3 : Tests (30min)

1. Tester push develop → deploy DEV
2. Tester push main → deploy PROD
3. Verifier notifications

Phase 4 : Documentation (30min)

1. Documenter le processus dans CLAUDE.md
2. Creer template conf.gouroubleu.yml
3. Documenter dans docs/cicd-workflow.md

Alternatives considerees

Option A : GitLab CI/CD runners (complexe)

• Necessite d'installer gitlab-runner sur les machines
• Plus lourd mais plus puissant
• Rejetee : trop complexe pour notre usage

Option B : Simple webhook (choisi)

• Script bash qui ecoute les webhooks
• Leger et facile a maintenir
• Suffisant pour nos besoins

Option C : Watchtower (automatique)

• Surveille les images Docker et redeploy auto
• Rejetee : ne gere pas le build depuis source

Risques

1. Securite webhook : Token GitLab doit etre verifie
2. Build qui echoue : Notification d'erreur requise
3. Conflit de ports : Verifier avant deploy

Validation requise

• [ ] Accord sur l'architecture proposee
• [ ] Accord sur le format conf.gouroubleu.yml
• [ ] Confirmation des projets a configurer en premier

En attente de validation avant implementation