# Comment générer un graphe depuis compose.yaml > Visualisez instantanément l'architecture de votre Docker Compose. Utilisez `compose-viz` pour générer un graphe clair des services, dépendances et ports exposés à partir de votre fichier `compose.yaml`. ---  **TL;DR** Cet article montre comment visualiser un fichier `compose.yaml` sous forme de graphe de dépendances avec l'image Docker `compose-viz`. Le résultat est une image (PNG, SVG et d'autres formats via `--format`) qui affiche d'un coup d'œil les services, leurs dépendances et les ports exposés — pratique pour comprendre de grosses architectures Docker multi-services. On y parle aussi de `docker compose config` pour résoudre et fusionner plusieurs fichiers `.yml` et variables avant la visualisation. Imaginez que vous ayez un très gros fichier `compose.yaml` avec beaucoup de services et de dépendances. Vous avez aussi plusieurs ports exposés. Vous aimeriez avoir une vue d'ensemble des services, des dépendances et des ports ouverts. C'est possible ? Oui ! fait la magie pour nous. Voici ce que `compose-viz` génère à partir d'un `compose.yaml` Joomla :  > **Comment interpréter l'image ?:** > > On voit que le port `8080` est exposé sur la machine. Ce port est, en fait, le port `80` du container `joomla`. Et on voit aussi que `joomla` a une dépendance avec le container `joomladb`. Facile, non ? ## Reproduisez-le vous-même {#reproduce-it-yourself} Pour la démo, ouvrez un shell Linux et lancez `mkdir -p /tmp/compose-viz && cd $_` pour créer un dossier appelé `compose-viz` dans votre dossier temporaire Linux et y entrer. Créez ensuite un nouveau fichier appelé `compose.yaml` avec ce contenu **simplifié** : **compose.yaml** ```yaml services: joomla: image: joomla ports: - 8080:80 depends_on: - joomladb joomladb: image: postgres:16.0-alpine ``` Laissez la magie opérer et lancez `docker run --rm -it -u $(id -u):$(id -g) -v $(pwd):/in wst24365888/compose-viz compose.yaml` — vous obtiendrez l'image montrée plus haut. > **Le flag --format:** > > En ajoutant `--format svg`, vous obtiendrez un SVG au lieu d'un PNG. La liste des formats de sortie supportés est énorme : `png|dot|jpeg|json|svg|bmp|canon|cmap|cmapx|cmapx_np|dot_json|emf|emfplus|eps|fig|gif|gv|imap|imap_np|ismap|jpe|jpg|json0|metafile|mp|pdf|pic|plain|plain-ext|pov|ps|ps2|tif|tiff|tk|vml|xdot|xdot1.2|xdot1.4|xdot_json`. ## Un exemple plus complexe {#a-more-complex-example} Remplacez le contenu du `compose.yaml` par celui-ci : **compose.yaml** ```yaml services: redis: image: redis:alpine ports: - "6379" networks: - frontend deploy: replicas: 2 update_config: parallelism: 2 delay: 10s restart_policy: condition: on-failure db: image: postgres:9.4 volumes: - db-data:/var/lib/postgresql/data networks: - backend deploy: placement: constraints: [ node.role == manager ] vote: image: dockersamples/examplevotingapp_vote:before ports: - 5000:80 networks: - frontend depends_on: - redis deploy: replicas: 2 update_config: parallelism: 2 restart_policy: condition: on-failure result: image: dockersamples/examplevotingapp_result:before ports: - 5001:80 networks: - backend depends_on: - db deploy: replicas: 1 update_config: parallelism: 2 delay: 10s restart_policy: condition: on-failure worker: image: dockersamples/examplevotingapp_worker networks: - frontend - backend deploy: mode: replicated replicas: 1 labels: [ APP=VOTING ] restart_policy: condition: on-failure delay: 10s max_attempts: 3 window: 120s placement: constraints: [ node.role == manager ] visualizer: image: dockersamples/visualizer ports: - "8080:8080" stop_grace_period: 1m30s volumes: - /var/run/docker.sock:/var/run/docker.sock deploy: placement: constraints: [ node.role == manager ] networks: frontend: backend: volumes: db-data: ``` Et l'image ci-dessous sera générée par l'outil :  Ici, on peut voir : * Nous avons quatre ports exposés : `5001`, `5000`, `6379` et `8080`. * Le port `8080` est lié à un service web `visualizer` ; ce service utilise un volume pointant vers `/var/run/docker.sock` * Les ports `5000` et `5001` renvoient à des services appelés `vote` et `result`. Comme le port interne est le port `80`, on sait que ces ports sont des interfaces web. * Le service `vote` (port `5000`) utilise un service `redis`, accessible via le port `6379`. * Le service `result` (port `5001`) est lié à un service Postgres appelé `db` et dispose de données persistantes (puisqu'on a un volume Docker appelé `db-data`). * Et ainsi de suite. Un tel outil de visualisation simplifie énormément la compréhension d'une architecture Docker. *`compose-viz` vous donne un seul rendu, figé. Si vous voulez contrôler exactement ce que le diagramme affiche, [Documentation as Code - Transform Your Infrastructure into Beautiful Diagrams with Python and Mermaid](/blog/docker-python-mermaid) analyse le même `compose.yaml` avec un script Python qui vous appartient, et [Docker - Diagrams as code](/blog/docker-diagram-as-code) liste une dizaine d'autres outils de diagram-as-code.* ## Docker config {#docker-config} Si, comme moi, vous utilisez beaucoup de fichiers `.yml` quand vous lancez Docker et/ou que vous y utilisez des variables d'environnement, lancez simplement `docker compose config` pour demander à Docker de *rendre* (à l'écran uniquement) ce qu'il appelle *Parse, resolve and render compose file in canonical format*, c'est-à-dire qu'il va fusionner tous vos `.yml` en une seule chaîne et résoudre les variables. Copiez/collez la sortie à l'écran dans un fichier temporaire et utilisez cet outil sur ce fichier.