La recherche de Docker vs Kubernetes suggère que vous devez en choisir un, mais ce cadrage provoque beaucoup de confusion. C’est un peu comme comparer un conteneur maritime avec le port qui en organise des milliers. Ils opèrent à différents niveaux et sont souvent utilisés côte à côte.

Ce guide explique ce que chacun fait, montre la même petite application dans les deux et se termine par une manière pratique de prendre une décision. Les commandes et fichiers ici sont des exemples standard que nous n’avons pas exécutés pour cet article, alors vérifiez-les par rapport aux versions que vous installez.

La réponse courte

Docker est une plate-forme permettant de regrouper une application et ses dépendances dans une image, puis d’exécuter cette image en tant que conteneur. Il répond à la question « Comment puis-je faire en sorte que cette application fonctionne de la même manière partout ? »

Kubernetes, souvent écrit en K8, est un orchestrateur de conteneurs. Il décide où les conteneurs s’exécutent sur de nombreuses machines, les redémarre en cas de panne et les fait évoluer en fonction de la demande. Il répond à la question « Comment puis-je assurer le fonctionnement fiable de centaines de conteneurs ? »

Docker et Kubernetes côte à côte

Ce que fait Docker

Avant les conteneurs, “ça marche sur ma machine” était un problème quotidien, car chaque serveur avait des versions différentes de tout. Docker regroupe votre code, votre environnement d’exécution et vos bibliothèques en une seule image. Une copie en cours d’exécution de cette image est un conteneur et partage le noyau de l’hôte. Elle démarre donc plus rapidement et utilise moins de mémoire qu’une machine virtuelle complète.

Le flux de travail comporte trois étapes :

1. Build : a Dockerfile décrit comment créer l’image.
2. Expédier : transférez l’image vers un registre, tel que Docker Hub.
3. Exécuter : démarrez les conteneurs à partir de cette image sur n’importe quelle machine compatible.

Pour vous familiariser avec cela, commencez par notre Tutoriel Docker pour les débutants, puis lisez nos Bonnes pratiques Dockerfile.

Ce que fait Kubernetes

Docker sur un serveur fonctionne bien jusqu’à ce que ce serveur tombe en panne, que le trafic le dépasse ou que vous ayez des dizaines de services à coordonner. Kubernetes s’occupe de ces tâches opérationnelles :

• Planification : placement des conteneurs sur des machines ayant suffisamment de capacité libre.
• Auto-réparation : remplacement des conteneurs défaillants et éloignement du travail des nœuds défaillants.
• Mise à l’échelle : ajout ou suppression de copies, manuellement ou en fonction de métriques.
• Découverte de services : donnant à un groupe changeant de conteneurs un nom stable.
• Mises à jour progressives : publication des nouvelles versions progressivement, avec un simple rollback.
• Configuration : gestion des paramètres et des secrets séparément des images.

L’idée centrale est l’état souhaité. Vous déclarez que trois copies devraient exister, et les contrôleurs continuent de comparer cela avec la réalité et de corriger toute différence. Notre Tutoriel Kubernetes pour débutants explique cela sur un cluster local.

Comment Docker et Kubernetes travaillent ensemble

Un chemin typique depuis l’ordinateur portable d’un développeur jusqu’à la production ressemble à ceci :

1. Un développeur écrit un Dockerfile et teste le conteneur localement.
2. Un pipeline CI/CD crée l’image et exécute les tests.
3. Le pipeline envoie une image versionnée vers un registre.
4. Un manifeste Kubernetes est mis à jour pour utiliser cette version d’image.
5. Kubernetes extrait l’image et la déploie sur le cluster.

Le travail de Docker est donc en grande partie terminé avant le démarrage de Kubernetes. L’image est le point de transfert entre eux.

Une application, dans les deux sens

Voici un petit service Web. L’image est construite de la même manière quel que soit l’outil qui l’exécute :

# Dockerfile
FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

L’exécuter avec Docker

docker build -t shop-api:1.0 .
docker run -d --name shop -p 8080:8000 --restart unless-stopped shop-api:1.0

Deux commandes et le tour est joué. C’est simple et convient à de nombreux petits projets. Mais il y a une copie sur une machine, et si la machine tombe en panne, le service l’accompagne.

L’exécuter avec Kubernetes

# shop.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shop
spec:
  replicas: 3
  selector:
    matchLabels:
      app: shop
  template:
    metadata:
      labels:
        app: shop
    spec:
      containers:
        - name: api
          image: registry.example.com/shop-api:1.0
          ports:
            - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: shop
