gitea ci

.gitea/workflows/ci-cd.yml

@@ -0,0 +1,168 @@
+# CI/CD Gitea Actions : tests à chaque push, puis sur `main` seulement,
+# build des images (registre de conteneurs intégré à Gitea) et déploiement
+# SSH sur le VPS.
+#
+# Nécessite un runner Gitea Actions (act_runner, exécuteur "docker") attaché
+# au dépôt ou à l'organisation.
+#
+# Secrets à définir (Paramètres du dépôt → Actions → Secrets) :
+#   REGISTRY_TOKEN   jeton d'accès (scope "write:package") pour pousser sur
+#                    le registre de conteneurs de cette instance Gitea
+#   SSH_KEY          clé privée SSH (format OpenSSH) pour se connecter au VPS
+#
+# Variables à définir (Paramètres du dépôt → Actions → Variables) :
+#   REGISTRY_HOST      hôte du registre (ex. gitea.mon-domaine.fr)
+#   REGISTRY_NAMESPACE espace du registre (ex. <organisation>/<depot>)
+#   REGISTRY_USER      utilisateur associé à REGISTRY_TOKEN
+#   SSH_HOST           hôte du VPS
+#   SSH_USER           utilisateur SSH
+#   DEPLOY_PATH        dossier du projet sur le VPS (ex. /opt/benevoles)
+#   VITE_EDITION_ID    UUID de l'édition de production, à renseigner APRÈS
+#                      la toute première mise en service (voir deploy/README.md)
+
+name: ci-cd
+
+on:
+  push:
+    branches: ['**']
+
+jobs:
+  backend-test:
+    runs-on: ubuntu-latest
+    container: python:3.12-slim
+    services:
+      postgres:
+        image: postgres:16-alpine
+        env:
+          POSTGRES_USER: benevoles
+          POSTGRES_PASSWORD: benevoles
+          POSTGRES_DB: benevoles_test
+        ports:
+          - 5432:5432
+    env:
+      TEST_DATABASE_URL: postgresql+psycopg://benevoles:benevoles@postgres:5432/benevoles_test
+      DATABASE_URL: postgresql+psycopg://benevoles:benevoles@postgres:5432/benevoles_test
+    steps:
+      - name: Installer git
+        run: apt-get update && apt-get install -y --no-install-recommends git
+      - uses: actions/checkout@v4
+      - name: Installer uv
+        run: pip install --no-cache-dir uv
+      - name: Installer les dépendances
+        working-directory: backend
+        run: uv sync
+      - name: Lint
+        working-directory: backend
+        run: uv run ruff check .
+      - name: Migrer la base de test
+        working-directory: backend
+        run: uv run alembic upgrade head
+      - name: Vérifier migration ↔ modèle
+        working-directory: backend
+        run: uv run alembic check
+      - name: Tests
+        working-directory: backend
+        run: uv run pytest -q
+
+  frontend-test:
+    runs-on: ubuntu-latest
+    container: node:20-alpine
+    steps:
+      - name: Installer git
+        run: apk add --no-cache git
+      - uses: actions/checkout@v4
+      - name: Installer les dépendances
+        working-directory: frontend
+        run: npm ci
+      - name: Typecheck
+        working-directory: frontend
+        run: npm run typecheck
+      - name: Lint
+        working-directory: frontend
+        run: npm run lint
+      - name: Build
+        working-directory: frontend
+        run: npm run build
+      - name: Smoke test
+        working-directory: frontend
+        run: npm run smoke
+
+  build-backend:
+    needs: backend-test
+    if: gitea.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    container: docker:27
+    services:
+      docker:
+        image: docker:27-dind
+    env:
+      DOCKER_HOST: tcp://docker:2375
+      DOCKER_TLS_CERTDIR: ""
+    steps:
+      - name: Installer git
+        run: apk add --no-cache git
+      - uses: actions/checkout@v4
+      - name: Connexion au registre
+        run: echo "${{ secrets.REGISTRY_TOKEN }}" | docker login "${{ vars.REGISTRY_HOST }}" -u "${{ vars.REGISTRY_USER }}" --password-stdin
+      - name: Build & push
+        run: |
+          IMAGE="${{ vars.REGISTRY_HOST }}/${{ vars.REGISTRY_NAMESPACE }}/backend"
+          docker build -t "$IMAGE:${{ gitea.sha }}" -t "$IMAGE:latest" backend
+          docker push "$IMAGE:${{ gitea.sha }}"
+          docker push "$IMAGE:latest"
+
+  build-frontend:
+    needs: frontend-test
+    if: gitea.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    container: docker:27
+    services:
+      docker:
+        image: docker:27-dind
+    env:
+      DOCKER_HOST: tcp://docker:2375
+      DOCKER_TLS_CERTDIR: ""
+    steps:
+      - name: Installer git
+        run: apk add --no-cache git
+      - uses: actions/checkout@v4
+      - name: Connexion au registre
+        run: echo "${{ secrets.REGISTRY_TOKEN }}" | docker login "${{ vars.REGISTRY_HOST }}" -u "${{ vars.REGISTRY_USER }}" --password-stdin
+      - name: Build & push
+        run: |
+          IMAGE="${{ vars.REGISTRY_HOST }}/${{ vars.REGISTRY_NAMESPACE }}/frontend"
+          docker build \
+            --build-arg VITE_API_MODE=http \
+            --build-arg VITE_EDITION_ID="${{ vars.VITE_EDITION_ID }}" \
+            -f frontend/Dockerfile.prod \
+            -t "$IMAGE:${{ gitea.sha }}" -t "$IMAGE:latest" frontend
+          docker push "$IMAGE:${{ gitea.sha }}"
+          docker push "$IMAGE:latest"
+
+  deploy:
+    needs: [build-backend, build-frontend]
+    if: gitea.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    container: alpine:3.20
+    steps:
+      - name: Installer les outils
+        run: apk add --no-cache git openssh-client rsync
+      - uses: actions/checkout@v4
+      - name: Déployer par SSH
+        run: |
+          mkdir -p ~/.ssh && chmod 700 ~/.ssh
+          echo "${{ secrets.SSH_KEY }}" | tr -d '\r' > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keyscan -H "${{ vars.SSH_HOST }}" >> ~/.ssh/known_hosts
+          rsync -az -e "ssh -i ~/.ssh/id_ed25519" deploy/docker-compose.prod.yml "${{ vars.SSH_USER }}@${{ vars.SSH_HOST }}:${{ vars.DEPLOY_PATH }}/docker-compose.prod.yml"
+          ssh -i ~/.ssh/id_ed25519 "${{ vars.SSH_USER }}@${{ vars.SSH_HOST }}" sh -s <<EOF
+            set -e
+            cd "${{ vars.DEPLOY_PATH }}"
+            echo "${{ secrets.REGISTRY_TOKEN }}" | docker login "${{ vars.REGISTRY_HOST }}" -u "${{ vars.REGISTRY_USER }}" --password-stdin
+            export BACKEND_IMAGE="${{ vars.REGISTRY_HOST }}/${{ vars.REGISTRY_NAMESPACE }}/backend:${{ gitea.sha }}"
+            export FRONTEND_IMAGE="${{ vars.REGISTRY_HOST }}/${{ vars.REGISTRY_NAMESPACE }}/frontend:${{ gitea.sha }}"
+            docker compose -f docker-compose.prod.yml pull
+            docker compose -f docker-compose.prod.yml run --rm backend uv run alembic upgrade head
+            docker compose -f docker-compose.prod.yml up -d
+            docker image prune -f
+          EOF

