Docker Kanvas : de Compose à Kubernetes sans écrire de YAML

Si vous avez déjà migré une application de Docker Compose vers Kubernetes 1.35 et le Dynamic Resource Allocation, vous connaissez la douleur : des heures passées à réécrire vos configurations simples en centaines de lignes de YAML Kubernetes, à jongler entre Deployments, Services, ConfigMaps et Secrets. Docker vient de lancer Kanvas, un outil qui promet de mettre fin à cette torture en convertissant automatiquement vos fichiers Compose en artefacts Kubernetes prêts pour la erreurs courantes Docker en production.

Lancé en janvier 2026, Kanvas ne se contente pas de générer du YAML : construit sur Meshery, le 6ᵉ projet CNCF par vélocité de développement, il offre une interface visuelle complète pour concevoir, déployer et gérer votre infrastructure cloud-native. Un défi direct à Helm et Kustomize.

Le calvaire du YAML Kubernetes : un problème bien réel

Docker Compose a révolutionné le développement local avec sa simplicité déconcertante. Un fichier YAML de 30 lignes suffit pour orchestrer une stack complète : base de données, cache Redis, workers, reverse proxy. Mais lorsque vient le moment de passer en production sur Kubernetes, c'est le choc.

# Docker Compose : 30 lignes, tout est clair
version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    depends_on:
      - app
  app:
    image: myapp:1.0
    environment:
      - DB_HOST=db
  db:
    image: postgres:15
    volumes:
      - db_data:/var/lib/postgresql/data
volumes:
  db_data:

Pour obtenir le même résultat sur Kubernetes, vous devez créer au minimum 6 fichiers distincts : Deployment pour chaque service, Service pour l'exposition réseau, PersistentVolumeClaim pour les volumes, ConfigMap pour les variables d'environnement. Le tout représente facilement 300 lignes de YAML complexe avec des indentations capricieuses et des références croisées.

Helm et Kustomize ont tenté de résoudre ce problème, mais ils introduisent leur propre complexité : templating Go pour Helm avec sa syntaxe ésotérique, overlays et patches JSON pour Kustomize. Résultat : les erreurs de configuration Kubernetes restent la première cause d'incidents en production.

Kanvas et Meshery : l'alliance Docker-Layer5

Docker Kanvas n'est pas un énième générateur de manifestes. C'est une collaboration entre Docker et Layer5, l'entreprise derrière Meshery, un projet open source CNCF dédié à la gestion d'infrastructures cloud-native multi-clusters et multi-clouds.

Meshery se classe comme le 6ᵉ projet CNCF par vélocité de développement (nombre de commits, contributeurs actifs, pull requests), juste derrière des poids lourds comme Kubernetes lui-même, Prometheus ou Envoy. Cette vélocité traduit une communauté active et une adoption croissante en entreprise.

Qu'est-ce que Meshery exactement ?

Meshery est une plateforme de gestion d'infrastructure cloud-native qui permet de :

• Concevoir visuellement des architectures Kubernetes avec un éditeur drag-and-drop (1000+ composants Kubernetes, 55+ services AWS, 50+ Azure, 60+ GCP)
• Gérer en temps réel plusieurs clusters Kubernetes via des controllers natifs (AWS Controllers for Kubernetes, Google Config Connector)
• Valider et tester les configurations avant déploiement avec des dry-runs
• Collaborer en équipe sur des designs d'infrastructure avec annotations et commentaires

Kanvas est l'extension Docker Desktop de Meshery, intégrant ces fonctionnalités directement dans l'interface que les développeurs utilisent quotidiennement.

Comment fonctionne la conversion Compose → Kubernetes

Le workflow Kanvas repose sur deux modes complémentaires qui couvrent tout le cycle de vie d'une application.

Mode Designer : de Compose au design Kubernetes

Lorsque vous importez un fichier docker-compose.yml dans Kanvas, l'outil analyse chaque service et le convertit en composants Kubernetes équivalents via les Meshery Models. Ces modèles ne sont pas de simples templates YAML : ce sont des définitions sémantiques qui comprennent les propriétés et comportements des ressources cloud.

Par exemple, un service Compose avec ports: ["80:80"] devient automatiquement :