spec:
  selector:
    app: shop
  ports:
    - port: 80
      targetPort: 8000

kubectl apply -f shop.yaml
kubectl get pods -l app=shop

Il y a beaucoup plus à écrire et vous avez besoin d’un cluster pour l’exécuter. En échange, vous obtenez trois copies, une adresse interne stable et un remplacement automatique. Ce compromis représente toute la décision en miniature : plus de complexité en échange de plus de résilience.

Que se passe-t-il lorsqu’un conteneur tombe en panne ?

La confusion des dockershim

Vous avez peut-être lu que « Kubernetes a abandonné Docker ». C’est vrai au sens strict du terme, et cela a inutilement effrayé beaucoup de gens. Kubernetes exécute les conteneurs via une norme appelée Container Runtime Interface. Docker Engine ne l’a pas implémenté directement, Kubernetes a donc inclus un adaptateur appelé dockershim. Cet adaptateur a été supprimé dans la version 1.24.

Les clusters utilisent désormais généralement des environnements d’exécution tels que containersd ou CRI-O. Les images que vous créez avec Docker fonctionnent toujours, car elles suivent la norme d’image Open Container Initiative (OCI). Vous pouvez donc continuer à construire avec Docker et votre cluster exécute le résultat avec un environnement d’exécution différent.

Docker Compose contre Swarm contre Kubernetes

La comparaison la plus significative concerne les outils qui coordonnent les conteneurs :

Docker Compose démarre plusieurs conteneurs associés à partir d’un seul fichier, et il est excellent pour une application Web et une base de données sur un ordinateur portable. Swarm est intégré à Docker et est beaucoup plus facile à apprendre que Kubernetes, mais son écosystème est beaucoup plus petit. Kubernetes possède la plus grande communauté et les plus grands outils, ce qui explique en grande partie pourquoi il est devenu la valeur par défaut pour les déploiements à grande échelle.

De quoi avez-vous besoin ?

Docker seul suffit généralement lorsque :

• Vous développez localement ou exécutez une petite application sur un serveur.
• Vous avez une petite équipe et pas de personnel opérationnel dédié.
• De brefs temps d’arrêt occasionnels sont acceptables.

Kubernetes commence à avoir un sens lorsque :

• Vous exécutez de nombreux services que différentes équipes déploient elles-mêmes.
• Vous avez besoin d’une haute disponibilité sur plusieurs machines ou zones.
• Le trafic varie suffisamment pour que la mise à l’échelle automatique permette d’économiser de l’argent réel.
• Vous avez les compétences ou le budget pour le faire fonctionner.

Il existe également un juste milieu. Les plateformes de conteneurs gérés, telles qu’AWS Fargate, Google Cloud Run ou PaaS, exécutent votre image Docker sans cluster à gérer. Pour de nombreuses entreprises en croissance, c’est la prochaine étape idéale, plutôt que de passer directement à Kubernetes.

Si vous souhaitez apprendre les deux pour des raisons professionnelles, l’ordre est clair : Docker d’abord, puis Kubernetes. Vous ne pouvez pas déboguer confortablement un Pod sans d’abord comprendre les images, les ports et les journaux de conteneurs.

Erreurs courantes

• Adopter Kubernetes trop tôt. Copier l’architecture d’une entreprise géante peut enfouir une petite équipe dans le travail opérationnel.
• Utilisation de la balise latest en production. Vous ne pouvez pas savoir ce qui est en cours d’exécution ou restaurer de manière fiable. Utilisez des balises de version spécifiques.
• Stockage des données dans des conteneurs. Les conteneurs sont jetables, utilisez donc des volumes ou une base de données gérée.
• Ignorer les contrôles de santé. Sans sondes de préparation et d’activité, Kubernetes ne peut pas prendre de bonnes décisions concernant votre application.
• Oublier les limites des ressources. Un conteneur gourmand peut affamer tout le reste sur un nœud.

Pour conclure

Docker emballe votre logiciel et Kubernetes l’exécute à grande échelle. Plutôt que de demander ce qui est le mieux, demandez quel problème vous rencontrez aujourd’hui. Si c’est “mon application est difficile à installer”, utilisez Docker. Si c’est “mes 40 services doivent survivre aux pannes de serveur”, regardez Kubernetes. Commencez avec l’outil le plus simple qui résout votre problème réel et progressez lorsque vous en voyez le besoin.

Questions fréquentes

Continuez à apprendre