.gitlab-ci.yml

@@ -1,116 +0,0 @@
-# CI/CD : tests à chaque push, puis sur `main` seulement, build des images
-# (registre de conteneurs GitLab) et déploiement SSH sur le VPS.
-#
-# Variables CI/CD à définir (Paramètres → CI/CD → Variables du projet) :
-#   SSH_HOST        hôte du VPS
-#   SSH_USER        utilisateur SSH
-#   SSH_KEY         clé privée SSH (format OpenSSH), variable « protégée »
-#                   + « masquée », type fichier ou variable multi-lignes
-#   DEPLOY_PATH     dossier du projet sur le VPS (ex. /opt/benevoles)
-#   VITE_EDITION_ID UUID de l'édition de production, à renseigner APRÈS la
-#                   toute première mise en service (voir deploy/README.md) —
-#                   le frontend fige cette valeur au moment du build.
-#
-# `CI_REGISTRY`, `CI_REGISTRY_USER`, `CI_REGISTRY_PASSWORD` et
-# `CI_REGISTRY_IMAGE` sont fournis automatiquement par GitLab.
-
-stages:
-  - test
-  - build
-  - deploy
-
-variables:
-  BACKEND_IMAGE: $CI_REGISTRY_IMAGE/backend
-  FRONTEND_IMAGE: $CI_REGISTRY_IMAGE/frontend
-
-backend-test:
-  stage: test
-  image: python:3.12-slim
-  services:
-    - name: postgres:16-alpine
-      alias: postgres
-  variables:
-    POSTGRES_USER: benevoles
-    POSTGRES_PASSWORD: benevoles
-    POSTGRES_DB: benevoles_test
-    TEST_DATABASE_URL: postgresql+psycopg://benevoles:benevoles@postgres:5432/benevoles_test
-    DATABASE_URL: postgresql+psycopg://benevoles:benevoles@postgres:5432/benevoles_test
-  before_script:
-    - pip install --no-cache-dir uv
-    - cd backend
-    - uv sync
-  script:
-    - uv run ruff check .
-    - uv run alembic upgrade head
-    - uv run alembic check
-    - uv run pytest -q
-
-frontend-test:
-  stage: test
-  image: node:20-alpine
-  before_script:
-    - cd frontend
-    - npm ci
-  script:
-    - npm run typecheck
-    - npm run lint
-    - npm run build
-    - npm run smoke
-
-build-backend:
-  stage: build
-  image: docker:27
-  services:
-    - docker:27-dind
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "main"'
-  script:
-    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
-    - docker build -t "$BACKEND_IMAGE:$CI_COMMIT_SHORT_SHA" -t "$BACKEND_IMAGE:latest" backend
-    - docker push "$BACKEND_IMAGE:$CI_COMMIT_SHORT_SHA"
-    - docker push "$BACKEND_IMAGE:latest"
-
-build-frontend:
-  stage: build
-  image: docker:27
-  services:
-    - docker:27-dind
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "main"'
-  script:
-    - docker login -u "$CI_REGISTRY_USER" -p "$CI_REGISTRY_PASSWORD" "$CI_REGISTRY"
-    - >
-      docker build
-      --build-arg VITE_API_MODE=http
-      --build-arg VITE_EDITION_ID="$VITE_EDITION_ID"
-      -f frontend/Dockerfile.prod
-      -t "$FRONTEND_IMAGE:$CI_COMMIT_SHORT_SHA" -t "$FRONTEND_IMAGE:latest"
-      frontend
-    - docker push "$FRONTEND_IMAGE:$CI_COMMIT_SHORT_SHA"
-    - docker push "$FRONTEND_IMAGE:latest"
-
-deploy:
-  stage: deploy
-  image: alpine:3.20
-  rules:
-    - if: '$CI_COMMIT_BRANCH == "main"'
-  before_script:
-    - apk add --no-cache openssh-client rsync
-    - eval "$(ssh-agent -s)"
-    - echo "$SSH_KEY" | tr -d '\r' | ssh-add -
-    - mkdir -p ~/.ssh && chmod 700 ~/.ssh
-    - ssh-keyscan -H "$SSH_HOST" >> ~/.ssh/known_hosts
-  script:
-    - rsync -az deploy/docker-compose.prod.yml "$SSH_USER@$SSH_HOST:$DEPLOY_PATH/docker-compose.prod.yml"
-    - |
-      ssh "$SSH_USER@$SSH_HOST" sh -s <<EOF
-        set -e
-        cd "$DEPLOY_PATH"
-        echo "$CI_REGISTRY_PASSWORD" | docker login -u "$CI_REGISTRY_USER" --password-stdin "$CI_REGISTRY"
-        export BACKEND_IMAGE="$BACKEND_IMAGE:$CI_COMMIT_SHORT_SHA"
-        export FRONTEND_IMAGE="$FRONTEND_IMAGE:$CI_COMMIT_SHORT_SHA"
-        docker compose -f docker-compose.prod.yml pull
-        docker compose -f docker-compose.prod.yml run --rm backend uv run alembic upgrade head
-        docker compose -f docker-compose.prod.yml up -d
-        docker image prune -f
-      EOF

