Premiers pas avec Docker et Kubernetes : démarrage rapide

Docker crée vos conteneurs. Kubernetes les orchestre à grande échelle. Ce guide vous permet de déployer votre première application en moins de 15 minutes. Selon le CNCF Annual Survey 2025, 82% des utilisateurs de conteneurs exécutent Kubernetes en production. Maîtriser ces deux technologies devient une compétence fondamentale pour tout professionnel DevOps.

TL;DR : Installez Docker Desktop (inclut Kubernetes), créez une image avec un Dockerfile, déployez-la sur votre cluster local avec kubectl apply. Résultat : une application conteneurisée accessible en 7 étapes.

Pour approfondir ces fondamentaux, découvrez la formation Kubernetes, les fondamentaux.

Pourquoi combiner Docker et Kubernetes ?

Docker est un moteur de conteneurisation. Il empaquète votre code, ses dépendances et sa configuration dans une image portable. Kubernetes est un orchestrateur. Il déploie, scale et supervise vos conteneurs sur un cluster de machines.

Docker construit les briques, Kubernetes les assemble.

À retenir : Docker et Kubernetes ne sont pas concurrents. Docker produit les conteneurs, Kubernetes les orchestre en production.

Pour comprendre ces différences en détail, consultez notre article Kubernetes vs Docker : comprendre les différences essentielles.

Prérequis techniques

Avant de commencer votre formation docker kubernetes premiers pas, vérifiez ces éléments :

Matériel minimum :

• 8 Go de RAM (16 Go recommandés)
• 20 Go d'espace disque libre
• Processeur avec virtualisation activée (VT-x/AMD-V)

Logiciels requis :

• macOS 12+, Windows 10/11 Pro, ou Linux Ubuntu 20.04+
• Terminal (zsh, bash, ou PowerShell)
• Éditeur de code (VS Code recommandé)

Comptes :

• Docker Hub (gratuit) pour stocker vos images

Étape 1 : Installer Docker Desktop avec Kubernetes

Docker Desktop intègre un cluster Kubernetes single-node. Téléchargez l'installateur depuis docker.com/products/docker-desktop.

# Vérifier l'installation Docker
docker --version
# Docker version 27.5.1, build 9f9e405

# Activer Kubernetes dans Docker Desktop
# Settings → Kubernetes → Enable Kubernetes → Apply & Restart

# Vérifier le cluster Kubernetes
kubectl version --client
# Client Version: v1.32.0

L'activation de Kubernetes prend 2-3 minutes. Docker Desktop télécharge les composants du control plane automatiquement.

À retenir : Docker Desktop fournit un cluster Kubernetes prêt à l'emploi. Aucune configuration complexe requise pour débuter.

Étape 2 : Créer une application Node.js minimale

Créez un dossier projet et ajoutez ces fichiers :

mkdir k8s-quickstart && cd k8s-quickstart

Fichier app.js :

const http = require('http');
const port = process.env.PORT || 3000;

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ 
    status: 'running',
    hostname: process.env.HOSTNAME,
    version: '1.0.0'
  }));
});

server.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

Fichier package.json :

{
  "name": "k8s-quickstart",
  "version": "1.0.0",
  "main": "app.js",
  "scripts": { "start": "node app.js" }
}

Étape 3 : Écrire un Dockerfile optimisé

Un Dockerfile efficace réduit la taille de l'image et améliore la sécurité. Les images Alpine font environ 3 Mo contre 70 Mo pour Ubuntu (Medium Docker Optimization).

# Fichier: Dockerfile
FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:22-alpine
WORKDIR /app
RUN addgroup -g 1001 appgroup && adduser -u 1001 -G appgroup -s /bin/sh -D appuser
COPY --from=builder /app/node_modules ./node_modules
COPY app.js .
USER appuser
EXPOSE 3000
CMD ["node", "app.js"]

Ce multi-stage build sépare les dépendances de build du runtime. Résultat : une image finale de 50 Mo au lieu de 200 Mo. Pour approfondir ces techniques, consultez notre guide Optimiser un Dockerfile pour Kubernetes : guide pas à pas.

Étape 4 : Construire et tester l'image Docker

Construisez l'image localement puis testez-la :

# Build de l'image
docker build -t k8s-quickstart:v1 .

# Vérifier la taille
docker images k8s-quickstart:v1
# REPOSITORY      TAG   SIZE
# k8s-quickstart  v1    52MB

# Test local
docker run -d -p 3000:3000 --name test-app k8s-quickstart:v1

