Minikube en 2026 : cluster Kubernetes local en 30 minutes

À la fin de ce tutoriel, vous aurez un cluster Kubernetes local Minikube prêt en ~30 minutes : installation, minikube start, kubectl, addon ingress, un Deployment + Service, puis une lecture claire des limites vs kind / k3s / kubeadm — pour labber sans cloud payant.

Niveau : Débutant → Intermédiaire · Temps estimé : 25–35 min · Versions cibles : Minikube (release courante 2026) · Kubernetes aligné driver · kubectl · Docker ou KVM/VirtualBox · Dernière vérification : 2026-09-13

Slug : minikube-cluster-local-2026 · Série : Kubernetes · Mot-clé SEO : minikube tutoriel

← Parcours : Tutoriel Kubernetes débutant · Certif : Préparer la CKA · Aussi : Docker Engine · Architecture K8s

Prérequis

Machine Linux / macOS / Windows (WSL2 recommandé sous Windows) avec ≥ 2 CPU, ≥ 2 Go RAM libres (4 Go+ confort)
Docker Engine ou un hyperviseur supporté (KVM, Hyper-V, VirtualBox selon OS)
Droits pour installer un binaire (curl / package manager) ; kubectl (Minikube peut le proposer)
Notions containers : image, port, volume — voir la série Docker DEH
Pas de cluster cloud requis pour ce lab

Coût estimé : 0 € (lab 100 % local). Aucune ressource Azure/AWS. Si vous enchaînez plus tard vers un cloud, gardez une région lab distincte.

Ce que nous allons construire

Lab Minikube 2026 (~30 min)
  ├── Install minikube + kubectl
  ├── minikube start (driver docker)
  ├── Vérifs : nodes, pods système, dashboard (option)
  ├── Addon ingress
  ├── App démo : Deployment + Service (+ Ingress)
  ├── Limites vs kind / k3s / kubeadm
  └── Erreurs fréquentes + FAQ + maillage CKA / Docker

(Schéma — alt : « Minikube 2026 : VM/conteneur driver → control plane local → Deployment/Service/Ingress ».)

Pourquoi Minikube en 2026 ?

Minikube reste l’un des moyens les plus pédagogiques de faire tourner un Kubernetes mononœud (ou multi-nœuds lab) sur un laptop. Idéal pour :

apprendre kubectl sans facture cloud ;
tester manifests (Deployment, Service, Ingress) avant AKS/EKS/GKE ;
préparer les gestes du parcours CKA en complément d’un vrai lab kubeadm (Minikube ≠ examen, mais excellent terrain de jeu).

Ce n’est pas un substitut à kubeadm pour la CKA (control plane réel, etcd, certificats). C’est le « bac à sable » rapide du parcours Kubernetes DEH.

Choix du driver (Docker, KVM, Hyper-V)

Le driver détermine comment Minikube isole le nœud Kubernetes :

Driver	Plateforme	Quand le choisir
`docker`	Linux / macOS / Windows (Desktop/WSL2)	Par défaut DEH 2026 — simple, rapide
`kvm2`	Linux	Perf native, pas de Docker requis
`hyperv`	Windows Pro	Sans Docker Desktop
`virtualbox`	Multi-OS	Fallback si rien d’autre
`podman`	Linux	Environnements rootless / Podman-first

minikube start --driver=docker
# ou explicitement :
# minikube start --driver=kvm2 --cpus=2 --memory=4096

Si start échoue avec un message « driver », listez les drivers détectés (minikube start --help) et vérifiez que le daemon (Docker/Podman/libvirt) tourne. Sur WSL2, préférez Docker Engine dans WSL plutôt qu’un mélange chaotique Desktop + WSL.

Profils, versions Kubernetes et multi-nœuds

Minikube permet de figer la version Kubernetes (utile pour coller à un curriculum) :

minikube start --kubernetes-version=v1.31.0 --driver=docker

Vérifiez la version supportée par votre release Minikube avant de figer : une version trop neuve ou trop ancienne peut être refusée.

Pour un lab multi-nœuds (scheduling, DaemonSet) :

minikube start --nodes=2 --driver=docker --cpus=2 --memory=3072
kubectl get nodes

Attention : multi-nœuds consomme plus de RAM. Sur un laptop 8 Go, restez mononœud pour ce tutoriel « 30 minutes ».

Les profils (-p nom) isolent kubeconfig et disque : pratique pour un cluster « apps » et un cluster « ingress expérimental » sans se marcher dessus.

Étape 1 — Installer Minikube et kubectl

Sous Linux (exemple officiel-like ; adaptez la version courante) :

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
minikube version