CLAUDE.md

@@ -398,11 +398,11 @@ fonctions d'IA. *(L'envoi d'emails par SMTP est en place — voir § 2.)*
 ├── README.md
 ├── docker-compose.yml              # dev : db + backend (hot reload)
 ├── .env.example
-├── .gitlab-ci.yml                  # CI/CD : tests → build (registre GitLab) → SSH sur le VPS
+├── .gitea/workflows/ci-cd.yml      # CI/CD : tests → build (registre Gitea) → SSH sur le VPS
 ├── deploy/
 │   ├── docker-compose.prod.yml     # db + backend + frontend, ports en 127.0.0.1
 │   ├── Caddyfile.benevoles         # bloc à ajouter au Caddy du VPS (reverse proxy)
-│   └── README.md                   # variables CI/CD requises, mise en service du VPS
+│   └── README.md                   # secrets/variables CI/CD requis, mise en service du VPS
 ├── docker/postgres-init/           # création de la base de test au 1er boot
 ├── backend/
 │   ├── pyproject.toml              # géré par uv
@@ -481,19 +481,22 @@ Aucune dépendance locale requise hors Docker.
 
 ## 9. Déploiement
 
-- Dépôt GitLab. VPS avec Docker + un Caddy déjà installé en service système
-  (hors de ce dépôt), qui reçoit tout le trafic public en HTTPS et fait
-  reverse proxy vers les conteneurs.
-- `.gitlab-ci.yml` : à chaque push, tests (backend + frontend) ; sur `main`
-  seulement, build des images `backend` et `frontend` (registre de conteneurs
-  du projet GitLab) puis SSH sur le VPS → copie de
+- Dépôt Gitea (instance auto-hébergée). VPS avec Docker + un Caddy déjà
+  installé en service système (hors de ce dépôt), qui reçoit tout le trafic
+  public en HTTPS et fait reverse proxy vers les conteneurs. Nécessite un
+  runner Gitea Actions (`act_runner`, exécuteur Docker) attaché au dépôt.
+- `.gitea/workflows/ci-cd.yml` : à chaque push, tests (backend + frontend) ;
+  sur `main` seulement, build des images `backend` et `frontend` (registre de
+  conteneurs intégré à Gitea) puis SSH sur le VPS → copie de
   `deploy/docker-compose.prod.yml` → `pull` → migration Alembic → `up -d`.
 - Le frontend est un **build statique** (`frontend/Dockerfile.prod`, servi par
   nginx) : `VITE_API_MODE`/`VITE_EDITION_ID` sont figées au moment du build,
   pas à l'exécution — l'édition de production doit donc exister avant la
   première construction de cette image (voir `deploy/README.md`).
