Comment générer un graphe depuis compose.yaml

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 ! https://github.com/compose-viz/compose-viz fait la magie pour nous.

Voici ce que compose-viz génère à partir d'un compose.yaml Joomla :

Reproduisez-le vous-même​

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é :

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.

Un exemple plus complexe​

Remplacez le contenu du compose.yaml par celui-ci :

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 - Transformez votre infrastructure en diagrammes soignés avec Python et Mermaid analyse le même compose.yaml avec un script Python qui vous appartient, et Docker - Des diagrammes en tant que code liste une dizaine d'autres outils de diagram-as-code.

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.