# kubectl (si absent)
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
kubectl version --client

macOS : brew install minikube kubectl. Windows : Chocolatey / winget / WSL2 (préférez WSL2 + Docker).

Vérifiez Docker :

docker info >/dev/null && echo "Docker OK"

Étape 2 — Démarrer le cluster

minikube start --driver=docker --cpus=2 --memory=3072
kubectl get nodes -o wide
kubectl get pods -A

minikube start crée (selon le driver) une VM ou un conteneur qui embarque le control plane. Attendez le statut Ready. Première fois : téléchargement d’images — comptez quelques minutes réseau.

Astuces utiles :

minikube status
minikube ip
minikube kubectl -- get pods -A   # si kubectl local diverge

Pour un second profil lab (isolation) :

minikube start -p lab-ingress --driver=docker
kubectl config get-contexts

Étape 3 — Addon Ingress

L’addon ingress déploie un contrôleur NGINX Ingress dans le cluster :

minikube addons enable ingress
kubectl get pods -n ingress-nginx
kubectl get svc -n ingress-nginx

Attendez que les pods ingress-nginx-controller soient Running. Sur certains drivers, l’IP d’accès passe par minikube service ou un tunnel :

minikube tunnel   # terminal dédié si LoadBalancer / besoin IP locale

Désactiver plus tard : minikube addons disable ingress.

Étape 4 — Deployment + Service (+ Ingress)

Créez une app démo (nginx) :

kubectl create namespace demo
kubectl create deployment web --image=nginx:1.27 -n demo
kubectl expose deployment web --port=80 --type=ClusterIP -n demo
kubectl get deploy,po,svc -n demo

Test interne :

kubectl -n demo run curl --rm -it --image=curlimages/curl -- \
  curl -sS http://web.demo.svc.cluster.local/

Manifeste Ingress minimal :

# ingress-web.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  namespace: demo
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: web.localtest.me
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80

kubectl apply -f ingress-web.yaml
kubectl get ingress -n demo
# Selon OS / DNS : web.localtest.me pointe souvent vers 127.0.0.1
# Sinon : curl -H "Host: web.localtest.me" http://$(minikube ip)

Vous venez de parcourir le chemin pédagogique : Pod → Deployment → Service → Ingress.

Ce que Minikube abstrait (et pourquoi ça compte pour la CKA)

Sous le capot, Minikube démarre un control plane et configure votre kubeconfig. Vous ne manipulez pas manuellement kubeadm init, les static pods /etc/kubernetes/manifests/, ni etcdctl au quotidien. C’est confortable pour apprendre les workloads, dangereux si vous croyez avoir « fini » la préparation CKA.

Utilisez Minikube pour :

itérer sur YAML Deployment / Service / Ingress / ConfigMap / Secret ;
comprendre namespaces, labels, selectors, probes ;
activer metrics-server et tester un HPA simple ;
casser volontairement un Pod (mauvaise image) et lire Events.

Passez à kubeadm pour :

certificats, kubelet, containerd ;
backup/restore etcd ;
join d’un worker, Node NotReady « réel » ;
NetworkPolicy avec un CNI explicite.

Le parcours DEH combine les deux : bac Minikube puis lab kubeadm dans le plan CKA.

Habitudes de lab productives

Créez toujours un namespace de démo (demo, lab-$(date +%s)) plutôt que default.
Préférez kubectl create … --dry-run=client -o yaml > fichier.yaml puis apply : vous apprenez le schéma des objets.
Chronométrez minikube start à froid vs à chaud : utile pour savoir si vous pouvez « rebuild » pendant une session.
Documentez le driver et la version K8s dans un README lab — évite les « ça marchait hier ».
Après chaque session : minikube stop si vous gardez l’état ; delete si le disque souffre.

Exemple HPA minimal une fois metrics-server actif (hors chemin critique des 30 min, mais excellent enchaînement) :

kubectl -n demo autoscale deployment web --cpu-percent=50 --min=1 --max=3
kubectl -n demo get hpa

Sans métriques, l’HPA restera « <unknown> » : d’où l’addon metrics-server.

Étape 5 — Dashboard et exploration (optionnel)

minikube addons enable dashboard
minikube addons enable metrics-server
minikube dashboard

Utile pour visualiser ; en CKA, privilégiez toujours la CLI. Pour HPA plus tard : metrics-server est un prérequis — voir aussi le plan préparer CKA.

Nettoyage

kubectl delete ns demo
minikube stop
# suppression complète du cluster profil :
# minikube delete
# minikube delete -p lab-ingress