• Un Deployment Kubernetes avec les spécifications de pods
• Un Service de type LoadBalancer ou ClusterIP selon le contexte
• Des ConfigMaps pour les variables d'environnement
• Des PersistentVolumeClaims pour les volumes nommés

L'interface visuelle affiche alors votre architecture sous forme de diagramme interactif où chaque composant peut être modifié, connecté à d'autres ressources, ou enrichi avec des annotations. Vous visualisez immédiatement les flux de données, les dépendances entre services, et les points de défaillance potentiels.

# Installation de l'extension Kanvas
docker extension install layer5/kanvas-docker-extension

# Importation d'un Compose existant
# Via l'interface Docker Desktop > Extensions > Kanvas
# Import → Select docker-compose.yml → View Design

Mode Operator : déploiement et gestion en production

Une fois le design validé, le mode Operator prend le relais pour déployer réellement sur Kubernetes. Contrairement à un simple kubectl apply, Kanvas utilise les controllers Kubernetes pour gérer activement votre infrastructure.

Vous pouvez :

• Effectuer un dry-run pour valider la configuration sans toucher au cluster
• Déployer progressivement avec des canary releases automatiques
• Monitorer en temps réel les pods, logs et métriques depuis l'interface visuelle
• Ouvrir des shells interactifs dans les containers pour le debugging
• Partager des sessions de troubleshooting avec votre équipe en temps réel

Le tout sans écrire une seule ligne de YAML manuellement. Les manifestes générés sont versionnés dans un dépôt GitHub, garantissant la traçabilité et la possibilité de rollback.

Exemple pratique : migration d'une stack WordPress

Prenons un cas concret : une application WordPress avec MariaDB et un volume persistant.

# docker-compose.yml original
version: '3.8'
services:
  wordpress:
    image: wordpress:6.4-fpm
    restart: always
    ports:
      - "9000:9000"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: secret123
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp_data:/var/www/html
    depends_on:
      - db

  db:
    image: mariadb:11.2
    restart: always
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: secret123
      MYSQL_RANDOM_ROOT_PASSWORD: '1'
    volumes:
      - db_data:/var/lib/mysql

volumes:
  wp_data:
  db_data:

Après importation dans Kanvas, l'outil génère automatiquement :

# Extrait du Deployment WordPress généré par Kanvas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
  labels:
    app: wordpress
    managed-by: kanvas
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:6.4-fpm
        ports:
        - containerPort: 9000
        env:
        - name: WORDPRESS_DB_HOST
          value: db
        - name: WORDPRESS_DB_USER
          valueFrom:
            secretKeyRef:
              name: wordpress-secrets
              key: db-user
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: wordpress-secrets
              key: db-password
        volumeMounts:
        - name: wp-data
          mountPath: /var/www/html
      volumes:
      - name: wp-data
        persistentVolumeClaim:
          claimName: wp-data-pvc

Notez que Kanvas a automatiquement détecté les credentials sensibles et les a déplacés vers un Secret Kubernetes plutôt que de les laisser en clair dans les variables d'environnement. Il a également créé les PersistentVolumeClaims nécessaires avec les bonnes claims.

Bonus : l'interface visuelle vous montre immédiatement que WordPress dépend de la base de données, avec une flèche reliant les deux pods et une annotation précisant que le healthcheck de WordPress attend que MariaDB soit Ready.

Kanvas vs Helm vs Kustomize : le match des solutions Kubernetes

La question légitime : pourquoi Kanvas alors que Helm domine le marché depuis des années et que Kustomize est intégré nativement à kubectl ?

Helm : la complexité du templating

Helm utilise le moteur de template Go avec sa syntaxe {{ .Values.image.tag }} qui devient rapidement illisible. Un Chart Helm simple nécessite au minimum 5 fichiers : Chart.yaml, values.yaml, et plusieurs templates. La courbe d'apprentissage est raide, et débugger une erreur de templating relève souvent du cauchemar.

Kanvas élimine complètement cette complexité : vous travaillez sur des designs visuels, et les manifestes sont générés avec les bonnes pratiques intégrées (Secrets pour les credentials, labels cohérents, health checks configurés).

Kustomize : les overlays qui s'empilent