-- Variables CI/CD requises (voir `deploy/README.md`) : `SSH_HOST`, `SSH_USER`,
-  `SSH_KEY`, `DEPLOY_PATH`, `VITE_EDITION_ID`.
+- Secrets/variables Actions requis (voir `deploy/README.md`) : secrets
+  `REGISTRY_TOKEN`, `SSH_KEY` ; variables `REGISTRY_HOST`,
+  `REGISTRY_NAMESPACE`, `REGISTRY_USER`, `SSH_HOST`, `SSH_USER`,
+  `DEPLOY_PATH`, `VITE_EDITION_ID`.
 - Le VPS porte un fichier `.env` (non versionné) avec `POSTGRES_USER`,
   `POSTGRES_PASSWORD`, `POSTGRES_DB`, `JWT_SECRET`, `PUBLIC_BASE_URL` et les
   variables `EMAIL_ENABLED` / `SMTP_*` (voir `deploy/README.md`).

README.md

@@ -48,4 +48,4 @@ démarrage du conteneur PostgreSQL.
 | `backend/`   | API FastAPI, modèle SQLModel, migrations Alembic |
 | `frontend/`  | Interface React + Vite + TS + Tailwind (service `frontend`) |
 | `deploy/`    | Configuration de déploiement production (compose, Caddy, runbook) |