stop conserve l’état ; delete libère disque et force un recreate propre.

Limites : Minikube vs kind vs k3s vs kubeadm

Outil	Force	Limite	Usage DEH
Minikube	UX simple, addons, multi-driver	Plus lourd ; pas un CP « bare » examen	Bac à sable apps + Ingress
kind	Clusters multi-nœuds dans Docker, CI friendly	Ingress/LoadBalancer à câbler	CI, tests de manifests
k3s	Léger, edge/homelab, install rapide	Distro opinionated (pas upstream pur)	Homelab, IoT, demos
kubeadm	Control plane réel (etcd, certs)	Plus long à installer / maintenir	Lab CKA principal

Verdict pédagogique DEH :

Apprendre kubectl / apps → Minikube (ce tutoriel) ou kind.
Préparer CKA → kubeadm + plan preparer-cka-kubernetes-2026.
Homelab long terme → k3s (ou kubeadm HA) selon goût.

Ne confondez pas « cluster local qui marche » et « compétences d’administrateur cluster » : la CKA mesure la seconde.

Minikube vs cloud managé (AKS/EKS/GKE)

Un cluster local ne remplace pas un service managé : pas de control plane HA opéré, pas d’autoscaler de nœuds cloud, pas d’identité cloud native (Workload Identity) hors addons expérimentaux. En revanche, 90 % des YAML applicatifs (Deployment, Service, Ingress, ConfigMap) se transfèrent. Workflow DEH conseillé : valider sur Minikube → pousser via CI → déployer sur AKS/EKS. Pour Azure, gardez la région lab canadacentral quand vous quittez le laptop.

Sécurité locale (rappels)

Même en local : ne montez pas votre $HOME entier dans des Pods « pour aller vite », n’exposez pas le dashboard sans auth sur une interface publique, et ne committez pas de kubeconfig d’entreprise dans le même repo que votre lab Minikube. Le cluster local est un terrain de jeu, pas une excuse pour de mauvaises habitudes Git.

Erreurs fréquentes

Symptôme	Cause probable	Correctif
`minikube start` échoue (driver)	Docker non démarré / permissions	`docker info` ; groupe `docker` ; relogin
Node NotReady long	CPU/RAM trop bas, disk plein	`--cpus` / `--memory` ; libérer disque
Ingress Pending / pas d’IP	Addon non Ready ; tunnel manquant	`kubectl -n ingress-nginx get po` ; `minikube tunnel`
`kubectl` pointe ailleurs	Mauvais context kubeconfig	`kubectl config use-context minikube`
ImagePullBackOff	Réseau / tag inexistant	Vérifier tag ; proxy entreprise
Lent au premier start	Pull images	Patience ; miroir éventuel

FAQ — minikube tutoriel

Minikube suffit-il pour préparer la CKA ?

Non comme seul lab. Minikube aide pour workloads, Services, Ingress, HPA. Pour etcd, certificats, kubeadm init/join : suivez preparer-cka-kubernetes-2026 et un cluster kubeadm.

Docker Desktop ou Docker Engine ?

Sous Linux, Docker Engine suffit (driver docker). Sous macOS/Windows, Docker Desktop ou une alternative compatible ; WSL2 + Engine est souvent plus prévisible pour les labs.

kind est-il « mieux » que Minikube en 2026 ?

Différent. kind excelle en CI multi-nœuds ; Minikube excelle en UX addons (ingress, dashboard, metrics). Choisissez selon le scénario, pas la hype.

Combien de RAM faut-il ?

Comptez 3–4 Go alloués au cluster pour Ingress + une app. En dessous de 2 Go, attendez-vous à des timeouts et OOM.

Comment enchaîner après ce lab ?

Parcours DEH : architecture → Pods → Deployments → Services → Ingress → plan CKA. Socle containers : installer Docker.

CTA — parcours Kubernetes

Vous avez un cluster Minikube local en ~30 minutes. Continuez le parcours Kubernetes DEH (Pods → Deployments → Services → Ingress), gardez Minikube pour itérer vite, et basculez sur kubeadm dès que vous préparez la CKA. Relisez aussi les bases Docker si le driver ou les images posent problème.

Meta publication (SEO)

Title SEO : Minikube en 2026 : cluster Kubernetes local en 30 minutes
Meta description : Minikube tutoriel 2026 : install, start, kubectl, addon ingress, Deployment+Service, limites vs kind/k3s/kubeadm. Lab FR DEH.
Focus keyword : minikube tutoriel
Slug : minikube-cluster-local-2026
URL cible : /minikube-cluster-local-2026/