Jouer avec Kubernetes à coût zéro en local : Minikube

Lorsque votre projet commence à contenir plusieurs microservices, orchestrer leurs exécutions, garantir leur disponibilité et les rendre observables devient vite complexe. Docker crée des images, mais il manque un planificateur capable d'assurer la stabilité et la résilience — c'est précisément le rôle de Kubernetes. Dans cet article, je vous guide pas à pas pour utiliser Minikube : un cluster Kubernetes léger, mono-nœud et local, parfait pour l'apprentissage et les expérimentations.

Qu'est-ce que Minikube ?

Minikube est un outil open source qui simule un cluster Kubernetes à un seul nœud sur votre machine. Son principal atout : il est rapide à démarrer, simple à utiliser et idéal pour se former sans provisionner d'infrastructure cloud.

• Usage : apprentissage, tests locaux, CI légère.
• Avantage : pas besoin d'un cloud — tout tourne en local (driver Docker, VirtualBox, Hyperkit...)
• Open source et gratuit.

Préparation de l'environnement

Avant de commencer, assurez-vous d'avoir :

• WSL 2 (si vous êtes sur Windows)
• Docker Desktop installé et opérationnel (nous l'utiliserons comme driver)
• Minikube installé et accessible depuis votre PATH

⚠️ Si vous avez un ancien cluster Minikube, supprimez-le d'abord : minikube delete

Exemple : sur macOS (Homebrew déjà présent)

1. Confirmer Docker : docker info
2. Installer Minikube : brew install minikube
3. Vérifier la version : minikube version

Démarrer Minikube (driver Docker)

La façon la plus simple si Docker tourne déjà :

minikube start --driver=docker

Au premier démarrage Minikube :

• Télécharge l'image Kubernetes nécessaire
• Crée un cluster mono-nœud local
• Configure kubectl pour utiliser le contexte minikube

Astuce : pour utiliser le Docker interne de Minikube (utile si vous voulez builder une image directement dans l'environnement Minikube) :

eval $(minikube docker-env)

echo ${DOCKER-HOST}

Vérifier l'état du cluster

Après le démarrage, vérifiez les nœuds :

kubectl get nodes

Vous devriez voir votre nœud minikube en Ready.

Ouvrir le Dashboard (optionnel)

Minikube propose un dashboard simple :

minikube dashboard

Le navigateur s'ouvrira avec une UI graphique pratique pour visualiser Pods, Deployments et Services.

Créer l'image & écrire le YAML de Deployment

Structure de projet recommandée (exemple FastAPI) :

fastapi-minikube/
                    ├── main.py
                    ├── requirements.txt
                    ├── Dockerfile
                    └── deployment.yml
                    

Builder l'image (après avoir fait eval $(minikube docker-env) si vous voulez que l'image soit disponible dans le Docker de Minikube) :

docker build -t fastapi-app:latest .

Exemples de morceaux de deployment.yml (schéma simplifié) :

apiVersion: apps/v1
                        kind: Deployment
        metadata:
        name: fastapi-deployment
        spec:
        replicas: 2
        selector:
        matchLabels:
        app: fastapi
        template:
        metadata:
        labels:
        app: fastapi
        spec:
        containers:
        - name: fastapi
        image: fastapi-app:latest
        ports:
        - containerPort: 80

        apiVersion: v1
        kind: Service
        metadata:
        name: fastapi-service
        spec:
        selector:
        app: fastapi
        ports:
        - protocol: TCP
        port: 80
        targetPort: 80
        type: NodePort

Déployer sur Minikube et vérifier

1. Appliquer le YAML : minikube kubectl -- apply -f deployment.yml
2. Voir l'état des pods : minikube kubectl -- get pods
3. Vérifier les services : minikube kubectl -- get svc
4. Ouvrir l'URL du service local : minikube service fastapi-service --url

✅ Si les Pods passent en Running : succès !

Principaux composants et comment ils s'articulent

Trois composants principaux forment le flux d'accès complet :

• Deployment — définit l'état désiré des Pods (réplicas, image, stratégie de mise à jour).
• Service — expose un ensemble de Pods via un point d'accès stable (ClusterIP, NodePort, LoadBalancer).
• Ingress — route le trafic HTTP/HTTPS externe vers les services appropriés (requiert un Ingress Controller).

Schématiquement :

Utilisateur externe → Ingress → Service → Pod (géré par Deployment)

Notes et bonnes pratiques

• Définissez readinessProbe et livenessProbe pour éviter les interruptions pendant les mises à jour.
• Pour les tests d'Ingress sur Minikube : minikube addons enable ingress.
• Favorisez ClusterIP + Ingress pour simuler un routage réaliste en production.
• Ne codez jamais en dur des secrets dans l'image — utilisez Secret et ConfigMap.

Tableau récapitulatif des étapes

      
      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: demo-config
      data:
        DEMO_MESSAGE: "Bonjour depuis ConfigMap"
      ---
      apiVersion: v1
      kind: Secret
      metadata:
        name: demo-secret
      type: Opaque
      data:
        SECRET_KEY: c3VwZXItc2VjcmV0   # "super-secret" en base64
      ---
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: demo-deployment
      spec:
        replicas: 1
        selector:
          matchLabels:
            app: demo-app
        template:
          metadata:
            labels:
              app: demo-app
          spec:
            containers:
            - name: busybox
              image: busybox
              command: ["/bin/sh", "-c", "sleep 3600"]
              envFrom:
              - configMapRef:
                  name: demo-config
              - secretRef:
                  name: demo-secret
              volumeMounts:
              - name: config-volume
                mountPath: /etc/demo
            volumes:
            - name: config-volume
              configMap:
                name: demo-config
      ---
      apiVersion: v1
      kind: Service
      metadata:
        name: demo-service
      spec:
        selector:
          app: demo-app
        ports:
        - port: 8080
          targetPort: 80
          protocol: TCP
      
        

      
      #!/bin/bash
      set -e
      
      echo "🚀 [Step 1] Apply ConfigMap & Secret resources"
      minikube kubectl -- apply -f k8s/configmap-secret.yml
      
      echo "🕓 Attente du pod..."
      sleep 5
      
      POD_NAME=$(minikube kubectl -- get pods -l app=demo-app -o jsonpath="{.items[0].metadata.name}")
      
      echo "🔍 [Step 2] Vérification des variables d'environnement"
      minikube kubectl -- exec -it $POD_NAME -- printenv | grep DEMO
      
      echo "🔍 [Step 3] Vérification des fichiers montés"
      minikube kubectl -- exec -it $POD_NAME -- ls /etc/demo
      
      echo "🔑 [Step 4] Vérification de la Secret décodée"
      minikube kubectl -- exec -it $POD_NAME -- printenv | grep SECRET_KEY
      
      read -p "🧹 Voulez-vous nettoyer les ressources ? (y/N): " yn
      if [[ $yn == "y" || $yn == "Y" ]]; then
          echo "🧹 Suppression des ConfigMap / Secret / Deployment / Service..."
          minikube kubectl -- delete -f k8s/configmap-secret.yml
      fi
      
        

      
      chmod +x scripts/configmap-secret-demo.sh
      ./scripts/configmap-secret-demo.sh
      
      
            
        

      
      # Pour simplement l'arrêter (recommandé)
      minikube stop
      
      # Pour tout supprimer (réinitialisation complète)
      minikube delete
      
      
            
        

Conclusion

Minikube est un outil puissant et léger pour se familiariser avec Kubernetes sans coûts cloud. En maîtrisant Deployment, Service et Ingress, vous apprendrez à orchestrer, exposer et sécuriser vos microservices localement avant d'aller en production.