Prérequis Installation

Vérifier tous les prérequis AVANT de commencer l'installation.

1. Système d'exploitation

OS	Status	Notes
Ubuntu 22.04 LTS	✅ Obligatoire	Seul OS supporté (nftables + iptables-nft)
Ubuntu 24.04 LTS	✅ Supporté	Testé, compatible
Debian 12	⚠️ Limité	nftables peut avoir des bugs
RHEL/CentOS 9	❌ Non	iptables-nft incompatible avec Docker 29
Autres distros	❌ Non	Non testé

Vérification:

lsb_release -a
# Devrait afficher: Release: 22.04 (ou 24.04)

cat /etc/issue
# Devrait afficher: Ubuntu 22.04.x LTS

2. Matériel (CPU / RAM / Disk)

Composant	Minimum	Recommandé	Notes
CPU	4 cores	8 cores	ARM (Raspberry) non supporté
RAM	8 GB	16 GB	12 services concurrents + logs
Disk	100 GB SSD	200 GB SSD	ELK 12 mois = 40-60 GB
Type Disk	SSD	NVMe	HDD = trop lent pour logs

Vérification:

# CPU
lscpu | grep "^CPU(s):"
nproc

# RAM
free -h | grep Mem

# Disk
df -h | grep "/$"

3. Logiciels requis

Docker 29.x

# Installer
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
newgrp docker

# Vérifier
docker --version
# Doit afficher: Docker version 29.x ou plus

docker buildx version
# Doit afficher: buildx version v0.x

Docker Compose 2.x (plugin)

# Vérifier (installé avec Docker 29+)
docker compose version
# Doit afficher: Docker Compose version v2.x ou plus

# Si absent
sudo apt-get update
sudo apt-get install docker-compose-plugin

Git, curl, openssl

# Installer
sudo apt-get install -y git curl openssl

# Vérifier
git --version
curl --version
openssl version

4. Réseau

IP fixe

# Vérifier
ip addr show | grep "inet " | grep -v "127.0.0.1"
# Devrait afficher une IP 192.168.x.x ou 10.x.x.x

# Si non-fixe, configurer
sudo nano /etc/netplan/01-netcfg.yaml
# Ajouter: dhcp4: no + static IP
sudo netplan apply

Ports ouverts

Ouvrir dans le firewall/routeur :

Port	Protocole	Service	Qui
80	TCP	HTTP (redirect HTTPS)	Traefik
443	TCP	HTTPS (API, admin, portail)	Traefik
1812	UDP	RADIUS Auth	CPE
1813	UDP	RADIUS Acct	CPE
2055	UDP	NetFlow	Switches/APs
51820	UDP	WireGuard VPN	Sites distants

Vérification (sur serveur):

# Écouter sur tous les ports
sudo netstat -tuln | grep LISTEN

# Ou avec ss
ss -tuln | grep LISTEN

Résolution DNS

# Vérifier connectivité
ping 8.8.8.8
nslookup google.com

# Si erreur: configurer /etc/resolv.conf
sudo nano /etc/resolv.conf
# Ajouter: nameserver 8.8.8.8

5. DuckDNS — Domaines & Token

Créer compte DuckDNS

1. Aller sur https://www.duckdns.org
2. Sign in (Google, GitHub, etc.)
3. Copier le token (visible dans dashboard)

Configurer 6 domaines

Créer dans DuckDNS dashboard :