# Valider le fonctionnement
curl http://localhost:3000
# {"status":"running","version":"1.0.0"}

# Nettoyer
docker stop test-app && docker rm test-app

L'image fonctionne en standalone. Passons au déploiement Kubernetes.

Étape 5 : Écrire les manifestes Kubernetes

Kubernetes utilise des fichiers YAML pour décrire l'état désiré. Créez un fichier k8s.yaml :

# Fichier: k8s.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: quickstart-app
  labels:
    app: quickstart
spec:
  replicas: 2
  selector:
    matchLabels:
      app: quickstart
  template:
    metadata:
      labels:
        app: quickstart
    spec:
      containers:
      - name: app
        image: k8s-quickstart:v1
        imagePullPolicy: Never  # Image locale
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "200m"
---
apiVersion: v1
kind: Service
metadata:
  name: quickstart-service
spec:
  type: NodePort
  selector:
    app: quickstart
  ports:
  - port: 80
    targetPort: 3000
    nodePort: 30080

Ce manifeste déclare un Deployment avec 2 réplicas et un Service NodePort pour exposer l'application.

À retenir : imagePullPolicy: Never indique à Kubernetes d'utiliser l'image Docker locale. Indispensable pour le développement sans registry.

Étape 6 : Déployer sur Kubernetes

Appliquez les manifestes et vérifiez le déploiement :

# Déployer l'application
kubectl apply -f k8s.yaml

# Vérifier les pods
kubectl get pods -l app=quickstart
# NAME                             READY   STATUS    AGE
# quickstart-app-7d4f8b6c9-abc12   1/1     Running   30s
# quickstart-app-7d4f8b6c9-def34   1/1     Running   30s

# Vérifier le service
kubectl get svc quickstart-service
# NAME                 TYPE       PORT(S)        
# quickstart-service   NodePort   80:30080/TCP

# Tester l'application
curl http://localhost:30080
# {"status":"running","hostname":"quickstart-app-7d4f8b6c9-abc12","version":"1.0.0"}

Kubernetes a créé 2 pods répartissant la charge. Le hostname dans la réponse change selon le pod qui répond.

Étape 7 : Scaler et observer

Testez l'élasticité de Kubernetes :

# Scaler à 5 réplicas
kubectl scale deployment quickstart-app --replicas=5

# Observer le scaling
kubectl get pods -l app=quickstart -w

# Voir les logs de tous les pods
kubectl logs -l app=quickstart --tail=10

# Décrire un pod pour le debug
kubectl describe pod -l app=quickstart | head -50

# Nettoyer
kubectl delete -f k8s.yaml

Cette commande scale illustre la puissance de Kubernetes : passer de 2 à 5 instances en quelques secondes. Pour gérer ces opérations en production, la formation LFS458 Administration Kubernetes couvre le scaling, le monitoring et le troubleshooting avancé.

Commandes essentielles à retenir

Notre section Monitoring et dépannage Kubernetes détaille les techniques de debug avancées.

Et après ? Votre parcours de formation

Vous avez déployé votre première application sur Kubernetes. C'est le point de départ. Comme le souligne un guide de TealHQ : "Don't let your knowledge remain theoretical - set up a real Kubernetes environment to solidify your skills" (TealHQ).

Prochaines étapes recommandées :

1. Explorez les bonnes pratiques conteneurisation et Docker pour optimiser vos images
2. Comparez les orchestrateurs dans notre Comparatif Kubernetes vs Docker Swarm, ECS et Nomad
3. Lisez les retours d'expérience migration Docker Swarm vers Kubernetes de professionnels
4. Consultez notre FAQ Docker et Kubernetes pour résoudre les problèmes courants

Pour une montée en compétences structurée, découvrez notre Formation Kubernetes : Guide Complet.

Passez à l'étape suivante

Ce quickstart Docker Kubernetes tutorial vous a permis de conteneuriser et déployer une application en 15 minutes. Pour développer ces compétences vers la certification :

• Kubernetes, les fondamentaux : découvrez l'architecture et les concepts clés en 1 journée
• LFD459 Kubernetes pour les développeurs d'applications : préparez la certification CKAD avec 3 jours de pratique intensive
• LFS458 Administration Kubernetes : maîtrisez l'administration de clusters pour la certification CKA. Pour approfondir, consultez notre devis formation Kubernetes.

Demandez votre devis personnalisé pour planifier votre parcours de formation Docker et Kubernetes.