Transformer le YAML Kubernetes en diagramme de cluster en un seul collage

Un déploiement Kubernetes est une pile de YAML qui décrit une forme qu'elle ne vous montre jamais. Un Ingress pointe vers un Service par son nom, le Service sélectionne des Pods par label, les Pods proviennent d'un Deployment, et un ConfigMap et un Secret sont montés quelque part en chemin. Chaque lien est une correspondance de chaîne enfouie dans un fichier différent. Pour comprendre comment le trafic atteint réellement votre conteneur, vous gardez six documents en tête en espérant avoir bien fait correspondre les labels.

Toute l'information est là ; elle n'est simplement jamais dessinée. Alors dessinez-la. Collez vos manifestes dans LetDraw : il lit les mêmes champs que Kubernetes (sélecteurs, noms, références) et dispose un diagramme de la façon dont les objets se connectent. Ce qui n'était qu'un dossier de YAML devient une image que vous pouvez montrer du doigt en revue.

Les manifestes Kubernetes décrivent déjà le graphe

Sous le capot, Kubernetes est un graphe d'objets reliés par des labels et des noms. Le backend d'un Ingress nomme un Service ; le sélecteur d'un Service correspond aux labels d'un modèle de Pod ; un Deployment possède ces Pods ; les volumes font référence à un ConfigMap ou à un Secret par son nom. Ces références sont exactement les arêtes d'un diagramme. Vous n'avez pas à inventer la structure ni à deviner les connexions : elles sont écrites dans le YAML sous forme de correspondances de chaînes littérales, et c'est précisément ce qui permet de les représenter automatiquement en toute sécurité.

Un collage, tout le cluster

Vous n'exportez rien de spécial. Les manifestes que vous appliquez déjà avec kubectl apply sont l'entrée. Concaténez-les (ou utilisez le même fichier multi-documents) et collez-les dans Générer à partir du code ; LetDraw analyse les objets et dessine les connexions qu'il trouve.

apiVersion: apps/v1
kind: Deployment
metadata: { name: api }
spec:
  replicas: 3
  selector: { matchLabels: { app: api } }
---
apiVersion: v1
kind: Service
metadata: { name: api }
spec:
  selector: { app: api }   # ← matches the Deployment's pods
  ports: [{ port: 80, targetPort: 8080 }]
---
apiVersion: networking.k8s.io/v1
kind: Ingress
spec:
  rules: [{ http: { paths: [{ backend:
    { service: { name: api } } }] } }]  # ← names the Service

Ce selector: app: api et ce service.name: api sont les arêtes. LetDraw les suit de la même manière que le cluster, si bien que le diagramme reflète la façon dont le trafic circule réellement, et non la façon dont vous vous en souvenez. Les namespaces deviennent les conteneurs dans lesquels tout s'inscrit, et les icônes rendent chaque type d'objet reconnaissable au premier coup d'œil.

Le YAML dit comment le cluster est câblé. Le diagramme n'est que ce câblage, rendu visible.

Désormais, c'est un diagramme normal

Une fois le brouillon sur le canevas, il est à vous de le façonner. C'est là que l'image devient quelque chose qui vaut la peine d'être conservé :

• Élaguez le bruit. Masquez les objets qui ne font pas partie de l'histoire (le quinzième ConfigMap que personne n'a besoin de voir dans un diagramme d'onboarding) et gardez le chemin de la requête au premier plan.
• Annotez les points délicats. Indiquez où se trouve la readiness probe, quel Service est uniquement interne, d'où vient réellement le Secret.
• Montrez plus d'un namespace. Collez-en plusieurs et laissez les frontières rendre évidente l'organisation multi-tenant.
• Gardez-le sous forme de code. Exportez en Mermaid ou D2 et déposez-le dans le dépôt à côté des manifestes, pour que le diagramme soit livré avec le cluster qu'il décrit.

Voyez le cluster que vous avez réellement déployé

L'écart entre le YAML que vous avez écrit et le cluster qui tourne, c'est là que se cachent les incidents : un sélecteur qui ne correspond à rien, un Service qui pointe vers le mauvais port, une route Ingress oubliée. Dessiner les manifestes transforme ces incohérences en quelque chose que vous pouvez voir, au lieu de les découvrir à 2 h du matin. Collez ce que vous appliquez déjà, obtenez une image de la façon dont tout se connecte, et conservez-la à côté du code qui l'a produite.

Copiez vos manifestes, collez-les une fois, et regardez le cluster s'assembler en diagramme.