¶ Installation et Configuration Kubernetes
Ce module vous guide à travers les différentes méthodes d'installation de Kubernetes, des environnements locaux aux déploiements cloud en passant par les clusters on-premise.
¶ Choisir sa Solution d'Installation
¶ Matrice de Décision
| Cas d'Usage | Solution Recommandée | Complexité | Temps Setup | Coût |
|---|---|---|---|---|
| Apprentissage | Minikube, Kind | Faible | 5-15 min | Gratuit |
| Développement | Docker Desktop K8s | Faible | 2-5 min | Gratuit |
| Test/Staging | kubeadm, Managed Cloud | Moyenne | 30-60 min | €-€€€ |
| Production | Cloud Managed (EKS/GKE/AKS) | Faible | 15-30 min | €€€ |
| On-Premise Prod | kubeadm, Kubespray, OpenShift | Élevée | 2-8h | €€€€ |
¶ Mise en Pratique : Évaluer vos Besoins
Répondez à ces questions pour choisir :
# 1. Quel est votre objectif ?
# - Apprendre Kubernetes
# - Développer une application
# - Déployer en production
# 2. Quelle est votre infrastructure ?
# - Machine personnelle (laptop/desktop)
# - Serveurs on-premise
# - Cloud public (AWS/GCP/Azure)
# 3. Quelles sont vos contraintes ?
# - Budget limité
# - Besoins de sécurité élevés
# - Équipe sans expertise Kubernetes
¶ Installation Locale
¶ Option 1 : Minikube (Recommandé pour débuter)
Avantages :
- Installation simple en 1 commande
- Support multi-OS (Windows, macOS, Linux)
- Add-ons intégrés (dashboard, ingress, metrics)
- Excellent pour l'apprentissage
Prérequis :
- 2 CPU, 2GB RAM minimum
- Docker, VirtualBox, ou Hyper-V installé
- 20GB d'espace disque libre
¶ Installation
macOS :
# Via Homebrew (recommandé)
brew install minikube
# Via Binary Direct
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-darwin-amd64
sudo install minikube-darwin-amd64 /usr/local/bin/minikube
Windows :
# Via Chocolatey
choco install minikube
# Via Windows Package Manager
winget install minikube
Linux :
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube
¶ Mise en Pratique : Premier Cluster
# 1. Démarrer Minikube avec Docker
minikube start --driver=docker
# 2. Vérifier l'installation
kubectl cluster-info
kubectl get nodes
# 3. Activer des add-ons utiles
minikube addons enable dashboard
minikube addons enable ingress
minikube addons enable metrics-server
# 4. Accéder au dashboard
minikube dashboard
# 5. Tester avec un premier pod
kubectl run test-pod --image=nginx --port=80
kubectl get pods
# 6. Nettoyer
kubectl delete pod test-pod
Commandes Minikube utiles :
# Voir l'IP du cluster
minikube ip
# SSH dans le node Minikube
minikube ssh
# Arrêter et redémarrer
minikube stop
minikube start
# Supprimer le cluster
minikube delete
# Voir les profils (clusters multiples)
minikube profile list
¶ Option 2 : Docker Desktop Kubernetes
Avantages :
- Intégration native avec Docker Desktop
- Pas de VM séparée
- Performances optimales sur Windows/macOS
Activation :
- Ouvrir Docker Desktop
- Settings → Kubernetes
- Cocher "Enable Kubernetes"
- Apply & Restart
# Vérifier l'activation
kubectl config current-context # Devrait afficher "docker-desktop"
¶ Option 3 : Kind (Kubernetes IN Docker)
Usage : CI/CD, tests automatisés, clusters temporaires
# Installation
GO111MODULE="on" go install sigs.k8s.io/[email protected]
# ou via homebrew: brew install kind
# Créer un cluster
kind create cluster --name test-cluster
# Créer un cluster multi-node
cat <<EOF | kind create cluster --config -
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF
# Supprimer
kind delete cluster --name test-cluster
¶ Installation On-Premise avec kubeadm
¶ Architecture Cible
graph TB
subgraph CP["Control Plane Node"]
API["🔧 kube-apiserver"]
ETCD["🗄️ etcd"]
SCHED["📅 kube-scheduler"]
CTL["🎮 controller-manager"]
KUB1["🤖 kubelet"]
PROXY1["🌐 kube-proxy"]
CONT1["📦 containerd"]
end
subgraph W1["Worker Node 1"]
KUB2["🤖 kubelet"]
PROXY2["🌐 kube-proxy"]
CONT2["📦 containerd"]
POD1["Pod A"]
POD2["Pod B"]
end
subgraph W2["Worker Node N"]
KUB3["🤖 kubelet"]
PROXY3["🌐 kube-proxy"]
CONT3["📦 containerd"]
POD3["Pod X"]
end
API --> KUB2
API --> KUB3
CONT2 --> POD1
CONT2 --> POD2
CONT3 --> POD3
¶ Prérequis Système
Configuration minimale :
- Control Plane : 2 CPU, 2GB RAM, 20GB disque
- Worker Nodes : 1 CPU, 1GB RAM, 10GB disque
- Réseau : Connexion entre tous les nodes
- OS : Ubuntu 20.04+ / CentOS 7+ / RHEL 7+
Ports réseau requis :
| Composant | Port | Protocole | Utilisé par |
|---|---|---|---|
| API Server | 6443 | TCP | kubectl, kubelet |
| etcd | 2379-2380 | TCP | API Server, etcd |
| Kubelet API | 10250 | TCP | Control plane |
| Scheduler | 10259 | TCP | Self |
| Controller Manager | 10257 | TCP | Self |
| NodePort Services | 30000-32767 | TCP | External traffic |
¶ Installation étape par étape
¶ 1. Préparation de tous les Nodes
Script de préparation (à exécuter sur TOUS les nodes) :
# Désactiver le swap (requis par Kubernetes)
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
# Configurer les modules kernel
# Charge le module kernel overlay, nécessaire pour le stockage en couches des conteneurs (overlayFS utilisé par containerd/Docker).
# Charge le module br_netfilter, qui permet à iptables de voir le trafic qui traverse les bridges réseau Linux (indispensable pour que les règles réseau de Kubernetes fonctionnent correctement).
sudo modprobe overlay && sudo modprobe br_netfilter
# Configuration réseau Kubernetes
# Active le passage du trafic bridgé par iptables, pour que kube-proxy puisse gérer le routage des Services et Pods
# Active le forwarding IP, permettant au nœud de router le trafic entre les Pods et vers l'extérieur
echo 'net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1' | sudo tee /etc/sysctl.d/k8s.conf
sudo sysctl --system
¶ 2. Installation de containerd (Container Runtime)
# Installation de containerd
sudo apt-get install -y containerd
# Configuration de containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
# Activer systemd cgroup driver (requis pour kubeadm)
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
# Redémarrer containerd
sudo systemctl restart containerd
sudo systemctl enable containerd
# Vérifier l'installation
sudo systemctl status containerd
¶ 3. Installation de kubeadm, kubelet, kubectl
# Ajouter le repository Kubernetes
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
# Installation des outils Kubernetes
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
# Bloquer les versions pour éviter les updates automatiques
sudo apt-mark hold kubelet kubeadm kubectl
# Activer kubelet
sudo systemctl enable kubelet
¶ 4. Initialisation du Control Plane
Sur le Control Plane Node uniquement :
# Initialiser le cluster
sudo kubeadm init \
--pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=$(hostname -I | cut -d' ' -f1) \
--kubernetes-version=v1.28.0
# IMPORTANT: Sauvegarder la commande 'kubeadm join' affichée !
# Configurer kubectl pour l'utilisateur courant
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
# Vérifier l'initialisation
kubectl cluster-info
kubectl get nodes
¶ 5. Installation du Plugin Réseau (CNI)
Flannel (Simple) :
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
Calico (Production avec Network Policies) :
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.0/manifests/tigera-operator.yaml
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.0/manifests/custom-resources.yaml
¶ 6. Ajout des Worker Nodes
Sur chaque Worker Node, exécutez la commande générée à l'étape 4 :
sudo kubeadm join <CONTROL-PLANE-IP>:6443 --token <TOKEN> \
--discovery-token-ca-cert-hash sha256:<HASH>
¶ 7. Vérification du Cluster
# Vérifier tous les nodes
kubectl get nodes
# Vérifier les pods système
kubectl get pods -n kube-system
# Tester le cluster
kubectl run test-nginx --image=nginx --port=80
kubectl expose pod test-nginx --type=NodePort --port=80
kubectl get services
# Accéder au service (remplacer <NODE-IP> et <NODE-PORT>)
curl http://<NODE-IP>:<NODE-PORT>
# Nettoyer
kubectl delete service test-nginx
kubectl delete pod test-nginx
¶ Mise en Pratique : Configuration Avancée
# 1. Configurer l'autocomplétion kubectl
echo 'source <(kubectl completion bash)' >>~/.bashrc
source ~/.bashrc
# 2. Configurer des alias utiles
echo 'alias k=kubectl' >>~/.bashrc
echo 'alias kgp="kubectl get pods"' >>~/.bashrc
echo 'alias kgs="kubectl get services"' >>~/.bashrc
# 3. Installer Helm (pour extensions futures)
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
# 4. Vérifier l'installation
helm version
¶ Solutions Cloud Managées
¶ Google Kubernetes Engine (GKE)
Avantages :
- Intégration native avec l'écosystème Google Cloud
- Mises à jour automatiques du Control Plane
- Autopilot mode (gestion complètement automatisée)
- Intégration Istio native
# Prérequis : installer gcloud CLI
# https://cloud.google.com/sdk/docs/install
# Se connecter à GCP
gcloud auth login
gcloud config set project YOUR_PROJECT_ID
# Créer un cluster GKE
gcloud container clusters create my-cluster \
--zone=europe-west1-b \
--num-nodes=3 \
--machine-type=e2-medium \
--enable-autoscaling \
--min-nodes=1 \
--max-nodes=5
# Configurer kubectl
gcloud container clusters get-credentials my-cluster --zone=europe-west1-b
# Vérifier
kubectl get nodes
¶ Amazon Elastic Kubernetes Service (EKS)
# Prérequis : AWS CLI et eksctl
# https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html
# https://eksctl.io/introduction/#installation
# Créer un cluster EKS
eksctl create cluster \
--name my-cluster \
--region eu-west-1 \
--nodegroup-name workers \
--nodes 3 \
--nodes-min 1 \
--nodes-max 4 \
--node-type t3.medium \
--managed
# kubectl est automatiquement configuré
kubectl get nodes
¶ Azure Kubernetes Service (AKS)
# Prérequis : Azure CLI
# https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
# Se connecter à Azure
az login
# Créer un groupe de ressources
az group create --name myResourceGroup --location francecentral
# Créer le cluster AKS
az aks create \
--resource-group myResourceGroup \
--name myAKSCluster \
--node-count 3 \
--enable-addons monitoring \
--generate-ssh-keys
# Configurer kubectl
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
# Vérifier
kubectl get nodes
¶ Outils et Ressources d'Installation
¶ kubeadm - L'outil Standard
Cas d'usage :
- Clusters de production on-premise
- Apprentissage de l'architecture Kubernetes
- Clusters personnalisés
Avantages :
- Approche officielle et standardisée
- Contrôle total sur la configuration
- Support des clusters HA
¶ Kubespray - Déploiement avec Ansible
Kubespray utilise Ansible pour automatiser le déploiement de clusters Kubernetes on-premise. Idéal pour les environnements de production avec multiples nodes.
Usage recommandé : Pour les déploiements à grande échelle ou quand vous maîtrisez déjà Ansible.
¶ Kops - Clusters Cloud (Principalement AWS)
Kops est un outil pour déployer et gérer des clusters Kubernetes sur AWS (et autres clouds). Bien que puissant pour les environnements de production, il est plus complexe que les solutions managées comme EKS.
Usage recommandé : Préférez EKS pour AWS, sauf si vous avez des besoins spécifiques de contrôle total du cluster.
¶ Accéder au Cluster Kubernetes
¶ Interface en Ligne de Commande (kubectl)
Configuration :
# Voir la configuration actuelle
kubectl config view
# Voir les contextes disponibles
kubectl config get-contexts
# Changer de contexte
kubectl config use-context docker-desktop
# Voir le contexte actuel
kubectl config current-context
Commandes essentielles :
# Informations sur le cluster
kubectl cluster-info
kubectl version
# Ressources du cluster
kubectl get nodes
kubectl get namespaces
kubectl get all --all-namespaces
# Aide et documentation
kubectl explain pods
kubectl explain deployment.spec
¶ Interface Graphique (GUI) - Kubernetes Dashboard
Note importante : Depuis la version 7.0+, l'installation du Kubernetes Dashboard a changé et nécessite maintenant Helm pour une installation simplifiée.
Installation moderne (recommandée) :
# Via Helm (méthode recommandée depuis v7+)
helm repo add kubernetes-dashboard https://kubernetes.github.io/dashboard/
helm upgrade --install kubernetes-dashboard kubernetes-dashboard/kubernetes-dashboard --create-namespace --namespace kubernetes-dashboard
Alternative pour l'apprentissage :
- Utilisez
minikube dashboard(plus simple) - Ou explorez des alternatives comme Lens (client desktop)
- Pour la production, considérez des solutions comme Rancher ou OpenLens
¶ API REST Directe
# Obtenir l'URL de l'API Server
kubectl config view -o jsonpath='{.clusters[0].cluster.server}'
# Tester l'accès à l'API (avec kubectl proxy)
kubectl proxy &
curl http://localhost:8001/api/v1/nodes
¶ Mise en Pratique : Explorer votre Cluster
# 1. Analyser les composants système
kubectl get pods -n kube-system
kubectl describe pod <kube-scheduler-pod> -n kube-system
# 2. Explorer les resources disponibles
kubectl api-resources
kubectl explain deployment
kubectl explain service
# 3. Créer un namespace de test
kubectl create namespace test-env
kubectl config set-context --current --namespace=test-env
# 4. Déployer une application de test
kubectl create deployment test-app --image=nginx:1.29.5 --replicas=2
kubectl expose deployment test-app --port=80 --type=NodePort
# Sur minikube pour récupérer l'url du service :
minikube service test-app --url
kubectl get all
# 5. Tester l'accès
kubectl get service test-app
# Noter le NodePort assigné, puis :
# curl http://<NODE-IP>:<NODE-PORT>
# 6. Nettoyer
kubectl delete namespace test-env
¶ Prochaines Étapes
Dans le module suivant, nous explorerons les concepts de base de Kubernetes et créerons nos premiers objets (Pods, Deployments, Services).
Ce que vous avez appris :
- Options d'installation (local, cloud, on-premise)
- Installation complète avec kubeadm
- Configuration et bonnes pratiques
- Méthodes d'accès au cluster
- Extensions et personnalisations
Ce qui vous attend :
- Concepts fondamentaux (Pods, Labels, Selectors)
- Contrôleurs (Deployments, ReplicaSets, Jobs)
- Gestion du cycle de vie des applications
- Premiers déploiements pratiques