Domaine	Utilisé pour	Points à
api-rgz	API FastAPI + webhook KKiaPay	IP serveur RGZ
admin-rgz	Dashboard admin React	IP serveur RGZ
access-rgz	Portail captif abonnés	IP serveur RGZ
grafana-rgz	Dashboard Grafana	IP serveur RGZ
registre-rgz	Site recensement (#81)	IP serveur RGZ
docs-rgz	Documentation (ce site)	IP serveur RGZ

Chaque domaine:

Domain: api-rgz
IP: [votre-ip-publique]
Token: [votre-token-duckdns]

Tester résolution

nslookup api-rgz.duckdns.org
# Doit retourner votre IP publique

Authentifier avec DuckDNS (automatique dans docker-compose)

# DuckDNS utilise token pour authentification
# certbot-dns-duckdns (via Traefik) = token dans .env

6. Clés API externes

Obtenir AVANT démarrage (section Installation les utilisera).

KKiaPay (Paiement mobile)

1. Créer compte: https://kkiapay.me
2. Activer sandbox ou production
3. Copier: Public Key + Secret Key

# Tester
curl -X POST https://api-sandbox.kkiapay.me/api/v1/transactions \
  -H "Authorization: Bearer PUBLIC_KEY" \
  -d '{"amount": 1000}'

Letexto (SMS)

1. Créer compte: https://letexto.com
2. Générer API Key
3. Copier: API Key

# Tester
curl -X POST https://api.letexto.com/send \
  -H "Authorization: Bearer API_KEY" \
  -d '{"phone": "+229xxxxx", "message": "test"}'

WhatsApp Business API

1. Créer compte Meta Business: https://business.facebook.com
2. Demander accès WhatsApp Business API
3. Copier: API Token + Phone Number ID

# Tester
curl -X POST https://graph.instagram.com/v19.0/YOUR_PHONE_NUMBER_ID/messages \
  -H "Authorization: Bearer YOUR_API_TOKEN"

SMTP (Email)

Utiliser:

• Gmail: App Password (si 2FA activé)
• SendGrid: API Key
• Postfix local: pas de credentials

# Tester
echo "test" | mail -s "test" user@example.com

7. Vérification complète

# Script de vérification (à créer)
#!/bin/bash

echo "=== Vérification prérequis RGZ ==="

# OS
echo -n "OS: "
lsb_release -a 2>/dev/null | grep Release | awk '{print $2}'

# CPU
echo -n "CPU: "
nproc
echo " cores"

# RAM
echo -n "RAM: "
free -h | grep Mem | awk '{print $2}'

# Disk
echo -n "Disk: "
df -h | grep "/$" | awk '{print $4}'

# Docker
echo -n "Docker: "
docker --version

# Docker Compose
echo -n "Compose: "
docker compose version

# Git
echo -n "Git: "
git --version

# Réseau
echo -n "IP: "
ip addr show | grep "inet " | grep -v "127.0.0.1" | awk '{print $2}' | head -1

# DuckDNS
echo -n "DuckDNS (api-rgz): "
nslookup api-rgz.duckdns.org 2>/dev/null | grep "Address:" | tail -1 | awk '{print $2}'

echo "=== OK si tout affiche les valeurs ==="

⚠️ Lessons Learned Critiques

LL	Règle
LL#40	JAMAIS nft flush ruleset sur Docker = détruit chains Docker + perte connectivité
LL#72	Docker Compose crée réseau rgz_rgz-net (préfixé par projet)
LL#43	Healthcheck Docker = toujours utiliser 127.0.0.1 (jamais localhost)

Checkpoints avant installation

• [ ] OS = Ubuntu 22.04 LTS (vérifiée)
• [ ] CPU ≥ 4 cores
• [ ] RAM ≥ 8 GB
• [ ] Disk ≥ 100 GB SSD
• [ ] Docker 29.x installé
• [ ] Docker Compose 2.x opérationnel
• [ ] IP fixe configurée
• [ ] Ports 80, 443 ouverts firewall
• [ ] Ports 1812, 1813, 2055 UDP ouverts
• [ ] 6 domaines DuckDNS créés (api-rgz, admin-rgz, access-rgz, grafana-rgz, registre-rgz, docs-rgz)
• [ ] Token DuckDNS copié
• [ ] Clés API KKiaPay, Letexto, WhatsApp obtenues
• [ ] nslookup api-rgz.duckdns.org = IP publique ✅

Étape suivante: Installation