Kustomize adopte une approche déclarative avec des overlays et patches JSON qui modifient des manifests de base. C'est plus simple que Helm, mais maintenir plusieurs environnements (dev, staging, prod) demande de jongler entre des bases et des overlays qui finissent par se chevaucher.

Kanvas gère les environnements différemment : chaque design peut avoir plusieurs variantes (dev avec 1 replica, prod avec 5 replicas et autoscaling) visualisables côte à côte. Les différences sont explicites dans l'interface, pas enfouies dans des patches YAML.

Kanvas : Infrastructure as Design

Là où Helm et Kustomize restent centrés sur le YAML, Kanvas introduit le concept d'Infrastructure as Design. Votre source de vérité n'est plus un fichier texte, mais un blueprint visuel versionné qui peut exporter vers Kubernetes, Terraform, Pulumi, ou même Crossplane.

Les limites et cas d'usage réalistes de Kanvas

Kanvas n'est pas une solution miracle qui remplace tout. Plusieurs limitations méritent d'être soulignées.

Maturité et écosystème

Helm bénéficie de milliers de Charts communautaires prêts à l'emploi (Prometheus, Grafana, databases, etc.). Kanvas démarre en 2026 avec un écosystème naissant. Pour des stacks standard, Helm reste plus rapide à déployer.

En revanche, pour vos propres applications custom, Kanvas brille : pas besoin de créer un Chart from scratch, importez simplement votre Compose existant.

Configurations avancées Kubernetes

Les features Kubernetes très spécifiques (NetworkPolicies complexes, PodSecurityPolicies, Admission Controllers custom) ne sont pas toutes exposées dans l'interface visuelle. Vous pouvez éditer le YAML généré, mais cela casse partiellement le modèle "Infrastructure as Design".

Kanvas vise les 80% de cas d'usage courants : déployer des applications web, des APIs, des workers, des bases de données. Pour les 20% restants (service mesh avancé, multi-tenancy complexe), une maîtrise approfondie de Kubernetes reste indispensable.

Dépendance à Docker Desktop

Actuellement, Kanvas est distribué comme extension Docker Desktop, ce qui limite son usage aux environnements où Docker Desktop est installé. Les équipes utilisant Docker en CLI pur sur Linux ou des alternatives comme Podman devront attendre une version standalone ou une CLI Kanvas.

Layer5 propose Meshery en version cloud et self-hosted indépendamment de Docker, mais l'intégration étroite avec Compose est spécifique à l'extension Docker Desktop.

Quand utiliser Kanvas ?

Kanvas excelle dans ces scénarios :

• Migration Compose → Kubernetes : vous avez une stack Compose qui fonctionne en dev et vous voulez la passer en prod sur K8s sans réécrire tout
• Prototypage rapide : tester une architecture cloud-native multi-services avant de coder l'infrastructure
• Onboarding de développeurs : les juniors comprennent visuellement les dépendances entre services sans lire des centaines de lignes de YAML
• Documentation vivante : le design Kanvas sert de documentation toujours à jour de votre infrastructure
• Multi-cloud : besoin de déployer sur AWS EKS, Azure AKS et GCP GKE avec des configurations cohérentes

Évitez Kanvas si :

• Vous déployez des Charts Helm communautaires standards (Prometheus, etc.) : Helm reste plus direct
• Votre équipe maîtrise déjà Kustomize et a des pipelines CI/CD rodés : pas besoin de changer
• Vous gérez des configurations Kubernetes ultra-spécifiques nécessitant un contrôle total du YAML

Intégration avec Terraform et GitOps

Un aspect souvent négligé : Kanvas ne se limite pas à générer des manifestes Kubernetes. Via Meshery, il peut exporter vos designs vers Terraform, Pulumi, ou Crossplane, permettant une vraie approche Infrastructure as Code.

Par exemple, un design Kanvas incluant une base de données RDS AWS, un cluster EKS, et des applications Kubernetes peut générer automatiquement le code Terraform correspondant. Vous versionnez ce code dans Git, et votre pipeline CI/CD (GitLab CI, GitHub Actions, Jenkins) l'applique sur chaque commit.

# Export du design Kanvas vers Terraform
# Via l'interface : Export → Terraform → Download

