From de02fb28ca983ac58eed54b8637de58816e06b9e Mon Sep 17 00:00:00 2001 From: syoul Date: Tue, 23 Dec 2025 20:11:09 +0100 Subject: [PATCH] Initial commit: Infrastructure Git CI/CD avec Gitea, Woodpecker, PostgreSQL, Consul et Registrator --- .gitignore | 59 +++ README.md | 84 +++++ consul/docker-compose.yml | 45 +++ consul/env.template | 10 + docs/01-architecture.md | 99 +++++ docs/02-installation.md | 176 +++++++++ docs/03-configuration-gitea.md | 160 ++++++++ docs/04-configuration-woodpecker.md | 209 +++++++++++ docs/05-configuration-postgresql.md | 213 +++++++++++ docs/06-configuration-consul.md | 423 ++++++++++++++++++++++ docs/07-configuration-registrator.md | 370 +++++++++++++++++++ docs/08-deploiement-consul-registrator.md | 399 ++++++++++++++++++++ docs/README.md | 142 ++++++++ gitea/docker-compose.yml | 46 +++ postgres/README.md | 100 +++++ postgres/docker-compose.env.yml | 39 ++ postgres/docker-compose.yml | 30 ++ registrator/docker-compose.yml | 24 ++ registrator/env.template | 11 + woodpecker/docker-compose.yml | 46 +++ 20 files changed, 2685 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 consul/docker-compose.yml create mode 100644 consul/env.template create mode 100644 docs/01-architecture.md create mode 100644 docs/02-installation.md create mode 100644 docs/03-configuration-gitea.md create mode 100644 docs/04-configuration-woodpecker.md create mode 100644 docs/05-configuration-postgresql.md create mode 100644 docs/06-configuration-consul.md create mode 100644 docs/07-configuration-registrator.md create mode 100644 docs/08-deploiement-consul-registrator.md create mode 100644 docs/README.md create mode 100644 gitea/docker-compose.yml create mode 100644 postgres/README.md create mode 100644 postgres/docker-compose.env.yml create mode 100644 postgres/docker-compose.yml create mode 100644 registrator/docker-compose.yml create mode 100644 registrator/env.template create mode 100644 woodpecker/docker-compose.yml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..80d2b50 --- /dev/null +++ b/.gitignore @@ -0,0 +1,59 @@ +# Secrets et fichiers sensibles - NE PAS VERSIONNER +.env +*.env +!*.env.template +!*.env.example +!env.template + +# Fichiers de configuration avec mots de passe +gitea/gitea.env +postgres/.env +consul/.env +registrator/.env + +# Logs +*.log +*.log.* + +# Fichiers temporaires +*.tmp +*.temp +*.swp +*.swo +*~ + +# IDE et editeurs +.idea/ +.vscode/ +.vscode-oss/ +.vscodium-insiders/ +*.code-workspace +.DS_Store + +# Docker +*.pid +docker-compose.override.yml + +# Sauvegardes +*.sql +*.sql.gz +*.snap +backup/ +backups/ +*.backup + +# Fichiers systeme +Thumbs.db +.DS_Store + +# Certificats et cles (si ajoutes plus tard) +*.pem +*.key +*.crt +*.cert +!*.example + +# Variables d'environnement locales +.env.local +.env.*.local + diff --git a/README.md b/README.md new file mode 100644 index 0000000..57026c7 --- /dev/null +++ b/README.md @@ -0,0 +1,84 @@ +# Infrastructure Git CI/CD + +Configuration Docker Compose pour une infrastructure complete de gestion de code source et d'integration continue. + +## Composants + +- **Gitea** : Serveur Git auto-heberge +- **Woodpecker CI** : Plateforme CI/CD +- **PostgreSQL** : Base de donnees pour Gitea +- **Consul** : Service discovery (optionnel) +- **Registrator** : Auto-registration Docker (optionnel) + +## Structure + +``` +. +├── consul/ # Configuration Consul +├── docs/ # Documentation complete +├── gitea/ # Configuration Gitea +├── postgres/ # Configuration PostgreSQL +├── registrator/ # Configuration Registrator +└── woodpecker/ # Configuration Woodpecker CI +``` + +## Documentation + +Voir le dossier [docs/](docs/) pour la documentation complete : + +- [Architecture](docs/01-architecture.md) +- [Installation](docs/02-installation.md) +- [Configuration Gitea](docs/03-configuration-gitea.md) +- [Configuration Woodpecker](docs/04-configuration-woodpecker.md) +- [Configuration PostgreSQL](docs/05-configuration-postgresql.md) +- [Configuration Consul](docs/06-configuration-consul.md) +- [Configuration Registrator](docs/07-configuration-registrator.md) +- [Deploiement Consul/Registrator](docs/08-deploiement-consul-registrator.md) + +## Deploiement + +### Sur le serveur + +```bash +cd /opt +git clone git@git.syoul.fr:syoul/infrastructure.git +cd infrastructure + +# Creer les fichiers .env necessaires +cp consul/env.template consul/.env +cp registrator/env.template registrator/.env +# Editer ces fichiers avec les vrais tokens + +# Deployer les services +cd consul && docker compose up -d +cd ../registrator && docker compose up -d +cd ../postgres && docker compose up -d +cd ../gitea && docker compose up -d +cd ../woodpecker && docker compose up -d +``` + +## Fichiers secrets + +Les fichiers suivants ne sont **PAS versionnes** et doivent etre crees sur le serveur : + +- `consul/.env` : Token administrateur Consul +- `registrator/.env` : Token Registrator +- `gitea/gitea.env` : Configuration Gitea avec mots de passe + +Utilisez les fichiers `*.template` comme reference. + +## Maintenance + +Pour mettre a jour l'infrastructure : + +```bash +cd /opt/infrastructure +git pull +# Redemarrer les services modifies +cd [service] && docker compose up -d +``` + +## Licence + +Prive - Infrastructure interne + diff --git a/consul/docker-compose.yml b/consul/docker-compose.yml new file mode 100644 index 0000000..b2c92fc --- /dev/null +++ b/consul/docker-compose.yml @@ -0,0 +1,45 @@ +services: + consul: + container_name: consul + image: hashicorp/consul:latest + restart: unless-stopped + command: agent -server -ui -node=server-1 -bootstrap-expect=1 -client=0.0.0.0 + + ports: + - "8500:8500" # UI web et API HTTP + - "8600:8600/udp" # DNS + - "8600:8600/tcp" # DNS + + environment: + # Configuration ACL pour la production + # default_policy: deny = tout est interdit par defaut + # enable_token_persistence: true = tokens sauvegardes sur disque + CONSUL_LOCAL_CONFIG: >- + { + "acl": { + "enabled": true, + "default_policy": "deny", + "enable_token_persistence": true + } + } + + volumes: + - consul-data:/consul/data + + networks: + gitgit_syoul_fr_gitea_net: + aliases: + - consul + + healthcheck: + test: ["CMD", "consul", "members"] + interval: 10s + timeout: 3s + retries: 3 + +volumes: + consul-data: + +networks: + gitgit_syoul_fr_gitea_net: + external: true diff --git a/consul/env.template b/consul/env.template new file mode 100644 index 0000000..94c30cb --- /dev/null +++ b/consul/env.template @@ -0,0 +1,10 @@ +# Token administrateur Consul (bootstrap token) +# Genere lors de l'initialisation des ACL avec : docker exec consul consul acl bootstrap +# +# INSTRUCTIONS : +# 1. Copier ce fichier vers .env +# 2. Remplacer la valeur du token par le vrai token +# 3. NE PAS VERSIONNER le fichier .env ! + +CONSUL_HTTP_TOKEN=votre-token-admin-ici + diff --git a/docs/01-architecture.md b/docs/01-architecture.md new file mode 100644 index 0000000..a0abc24 --- /dev/null +++ b/docs/01-architecture.md @@ -0,0 +1,99 @@ +# Architecture de l'infrastructure Git CI/CD + +## Vue d'ensemble + +Cette infrastructure fournit une solution complete de gestion de code source et d'integration continue. + +``` + +------------------+ + | Utilisateurs | + +--------+---------+ + | + +--------------+--------------+ + | | + v v + +-------------------+ +-------------------+ + | git.syoul.fr | | ci.syoul.fr | + | (Gitea :3300) | | (Woodpecker:9001)| + +--------+----------+ +--------+----------+ + | | + | +---------------------+ | + +-->| Consul :8500 |<--+ + | Service Discovery | + +----------+----------+ + | + +----------+----------+ + | Registrator | + | (auto-registration) | + +---------------------+ + | + +-------------+-------------+ + | | + +---------+---------+ +---------+---------+ + | PostgreSQL | | Woodpecker | + | (gitea_db) | | Agent | + +-------------------+ +-------------------+ +``` + +## Composants + +### Services principaux + +| Service | Port externe | Port interne | Description | +|---------|--------------|--------------|-------------| +| Gitea | 3300 | 3000 | Serveur Git auto-heberge | +| Gitea SSH | 2222 | 22 | Acces SSH pour Git | +| Woodpecker Server | 9001 | 8000 | Serveur CI/CD | +| Woodpecker Agent | - | 3000 | Agent d'execution des pipelines | +| PostgreSQL | - | 5432 | Base de donnees Gitea | +| Consul | 8500 | 8500 | Service discovery et UI | +| Consul DNS | 8600 | 8600 | Resolution DNS des services | +| Registrator | - | - | Enregistrement automatique | + +### Reseau Docker + +Tous les services utilisent le reseau Docker : `gitgit_syoul_fr_gitea_net` +- Sous-reseau : `172.18.0.0/16` +- Gateway : `172.18.0.1` + +### Volumes persistants + +| Volume | Service | Chemin dans le conteneur | +|--------|---------|--------------------------| +| `gitgit_syoul_fr_gitea_data` | Gitea | `/data` | +| `gitgit_syoul_fr_db_data` | PostgreSQL | `/var/lib/postgresql/data` | +| `woodpecker-data` | Woodpecker Server | `/var/lib/woodpecker` | +| `consul-data` | Consul | `/consul/data` | + +## Flux de communication + +### Authentification OAuth2 (Woodpecker <-> Gitea) + +1. Utilisateur accede a `ci.syoul.fr` +2. Woodpecker redirige vers `git.syoul.fr/login/oauth/authorize` +3. Utilisateur s'authentifie sur Gitea +4. Gitea redirige vers `ci.syoul.fr/authorize` avec le code +5. Woodpecker echange le code contre un token via `gitea:3000` + +### Communication interne (avec Consul) + +1. Registrator detecte les nouveaux conteneurs +2. Registrator enregistre les services dans Consul +3. Les services peuvent se trouver via DNS Consul : `gitea.service.consul` + +### Webhooks CI/CD + +1. Commit sur Gitea +2. Gitea envoie un webhook a Woodpecker +3. Woodpecker Server planifie le build +4. Woodpecker Agent execute le pipeline +5. Resultats affiches dans Gitea et Woodpecker + +## URLs d'acces + +| Service | URL | +|---------|-----| +| Gitea | http://git.syoul.fr | +| Woodpecker | https://ci.syoul.fr | +| Consul UI | http://[serveur]:8500 | + diff --git a/docs/02-installation.md b/docs/02-installation.md new file mode 100644 index 0000000..2e026ca --- /dev/null +++ b/docs/02-installation.md @@ -0,0 +1,176 @@ +# Guide d'installation + +## Prerequis + +- Docker et Docker Compose installes +- Acces SSH au serveur +- Domaines configures : `git.syoul.fr`, `ci.syoul.fr` + +## Ordre de deploiement + +**IMPORTANT** : Respecter l'ordre suivant pour eviter les problemes de dependances. + +``` +1. Reseau Docker (si non existant) +2. PostgreSQL (base de donnees) +3. Gitea (serveur Git) +4. Consul (service discovery) [optionnel] +5. Registrator (auto-registration) [optionnel] +6. Woodpecker (CI/CD) +``` + +## Etape 1 : Creer le reseau Docker + +Si le reseau n'existe pas : + +```bash +docker network create gitgit_syoul_fr_gitea_net +``` + +Verifier : + +```bash +docker network ls | grep gitea +``` + +## Etape 2 : Deployer PostgreSQL + +```bash +cd /opt/postgres +docker compose up -d +docker logs gitea_db +``` + +Verifier : + +```bash +docker exec gitea_db pg_isready -U gitea +``` + +## Etape 3 : Deployer Gitea + +```bash +cd /opt/gitea +docker compose up -d +docker logs gitea +``` + +Verifier : + +```bash +curl -s http://localhost:3300/api/v1/version +``` + +## Etape 4 : Deployer Consul (optionnel) + +```bash +cd /opt/consul +docker compose up -d +docker logs consul +``` + +Verifier : + +```bash +# UI accessible +curl -s http://localhost:8500/v1/status/leader + +# DNS fonctionne +dig @localhost -p 8600 consul.service.consul +``` + +## Etape 5 : Deployer Registrator (optionnel) + +**Prerequis** : Consul doit etre demarre et accessible. + +```bash +cd /opt/registrator +docker compose up -d +docker logs registrator +``` + +Verifier : + +```bash +# Les services apparaissent dans Consul +curl -s http://localhost:8500/v1/catalog/services | python3 -m json.tool +``` + +## Etape 6 : Deployer Woodpecker + +```bash +cd /opt/woodpecker +docker compose up -d +docker logs woodpecker-server +docker logs woodpecker-agent +``` + +Verifier : + +```bash +curl -s http://localhost:9001/api/info +``` + +## Verification finale + +### Tous les conteneurs sont en cours d'execution + +```bash +docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" +``` + +Resultat attendu : + +``` +NAMES STATUS PORTS +consul Up X minutes 0.0.0.0:8500->8500/tcp, ... +registrator Up X minutes +woodpecker-agent Up X minutes 3000/tcp +woodpecker-server Up X minutes 0.0.0.0:9001->8000/tcp, ... +gitea Up X minutes 0.0.0.0:3300->3000/tcp, ... +gitea_db Up X minutes 5432/tcp +``` + +### Services enregistres dans Consul + +```bash +curl -s http://localhost:8500/v1/catalog/services +``` + +### Test de connexion OAuth2 + +1. Acceder a https://ci.syoul.fr +2. Cliquer sur "Se connecter avec git.syoul.fr" +3. S'authentifier sur Gitea +4. Autoriser l'application Woodpecker +5. Etre redirige vers le dashboard Woodpecker + +## Commandes de maintenance + +### Redemarrer un service + +```bash +cd /opt/[service] +docker compose restart +``` + +### Voir les logs + +```bash +docker logs -f [nom-conteneur] +``` + +### Mettre a jour un service + +```bash +cd /opt/[service] +docker compose pull +docker compose up -d +``` + +### Sauvegarder PostgreSQL + +```bash +docker exec gitea_db pg_dump -U gitea gitea > backup_$(date +%Y%m%d_%H%M%S).sql +``` + diff --git a/docs/03-configuration-gitea.md b/docs/03-configuration-gitea.md new file mode 100644 index 0000000..fdb77e6 --- /dev/null +++ b/docs/03-configuration-gitea.md @@ -0,0 +1,160 @@ +# Configuration Gitea + +## Fichiers de configuration + +- `gitea/docker-compose.yml` : Configuration Docker Compose +- `gitea/gitea.env` : Variables d'environnement + +## Configuration actuelle + +### docker-compose.yml + +```yaml +services: + gitea: + container_name: gitea + image: gitea/gitea:latest + restart: always + env_file: + - gitea.env + networks: + - gitgit_syoul_fr_gitea_net + volumes: + - gitgit_syoul_fr_gitea_data:/data + ports: + - "3300:3000" # Web UI + - "2222:22" # SSH + +volumes: + gitgit_syoul_fr_gitea_data: + external: true + +networks: + gitgit_syoul_fr_gitea_net: + external: true +``` + +### Variables d'environnement (gitea.env) + +| Variable | Valeur | Description | +|----------|--------|-------------| +| `USER_UID` | 1000 | UID de l'utilisateur Gitea | +| `USER_GID` | 1000 | GID de l'utilisateur Gitea | +| `GITEA__database__DB_TYPE` | postgres | Type de base de donnees | +| `GITEA__database__HOST` | gitea_db:5432 | Hote de la base de donnees | +| `GITEA__database__NAME` | gitea | Nom de la base de donnees | +| `GITEA__database__USER` | gitea | Utilisateur de la base de donnees | +| `GITEA__database__PASSWD` | *** | Mot de passe de la base de donnees | +| `GITEA__server__DOMAIN` | git.syoul.fr | Domaine public | +| `GITEA__server__PROTOCOL` | http | Protocole interne | +| `GITEA__server__ROOT_URL` | http://git.syoul.fr/ | URL racine publique | +| `GITEA__server__HTTP_PORT` | 3000 | Port HTTP interne | + +## Configuration OAuth2 pour Woodpecker + +### Creer l'application OAuth2 + +1. Se connecter a Gitea en tant qu'administrateur +2. Aller dans **Parametres utilisateur** > **Applications** +3. Sous "Gerer les applications OAuth2", creer une nouvelle application : + - **Nom** : `Woodpecker CI` + - **URI de redirection** : `https://ci.syoul.fr/authorize` + - **Client confidentiel** : Oui +4. Noter le **Client ID** et le **Client Secret** + +### Configurer Woodpecker + +Dans `woodpecker/docker-compose.yml`, utiliser : + +```yaml +environment: + WOODPECKER_GITEA_CLIENT: "votre-client-id" + WOODPECKER_GITEA_SECRET: "votre-client-secret" +``` + +## Configuration des webhooks + +### Autoriser les webhooks locaux + +Dans Gitea, ajouter dans `app.ini` ou via variables d'environnement : + +```ini +[webhook] +ALLOWED_HOST_LIST = external,loopback,private +``` + +Via docker-compose : + +```yaml +environment: + GITEA__webhook__ALLOWED_HOST_LIST: external,loopback,private +``` + +### Configurer le webhook automatique + +Woodpecker configure automatiquement les webhooks lors de l'activation d'un depot. Verifier dans : + +**Depot** > **Parametres** > **Webhooks** + +## Maintenance + +### Sauvegarder Gitea + +```bash +# Sauvegarder le volume de donnees +docker run --rm -v gitgit_syoul_fr_gitea_data:/data -v $(pwd):/backup alpine tar cvzf /backup/gitea_backup_$(date +%Y%m%d).tar.gz /data + +# Sauvegarder la base de donnees +docker exec gitea_db pg_dump -U gitea gitea > gitea_db_$(date +%Y%m%d).sql +``` + +### Mettre a jour Gitea + +```bash +cd /opt/gitea +docker compose pull +docker compose up -d +``` + +### Logs + +```bash +docker logs gitea -f +``` + +## Depannage + +### Erreur de connexion a la base de donnees + +Verifier que PostgreSQL est accessible : + +```bash +docker exec gitea_db pg_isready -U gitea +``` + +Verifier le reseau : + +```bash +docker exec gitea ping -c 2 gitea_db +``` + +### Erreur OAuth2 "Client ID not registered" + +1. Verifier que l'application OAuth2 existe dans Gitea +2. Verifier que le Client ID dans Woodpecker correspond +3. Verifier que l'URI de redirection est correcte + +### Problemes d'envoi d'emails + +Verifier les logs : + +```bash +docker logs gitea 2>&1 | grep -i mail +``` + +Tester la connexion SMTP : + +```bash +docker exec gitea curl -v telnet://mail.anuanua.fr:465 +``` + diff --git a/docs/04-configuration-woodpecker.md b/docs/04-configuration-woodpecker.md new file mode 100644 index 0000000..41470c8 --- /dev/null +++ b/docs/04-configuration-woodpecker.md @@ -0,0 +1,209 @@ +# Configuration Woodpecker CI + +## Fichiers de configuration + +- `woodpecker/docker-compose.yml` : Configuration Docker Compose + +## Configuration actuelle + +### docker-compose.yml + +```yaml +services: + woodpecker-server: + image: woodpeckerci/woodpecker-server:latest + container_name: woodpecker-server + restart: unless-stopped + ports: + - "9001:8000" + environment: + WOODPECKER_GITEA: "true" + WOODPECKER_GITEA_URL: "http://gitea:3000" + WOODPECKER_GITEA_CLIENT: "77390faa-e609-4f00-846b-955aab74095e" + WOODPECKER_GITEA_SECRET: "***" + WOODPECKER_AGENT_SECRET: "***" + WOODPECKER_ADMIN: "syoul" + WOODPECKER_HOST: "https://ci.syoul.fr" + volumes: + - woodpecker-data:/var/lib/woodpecker + networks: + - gitea_net + + woodpecker-agent: + image: woodpeckerci/woodpecker-agent:latest + container_name: woodpecker-agent + restart: unless-stopped + depends_on: + - woodpecker-server + environment: + WOODPECKER_SERVER: "woodpecker-server:9000" + WOODPECKER_AGENT_SECRET: "***" + WOODPECKER_HEALTHCHECK_ADDR: ":3001" + volumes: + - /var/run/docker.sock:/var/run/docker.sock + networks: + - gitea_net + +volumes: + woodpecker-data: + +networks: + gitea_net: + external: true + name: gitgit_syoul_fr_gitea_net +``` + +## Variables d'environnement + +### Woodpecker Server + +| Variable | Description | +|----------|-------------| +| `WOODPECKER_GITEA` | Active l'integration Gitea | +| `WOODPECKER_GITEA_URL` | URL interne de Gitea (via Docker network) | +| `WOODPECKER_GITEA_CLIENT` | Client ID de l'application OAuth2 | +| `WOODPECKER_GITEA_SECRET` | Client Secret de l'application OAuth2 | +| `WOODPECKER_AGENT_SECRET` | Secret partage avec les agents | +| `WOODPECKER_ADMIN` | Utilisateur administrateur | +| `WOODPECKER_HOST` | URL publique de Woodpecker | + +### Woodpecker Agent + +| Variable | Description | +|----------|-------------| +| `WOODPECKER_SERVER` | Adresse du serveur (via Docker network) | +| `WOODPECKER_AGENT_SECRET` | Secret partage avec le serveur | +| `WOODPECKER_HEALTHCHECK_ADDR` | Adresse du healthcheck | + +## URLs importantes + +- **WOODPECKER_GITEA_URL** : `http://gitea:3000` + - URL interne via le reseau Docker + - Permet a Woodpecker de communiquer avec Gitea pour l'API + +- **WOODPECKER_HOST** : `https://ci.syoul.fr` + - URL publique pour les redirections OAuth2 + - Utilisee pour les callbacks + +## Flux OAuth2 + +``` +Navigateur -> ci.syoul.fr/login + | + v +Woodpecker -> Redirect vers git.syoul.fr/login/oauth/authorize + | + v +Utilisateur s'authentifie sur Gitea + | + v +Gitea -> Redirect vers ci.syoul.fr/authorize?code=XXX + | + v +Woodpecker -> POST http://gitea:3000/login/oauth/access_token + | (echange du code contre un token) + v +Utilisateur connecte sur Woodpecker +``` + +## Configuration des pipelines + +### Fichier .woodpecker.yml + +Creer un fichier `.woodpecker.yml` a la racine du depot : + +```yaml +steps: + build: + image: alpine:latest + commands: + - echo "Hello from Woodpecker!" + + test: + image: alpine:latest + commands: + - echo "Running tests..." +``` + +### Activer un depot + +1. Se connecter a Woodpecker (ci.syoul.fr) +2. Cliquer sur "Add repository" +3. Selectionner le depot Gitea +4. Activer le depot + +Woodpecker configure automatiquement le webhook dans Gitea. + +## Maintenance + +### Verifier les agents connectes + +```bash +docker logs woodpecker-server | grep -i agent +``` + +### Redemarrer les services + +```bash +cd /opt/woodpecker +docker compose restart +``` + +### Mettre a jour Woodpecker + +```bash +cd /opt/woodpecker +docker compose pull +docker compose up -d +``` + +## Depannage + +### Erreur OAuth2 + +**Symptome** : "Erreur lors de l'authentification aupres du fournisseur OAuth" + +**Causes possibles** : + +1. **Woodpecker ne peut pas joindre Gitea** : + ```bash + docker exec woodpecker-server wget -qO- http://gitea:3000/api/v1/version + ``` + +2. **Client ID ou Secret incorrect** : + - Verifier dans Gitea > Parametres > Applications + - Comparer avec `docker inspect woodpecker-server | grep CLIENT` + +3. **URL de redirection incorrecte** : + - Dans Gitea, verifier que l'URI de redirection est `https://ci.syoul.fr/authorize` + +### Agent non connecte + +**Symptome** : Les builds restent en attente + +**Verification** : + +```bash +docker logs woodpecker-agent | grep -i error +``` + +**Causes possibles** : + +1. **WOODPECKER_AGENT_SECRET different** : + - Verifier que le secret est identique sur le serveur et l'agent + +2. **Reseau Docker** : + ```bash + docker exec woodpecker-agent ping -c 2 woodpecker-server + ``` + +### Builds echouent avec erreur Docker + +**Symptome** : "Cannot connect to Docker daemon" + +**Solution** : Verifier le montage du socket Docker : + +```bash +docker exec woodpecker-agent ls -la /var/run/docker.sock +``` + diff --git a/docs/05-configuration-postgresql.md b/docs/05-configuration-postgresql.md new file mode 100644 index 0000000..b487ea8 --- /dev/null +++ b/docs/05-configuration-postgresql.md @@ -0,0 +1,213 @@ +# Configuration PostgreSQL + +## Fichiers de configuration + +- `postgres/docker-compose.yml` : Configuration Docker Compose +- `postgres/docker-compose.env.yml` : Version avec fichier .env (optionnelle) + +## Configuration actuelle + +### docker-compose.yml + +```yaml +services: + gitea_db: + container_name: gitea_db + image: postgres:14 + restart: always + environment: + POSTGRES_USER: gitea + POSTGRES_PASSWORD: Gitea_Db-2025_Secure + POSTGRES_DB: gitea + volumes: + - gitgit_syoul_fr_db_data:/var/lib/postgresql/data + networks: + - gitgit_syoul_fr_gitea_net + +volumes: + gitgit_syoul_fr_db_data: + external: true + +networks: + gitgit_syoul_fr_gitea_net: + external: true +``` + +## Variables d'environnement + +| Variable | Valeur | Description | +|----------|--------|-------------| +| `POSTGRES_USER` | gitea | Utilisateur de la base de donnees | +| `POSTGRES_PASSWORD` | *** | Mot de passe | +| `POSTGRES_DB` | gitea | Nom de la base de donnees | + +## Volume persistant + +Le volume `gitgit_syoul_fr_db_data` contient toutes les donnees PostgreSQL : + +- Tables de la base de donnees +- Configuration PostgreSQL +- WAL (Write-Ahead Logging) + +**IMPORTANT** : Ce volume est critique et doit etre sauvegarde regulierement. + +## Sauvegardes + +### Sauvegarde logique (pg_dump) + +```bash +# Sauvegarde complete +docker exec gitea_db pg_dump -U gitea gitea > backup_$(date +%Y%m%d_%H%M%S).sql + +# Sauvegarde compressee +docker exec gitea_db pg_dump -U gitea gitea | gzip > backup_$(date +%Y%m%d_%H%M%S).sql.gz +``` + +### Restauration + +```bash +# Restaurer depuis une sauvegarde +cat backup.sql | docker exec -i gitea_db psql -U gitea gitea + +# Ou pour un fichier compresse +gunzip -c backup.sql.gz | docker exec -i gitea_db psql -U gitea gitea +``` + +### Sauvegarde du volume Docker + +```bash +# Arreter le conteneur avant la sauvegarde +docker stop gitea_db + +# Sauvegarder le volume +docker run --rm \ + -v gitgit_syoul_fr_db_data:/data \ + -v $(pwd):/backup \ + alpine tar cvzf /backup/postgres_volume_$(date +%Y%m%d).tar.gz /data + +# Redemarrer le conteneur +docker start gitea_db +``` + +## Maintenance + +### Verifier l'etat + +```bash +docker exec gitea_db pg_isready -U gitea +``` + +### Se connecter a la base + +```bash +docker exec -it gitea_db psql -U gitea gitea +``` + +### Lister les tables + +```sql +\dt +``` + +### Taille de la base + +```bash +docker exec gitea_db psql -U gitea gitea -c "SELECT pg_size_pretty(pg_database_size('gitea'));" +``` + +### Vacuum (maintenance) + +```bash +docker exec gitea_db vacuumdb -U gitea gitea +``` + +## Mise a jour + +### Mise a jour mineure (14.x -> 14.y) + +```bash +cd /opt/postgres +docker compose pull +docker compose up -d +``` + +### Mise a jour majeure (14 -> 15) + +**ATTENTION** : Necessite une migration manuelle des donnees. + +1. Sauvegarder la base : + ```bash + docker exec gitea_db pg_dump -U gitea gitea > backup_before_upgrade.sql + ``` + +2. Arreter le conteneur : + ```bash + docker compose down + ``` + +3. Modifier la version dans docker-compose.yml : + ```yaml + image: postgres:15 + ``` + +4. Supprimer l'ancien volume (ATTENTION !) : + ```bash + # Uniquement si vous avez une sauvegarde ! + docker volume rm gitgit_syoul_fr_db_data + docker volume create gitgit_syoul_fr_db_data + ``` + +5. Demarrer le nouveau conteneur : + ```bash + docker compose up -d + ``` + +6. Restaurer la base : + ```bash + cat backup_before_upgrade.sql | docker exec -i gitea_db psql -U gitea gitea + ``` + +## Depannage + +### Connexion refusee + +```bash +# Verifier que le conteneur tourne +docker ps | grep gitea_db + +# Verifier les logs +docker logs gitea_db + +# Verifier le reseau +docker network inspect gitgit_syoul_fr_gitea_net | grep gitea_db +``` + +### Base corrompue + +En cas de corruption, restaurer depuis une sauvegarde : + +```bash +# Arreter Gitea +docker stop gitea + +# Supprimer et recreer la base +docker exec gitea_db psql -U gitea postgres -c "DROP DATABASE gitea;" +docker exec gitea_db psql -U gitea postgres -c "CREATE DATABASE gitea;" + +# Restaurer +cat backup.sql | docker exec -i gitea_db psql -U gitea gitea + +# Redemarrer Gitea +docker start gitea +``` + +### Performances + +Optimiser les performances en ajoutant des variables d'environnement : + +```yaml +environment: + POSTGRES_INITDB_ARGS: "--encoding=UTF8" + # Ou monter un fichier de configuration personnalise +``` + diff --git a/docs/06-configuration-consul.md b/docs/06-configuration-consul.md new file mode 100644 index 0000000..e394e4c --- /dev/null +++ b/docs/06-configuration-consul.md @@ -0,0 +1,423 @@ +# Configuration Consul + +## Presentation + +Consul est un outil de service discovery et de configuration distribuee. Dans cette infrastructure, il permet : + +- Decouverte automatique des services Docker +- Resolution DNS des services (ex: `gitea.service.consul`) +- Health checks centralises +- Interface web de gestion +- Controle d'acces via ACL (mode production) + +## Fichiers de configuration + +- `consul/docker-compose.yml` : Configuration Docker Compose +- `consul/env.template` : Template pour les variables d'environnement + +## Configuration production (avec ACL) + +### docker-compose.yml + +```yaml +services: + consul: + container_name: consul + image: hashicorp/consul:latest + restart: unless-stopped + command: agent -server -ui -node=server-1 -bootstrap-expect=1 -client=0.0.0.0 + + ports: + - "8500:8500" # UI web et API HTTP + - "8600:8600/udp" # DNS + - "8600:8600/tcp" # DNS + + environment: + # Configuration ACL pour la production + CONSUL_LOCAL_CONFIG: >- + { + "acl": { + "enabled": true, + "default_policy": "deny", + "enable_token_persistence": true + } + } + + volumes: + - consul-data:/consul/data + + networks: + gitgit_syoul_fr_gitea_net: + aliases: + - consul + + healthcheck: + test: ["CMD", "consul", "members"] + interval: 10s + timeout: 3s + retries: 3 + +volumes: + consul-data: + +networks: + gitgit_syoul_fr_gitea_net: + external: true +``` + +## Configuration ACL + +### Politique de securite + +| Parametre | Valeur | Description | +|-----------|--------|-------------| +| `acl.enabled` | `true` | Active le systeme ACL | +| `acl.default_policy` | `deny` | Tout est interdit par defaut | +| `acl.enable_token_persistence` | `true` | Tokens sauvegardes sur disque | + +### Types de tokens + +| Token | Usage | Permissions | +|-------|-------|-------------| +| Bootstrap (admin) | Administration Consul | Toutes | +| Registrator | Enregistrer des services | service:write, node:read, agent:read | +| Lecture seule | UI, monitoring | service:read, node:read | + +### Initialisation des ACL + +Apres le premier demarrage de Consul : + +```bash +# 1. Bootstrap des ACL (genere le token admin) +docker exec consul consul acl bootstrap +``` + +Resultat : +``` +AccessorID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx +SecretID: yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy <-- TOKEN ADMIN +Description: Bootstrap Token (Global Management) +Local: false +Create Time: 2025-01-01 00:00:00.000000000 +0000 UTC +Policies: + 00000000-0000-0000-0000-000000000001 - global-management +``` + +**IMPORTANT** : Notez le `SecretID`, c'est votre token administrateur. + +### Creer un token pour Registrator + +```bash +# 2. Creer la policy pour Registrator +docker exec consul consul acl policy create \ + -name "registrator" \ + -description "Policy pour Registrator" \ + -rules ' +service_prefix "" { + policy = "write" +} +node_prefix "" { + policy = "read" +} +agent_prefix "" { + policy = "read" +} +' \ + -token "VOTRE_TOKEN_ADMIN" + +# 3. Creer le token avec cette policy +docker exec consul consul acl token create \ + -description "Token Registrator" \ + -policy-name "registrator" \ + -token "VOTRE_TOKEN_ADMIN" +``` + +Notez le `SecretID` du token Registrator pour configurer Registrator. + +### Creer un token de lecture (optionnel) + +Pour l'acces a l'UI en lecture seule : + +```bash +# Creer la policy de lecture +docker exec consul consul acl policy create \ + -name "read-only" \ + -description "Policy lecture seule" \ + -rules ' +service_prefix "" { + policy = "read" +} +node_prefix "" { + policy = "read" +} +key_prefix "" { + policy = "read" +} +' \ + -token "VOTRE_TOKEN_ADMIN" + +# Creer le token +docker exec consul consul acl token create \ + -description "Token lecture seule" \ + -policy-name "read-only" \ + -token "VOTRE_TOKEN_ADMIN" +``` + +## Options de la commande + +| Option | Description | +|--------|-------------| +| `-server` | Mode serveur (vs client) | +| `-ui` | Active l'interface web | +| `-node=server-1` | Nom du noeud | +| `-bootstrap-expect=1` | Nombre de serveurs attendus (1 pour mode standalone) | +| `-client=0.0.0.0` | Ecoute sur toutes les interfaces | + +## Ports + +| Port | Protocole | Description | +|------|-----------|-------------| +| 8500 | TCP | API HTTP et UI web | +| 8600 | TCP/UDP | DNS | +| 8300 | TCP | Communication serveur-a-serveur | +| 8301 | TCP/UDP | Gossip LAN | +| 8302 | TCP/UDP | Gossip WAN | + +## Interface web + +Accessible sur : `http://[serveur]:8500` + +**Avec ACL** : Utilisez le token admin ou un token de lecture pour acceder a l'UI. + +### Sections principales + +- **Services** : Liste des services enregistres +- **Nodes** : Liste des noeuds Consul +- **Key/Value** : Stockage cle-valeur +- **ACL** : Gestion des tokens et policies + +## API HTTP avec ACL + +### Authentification + +Ajouter le header `X-Consul-Token` ou le parametre `?token=` : + +```bash +# Via header +curl -H "X-Consul-Token: VOTRE_TOKEN" http://localhost:8500/v1/catalog/services + +# Via parametre +curl "http://localhost:8500/v1/catalog/services?token=VOTRE_TOKEN" +``` + +### Lister les services + +```bash +curl -H "X-Consul-Token: $CONSUL_TOKEN" http://localhost:8500/v1/catalog/services +``` + +### Details d'un service + +```bash +curl -H "X-Consul-Token: $CONSUL_TOKEN" http://localhost:8500/v1/catalog/service/gitea +``` + +### Etat du cluster + +```bash +curl http://localhost:8500/v1/status/leader # Ne necessite pas de token +curl http://localhost:8500/v1/status/peers +``` + +### Health checks + +```bash +curl -H "X-Consul-Token: $CONSUL_TOKEN" http://localhost:8500/v1/health/service/gitea +``` + +## DNS Consul + +Le DNS Consul ne necessite pas de token par defaut. + +### Resolution d'un service + +```bash +# Depuis le serveur +dig @localhost -p 8600 gitea.service.consul + +# Depuis un conteneur Docker +docker exec consul dig @127.0.0.1 -p 8600 gitea.service.consul +``` + +### Format des noms DNS + +- `.service.consul` : Service global +- `.service..consul` : Service dans un datacenter specifique +- `.node.consul` : Noeud specifique + +## Utilisation avec les autres services + +### Configurer un service pour utiliser Consul DNS + +Dans docker-compose.yml : + +```yaml +services: + mon-service: + dns: + - 172.18.0.X # IP du conteneur Consul + dns_search: + - service.consul +``` + +### Exemple avec Woodpecker + +```yaml +services: + woodpecker-server: + environment: + WOODPECKER_GITEA_URL: "http://gitea.service.consul:3000" + dns: + - 172.18.0.X +``` + +## Maintenance + +### Verifier l'etat + +```bash +docker exec consul consul members +``` + +### Lister les tokens + +```bash +docker exec consul consul acl token list -token "VOTRE_TOKEN_ADMIN" +``` + +### Revoquer un token + +```bash +docker exec consul consul acl token delete -id "TOKEN_ACCESSOR_ID" -token "VOTRE_TOKEN_ADMIN" +``` + +### Voir les logs + +```bash +docker logs consul -f +``` + +### Forcer la deregistration d'un service + +```bash +curl -X PUT -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/agent/service/deregister/[service-id] +``` + +### Sauvegarder les donnees + +```bash +docker exec consul consul snapshot save /consul/data/backup.snap -token "VOTRE_TOKEN_ADMIN" +docker cp consul:/consul/data/backup.snap ./consul_backup_$(date +%Y%m%d).snap +``` + +### Restaurer une sauvegarde + +```bash +docker cp ./backup.snap consul:/consul/data/backup.snap +docker exec consul consul snapshot restore /consul/data/backup.snap -token "VOTRE_TOKEN_ADMIN" +``` + +## Depannage + +### Erreur "Permission denied" ou "ACL not found" + +Le token utilise n'a pas les permissions necessaires. + +```bash +# Verifier les permissions du token +docker exec consul consul acl token read -id "TOKEN_ACCESSOR_ID" -token "VOTRE_TOKEN_ADMIN" +``` + +### Consul ne demarre pas + +```bash +# Verifier les logs +docker logs consul + +# Verifier le volume +docker volume inspect consul-data +``` + +### Services non visibles + +```bash +# Verifier que Registrator fonctionne +docker logs registrator + +# Verifier que Registrator a un token valide +docker exec registrator env | grep CONSUL + +# Verifier les health checks +curl -H "X-Consul-Token: $CONSUL_TOKEN" http://localhost:8500/v1/health/checks/[service-name] +``` + +### Erreur DNS + +```bash +# Tester la resolution +dig @localhost -p 8600 consul.service.consul + +# Verifier que le port 8600 est accessible +netstat -tuln | grep 8600 +``` + +## Securite - Recommandations production + +### 1. ACL activees (fait) + +La configuration actuelle active les ACL avec `default_policy: deny`. + +### 2. Restreindre l'acces reseau + +Ne pas exposer le port 8500 sur Internet. Utiliser un VPN ou un reverse proxy authentifie. + +### 3. Configurer TLS (optionnel) + +Pour chiffrer les communications : + +```yaml +environment: + CONSUL_LOCAL_CONFIG: >- + { + "acl": { + "enabled": true, + "default_policy": "deny", + "enable_token_persistence": true + }, + "verify_incoming": true, + "verify_outgoing": true, + "verify_server_hostname": true, + "ca_file": "/consul/config/ca.pem", + "cert_file": "/consul/config/server.pem", + "key_file": "/consul/config/server-key.pem" + } +``` + +### 4. Rotation des tokens + +Changer regulierement les tokens et revoquer les anciens. + +## Haute disponibilite + +Pour un cluster de production, deployer au moins 3 serveurs Consul : + +```yaml +services: + consul-1: + command: agent -server -node=server-1 -bootstrap-expect=3 ... + consul-2: + command: agent -server -node=server-2 -join=consul-1 ... + consul-3: + command: agent -server -node=server-3 -join=consul-1 ... +``` diff --git a/docs/07-configuration-registrator.md b/docs/07-configuration-registrator.md new file mode 100644 index 0000000..42e9164 --- /dev/null +++ b/docs/07-configuration-registrator.md @@ -0,0 +1,370 @@ +# Configuration Registrator + +## Presentation + +Registrator surveille automatiquement les conteneurs Docker et les enregistre dans Consul. Il detecte : + +- Les nouveaux conteneurs demarres +- Les conteneurs arretes (deregistration automatique) +- Les ports exposes +- Les metadonnees (labels) + +## Fichiers de configuration + +- `registrator/docker-compose.yml` : Configuration Docker Compose +- `registrator/env.template` : Template pour le token Consul + +## Configuration production (avec ACL) + +### docker-compose.yml + +```yaml +services: + registrator: + container_name: registrator + image: gliderlabs/registrator:latest + restart: unless-stopped + + env_file: + - .env + + # -internal : utilise les IPs internes Docker + # Le token est passe via la variable d'environnement CONSUL_HTTP_TOKEN + command: -internal consul://consul:8500 + + volumes: + - /var/run/docker.sock:/tmp/docker.sock:ro + + networks: + - gitgit_syoul_fr_gitea_net + +networks: + gitgit_syoul_fr_gitea_net: + external: true +``` + +### Fichier .env + +Creer le fichier `.env` a partir du template `env.template` : + +```bash +cp env.template .env +``` + +Contenu du fichier `.env` : + +``` +CONSUL_HTTP_TOKEN=votre-token-registrator-ici +``` + +**IMPORTANT** : Ne pas versionner le fichier `.env` dans git ! + +## Configuration du token Registrator + +### Permissions requises + +Le token Registrator doit avoir les permissions suivantes : + +| Ressource | Permission | Description | +|-----------|------------|-------------| +| `service_prefix ""` | write | Enregistrer/desenregistrer des services | +| `node_prefix ""` | read | Lire les informations des noeuds | +| `agent_prefix ""` | read | Lire les informations des agents | + +### Creer le token + +Voir [Configuration Consul](06-configuration-consul.md#creer-un-token-pour-registrator) pour les instructions detaillees. + +Resume rapide : + +```bash +# 1. Creer la policy +docker exec consul consul acl policy create \ + -name "registrator" \ + -description "Policy pour Registrator" \ + -rules ' +service_prefix "" { + policy = "write" +} +node_prefix "" { + policy = "read" +} +agent_prefix "" { + policy = "read" +} +' \ + -token "VOTRE_TOKEN_ADMIN" + +# 2. Creer le token +docker exec consul consul acl token create \ + -description "Token Registrator" \ + -policy-name "registrator" \ + -token "VOTRE_TOKEN_ADMIN" +``` + +## Options de la commande + +| Option | Description | +|--------|-------------| +| `-internal` | Utilise les IPs internes Docker (vs IPs externes) | +| `consul://consul:8500` | Adresse du serveur Consul | + +### Autres options disponibles + +| Option | Description | +|--------|-------------| +| `-ip` | IP a utiliser pour l'enregistrement | +| `-tags` | Tags par defaut a ajouter | +| `-resync` | Intervalle de resynchronisation (ex: `60`) | +| `-deregister` | Mode de deregistration : `always`, `on-success` | +| `-cleanup` | Nettoyer les services orphelins au demarrage | + +## Variable d'environnement pour l'authentification + +| Variable | Description | +|----------|-------------| +| `CONSUL_HTTP_TOKEN` | Token ACL pour s'authentifier aupres de Consul | +| `CONSUL_HTTP_ADDR` | Adresse de Consul (optionnel, defaut: localhost:8500) | + +## Montage du socket Docker + +Le montage `/var/run/docker.sock:/tmp/docker.sock:ro` permet a Registrator de : + +- Surveiller les evenements Docker +- Lire les metadonnees des conteneurs +- Mode lecture seule (`:ro`) pour la securite + +## Enregistrement automatique des services + +### Sans configuration + +Par defaut, Registrator enregistre chaque port expose avec : + +- **Nom du service** : nom du conteneur + port +- **ID du service** : conteneur:port +- **Port** : port expose + +### Avec labels Docker + +Personnaliser l'enregistrement avec des labels : + +```yaml +services: + gitea: + labels: + - "SERVICE_NAME=gitea" + - "SERVICE_TAGS=web,git,vcs" + - "SERVICE_3000_CHECK_HTTP=/api/v1/version" + - "SERVICE_3000_CHECK_INTERVAL=10s" +``` + +### Labels disponibles + +| Label | Description | +|-------|-------------| +| `SERVICE_NAME` | Nom du service (override) | +| `SERVICE_TAGS` | Tags separes par des virgules | +| `SERVICE_ID` | ID personnalise | +| `SERVICE_IGNORE` | Ignorer ce conteneur (`true`) | +| `SERVICE__NAME` | Nom pour un port specifique | +| `SERVICE__TAGS` | Tags pour un port specifique | +| `SERVICE__CHECK_HTTP` | Health check HTTP | +| `SERVICE__CHECK_TCP` | Health check TCP | +| `SERVICE__CHECK_SCRIPT` | Health check script | +| `SERVICE__CHECK_INTERVAL` | Intervalle du health check | +| `SERVICE__CHECK_TIMEOUT` | Timeout du health check | + +## Exemples de configuration avec labels + +### Gitea avec health check + +```yaml +services: + gitea: + container_name: gitea + image: gitea/gitea:latest + labels: + - "SERVICE_NAME=gitea" + - "SERVICE_TAGS=web,git" + - "SERVICE_3000_CHECK_HTTP=/api/v1/version" + - "SERVICE_3000_CHECK_INTERVAL=15s" + - "SERVICE_3000_CHECK_TIMEOUT=5s" +``` + +### PostgreSQL avec health check TCP + +```yaml +services: + gitea_db: + container_name: gitea_db + image: postgres:14 + labels: + - "SERVICE_NAME=gitea-db" + - "SERVICE_TAGS=postgres,database" + - "SERVICE_5432_CHECK_TCP=true" + - "SERVICE_5432_CHECK_INTERVAL=10s" +``` + +### Woodpecker Server + +```yaml +services: + woodpecker-server: + container_name: woodpecker-server + image: woodpeckerci/woodpecker-server:latest + labels: + - "SERVICE_NAME=woodpecker" + - "SERVICE_TAGS=ci,web" + - "SERVICE_8000_CHECK_HTTP=/healthz" + - "SERVICE_8000_CHECK_INTERVAL=10s" +``` + +### Ignorer un conteneur + +```yaml +services: + internal-service: + labels: + - "SERVICE_IGNORE=true" +``` + +## Verification + +### Services enregistres + +```bash +# Via API Consul (avec token) +curl -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/catalog/services | python3 -m json.tool + +# Via UI Consul +# http://[serveur]:8500/ui/dc1/services +``` + +### Details d'un service + +```bash +curl -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/catalog/service/gitea | python3 -m json.tool +``` + +### Logs Registrator + +```bash +docker logs registrator -f +``` + +## Maintenance + +### Redemarrer Registrator + +```bash +cd /opt/registrator +docker compose restart +``` + +**Note** : Au redemarrage, Registrator re-scanne tous les conteneurs et les re-enregistre dans Consul. + +### Forcer une resynchronisation + +```bash +# Option 1 : Redemarrer Registrator +docker restart registrator + +# Option 2 : Utiliser l'option -resync +# (modifier la commande pour ajouter -resync 60) +``` + +### Nettoyer les services orphelins + +Si des services restent enregistres apres l'arret d'un conteneur : + +```bash +# Via API Consul (avec token) +curl -X PUT -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/agent/service/deregister/[service-id] + +# Ou relancer Registrator avec -cleanup +docker run --rm \ + -v /var/run/docker.sock:/tmp/docker.sock \ + -e CONSUL_HTTP_TOKEN="$REGISTRATOR_TOKEN" \ + gliderlabs/registrator:latest \ + -cleanup consul://consul:8500 +``` + +## Depannage + +### Erreur "Permission denied" ou "ACL disabled" + +Le token Registrator est invalide ou n'a pas les bonnes permissions. + +```bash +# Verifier que le token est defini +docker exec registrator env | grep CONSUL + +# Verifier les logs +docker logs registrator + +# Tester le token manuellement +curl -H "X-Consul-Token: $REGISTRATOR_TOKEN" \ + http://localhost:8500/v1/agent/services +``` + +### Registrator ne demarre pas + +```bash +# Verifier que Consul est accessible +docker exec registrator wget -qO- http://consul:8500/v1/status/leader + +# Verifier le socket Docker +docker exec registrator ls -la /tmp/docker.sock +``` + +### Services non enregistres + +1. Verifier les logs Registrator : + ```bash + docker logs registrator + ``` + +2. Verifier que le conteneur expose des ports : + ```bash + docker inspect [conteneur] | grep -A 10 "ExposedPorts" + ``` + +3. Verifier que le label `SERVICE_IGNORE` n'est pas defini + +4. Verifier que le token a les permissions `service:write` + +### Health checks echouent + +1. Verifier que le endpoint existe : + ```bash + docker exec [conteneur] curl -s http://localhost:[port]/[path] + ``` + +2. Verifier les logs du service + +3. Ajuster l'intervalle ou le timeout du health check + +## Securite + +### Token minimal + +Utiliser un token avec les permissions minimales necessaires (voir section "Configuration du token Registrator"). + +### Socket Docker en lecture seule + +Le socket Docker est monte en lecture seule (`:ro`) pour limiter les risques. + +### Ne pas versionner les secrets + +Le fichier `.env` contenant le token ne doit pas etre versionne dans git. + +## Alternatives + +Si Registrator ne repond pas a vos besoins, considerez : + +- **Consul-Template** : Generation de configuration basee sur Consul +- **Traefik** : Reverse proxy avec service discovery Docker natif +- **Fabio** : Load balancer base sur Consul diff --git a/docs/08-deploiement-consul-registrator.md b/docs/08-deploiement-consul-registrator.md new file mode 100644 index 0000000..c5ab6fe --- /dev/null +++ b/docs/08-deploiement-consul-registrator.md @@ -0,0 +1,399 @@ +# Deploiement de Consul et Registrator (mode production) + +Ce guide explique comment deployer Consul et Registrator avec ACL sur l'infrastructure existante **sans perturber les services en production**. + +## Prerequis + +- Infrastructure existante fonctionnelle (Gitea, Woodpecker, PostgreSQL) +- Acces SSH au serveur +- Reseau Docker `gitgit_syoul_fr_gitea_net` existant + +## Vue d'ensemble + +``` +AVANT (actuel) APRES (avec Consul + ACL) +---------------- ------------------------- + + [Gitea] [Gitea] <-+ + | | | + v v | + [gitea:3000] [gitea:3000] + ^ ^ | + | | | + [Woodpecker] [Woodpecker] + | | + v v + [Consul + ACL] <-- [Registrator + Token] +``` + +## Etape 1 : Copier les fichiers sur le serveur + +```bash +# Depuis votre machine locale +scp -r consul/ portainer2:/opt/ +scp -r registrator/ portainer2:/opt/ +``` + +## Etape 2 : Deployer Consul + +### Demarrer Consul + +```bash +ssh portainer2 +cd /opt/consul +docker compose up -d +``` + +### Verifier le demarrage + +```bash +# Attendre quelques secondes +sleep 10 + +# Verifier que le conteneur est lance +docker ps | grep consul + +# Verifier les logs +docker logs consul + +# Tester l'API (sans token, certaines routes sont accessibles) +curl -s http://localhost:8500/v1/status/leader +``` + +### Verifier l'interface web + +Acceder a : `http://[IP-serveur]:8500` + +**Note** : Avec les ACL activees, vous verrez un message demandant un token pour acceder aux services. + +## Etape 3 : Initialiser les ACL + +### Bootstrap des ACL + +```bash +# Generer le token administrateur +docker exec consul consul acl bootstrap +``` + +**IMPORTANT** : Notez le `SecretID` retourne. C'est votre token administrateur. + +Exemple de sortie : +``` +AccessorID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx +SecretID: abcdef12-3456-7890-abcd-ef1234567890 <-- NOTEZ CE TOKEN ! +Description: Bootstrap Token (Global Management) +Local: false +Create Time: 2025-01-01 00:00:00.000000000 +0000 UTC +Policies: + 00000000-0000-0000-0000-000000000001 - global-management +``` + +### Stocker le token admin + +```bash +# Sur le serveur, creer le fichier .env pour Consul +cd /opt/consul +echo "CONSUL_HTTP_TOKEN=abcdef12-3456-7890-abcd-ef1234567890" > .env +chmod 600 .env + +# Exporter pour les commandes suivantes +export CONSUL_TOKEN="abcdef12-3456-7890-abcd-ef1234567890" +``` + +### Creer la policy pour Registrator + +```bash +docker exec consul consul acl policy create \ + -name "registrator" \ + -description "Policy pour Registrator - enregistrement des services" \ + -rules ' +service_prefix "" { + policy = "write" +} +node_prefix "" { + policy = "read" +} +agent_prefix "" { + policy = "read" +} +' \ + -token "$CONSUL_TOKEN" +``` + +### Creer le token Registrator + +```bash +docker exec consul consul acl token create \ + -description "Token Registrator" \ + -policy-name "registrator" \ + -token "$CONSUL_TOKEN" +``` + +Notez le `SecretID` du token Registrator. + +Exemple : +``` +AccessorID: yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy +SecretID: registr8-or12-3456-7890-tokenexample <-- TOKEN REGISTRATOR +Description: Token Registrator +... +``` + +## Etape 4 : Deployer Registrator + +### Configurer le token + +```bash +cd /opt/registrator + +# Creer le fichier .env avec le token Registrator +echo "CONSUL_HTTP_TOKEN=registr8-or12-3456-7890-tokenexample" > .env +chmod 600 .env +``` + +### Demarrer Registrator + +```bash +docker compose up -d +``` + +### Verifier le demarrage + +```bash +# Verifier que le conteneur est lance +docker ps | grep registrator + +# Verifier les logs (pas d'erreur ACL) +docker logs registrator +``` + +## Etape 5 : Verifier les services enregistres + +```bash +# Via l'API (avec token admin) +curl -s -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/catalog/services | python3 -m json.tool +``` + +Vous devriez voir les services existants : +```json +{ + "consul": [], + "gitea-3000": [], + "woodpecker-server-8000": [], + "gitea_db-5432": [] +} +``` + +**Note** : Les noms de services sont automatiques. Pour des noms propres, ajoutez des labels (etape suivante). + +## Etape 6 : Ajouter les labels aux services (optionnel mais recommande) + +Pour avoir des noms de services propres et des health checks, modifier les docker-compose existants. + +### Gitea + +Modifier `/opt/gitea/docker-compose.yml` : + +```yaml +services: + gitea: + container_name: gitea + image: gitea/gitea:latest + restart: always + + # Ajouter ces labels + labels: + - "SERVICE_NAME=gitea" + - "SERVICE_TAGS=web,git" + - "SERVICE_3000_CHECK_HTTP=/api/v1/version" + - "SERVICE_3000_CHECK_INTERVAL=15s" + + # ... reste de la configuration inchangee ... +``` + +### PostgreSQL + +Modifier `/opt/postgres/docker-compose.yml` : + +```yaml +services: + gitea_db: + container_name: gitea_db + image: postgres:14 + restart: always + + # Ajouter ces labels + labels: + - "SERVICE_NAME=gitea-db" + - "SERVICE_TAGS=postgres,database" + - "SERVICE_5432_CHECK_TCP=true" + - "SERVICE_5432_CHECK_INTERVAL=10s" + + # ... reste de la configuration inchangee ... +``` + +### Woodpecker + +Modifier `/opt/woodpecker/docker-compose.yml` : + +```yaml +services: + woodpecker-server: + # ... + labels: + - "SERVICE_NAME=woodpecker" + - "SERVICE_TAGS=ci,web" + - "SERVICE_8000_CHECK_HTTP=/healthz" + - "SERVICE_8000_CHECK_INTERVAL=15s" + + woodpecker-agent: + # ... + labels: + - "SERVICE_NAME=woodpecker-agent" + - "SERVICE_TAGS=ci,agent" +``` + +### Appliquer les changements + +```bash +# Pour chaque service modifie +cd /opt/[service] +docker compose up -d +``` + +**Note** : Cette operation redemarrera les conteneurs. Effectuer pendant une periode de faible activite. + +## Etape 7 : Tester la resolution DNS (optionnel) + +### Depuis le serveur + +```bash +dig @localhost -p 8600 gitea.service.consul +dig @localhost -p 8600 woodpecker.service.consul +dig @localhost -p 8600 gitea-db.service.consul +``` + +### Depuis un conteneur + +```bash +docker exec consul dig @127.0.0.1 -p 8600 gitea.service.consul +``` + +## Verification finale + +### Tous les services sont enregistres + +```bash +curl -s -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/catalog/services | python3 -m json.tool +``` + +Resultat attendu (avec labels) : + +```json +{ + "consul": [], + "gitea": ["web", "git"], + "gitea-db": ["postgres", "database"], + "woodpecker": ["ci", "web"], + "woodpecker-agent": ["ci", "agent"] +} +``` + +### Health checks sont verts + +Dans l'interface Consul : `http://[IP-serveur]:8500/ui/dc1/services` + +Utilisez le token admin pour voir les services. Tous devraient avoir un statut "passing" (vert). + +### Resolution DNS fonctionne + +```bash +dig @localhost -p 8600 gitea.service.consul +short +# Devrait retourner l'IP du conteneur gitea +``` + +### Tokens fonctionnels + +```bash +# Test token admin +curl -s -H "X-Consul-Token: $CONSUL_TOKEN" \ + http://localhost:8500/v1/acl/tokens | head -20 + +# Test token Registrator (via logs) +docker logs registrator 2>&1 | grep -i error +# Pas d'erreur = token OK +``` + +## Resume des tokens + +| Token | Fichier | Usage | +|-------|---------|-------| +| Admin (bootstrap) | `/opt/consul/.env` | Administration Consul | +| Registrator | `/opt/registrator/.env` | Enregistrement des services | + +## Rollback + +Si vous rencontrez des problemes et souhaitez desactiver Consul/Registrator : + +```bash +# Arreter Registrator et Consul +cd /opt/registrator && docker compose down +cd /opt/consul && docker compose down + +# Les services existants continueront de fonctionner normalement +# via le reseau Docker classique +``` + +Pour repartir de zero (supprimer les donnees Consul) : + +```bash +docker volume rm consul_consul-data +``` + +## Securite - Bonnes pratiques + +### 1. Proteger les fichiers .env + +```bash +chmod 600 /opt/consul/.env +chmod 600 /opt/registrator/.env +``` + +### 2. Ne pas exposer le port 8500 sur Internet + +Utiliser un firewall ou n'exposer que sur localhost : + +```yaml +ports: + - "127.0.0.1:8500:8500" +``` + +### 3. Rotation des tokens + +Periodiquement (ex: tous les 3 mois) : + +1. Creer un nouveau token Registrator +2. Mettre a jour `/opt/registrator/.env` +3. Redemarrer Registrator +4. Revoquer l'ancien token + +### 4. Sauvegardes + +```bash +# Sauvegarder Consul +docker exec consul consul snapshot save /consul/data/backup.snap -token "$CONSUL_TOKEN" +docker cp consul:/consul/data/backup.snap ./consul_backup_$(date +%Y%m%d).snap + +# Sauvegarder les tokens (fichiers .env) +cp /opt/consul/.env ./consul_env_backup_$(date +%Y%m%d) +cp /opt/registrator/.env ./registrator_env_backup_$(date +%Y%m%d) +``` + +## Prochaines etapes + +1. **Surveillance** : Ajouter des alertes basees sur les health checks Consul +2. **Configuration distribuee** : Utiliser le Key/Value store de Consul +3. **Haute disponibilite** : Deployer plusieurs noeuds Consul +4. **TLS** : Activer le chiffrement des communications diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 0000000..0598061 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,142 @@ +# Documentation Infrastructure Git CI/CD + +Cette documentation couvre l'installation, la configuration et la maintenance de l'infrastructure Git et CI/CD. + +## Index + +### Architecture et Installation + +1. [Architecture](01-architecture.md) - Vue d'ensemble de l'infrastructure +2. [Installation](02-installation.md) - Guide d'installation complet + +### Configuration des services + +3. [Gitea](03-configuration-gitea.md) - Serveur Git auto-heberge +4. [Woodpecker](04-configuration-woodpecker.md) - CI/CD +5. [PostgreSQL](05-configuration-postgresql.md) - Base de donnees + +### Service Discovery (optionnel, mode production) + +6. [Consul](06-configuration-consul.md) - Service discovery avec ACL +7. [Registrator](07-configuration-registrator.md) - Auto-registration Docker avec token +8. [Deploiement Consul](08-deploiement-consul-registrator.md) - Guide de deploiement securise + +## Stack technique + +| Composant | Version | Description | +|-----------|---------|-------------| +| Gitea | latest | Serveur Git | +| Woodpecker | latest | CI/CD | +| PostgreSQL | 14 | Base de donnees | +| Consul | latest | Service discovery avec ACL | +| Registrator | latest | Auto-registration avec token | + +## Mode production + +Cette infrastructure est configuree pour la production avec : + +- **ACL Consul** : Controle d'acces active (`default_policy: deny`) +- **Tokens separes** : Token admin et token Registrator +- **Secrets non versionnes** : Fichiers `.env` a creer sur le serveur + +### Fichiers de secrets (non versionnes) + +| Fichier | Contenu | +|---------|---------| +| `/opt/consul/.env` | Token administrateur Consul | +| `/opt/registrator/.env` | Token Registrator | + +## URLs d'acces + +| Service | URL | +|---------|-----| +| Gitea | http://git.syoul.fr | +| Woodpecker | https://ci.syoul.fr | +| Consul UI | http://[serveur]:8500 (local, token requis) | + +## Structure des dossiers + +``` +/opt/ + consul/ + docker-compose.yml + env.template # Template pour .env + .env # Token admin (a creer, non versionne) + gitea/ + docker-compose.yml + gitea.env + postgres/ + docker-compose.yml + registrator/ + docker-compose.yml + env.template # Template pour .env + .env # Token Registrator (a creer, non versionne) + woodpecker/ + docker-compose.yml +``` + +## Reseau Docker + +Tous les services utilisent le reseau : `gitgit_syoul_fr_gitea_net` + +## Commandes rapides + +### Etat des services + +```bash +docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" +``` + +### Logs d'un service + +```bash +docker logs -f [nom-conteneur] +``` + +### Redemarrer un service + +```bash +cd /opt/[service] +docker compose restart +``` + +### Sauvegarder la base de donnees + +```bash +docker exec gitea_db pg_dump -U gitea gitea > backup_$(date +%Y%m%d).sql +``` + +### Sauvegarder Consul + +```bash +export CONSUL_TOKEN="votre-token-admin" +docker exec consul consul snapshot save /consul/data/backup.snap -token "$CONSUL_TOKEN" +docker cp consul:/consul/data/backup.snap ./consul_backup_$(date +%Y%m%d).snap +``` + +### Lister les services Consul + +```bash +export CONSUL_TOKEN="votre-token-admin" +curl -s -H "X-Consul-Token: $CONSUL_TOKEN" http://localhost:8500/v1/catalog/services +``` + +## Securite + +### Bonnes pratiques appliquees + +1. **ACL Consul** : Tout est interdit par defaut +2. **Tokens separes** : Chaque service a son propre token +3. **Secrets non versionnes** : Les fichiers `.env` ne sont pas dans git +4. **Permissions fichiers** : `chmod 600` sur les fichiers `.env` + +### A faire sur le serveur + +- Ne pas exposer le port 8500 sur Internet +- Configurer un firewall +- Rotation periodique des tokens + +## Contacts et support + +- **Administrateur** : syoul +- **Email** : contact@anuanua.fr diff --git a/gitea/docker-compose.yml b/gitea/docker-compose.yml new file mode 100644 index 0000000..ca0b2a3 --- /dev/null +++ b/gitea/docker-compose.yml @@ -0,0 +1,46 @@ + GNU nano 7.2 /opt/gitea/docker-compose.yml +version: "3.9" + +services: + gitea: + container_name: gitea + image: gitea/gitea:latest + restart: always + + env_file: + - gitea.env + + networks: + - gitgit_syoul_fr_gitea_net + + volumes: + - gitgit_syoul_fr_gitea_data:/data + + ports: + - "3300:3000" + - "2222:22" + +# depends_on: +# - gitea_db + +# gitea_db: +# container_name: gitea_db +# image: postgres:14 +# restart: always +# +# environment: +# POSTGRES_DB: gitea +# POSTGRES_USER: gitea +# POSTGRES_PASSWORD: Gitea_Db-2025_Secure + +volumes: + gitgit_syoul_fr_gitea_data: + external: true + + +networks: + gitgit_syoul_fr_gitea_net: + external: true +# gitgit_syoul_fr_db_data: +# external: true + diff --git a/postgres/README.md b/postgres/README.md new file mode 100644 index 0000000..fc2b6d4 --- /dev/null +++ b/postgres/README.md @@ -0,0 +1,100 @@ +# Configuration PostgreSQL pour Gitea + +Ce dossier contient la configuration Docker Compose pour pérenniser le conteneur PostgreSQL de Gitea. + +## Configuration actuelle + +- **Image** : `postgres:14` +- **Nom du conteneur** : `gitea_db` +- **Volume** : `gitgit_syoul_fr_db_data` (existant, ne sera pas recréé) +- **Réseau** : `gitgit_syoul_fr_gitea_net` (existant, ne sera pas recréé) +- **Restart policy** : `always` + +## Utilisation + +### Vérifier la configuration + +```bash +cd /opt/postgres # ou le chemin où vous avez copié ce fichier +docker compose config +``` + +### Important : Ne pas appliquer maintenant + +**ATTENTION** : Le conteneur PostgreSQL est actuellement en production et fonctionne. Ce fichier docker-compose.yml est une sauvegarde de la configuration pour le jour où vous devrez recréer le conteneur. + +### Quand utiliser ce fichier + +1. **En cas de migration** : Si vous devez déplacer le conteneur vers un autre serveur +2. **En cas de recréation** : Si le conteneur doit être recréé (mise à jour, problème, etc.) +3. **Pour la documentation** : Pour avoir une trace de la configuration actuelle + +### Procédure de migration/recréation (à faire plus tard) + +1. **Sauvegarder la base de données** : + ```bash + docker exec gitea_db pg_dump -U gitea gitea > backup_$(date +%Y%m%d).sql + ``` + +2. **Arrêter le conteneur existant** (si nécessaire) : + ```bash + docker stop gitea_db + ``` + +3. **Utiliser le docker-compose.yml** : + ```bash + cd /opt/postgres + docker compose up -d + ``` + +4. **Vérifier que tout fonctionne** : + ```bash + docker ps | grep gitea_db + docker logs gitea_db + ``` + +### Notes importantes + +- Le volume `gitgit_syoul_fr_db_data` contient toutes les données PostgreSQL +- Le réseau `gitgit_syoul_fr_gitea_net` est partagé avec Gitea et Woodpecker +- Le mot de passe est celui actuellement utilisé en production +- Aucun port n'est exposé (communication interne uniquement) + +## Sécurité + +### Version actuelle (docker-compose.yml) + +Le mot de passe est stocké en clair dans le `docker-compose.yml` avec la valeur actuelle : `Gitea_Db-2025_Secure` + +### Version sécurisée avec fichier .env (optionnelle) + +Pour une meilleure sécurité, vous pouvez utiliser `docker-compose.env.yml` qui charge les variables depuis un fichier `.env` : + +1. **Créer le fichier .env** (sur le serveur uniquement, ne pas versionner) : + ```bash + cd /opt/postgres + cat > .env << 'EOF' + POSTGRES_USER=gitea + POSTGRES_PASSWORD=Gitea_Db-2025_Secure + POSTGRES_DB=gitea + EOF + ``` + +2. **Vérifier que .env est ignoré par git** : + ```bash + echo ".env" >> .gitignore + git check-ignore .env + ``` + +3. **Utiliser la version avec .env** : + ```bash + docker compose -f docker-compose.env.yml up -d + ``` + +### Alternatives de sécurité avancées + +Pour une sécurité encore plus poussée : +1. Utiliser Docker Secrets (en mode Swarm) +2. Utiliser un gestionnaire de secrets externe (Vault, etc.) +3. Chiffrer le fichier `.env` avec des outils comme `sops` ou `ansible-vault` + diff --git a/postgres/docker-compose.env.yml b/postgres/docker-compose.env.yml new file mode 100644 index 0000000..49ee002 --- /dev/null +++ b/postgres/docker-compose.env.yml @@ -0,0 +1,39 @@ +version: "3.9" + +# Version alternative avec fichier .env pour plus de sécurité +# Pour utiliser cette version : +# 1. Copiez .env.example vers .env +# 2. Remplissez les vraies valeurs dans .env +# 3. Utilisez ce fichier au lieu de docker-compose.yml + +services: + gitea_db: + container_name: gitea_db + image: postgres:14 + restart: always + + env_file: + - .env + + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + + volumes: + - gitgit_syoul_fr_db_data:/var/lib/postgresql/data + + networks: + - gitgit_syoul_fr_gitea_net + + # Pas de ports exposés - communication interne uniquement + # Le conteneur est accessible via le réseau Docker via les aliases: gitea_db, db + +volumes: + gitgit_syoul_fr_db_data: + external: true + +networks: + gitgit_syoul_fr_gitea_net: + external: true + diff --git a/postgres/docker-compose.yml b/postgres/docker-compose.yml new file mode 100644 index 0000000..18a6e64 --- /dev/null +++ b/postgres/docker-compose.yml @@ -0,0 +1,30 @@ +version: "3.9" + +services: + gitea_db: + container_name: gitea_db + image: postgres:14 + restart: always + + environment: + POSTGRES_USER: gitea + POSTGRES_PASSWORD: Gitea_Db-2025_Secure + POSTGRES_DB: gitea + + volumes: + - gitgit_syoul_fr_db_data:/var/lib/postgresql/data + + networks: + - gitgit_syoul_fr_gitea_net + + # Pas de ports exposés - communication interne uniquement + # Le conteneur est accessible via le réseau Docker via les aliases: gitea_db, db + +volumes: + gitgit_syoul_fr_db_data: + external: true + +networks: + gitgit_syoul_fr_gitea_net: + external: true + diff --git a/registrator/docker-compose.yml b/registrator/docker-compose.yml new file mode 100644 index 0000000..168ac94 --- /dev/null +++ b/registrator/docker-compose.yml @@ -0,0 +1,24 @@ +services: + registrator: + container_name: registrator + image: gliderlabs/registrator:latest + restart: unless-stopped + + # IMPORTANT : Creer le fichier .env a partir de env.template avant le deploiement + # Le fichier .env contient le token CONSUL_HTTP_TOKEN pour l'authentification ACL + env_file: + - .env + + # -internal : utilise les IPs internes Docker + # Le token est passe via la variable d'environnement CONSUL_HTTP_TOKEN + command: -internal consul://consul:8500 + + volumes: + - /var/run/docker.sock:/tmp/docker.sock:ro + + networks: + - gitgit_syoul_fr_gitea_net + +networks: + gitgit_syoul_fr_gitea_net: + external: true diff --git a/registrator/env.template b/registrator/env.template new file mode 100644 index 0000000..02cacf2 --- /dev/null +++ b/registrator/env.template @@ -0,0 +1,11 @@ +# Token Consul pour Registrator +# Ce token doit avoir les permissions : service:write, node:read, agent:read +# Genere lors de l'initialisation des ACL Consul +# +# INSTRUCTIONS : +# 1. Copier ce fichier vers .env +# 2. Remplacer la valeur du token par le vrai token +# 3. NE PAS VERSIONNER le fichier .env ! + +CONSUL_HTTP_TOKEN=votre-token-registrator-ici + diff --git a/woodpecker/docker-compose.yml b/woodpecker/docker-compose.yml new file mode 100644 index 0000000..30c5352 --- /dev/null +++ b/woodpecker/docker-compose.yml @@ -0,0 +1,46 @@ +version: "3.8" + +services: + woodpecker-server: + image: woodpeckerci/woodpecker-server:latest + container_name: woodpecker-server + restart: unless-stopped + ports: + - "9001:8000" + environment: + WOODPECKER_GITEA: "true" + WOODPECKER_GITEA_URL: "http://gitea:3000" + WOODPECKER_GITEA_CLIENT: "77390faa-e609-4f00-846b-955aab74095e" + WOODPECKER_GITEA_SECRET: "gto_iz4cxjukjemthvcqkovb4lnmaf5cbqvmudzemowclyok54k647dq" + + WOODPECKER_AGENT_SECRET: "620d5723e91c8d6b220d50fb3790dc12b7a166181dddbce0e05a616c5b2e4aa6" + WOODPECKER_ADMIN: "syoul" + WOODPECKER_HOST: "https://ci.syoul.fr" + + volumes: + - woodpecker-data:/var/lib/woodpecker + networks: + - gitea_net + + woodpecker-agent: + image: woodpeckerci/woodpecker-agent:latest + container_name: woodpecker-agent + restart: unless-stopped + depends_on: + - woodpecker-server + environment: + WOODPECKER_SERVER: "woodpecker-server:9000" + WOODPECKER_AGENT_SECRET: "620d5723e91c8d6b220d50fb3790dc12b7a166181dddbce0e05a616c5b2e4aa6" + WOODPECKER_HEALTHCHECK_ADDR: ":3001" + volumes: + - /var/run/docker.sock:/var/run/docker.sock + networks: + - gitea_net + +volumes: + woodpecker-data: + +networks: + gitea_net: + external: true + name: gitgit_syoul_fr_gitea_net