Guide ZX7 - Roadmap & Cookbook

Docker et Kubernetes-101

Introduction : Pourquoi Docker & Kubernetes ?

Dans le développement logiciel moderne, la rapidité et la fiabilité du déploiement sont cruciales. C'est là que Docker et Kubernetes entrent en jeu. Ils résolvent le fameux problème : "ça marche sur ma machine !".

Ce guide est une feuille de route (Roadmap) et un livre de recettes (Cookbook) pour vous aider à maîtriser ces deux technologies essentielles.

Partie 1 : Roadmap & Cookbook Docker

Étape 1 : Concepts Fondamentaux et Installation

Avant tout, il faut comprendre les bases. Un conteneur n'est pas une machine virtuelle. Il partage le noyau du système d'exploitation hôte, ce qui le rend beaucoup plus léger et rapide.

  1. Comprendre les concepts : Image, Conteneur, Dockerfile, Registre (Docker Hub).
  2. Installer Docker Desktop : Le moyen le plus simple de démarrer sur Windows, macOS ou Linux. Rendez-vous sur le site officiel de Docker.
  3. Vérifier l'installation : Ouvrez votre terminal et tapez :
docker --version
docker run hello-world

Si tout se passe bien, vous verrez un message de bienvenue de Docker.

Étape 2 : Le Cookbook Docker - Votre Première Image

Créons une image pour un serveur web Nginx simple qui affiche une page personnalisée.

  1. Créez un dossier pour votre projet, et à l'intérieur, créez deux fichiers :
  2. Fichier index.html : 
    


    Bienvenue sur Docker !


    
    Félicitations ! Votre premier conteneur Nginx fonctionne.
  3. Fichier Dockerfile (sans extension) : C'est la recette pour construire votre image. 
    # Étape 1: Utiliser une image de base officielle Nginx
FROM nginx:alpine

# Étape 2: Copier notre fichier HTML personnalisé dans le serveur web
COPY index.html /usr/share/nginx/html/index.html

# Étape 3 (optionnelle): Exposer le port 80
EXPOSE 80
  4. Construire et exécuter :

    Dans votre terminal, à la racine de votre projet :

    # Construire l'image et la nommer "mon-nginx"
docker build -t mon-nginx .

# Lancer un conteneur à partir de cette image
# -d: mode détaché (en arrière-plan)
# -p 8080:80: rediriger le port 8080 de votre machine vers le port 80 du conteneur
docker run -d -p 8080:80 --name mon-serveur-web mon-nginx

    Ouvrez votre navigateur et allez sur http://localhost:8080. Vous devriez voir votre page personnalisée !

Étape 3 : Commandes Docker Essentielles

# Lister les conteneurs en cours d'exécution
docker ps

# Lister tous les conteneurs (même ceux arrêtés)
docker ps -a

# Arrêter un conteneur
docker stop mon-serveur-web

# Redémarrer un conteneur
docker start mon-serveur-web

# Supprimer un conteneur (il doit être arrêté d'abord)
docker rm mon-serveur-web

# Lister les images sur votre machine
docker images

# Supprimer une image
docker rmi mon-nginx

# Voir les logs d'un conteneur
docker logs mon-serveur-web

Étape 4 : Docker Compose pour les applications multi-conteneurs

Docker Compose permet de définir et de lancer des applications composées de plusieurs services (ex: un site web + une base de données) avec un seul fichier YAML.

Créez un fichier docker-compose.yml :

version: '3.8'

services:
  # Service web basé sur notre Dockerfile
  web:
    build: .
    ports:
      - "8080:80"
      
  # Service de base de données Redis
  redis:
    image: "redis:alpine"

Lancez le tout avec une seule commande :

# Démarrer tous les services en arrière-plan
docker-compose up -d

# Arrêter et supprimer les conteneurs
docker-compose down

Partie 2 : Roadmap & Cookbook Kubernetes

Étape 1 : Concepts Fondamentaux et Installation Locale

Kubernetes introduit de nouveaux concepts pour gérer les conteneurs à grande échelle.

Installation : Pour apprendre, utilisez un cluster local. Options populaires :

Une fois votre cluster local actif (via Docker Desktop par exemple), vérifiez qu'il fonctionne :

kubectl get nodes

Étape 2 : Le Cookbook K8s - Déployer votre conteneur

Nous allons déployer l'image mon-nginx que nous avons créée précédemment sur notre cluster Kubernetes local. Pour cela, on utilise des fichiers de configuration YAML.

Tout d'abord, poussez votre image sur un registre accessible, comme Docker Hub. Si vous utilisez un cluster local comme Docker Desktop ou Minikube, cette étape n'est souvent pas nécessaire car ils partagent le daemon Docker.

  1. Créez un fichier deployment.yaml :
    2. apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-nginx-deployment
spec:
  replicas: 2 # Nous voulons 2 instances de notre pod
  selector:
    matchLabels:
      app: mon-nginx
  template:
    metadata:
      labels:
        app: mon-nginx
    spec:
      containers:
      - name: nginx-container
        image: mon-nginx # Nom de l'image construite localement
        imagePullPolicy: IfNotPresent # Important pour utiliser l'image locale
        ports:
        - containerPort: 80
  2. Créez un fichier service.yaml pour exposer le déploiement :
    3. apiVersion: v1
kind: Service
metadata:
  name: mon-nginx-service
spec:
  type: NodePort # Expose le service sur un port statique de chaque nœud
  selector:
    app: mon-nginx # Cible les pods avec ce label
  ports:
    - protocol: TCP
      port: 80       # Port du service dans le cluster
      targetPort: 80 # Port sur les pods
      # nodePort: 30007 # Optionnel: port fixe sur la machine hôte
  3. Appliquer les configurations et tester :
    4. # Appliquer le déploiement
kubectl apply -f deployment.yaml

# Appliquer le service
kubectl apply -f service.yaml

# Vérifier que les pods tournent (attendez quelques secondes)
kubectl get pods

# Obtenir les informations du service pour savoir comment y accéder
kubectl get service mon-nginx-service

    La dernière commande vous montrera le port mappé sur votre machine locale (par exemple, 80:3XXXX/TCP). Vous pourrez alors accéder à votre application sur http://localhost:PORT où PORT est le numéro affiché (ex: 30007).

Étape 3 : Commandes kubectl Essentielles

# Lister les déploiements, services, pods...
kubectl get all

# Décrire une ressource pour voir les détails et événements
kubectl describe pod [nom-du-pod]
kubectl describe deployment [nom-du-deployment]

# Voir les logs d'un pod
kubectl logs [nom-du-pod]

# Se connecter à un conteneur dans un pod
kubectl exec -it [nom-du-pod] -- /bin/sh

# Mettre à l'échelle un déploiement
kubectl scale deployment mon-nginx-deployment --replicas=4

# Supprimer les ressources créées
kubectl delete -f service.yaml
kubectl delete -f deployment.yaml

Partie 3 : Roadmap - Aller plus loin

Une fois que vous maîtrisez les bases, voici les prochaines étapes de votre parcours d'apprentissage.

Docker Avancé

Kubernetes Avancé

Conclusion de la Roadmap

Le voyage pour maîtriser Docker et Kubernetes est continu. La meilleure façon d'apprendre est de pratiquer. N'hésitez pas à expérimenter, à déployer vos propres applications et à explorer l'immense écosystème qui entoure ces outils.

Ressources utiles :