1. Structure Modulaire par include:

Le docker-compose.yml racine de sever-admin ne définit aucun service. Il fusionne 7 fichiers via la directive include: de Docker Compose — le tout forme UN SEUL projet Compose :

# sever-admin/docker-compose.yml (contenu réel)
include:
  - docker-compose.cache.yml          # redis
  - docker-compose.broker.yml         # broker Kafka + Zookeeper + kafka-ui
  - docker-compose.db-admin.yml       # adminer
  - docker-compose.doc.yml            # server_admin_doc (documentation Nginx)
  - docker-compose.ansible.yml        # semaphore + rundeck
  - docker-compose.monitoring.yml     # dozzle + beszel-hub + beszel-agent
  - docker-compose.observability.yml  # loki + promtail + grafana

Conséquences pratiques :

cd /home/admin/app/sever-admin
docker compose up -d                 # tout le stack infra
docker compose up -d grafana         # un seul service (grâce à la fusion include)
docker compose -f docker-compose.observability.yml up -d   # un seul groupe

Les chemins bind-mount (./build, ./monitoring) restent relatifs à la racine du repo car les fichiers inclus y sont tous.

2. Le Réseau : proxy_server_network

Réseau Docker externe (créé une fois, hors compose) partagé par tous les stacks (sever-admin, clarajob_sa, marketisia, auth-server, main-server-proxy) :

networks:
  proxy_server_network:
    external: true

  • Communication inter-stack par nom de container : marketisia-front-api joint Kafka via marketisia-kafka:29092, ClaraJob joint sa DB via clarajob-ddl:5432

  • Traefik route le trafic HTTPS entrant vers les containers via les labels (traefik.http.routers.*.rule=Host(…​))

  • Création si absent : docker network create proxy_server_network

3. Détail des Fichiers Compose (services réels)

3.1. docker-compose.cache.yml — Redis partagé

Container

redis (image redis:7-alpine)

Config

--appendonly yes --requirepass ${REDIS_PASSWORD} --maxmemory 32mb --maxmemory-policy allkeys-lru

Port

${REDIS_PORT:-6379}:6379

Volume

redis-data:/data

Limite RAM

40m (maxmemory 32mb < mem_limit pour laisser la marge AOF et éviter l’OOM-killer)

Healthcheck

redis-cli --raw incr ping toutes les 10s

Connexion via RedisInsight : redis://default:${REDIS_PASSWORD}@redis:6379 (user default, DB 0).

3.2. docker-compose.broker.yml — Messaging partagé (source de vérité UNIQUE)

Stack consommée par hostname par les services applicatifs (marketisia-front-api, paiement-service, …) qui ne la redéploient jamais.

Container Image Ports Notes

marketisia-kafka

confluentinc/cp-kafka:7.6.0

9092, 29092

Listeners : PLAINTEXT://marketisia-kafka:29092 (interne Docker) + PLAINTEXT_HOST://localhost:9092 (hôte). Rétention logs 168h. Auto-create topics ON. mem 512m.

marketisia-zookeeper

confluentinc/cp-zookeeper:7.6.0

interne (2181)

Coordination Kafka. mem 128m.

schema-registry

confluentinc/cp-schema-registry:7.6.0

8081

Registre de schémas Avro/JSON. mem 512m.

rabbitmq

rabbitmq:3.13-management

5672 (AMQP), 15672 (UI)

User/pass par défaut dev/dev (variables RABBITMQ_USER/RABBITMQ_PASS).

marketisia-kafka-ui

provectuslabs/kafka-ui:latest

8091 → 8080

Monitoring et injection de messages depuis le navigateur. Cluster marketisia-local. mem 384m.

Le port hôte de Kafka UI est 8091 (pas 8090) — 8090 est réservé à Beszel Hub. Depuis un container applicatif, le bootstrap server Kafka est marketisia-kafka:29092 ; depuis l’hôte, localhost:9092.

3.3. docker-compose.db-admin.yml — Admin DB

Container Image Port Notes

adminer

adminer

9093 → 8080

Exposé aussi via Traefik : adminer.marketisia.com, adminer.clarajob.com, adminer.pretydate.com. mem 50m.

marketisia-pgadmin

dpage/pgadmin4:latest

5050 → 80

Serveurs pré-provisionnés via ./docker/pgadmin/servers.json. mem 128m.

3.4. docker-compose.doc.yml — Documentation

Container

server_admin_doc (image nginx:latest)

Port

${DOCPORT}:80 (8050 en production)

Volume

./build/generatedSite:/usr/share/nginx/html — le site AsciiDoc généré par le build Gradle

3.5. docker-compose.ansible.yml — Pilotage Ansible par UI web

Container Image Port Notes

semaphore

semaphoreui/semaphore:latest

3001 → 3000

UI web pour exécuter les playbooks (backup/restore/deploy). Stockage BoltDB local (pas de DB externe). Login par défaut admin/admin.

rundeck

rundeck/rundeck:5.6.0

4440

