Technologies et infrastructures → Docker Composer et Dev-environnement

Composer Docker et environnement Dev

1) Pourquoi Composer

• La parité avec la vente (images, variables, réseaux) → moins « fonctionne chez moi ».
• Départ rapide pour les débutants → « make up » et dans le combat.
• Stands isolés par développeur/branche → travail parallèle sans conflit.
• Tests d'intégration sur les dépendances réelles.

2) Structure de référentiel de base

project/
docker/
app/# Dockerfile, web/# Nginx/Traefik scripts and seed/# siders/compose fixes. yaml # common base stack compose. override. yaml # local overrides (v.gitignore)
compose. ci. yaml # for CI
.env. example # environment template
Makefile # convenient goals devcontainer. json # VS Code Dev Containers (optional)

• compose. yaml - décrit le « squelette » (services, réseaux, volumes) est le même pour dev/CI.
• override ne sont que des modifications locales : mappings de répertoires, ports, drapeaux debug.
• .env. example → le développeur copie dans '.env' et remplace les valeurs.

3) Cadre composé. yaml (exemple)

yaml name: project services:
gateway:
image: traefik:v3 command:
- "--providers. docker=true"
- "--entrypoints. web. address=:80"
- "--entrypoints. websecure. address=:443"
- "--certificatesresolvers. dev. acme. tlschallenge=true"
ports: ["80:80", "443:443"]
volumes:
- /var/run/docker. sock:/var/run/docker. sock:ro networks: [edge, core]

api:
build:
context:.
dockerfile: docker/app/Dockerfile target: dev env_file: [.env]
command:./scripts/dev-start. sh volumes:
-./:/app:cached depends_on: [db, redis, kafka]
labels:
- "traefik. http. routers. api. rule=Host(`${API_HOST}`)"
- "traefik. http. services. api. loadbalancer. server. port=8080"
networks: [core]

db:
image: postgres:16 environment:
POSTGRES_USER: ${DB_USER}
POSTGRES_PASSWORD: ${DB_PASS}
POSTGRES_DB: ${DB_NAME}
volumes:
- pgdata:/var/lib/postgresql/data healthcheck: {test: ["CMD-SHELL","pg_isready -U $$POSTGRES_USER"], interval: 5s, timeout: 3s, retries: 20}
networks: [core]

redis:
image: redis:7 command: ["redis-server","--appendonly","yes"]
volumes: [ "redisdata:/data" ]
networks: [core]

kafka:
image: bitnami/kafka:3 environment:
KAFKA_ENABLE_KRAFT: "yes"
KAFKA_CFG_PROCESS_ROLES: "controller,broker"
KAFKA_CFG_NODE_ID: 1
KAFKA_CFG_LISTENERS: PLAINTEXT://:9092
KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092 networks: [core]

mailhog:
image: mailhog/mailhog ports: ["8025:8025"]
networks: [core]

mock-psp:
image: wiremock/wiremock:3 command: ["--verbose","--global-response-templating"]
volumes: ["./docker/mocks/psp:/home/wiremock"]
labels:
- "traefik. http. routers. mockpsp. rule=Host(`${PSP_HOST}`)"
networks: [core]

volumes:
pgdata: {}
redisdata: {}

networks:
edge: {}
core: {}

• Traefik/NGINX comme gateway : rapproche le schéma de routage de la vente.
• Healthcheck et depends_on avec 'condition : service_healthy' (en v3 via les scripts waiting) est un démarrage ordonné.
• Volumes pour la persistance (OBD/cache) et bind-mount pour le code (hot-reload).

4) Profils et fichiers multiples

Les profils ('profils : [dev, ci, extras]') incluent/excluent les services ('docker compose --profile extras up -d').

• `docker compose -f compose. yaml -f compose. dev. yaml up 'est une fusion de configurations.

• `compose. yaml 'est la base.
• `compose. dev. yaml '- bind-mounts, debug, ficheflagi.
• `compose. extras. yaml '- instrumental (Grafana, pgAdmin, Kafdrop).
• `compose. ci. yaml 'est une « tête sans graphe », sans bind-mounts.

5) Variables, secrets et réglages

.env est une source commune de variables : hôtes, creds de tests OBD, drapeaux.

• les secrets de dummy locaux (clés de bouchon),
• Intégration avec skinny-Vault/SOPS pour les applications particulièrement sensibles.
• Principe : données minimales nécessaires. PAN/PII - jetons/fictions.

6) Assemblages et vitesse

6. 1 Multi-stage + BuildKit

Dockerfile avec les objectifs "base", "dev", "prod' ; cache-layer générique pour les dépendances.
Activer BuildKit : 'DOCKER_BUILDKIT = 1' (ou en configh).
Mise en cache : '--mount = type = cache, target =/root/.cache/...' pour pip/npm/maven.

6. 2 Cycle rapide

Bind-mount code + hot-reload (nodemon, uvicorn --reload, Spring Devtools).
Un target dev séparé avec uniquement l'assemblage de ce que vous voulez.
Makefile objectifs: `make up`, `make down`, `make logs`, `make rebuild`, `make seed`.

make
ENV?= dev up:
docker compose --profile $(ENV) up -d down:
docker compose down -v logs:
docker compose logs -f --tail=200 rebuild:
DOCKER_BUILDKIT=1 docker compose build --pull --no-cache api seed:
docker compose run --rm api./scripts/seed. sh migrate:
docker compose run --rm api./scripts/migrate. sh test:
docker compose -f compose. yaml -f compose. ci. yaml run --rm api./scripts/test. sh

7) OBD, migration, siège

Les migrations (Flyway/Liquibase/Alembic/Prisma) sont exécutées par le hook script après le démarrage de 'db' (healthcheck en attente).
Siding : conteneur séparé 'seed' avec fictions ; répétable et idempotent.
Snapshots de données : le volume 'pgdata' peut être réinitialisé/restauré par le script 'reset-db. sh`.

