Installation de Kubernetes

---

1 - Options d'installation

Il existe plusieurs façons d'installer Kubernetes selon vos besoins :

Solution	Usage	Avantages	Inconvénients
Minikube	Dev local	Facile, multi-driver	Mono-node
Kind	CI/CD, tests	Rapide, multi-node	Pas pour prod
kubeadm	Production	Flexible, officiel	Complexe
k3s	Edge, IoT	Léger	Moins de fonctionnalités
EKS/AKS/GKE	Cloud	Managé, HA	Coût, vendor lock-in

---

2 - Installation de kubectl

kubectl est l'outil en ligne de commande pour interagir avec Kubernetes.

2.1 Installation sur Linux

# Télécharger la dernière version
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

# Rendre exécutable et déplacer
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

# Vérifier l'installation
kubectl version --client

2.2 Installation sur macOS

# Avec Homebrew
brew install kubectl

# Ou téléchargement direct
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/amd64/kubectl"

2.3 Installation sur Windows

# Avec Chocolatey
choco install kubernetes-cli

# Ou téléchargement direct
curl -LO "https://dl.k8s.io/release/v1.28.0/bin/windows/amd64/kubectl.exe"

2.4 Configuration de l'autocomplétion

# Bash
echo 'source <(kubectl completion bash)' >> ~/.bashrc
echo 'alias k=kubectl' >> ~/.bashrc
echo 'complete -o default -F __start_kubectl k' >> ~/.bashrc
source ~/.bashrc

# Zsh
echo 'source <(kubectl completion zsh)' >> ~/.zshrc
source ~/.zshrc

---

3 - Minikube

Minikube crée un cluster Kubernetes mono-node sur votre machine locale.

3.1 Installation

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

# macOS
brew install minikube

# Windows
choco install minikube

3.2 Drivers disponibles

3.3 Démarrer un cluster

# Démarrer avec le driver Docker (recommandé)
minikube start --driver=docker

# Avec des ressources personnalisées
minikube start --driver=docker --cpus=4 --memory=8192 --disk-size=50g

# Avec une version spécifique de Kubernetes
minikube start --kubernetes-version=v1.28.0

# Vérifier le status
minikube status

# Output attendu :
# minikube
# type: Control Plane
# host: Running
# kubelet: Running
# apiserver: Running
# kubeconfig: Configured

3.4 Commandes utiles Minikube

# Accéder au dashboard
minikube dashboard

# Obtenir l'IP du cluster
minikube ip

# SSH dans le node
minikube ssh

# Exposer un service via tunnel
minikube tunnel

# Arrêter le cluster
minikube stop

# Supprimer le cluster
minikube delete

# Créer un cluster multi-node
minikube start --nodes 3

3.5 Add-ons Minikube

# Lister les add-ons disponibles
minikube addons list

# Activer des add-ons
minikube addons enable ingress
minikube addons enable metrics-server
minikube addons enable dashboard

# Désactiver un add-on
minikube addons disable dashboard

---

4 - Kind (Kubernetes IN Docker)

Kind exécute des clusters Kubernetes dans des conteneurs Docker.

4.1 Installation

# Linux / macOS
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# macOS avec Homebrew
brew install kind

# Windows
choco install kind

4.2 Créer un cluster simple

# Cluster par défaut (1 node)
kind create cluster

# Cluster nommé
kind create cluster --name mon-cluster

# Vérifier
kind get clusters
kubectl cluster-info --context kind-mon-cluster

4.3 Cluster multi-node

# kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
    kubeadmConfigPatches:
    - |
      kind: InitConfiguration
      nodeRegistration:
        kubeletExtraArgs:
          node-labels: "ingress-ready=true"
    extraPortMappings:
    - containerPort: 80
      hostPort: 80
      protocol: TCP
    - containerPort: 443
      hostPort: 443
      protocol: TCP
  - role: worker
  - role: worker
  - role: worker

# Créer le cluster avec la configuration
kind create cluster --config kind-config.yaml --name prod-like

# Vérifier les nodes
kubectl get nodes

4.4 Charger des images locales

# Construire une image locale
docker build -t mon-app:v1 .

# Charger l'image dans Kind
kind load docker-image mon-app:v1 --name mon-cluster

# Utiliser l'image dans un déploiement
kubectl create deployment mon-app --image=mon-app:v1

4.5 Supprimer un cluster

