syoul/infrastructure
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: Infrastructure Git CI/CD avec Gitea, Woodpecker, PostgreSQL, Consul et Registrator

Browse Source
This commit is contained in:
syoul
2025-12-23 20:11:09 +01:00
commit de02fb28ca
20 changed files with 2685 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
docs/01-architecture.md Normal file
View File

@ -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 |

176
docs/02-installation.md Normal file
View File

@ -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
```

160
docs/03-configuration-gitea.md Normal file
View File

@ -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
```

209
docs/04-configuration-woodpecker.md Normal file
View File

@ -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
```

213
docs/05-configuration-postgresql.md Normal file
View File

@ -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
```

423
docs/06-configuration-consul.md Normal file
View File

@ -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>.service.consul` : Service global
- `<service>.service.<datacenter>.consul` : Service dans un datacenter specifique
- `<node>.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 ...
```

370
docs/07-configuration-registrator.md Normal file
View File

@ -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_<port>_NAME` | Nom pour un port specifique |
| `SERVICE_<port>_TAGS` | Tags pour un port specifique |
| `SERVICE_<port>_CHECK_HTTP` | Health check HTTP |
| `SERVICE_<port>_CHECK_TCP` | Health check TCP |
| `SERVICE_<port>_CHECK_SCRIPT` | Health check script |
| `SERVICE_<port>_CHECK_INTERVAL` | Intervalle du health check |
| `SERVICE_<port>_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

399
docs/08-deploiement-consul-registrator.md Normal file
View File

@ -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

142
docs/README.md Normal file
View File

@ -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