8) Courtiers, caches, CDC

Kafka/Rabbit/Redpanda - comme dans la vente (configi minimum).
Redis avec AOF inclus pour le réalisme.
Connecteurs CDC (en option) : Debezium dans un service distinct pour les tests analytiques d'intégration.

9) Moki fournisseurs externes

WireMock/Prism pour REST, MockServer pour les scénarios complexes.
Mailhog/SMTP4Dev pour les lettres.
Localstack/MinIO pour stores cloud et compatibilité S3.
Politique : Tous les PSP/KYC/KMS externes - par le biais de l'OpenAPI, et non « sur Internet ».

10) Proxy inverse et TLS

• `api. local. test`, `mockpsp. local. test`.
• TLS : mkcert pour émettre un certificat local de confiance pour tester HSTS/secure-cookies.
• Incluez les sessions de sticky uniquement pour les cas où c'est vraiment important.

11) Profils de développeur : Node/Python/Java

Node : mount 'node_modules' comme cache (volume) pour accélérer l'installation ; 'CHOKIDAR_USEPOLLING = 1' sur Windows/WSL.
Python: `pip cache` comme volume, `watchfiles`/`uvicorn --reload`.
Java : JRebel/Devtools, 'mvn -T 1C -o' + couche avec des dépendances.

12) Tests et qualité

Les tests d'intégration sont conduits au sein du réseau Compose : 'docker compose run test'.
Testcontainers (pour JVM/Node/Python/.NET) est une option chorale pour l'intégration unitaire sans pile complète.
Test de contrat avec le centre de Coco → gate en CI.
Linters/Pre-commit : Exécutez dans le conteneur pour la répétition.

13) Devcontainers et « IDE-as-code »

`devcontainer. json 'enregistre l'image de la raclée (CLI, SDK, linters), monte le projet, lance' postCreateCommand '.
Profite : les mêmes outils, ne pas « boucher » l'hôte, la nouvelle machine - prête en quelques minutes.

14) Sécurité en dev

Sans root dans les images d'application ; 'readOnlyRootFilesystem' quand c'est possible.
Pas de clés/secrets de combat, même temporairement.
Logs - sans PII/PAN ; masquage au niveau du formateur.
Ségrégation des ports et des réseaux : accès externe uniquement via gateway.

15) FinOps/performance en local

Limiter les ressources : 'deploy. resources. limit' (Compose lit partiellement, mais aide la discipline).
Réduire le fan-out (moins de services par défaut ; extras - profils).
Cache BuildKit et cache volume pour les gestionnaires de paquets.

16) CI avec Compose

Utilisez les mêmes 'compose'. yaml` + `compose. ci. yaml'sans bind-mounts.
Caches de dépendances - comme volumes attachables entre jobs/calques.
Jobs parallèles : 'name :' dans Composer est différent (ou préfixe par branche) afin que les stands ne soient pas en conflit.

17) Trablshuting

'docker compose'ps '/' logs -f '/'exec' est le diagnostic de base.
Vérifiez DNS sur le réseau Composer (service par nom).
Si bind-mount « freine » sur macOS/Windows - ': cached '/' : delegated' ou Mutagen/virtuofs.
Healthcheck est « vert », mais le service est « mort » : vérifiez la lecture de votre Apps et l'ordre des migrations.

18) Check-list de mise en œuvre

1. Pile de base (gateway, api, db, cache, queue) en composite. yaml.
2. Les modifications locales sont dans override (v.gitignore).
3..env. example complet et actuel ; 'make bootstrap' le copie en '.env'.
4. Healthchecks et script d'attente OBD/migration.
5. WireMock/Localstack/MinIO pour les fournisseurs externes.
6. Siding et migration en tant que « make seed/migrate ».
7. BuildKit + multi-stage, caches de dépendances.
8. Devcontainers/Makefile pour un démarrage rapide.
9. Profils 'extras' pour outils (Grafana/pgAdmin/Kafdrop).
10. CI utilise la même composition (+ ci-override).

19) Anti-modèles

« Monstre-composition » sur 40 services, toujours en cours d'exécution : incluez les profils.
Des ports durement cloués en conflit entre développeurs.
Secrets/clés dans Git ou '.env. example`.
Dépendance à « Internet » pour les tests (PSP/KYC réels).
L'absence de santé/d'attente - les courses de migration et de départ.
Aucun siège → tests d'intégration flaky.

20) Résultat

Composer est le moteur de la vitesse de développement : un fichier décrit votre monde de services et les profils/overrides donnent de la flexibilité. Gardez la parité avec la vente, automatisez l'assise et la migration, gardez le moki et le TLS « comme dans le combat », accélérez les assemblages BuildKit 'om - et vous obtiendrez un environnement local où il est facile de travailler, de tester facilement et de lire en toute sécurité les scripts de vente iGaming/fintech.