# Supprimer un cluster spécifique
kind delete cluster --name mon-cluster

# Supprimer tous les clusters
kind delete clusters --all

---

5 - kubeadm

kubeadm est l'outil officiel pour créer des clusters Kubernetes de production.

5.1 Prérequis

5.2 Préparation des nodes (sur tous les nodes)

# Désactiver le swap
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

# Charger les modules kernel nécessaires
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe overlay
sudo modprobe br_netfilter

# Paramètres sysctl requis
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system

5.3 Installer containerd

# Installer containerd
sudo apt-get update
sudo apt-get install -y containerd

# Configurer containerd
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml

# Activer systemd cgroup driver
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

# Redémarrer containerd
sudo systemctl restart containerd
sudo systemctl enable containerd

5.4 Installer kubeadm, kubelet et kubectl

# Ajouter le repo Kubernetes
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

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

# Installer les composants
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

5.5 Initialiser le Control Plane

# Sur le node master
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=<IP_MASTER>

# 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

# Installer le plugin réseau (Calico)
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.0/manifests/calico.yaml

# Ou Flannel
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

5.6 Joindre les Worker Nodes

# La commande join est affichée après kubeadm init
# Exécuter sur chaque worker node :
sudo kubeadm join <MASTER_IP>:6443 --token <TOKEN> \
    --discovery-token-ca-cert-hash sha256:<HASH>

# Si le token a expiré, générer un nouveau :
kubeadm token create --print-join-command

5.7 Vérification du cluster

# Vérifier les nodes
kubectl get nodes

# Output attendu :
# NAME          STATUS   ROLES           AGE   VERSION
# master        Ready    control-plane   10m   v1.28.0
# worker-1      Ready    <none>          5m    v1.28.0
# worker-2      Ready    <none>          5m    v1.28.0

# Vérifier les pods système
kubectl get pods -n kube-system

---

6 - Services Kubernetes managés

6.1 Amazon EKS

# Installer eksctl
curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
sudo mv /tmp/eksctl /usr/local/bin

# Créer un cluster EKS
eksctl create cluster \
  --name mon-cluster \
  --region eu-west-1 \
  --nodegroup-name workers \
  --node-type t3.medium \
  --nodes 3 \
  --nodes-min 1 \
  --nodes-max 5 \
  --managed

6.2 Azure AKS

# Installer Azure CLI
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Se connecter
az login

# Créer un groupe de ressources
az group create --name monResourceGroup --location westeurope

# Créer un cluster AKS
az aks create \
  --resource-group monResourceGroup \
  --name monClusterAKS \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keys

# Configurer kubectl
az aks get-credentials --resource-group monResourceGroup --name monClusterAKS

6.3 Google GKE

# Installer gcloud CLI
# https://cloud.google.com/sdk/docs/install

# Se connecter
gcloud auth login
gcloud config set project MON_PROJET

# Créer un cluster GKE
gcloud container clusters create mon-cluster \
  --zone europe-west1-b \
  --num-nodes 3 \
  --machine-type e2-medium

# Configurer kubectl
gcloud container clusters get-credentials mon-cluster --zone europe-west1-b

---

7 - Vérification de l'installation

7.1 Tests de base

# Vérifier la version
kubectl version

# Informations du cluster
kubectl cluster-info

# Liste des nodes
kubectl get nodes -o wide

# Composants du système
kubectl get componentstatuses  # Deprecated mais utile
kubectl get pods -n kube-system

7.2 Déployer une application test

# Déployer nginx
kubectl create deployment nginx --image=nginx

# Exposer le déploiement
kubectl expose deployment nginx --port=80 --type=NodePort

# Vérifier
kubectl get pods,svc

# Tester l'accès
kubectl port-forward svc/nginx 8080:80
# Ouvrir http://localhost:8080

# Nettoyer
kubectl delete deployment nginx
kubectl delete svc nginx

---

Résumé

Dans ce chapitre, nous avons appris à :

• Installer kubectl sur différents OS
• Utiliser Minikube pour le développement local
• Créer des clusters avec Kind pour les tests
• Déployer un cluster de production avec kubeadm
• Utiliser les services managés EKS, AKS, GKE

---

Prochaine étape

Dans le prochain chapitre, nous explorerons les Pods et Conteneurs, l'unité de base de Kubernetes.

→ Chapitre suivant : Pods et Conteneurs

---

← Retour à la table des matières