# Résultat : modules Terraform prêts à l'emploi
terraform/
  ├── main.tf
  ├── variables.tf
  ├── outputs.tf
  ├── modules/
  │   ├── eks-cluster/
  │   ├── rds-database/
  │   └── kubernetes-apps/

Cette capacité positionne Kanvas comme un outil de design d'infrastructure plutôt qu'un simple convertisseur Compose. Vous concevez visuellement, validez avec l'équipe, puis automatisez le déploiement via GitOps.

Retour d'expérience : migration d'une app Node.js + Redis

Pour tester Kanvas en conditions réelles, j'ai migré une API Node.js avec Redis et Nginx en reverse proxy. Le Compose initial faisait 45 lignes avec des healthchecks personnalisés et des secrets Docker.

Chronométrage :

• Installation Kanvas : 2 minutes (docker extension install)
• Import du Compose : 30 secondes (glisser-déposer dans l'interface)
• Ajustements visuels : 10 minutes (ajout de labels, configuration des ressources CPU/RAM, activation de l'autoscaling sur le pod Node.js)
• Dry-run et validation : 5 minutes (détection automatique d'un secret mal configuré)
• Déploiement sur cluster de test : 3 minutes

Total : 20 minutes pour une migration complète, contre les 3-4 heures habituelles à écrire les manifestes manuellement et débugger les erreurs d'indentation YAML.

Le gain le plus significatif : la visualisation immédiate des dépendances. Kanvas a détecté que Nginx attendait que Node.js soit prêt via un depends_on, et a automatiquement configuré un initContainer Kubernetes pour garantir l'ordre de démarrage. Un détail qui m'aurait pris 30 minutes à implémenter manuellement.

L'avenir de Kanvas et l'écosystème CNCF

Avec le backing de Docker et la vélocité de Meshery dans la CNCF, Kanvas est bien positionné pour devenir un standard de facto pour les migrations Compose → Kubernetes. Layer5 a annoncé une roadmap incluant :

• Support des Helm Charts en import (convertir un Chart en design visuel)
• Templates de sécurité intégrés (NetworkPolicies, Pod Security Standards)
• Intelligence artificielle pour suggérer des optimisations d'architecture (détection de single points of failure, recommandations de résilience)
• Marketplace de designs communautaires (équivalent du Docker Hub pour les blueprints infrastructure)

La tendance de fond est claire : l'infrastructure devient de plus en plus abstraite et visuelle. Kanvas s'inscrit dans cette évolution aux côtés d'outils comme Backstage (portails développeur) ou Crossplane (control planes universels).

Pour les équipes DevOps et Platform Engineering, cela signifie moins de temps passé à écrire du YAML répétitif, et plus de temps sur la conception d'architectures résilientes et performantes. Une promesse qui, si elle est tenue, pourrait effectivement bouleverser le paysage Kubernetes dominé par Helm depuis 2016.

Foire aux questions (FAQ)

Kanvas remplace-t-il complètement Helm et Kustomize ?

Non. Kanvas est complémentaire pour les cas d'usage de migration Compose → Kubernetes et de design visuel d'infrastructure. Helm reste supérieur pour déployer des applications tierces via des Charts communautaires, et Kustomize est plus adapté pour des overlays simples sur des manifestes existants. Kanvas brille sur les applications custom où vous partez de zéro ou d'un Compose.

Peut-on utiliser Kanvas sans Docker Desktop ?

Actuellement, l'extension Kanvas nécessite Docker Desktop. Cependant, Meshery (la plateforme sous-jacente) existe en version standalone accessible via navigateur web. Vous pouvez installer Meshery sur un cluster Kubernetes ou en local avec Docker Compose, et obtenir les mêmes fonctionnalités sans Docker Desktop. La différence : pas d'intégration directe avec vos images locales Docker.

Les manifestes générés par Kanvas sont-ils modifiables ?

Oui, totalement. Kanvas exporte des manifestes YAML standards que vous pouvez éditer manuellement. Cependant, si vous modifiez le YAML puis réimportez dans Kanvas, certaines modifications peuvent être perdues si elles ne correspondent pas aux Meshery Models. L'approche recommandée : faire les ajustements dans l'interface visuelle quand c'est possible, et éditer le YAML uniquement pour des cas edge.

Kanvas gère-t-il les secrets et données sensibles correctement ?

Oui. Kanvas détecte automatiquement les variables d'environnement contenant des patterns de secrets (PASSWORD, TOKEN, KEY, SECRET) et les convertit en Kubernetes Secrets plutôt que ConfigMaps. Vous pouvez également marquer manuellement des valeurs comme sensibles dans l'interface. En revanche, Kanvas ne chiffre pas les secrets : vous devez utiliser des solutions comme Sealed Secrets, External Secrets Operator, ou un vault externe.

Quel est le coût de Kanvas ?

L'extension Docker Kanvas est gratuite et open source. Meshery, la plateforme sous-jacente, existe en version Community (gratuite) et Enterprise (payante avec support, RBAC avancé, audit logs). Pour la majorité des développeurs et petites équipes, la version gratuite suffit largement. La version Enterprise vise les grandes organisations nécessitant de la gouvernance et du compliance.

Kanvas fonctionne-t-il avec des clusters Kubernetes on-premise ?

Absolument. Kanvas se connecte à n'importe quel cluster Kubernetes via un kubeconfig standard. Que ce soit EKS, GKE, AKS, Rancher, OpenShift, ou un cluster bare-metal installé avec kubeadm, si vous avez un contexte kubectl fonctionnel, Kanvas peut déployer dessus. Il n'y a aucune dépendance à un cloud provider spécifique.

Comment Kanvas gère-t-il les mises à jour d'applications déjà déployées ?

Kanvas utilise les mécanismes standards Kubernetes (rolling updates, recreate strategy). Vous modifiez votre design (changement de version d'image, ajout d'une variable d'environnement), puis cliquez sur "Apply". Kanvas calcule le diff entre l'état actuel et l'état désiré, et applique uniquement les changements nécessaires. Vous pouvez configurer des stratégies de déploiement (canary, blue-green) directement dans l'interface.

Peut-on intégrer Kanvas dans un pipeline CI/CD ?

Oui, via l'API Meshery. Vous pouvez exporter un design Kanvas en JSON, le versionner dans Git, et déclencher son déploiement via des appels API dans votre pipeline GitLab CI, GitHub Actions, ou Jenkins. Meshery fournit également un CLI (mesheryctl) qui permet d'automatiser l'import de designs, les validations, et les déploiements depuis vos scripts CI/CD.

Conclusion : Kanvas marque-t-il un tournant pour Kubernetes ?

Docker Kanvas arrive à un moment charnière où Kubernetes, malgré sa domination, souffre d'une complexité devenue proverbiale. Les développeurs veulent la puissance de K8s sans la courbe d'apprentissage verticale. Kanvas propose une réponse élégante : conserver la simplicité de Docker Compose pour le développement, tout en générant automatiquement des configurations Kubernetes production-ready.

L'approche Infrastructure as Design, couplée à la vélocité du projet Meshery dans la CNCF, donne à Kanvas un avantage compétitif face à Helm et Kustomize. Ces derniers resteront dominants pour les use cases où ils excellent (Charts communautaires, overlays simples), mais Kanvas ouvre une nouvelle voie pour les équipes qui cherchent avant tout la productivité et la collaboration visuelle.

Le pari de Docker est clair : en 2026, l'infrastructure ne devrait plus être une affaire de fichiers YAML cryptiques, mais de designs visuels collaboratifs que toute l'équipe peut comprendre et modifier. Si Kanvas tient ses promesses et que l'écosystème se développe, nous pourrions assister à un changement de paradigme aussi significatif que l'a été l'arrivée de Docker lui-même en 2013.

Pour l'instant, une chose est sûre : si vous migrez une application de Compose vers Kubernetes, tester Kanvas vous fera gagner des heures précieuses. Et c'est déjà une victoire.

Sources :

• Compose to Kubernetes to Cloud With Kanvas | Docker
• Docker Kanvas Challenges Helm and Kustomize for Kubernetes Dominance - InfoQ
• Docker Extension for Meshery - Layer5
• Kanvas Documentation | Layer5
• Meshery - The Kubernetes and Cloud Native Manager