-| `.gitlab-ci.yml` | Chaîne CI/CD (tests → build → SSH sur le VPS) |
+| `.gitea/workflows/` | Chaîne CI/CD (tests → build → SSH sur le VPS) |

backend/app/seed.py

@@ -139,21 +139,22 @@ LAST_NAMES = [
 _C = PositionCategory
 # (nom, catégorie, lieu, _ inutilisé)
 POSITIONS: list[tuple[str, PositionCategory, str, list[str]]] = [
-    ("Bar central", _C.BAR, "Chapiteau", []),
-    ("Bar scène", _C.BAR, "Grande scène", []),
-    ("Billetterie entrée", _C.TICKETING, "Entrée principale", []),
-    ("Billetterie navette", _C.TICKETING, "Parking P2", []),
-    ("Accueil artistes", _C.WELCOME, "Backstage", []),
-    ("Accueil public", _C.WELCOME, "Entrée principale", []),
-    ("Parking P1", _C.PARKING, "Entrée nord", ["PERMIS_B"]),
-    ("Parking P2", _C.PARKING, "Entrée sud", ["PERMIS_B"]),
-    ("Propreté site", _C.CLEANING, "Ensemble du site", []),
-    ("Propreté sanitaires", _C.CLEANING, "Zone sanitaires", []),
-    ("Catering bénévoles", _C.CATERING, "Tente staff", []),
-    ("Catering artistes", _C.CATERING, "Backstage", []),
-    ("Montage structures", _C.SETUP, "Ensemble du site", ["CACES"]),
-    ("Régie grande scène", _C.STAGE, "Grande scène", ["REGIE_SON"]),
-    ("Poste de secours", _C.OTHER, "Infirmerie", ["SST"]),
+    ("Bar extérieur", _C.BAR, "", []),
+    ("Entrées", _C.BAR, "", []),
+    ("Tickets", _C.BAR, "", []),
+    ("Propreté", _C.BAR, "", []),
+    ("Bar à vin", _C.BAR, "", []),
+    ("Bar à bières", _C.BAR, "", []),
+    ("Backstage", _C.BAR, "", []),
+    ("Restauration", _C.BAR, "", []),
+    ("Catering", _C.BAR, "", []),
+    ("Plonge", _C.BAR, "", []),
+    ("Prévention", _C.BAR, "", []),
+    ("Bus", _C.BAR, "", []),
+    ("Mécénat", _C.BAR, "", []),
+    ("Accueil artiste", _C.BAR, "", []),
+    ("Trésorie", _C.BAR, "", []),
+    ("Communication", _C.BAR, "", []),
 ]
 
 # fenêtres horaires (heure de début, heure de fin ; > 24 ⇒ le lendemain)

deploy/README.md

@@ -1,15 +1,18 @@
 # Déploiement
 
-Le pipeline [`.gitlab-ci.yml`](../.gitlab-ci.yml) se déclenche sur **chaque
-push** :
+Le pipeline [`.gitea/workflows/ci-cd.yml`](../.gitea/workflows/ci-cd.yml) (Gitea
+Actions) se déclenche sur **chaque push** :
 
 1. tests (backend : `ruff` + `pytest` + `alembic check` ; frontend :
    `typecheck` + `lint` + `build` + `smoke`) ;
 2. sur `main` seulement : build des images `backend` et `frontend`, poussées
-   sur le registre de conteneurs du projet GitLab ;
+   sur le registre de conteneurs intégré à Gitea ;
 3. copie de `deploy/docker-compose.prod.yml` sur le VPS par SSH ;
 4. `docker compose pull`, migration Alembic, `up -d`.
 
+Nécessite un runner Gitea Actions (`act_runner`, exécuteur Docker) activé sur
+l'instance et attaché au dépôt.
+
 Le VPS n'expose rien directement : un **Caddy déjà installé sur le
 serveur** (service système, hors de ce dépôt) reçoit le trafic public sur
 443 et reverse-proxy vers les deux conteneurs, qui n'écoutent que sur
@@ -39,28 +42,35 @@ serveur** (service système, hors de ce dépôt) reçoit le trafic public sur
   Caddy) : suffisant contre la force brute sur un compte connu, pas contre
   une attaque distribuée sur de nombreux emails différents.
 