Alternative à Semaphore : workflows multi-steps, RBAC, scheduler, audit log. H2 embedded. ⚠️ JVM ~1 Go RAM. Login admin/admin.

3.6. docker-compose.monitoring.yml — Monitoring

Container Image Port Notes

clarajob-dozzle

amir20/dozzle:latest

9999 → 8080

Logs Docker temps réel dans le navigateur. Lecture seule (docker.sock:ro), aucune donnée stockée. mem 40m.

beszel-hub

henrygd/beszel:latest

8090

Dashboard métriques CPU/RAM/disque/réseau + monitoring containers. Traefik : beszel.clarajob.com / beszel.marketisia.com. Premier login : créer le compte admin. mem 100m.

beszel-agent

henrygd/beszel-agent:latest

host network (45876)

Agent qui collecte les métriques et les pousse au hub (clé BESZEL_AGENT_KEY). mem 50m.

redisinsight

redis/redisinsight:latest

5540

UI Redis (exploration clés, monitoring). Labels Traefik présents.

3.7. docker-compose.observability.yml — Logs centralisés

Container Image Port Notes

loki

grafana/loki:3.4.2

interne (3100)

Stockage/agrégation des logs. Config : ./monitoring/loki/loki-config.yml. mem 150m.

promtail

grafana/promtail:3.4.2

interne

Collecteur : lit /var/lib/docker/containers + docker.sock et pousse vers Loki. mem 100m.

grafana

grafana/grafana:12.0.0

3000

Dashboards. Datasource Loki provisionnée via ./monitoring/grafana/provisioning. Login : GRAFANA_ADMIN_USER/GRAFANA_ADMIN_PASSWORD (défaut admin/admin). mem 150m.

Chaîne complète : containers → Promtail → Loki → Grafana (pas de Prometheus ni d’ELK dans ce projet).

4. Stacks Applicatifs (repos séparés)

Rappel — ces services ne sont pas dans sever-admin, mais dans les compose de leurs repos :

clarajob_sa/docker-compose.yml :
  clarajob-ddl, clarajob-mongo, clarajob-mongoku, clarajob-redis,
  minio-service, minio-backup, clarajob-front-api, clarajob-front-gui,
  swagger-ui, redoc, rapidoc   (+ cible Ansible clarajob-embedding)

marketisia/docker/docker-compose.yml :
  marketisia-ddl, marketisia-redis, marketisia-front-api, marketisia-front-gui

auth-server/docker-compose.yml :
  auth_server_db, keycloak

documentation/docker-compose.yml :
  documentation   (nginx:latest servant build/generatedSite — pré-généré et versionné,
                   router Traefik "documentation" : documentation.clarajob.com
                   || documentation.marketisia.com || documentation.pretydate.com)

main-server-proxy/docker-compose.yml :
  traefik-service

5. Conventions Observées dans les Compose du Projet

Ces patterns sont appliqués de façon systématique — à respecter pour tout nouveau service :

  1. networks: [proxy_server_network] (external) sur chaque service

  2. restart: unless-stopped (ou always pour adminer/doc)

  3. mem_limit + memswap_limit sur chaque service (serveur Lightsail à RAM limitée : 40m à 1g selon le service)

  4. Healthchecks sur les services critiques (redis, kafka, zookeeper, rabbitmq, loki, grafana)

  5. Ports paramétrés par variables d’env avec défaut : "${GRAFANA_PORT:-3000}:3000"

  6. Secrets via variables d’env (.env local + vault Ansible), jamais en dur

  7. Labels Traefik pour l’exposition HTTPS publique (Host(…​), entrypoints=websecure)

  8. logging json-file avec rotation quand les logs sont volumineux (ex. dozzle : max-size: 5m, max-file: 2)

  9. Volumes nommés pour toute donnée persistante (redis-data, kafka-data, grafana-data, …)

6. Commandes Docker Utiles (sur le serveur)

ssh -i ~/.ssh/serverAdminSSHKeypair.pem admin@18.158.207.98

# État
docker ps                                        # containers actifs
docker ps -a --filter status=exited              # containers morts
docker stats --no-stream                         # CPU/RAM instantané
docker network inspect proxy_server_network      # qui est sur le réseau

# Logs
docker logs clarajob-front-api --tail 100
docker logs -f marketisia-kafka

# Stack sever-admin
cd /home/admin/app/sever-admin
docker compose ps
docker compose up -d grafana
docker compose restart adminer

# Stack applicatif
cd /home/admin/app/clarajob_sa
docker compose ps
cd /home/admin/app/marketisia
docker compose -f docker/docker-compose.yml ps

# Volumes
docker volume ls
docker volume inspect clarajob_sa_minio_data

# Nettoyage (prudence)
docker system df                                 # espace utilisé
docker image prune -a                            # images inutilisées

Ne jamais lancer docker compose down -v : le flag -v supprime les volumes donc les données (DBs, Grafana, Kafka…​). Utiliser stop/up -d, ou passer par make deploy.

7. Prochaines Étapes