-## Étape 0 — pousser le dépôt sur GitLab
+## Étape 0 — pousser le dépôt sur Gitea
 
 ```bash
-# Créer d'abord un projet vide sur GitLab (sans README ni .gitignore), puis :
-git remote add origin git@gitlab.com:<namespace>/<projet>.git
+# Créer d'abord un dépôt vide sur Gitea (sans README ni .gitignore), puis :
+git remote add origin git@gitea.mon-domaine.fr:<namespace>/<projet>.git
 git push -u origin main
 ```
 
-## Variables CI/CD à définir (Paramètres → CI/CD → Variables)
+## Secrets et variables à définir (Paramètres du dépôt → Actions)
+
+Secrets (Paramètres → Actions → Secrets) :
+
+| Secret            | Description                                                      |
+|-------------------|-------------------------------------------------------------------|
+| `REGISTRY_TOKEN`  | Jeton d'accès (scope `write:package`) pour pousser sur le registre de conteneurs de l'instance Gitea |
+| `SSH_KEY`         | Clé privée SSH (format OpenSSH)                                   |
+
+Variables (Paramètres → Actions → Variables) :
 
 | Variable             | Description                                                      |
-|-------------------|-------------------------------------------------------------------|
+|-----------------------|-------------------------------------------------------------------|
+| `REGISTRY_HOST`       | Hôte du registre (ex. `gitea.mon-domaine.fr`)                    |
+| `REGISTRY_NAMESPACE`  | Espace du registre (ex. `<organisation>/<depot>`)                |
+| `REGISTRY_USER`       | Utilisateur associé à `REGISTRY_TOKEN`                            |
 | `SSH_HOST`            | Hôte du VPS                                                        |
 | `SSH_USER`            | Utilisateur SSH                                                    |
-| `SSH_KEY`         | Clé privée SSH (format OpenSSH) — **masquée**, sur `main` seulement|
 | `DEPLOY_PATH`         | Dossier du projet sur le VPS (ex. `/opt/benevoles`)               |
 | `VITE_EDITION_ID`     | UUID de l'édition de production — **à ajouter après** l'étape 3   |
 
-`CI_REGISTRY`, `CI_REGISTRY_USER`, `CI_REGISTRY_PASSWORD` et
-`CI_REGISTRY_IMAGE` sont fournies automatiquement par GitLab, rien à
-configurer.
-
 La clé publique correspondant à `SSH_KEY` doit être dans le
 `~/.ssh/authorized_keys` de `SSH_USER` sur le VPS.
 
@@ -101,10 +111,10 @@ quel — il n'y a rien d'autre à y copier.
 Le frontend a besoin de l'UUID d'une édition pour être construit (voir plus
 bas) : le tout premier déploiement se fait donc en deux temps.
 
-1. Sur GitLab, lancer le pipeline sur `main` normalement (Push → CI/CD →
-   Pipelines, ou un simple commit). Le job `build-frontend` échouera ou
-   produira une image sans édition tant que `VITE_EDITION_ID` n'existe pas :
-   c'est attendu, on l'ignore pour l'instant.
+1. Sur Gitea, lancer le pipeline sur `main` normalement (Push → Actions, ou
+   un simple commit). Le job `build-frontend` échouera ou produira une image
+   sans édition tant que `VITE_EDITION_ID` n'existe pas : c'est attendu, on
+   l'ignore pour l'instant.
 2. Une fois `build-backend` et `deploy` passés, `db` et `backend` tournent
    sur le VPS.
 
@@ -129,10 +139,11 @@ docker compose -f docker-compose.prod.yml exec -T db \
 
 ## Étape 4 — brancher le frontend sur cette édition
 
-Dans GitLab, ajouter la variable CI/CD `VITE_EDITION_ID` avec cet UUID, puis
-relancer le pipeline sur `main` (bouton *Retry* sur le dernier pipeline, ou un
-nouveau commit). Cette fois `build-frontend` construit une image qui pointe
-sur la bonne édition, et `deploy` démarre le service `frontend`.
+Dans Gitea, ajouter la variable `VITE_EDITION_ID` (Paramètres → Actions →
+Variables) avec cet UUID, puis relancer le pipeline sur `main` (bouton
+*Re-run* sur le dernier run, ou un nouveau commit). Cette fois
+`build-frontend` construit une image qui pointe sur la bonne édition, et
+`deploy` démarre le service `frontend`.
 
 `VITE_EDITION_ID` ne change plus ensuite : elle ne se touche à nouveau que
 pour une nouvelle édition (festival de l'année suivante) qu'on voudrait

deploy/docker-compose.prod.yml

@@ -4,7 +4,7 @@ name: benevoles
 # côté de ce fichier (non versionné) : POSTGRES_USER, POSTGRES_PASSWORD,
 # POSTGRES_DB, JWT_SECRET, PUBLIC_BASE_URL et les variables SMTP_* / EMAIL_ENABLED.
 # BACKEND_IMAGE / FRONTEND_IMAGE sont exportées par le pipeline de déploiement
-# (.gitlab-ci.yml).
+# (.gitea/workflows/ci-cd.yml).
 #
 # Les deux services ne publient que sur `127.0.0.1` : c'est le Caddy du VPS
 # (hors de ce compose, voir deploy/README.md) qui reçoit le trafic public et
@@ -27,7 +27,7 @@ services:
       retries: 10
 
   backend:
-    image: ${BACKEND_IMAGE:-registry.gitlab.com/OWNER/REPO/backend:latest}
+    image: ${BACKEND_IMAGE:-gitea.mon-domaine.fr/OWNER/REPO/backend:latest}
     environment:
       DATABASE_URL: postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
       ENVIRONMENT: production
@@ -50,7 +50,7 @@ services:
     restart: unless-stopped
 
   frontend:
-    image: ${FRONTEND_IMAGE:-registry.gitlab.com/OWNER/REPO/frontend:latest}
+    image: ${FRONTEND_IMAGE:-gitea.mon-domaine.fr/OWNER/REPO/frontend:latest}
     depends_on:
       - backend
     ports:

frontend/tailwind.config.js

@@ -38,7 +38,7 @@ export default {
         'hatch-orange':
           'repeating-linear-gradient(45deg,#FF5C39 0 6px,#E0421F 6px 12px)',
         'hatch-mauve':
-          'repeating-linear-gradient(45deg,#CBA6E3 0 6px,#BE93D9 6px 12px)',
+          'repeating-linear-gradient(-45deg,#CBA6E3 0 6px,#BE93D9 6px 12px)',
         // Hachures « brouillon »
         'hatch-ink':
           'repeating-linear-gradient(45deg,#14110E 0 8px,#2A2520 8px 16px)',