Module 1 : Architecture et Concepts

Objectifs du Module

Comprendre l'architecture Kubernetes
Identifier les composants du Control Plane
Comprendre le rôle des Worker Nodes
Installer un cluster avec kubeadm

Durée : 3 heures

1. Vue d'Ensemble

1.1 Qu'est-ce que Kubernetes ?

Kubernetes - Problème et Solution

Kubernetes = "K8s" (K + 8 lettres + s) Origine: Google Borg → Kubernetes (2014, CNCF)

1.2 Concepts Clés

Kubernetes Objects Hierarchy

2. Architecture du Control Plane

2.1 Vue d'Ensemble

Kubernetes Control Plane Architecture

2.2 API Server

# L'API Server est le cœur de Kubernetes
# Toutes les communications passent par lui

# Endpoints principaux
# /api/v1/namespaces
# /api/v1/pods
# /api/v1/services
# /apis/apps/v1/deployments

# Exemple de requête API
# kubectl get pods = GET /api/v1/namespaces/default/pods

# Vérifier la santé de l'API Server
kubectl get --raw='/healthz'
kubectl get --raw='/readyz'

# Lister les API disponibles
kubectl api-resources
kubectl api-versions

2.3 etcd

# etcd = base de données clé-valeur distribuée
# Stocke TOUT l'état du cluster

# Caractéristiques
# - Consensus Raft (haute disponibilité)
# - Données chiffrées au repos
# - Backup critique

# Accéder à etcd (en cas de debug)
ETCDCTL_API=3 etcdctl \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  get / --prefix --keys-only | head -20

# Backup etcd
ETCDCTL_API=3 etcdctl snapshot save /backup/etcd-snapshot.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

# Restaurer etcd
ETCDCTL_API=3 etcdctl snapshot restore /backup/etcd-snapshot.db \
  --data-dir=/var/lib/etcd-restored

2.4 Scheduler

Kubernetes Scheduler - Algorithme de Placement

2.5 Controller Manager

Kubernetes Controller Reconciliation Loop

# Le Controller Manager exécute les boucles de contrôle
# Chaque controller surveille et réconcilie un type de ressource

# Controllers principaux :
# - ReplicaSet Controller : Maintient le nombre de replicas
# - Deployment Controller : Gère les rollouts
# - Node Controller : Surveille la santé des nodes
# - Service Controller : Gère les LoadBalancers cloud
# - Endpoint Controller : Peuple les Endpoints
# - Namespace Controller : Gère le cycle de vie des namespaces
# - ServiceAccount Controller : Crée les SA par défaut

# Boucle de contrôle (Reconciliation Loop)
#
#  ┌─────────────────────────────────────────────┐
#  │                                             │
#  ▼                                             │
# Observe ─────▶ Compare ─────▶ Act ─────────────┘
# (État actuel)  (vs désiré)   (Réconcilier)

3. Architecture des Worker Nodes

3.1 Composants

Kubernetes Worker Node Architecture

Kubernetes Worker Node Components

3.2 Structure d'un Pod

Kubernetes Pod Structure

3.3 Kubelet

# Configuration kubelet
# /var/lib/kubelet/config.yaml

# Vérifier le status
systemctl status kubelet

# Logs kubelet
journalctl -u kubelet -f

# Configuration importante
cat /var/lib/kubelet/config.yaml
# - clusterDNS
# - clusterDomain
# - cgroupDriver (systemd recommandé)
# - containerRuntimeEndpoint

# Kubelet Static Pods
# /etc/kubernetes/manifests/
# Les pods définis ici sont gérés directement par kubelet
ls /etc/kubernetes/manifests/
# kube-apiserver.yaml
# kube-controller-manager.yaml
# kube-scheduler.yaml
# etcd.yaml

3.4 Container Runtime

# containerd est le runtime par défaut depuis K8s 1.24

# Vérifier containerd
systemctl status containerd
containerd --version

# CLI pour containerd
crictl ps
crictl images
crictl logs <container-id>

# Configuration containerd
cat /etc/containerd/config.toml

# Plugins CNI
ls /etc/cni/net.d/
ls /opt/cni/bin/

4. Installation avec kubeadm

4.1 Prérequis

# Sur TOUS les nodes (control plane + workers)

# 1. Désactiver le swap
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

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

sudo modprobe overlay
sudo modprobe br_netfilter

# 3. Paramètres sysctl
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

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

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

# Configurer SystemdCgroup = true
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd

4.2 Installation kubeadm, kubelet, kubectl

# Ajouter le repo 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.29/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.29/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

# Vérifier
kubeadm version
kubectl version --client
kubelet --version

4.3 Initialisation du Control Plane

# Sur le node Control Plane uniquement

# Initialiser le cluster
sudo kubeadm init \
  --pod-network-cidr=10.244.0.0/16 \
  --apiserver-advertise-address=<IP_CONTROL_PLANE>

# 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 le cluster
kubectl cluster-info
kubectl get nodes
# STATUS = NotReady (pas encore de CNI)

# Installer un CNI (Calico)
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml

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

# Vérifier que le node passe Ready
kubectl get nodes
# STATUS = Ready

4.4 Joindre les Worker Nodes

# Sur chaque Worker Node

# Utiliser la commande affichée par kubeadm init
sudo kubeadm join <IP_CONTROL_PLANE>:6443 \
  --token <TOKEN> \
  --discovery-token-ca-cert-hash sha256:<HASH>

# Si le token a expiré, en créer un nouveau (sur le control plane)
kubeadm token create --print-join-command

# Vérifier depuis le control plane
kubectl get nodes
# Tous les nodes doivent être Ready

4.5 Configuration Post-Installation

# Autoriser le scheduling sur le control plane (optionnel, dev only)
kubectl taint nodes --all node-role.kubernetes.io/control-plane-

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

# Déployer un test
kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl get svc nginx

# Accéder via NodePort
curl http://<NODE_IP>:<NODE_PORT>

5. Alternatives d'Installation

5.1 minikube (Local Dev)

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

# Démarrer un cluster
minikube start --driver=docker --cpus=2 --memory=4096

# Addons utiles
minikube addons enable ingress
minikube addons enable metrics-server
minikube addons enable dashboard

# Dashboard
minikube dashboard

# Accéder aux services
minikube service <service-name>

# Tunnel pour LoadBalancer
minikube tunnel

5.2 kind (Kubernetes IN Docker)

# Installation kind
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

# Créer un cluster simple
kind create cluster

# Cluster multi-nodes
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF

# Charger une image dans kind
kind load docker-image my-app:latest

5.3 k3s (Lightweight)

# Installation k3s (single node)
curl -sfL https://get.k3s.io | sh -

# Vérifier
sudo k3s kubectl get nodes

# Copier la config
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
sudo chown $USER ~/.kube/config

# Ajouter un agent (worker)
# Sur le server, récupérer le token
sudo cat /var/lib/rancher/k3s/server/node-token

# Sur le worker
curl -sfL https://get.k3s.io | K3S_URL=https://<SERVER_IP>:6443 K3S_TOKEN=<TOKEN> sh -

Exercice : À Vous de Jouer

Mise en Pratique

Objectif : Installer et explorer votre premier cluster Kubernetes

Contexte : Vous devez mettre en place un environnement Kubernetes local pour comprendre son architecture et ses composants fondamentaux.

Tâches à réaliser :

Installer un cluster Kubernetes avec minikube ou kind
Explorer les composants du Control Plane dans le namespace kube-system
Vérifier la communication avec l'API Server et lister les ressources disponibles
Créer votre premier déploiement nginx et examiner son cycle de vie
Identifier sur quel node le pod a été schedulé et pourquoi

Critères de validation :

[ ] Cluster opérationnel avec status "Ready"
[ ] Tous les composants du Control Plane sont Running
[ ] L'API Server répond correctement aux requêtes
[ ] Le pod nginx est déployé et accessible
[ ] Vous pouvez expliquer le rôle de chaque composant observé

Solution

Étape 1 : Installation du cluster

# Option 1: minikube
minikube start --driver=docker --cpus=2 --memory=4096

# Option 2: kind
kind create cluster --name demo

Étape 2 : Explorer les composants du Control Plane

# Lister les pods système
kubectl get pods -n kube-system

# Détails de l'API Server
kubectl describe pod -n kube-system -l component=kube-apiserver

# Détails du Scheduler
kubectl describe pod -n kube-system -l component=kube-scheduler

# Détails du Controller Manager
kubectl describe pod -n kube-system -l component=kube-controller-manager

# Détails d'etcd
kubectl describe pod -n kube-system -l component=etcd

Étape 3 : Vérifier l'API Server

# Informations du cluster
kubectl cluster-info

# Santé de l'API
kubectl get --raw='/healthz'
kubectl get --raw='/readyz'

# Lister toutes les ressources API disponibles
kubectl api-resources | head -20

# Versions des APIs
kubectl api-versions

Étape 4 : Premier déploiement

# Créer un déploiement nginx
kubectl create deployment nginx --image=nginx:1.25

# Vérifier le déploiement
kubectl get deployments
kubectl get replicasets
kubectl get pods

# Examiner en détail
kubectl describe pod nginx-<pod-id>

# Voir les événements
kubectl get events --sort-by=.metadata.creationTimestamp

Étape 5 : Analyse du scheduling

# Identifier le node
kubectl get pods -o wide

# Examiner les événements de scheduling
kubectl describe pod nginx-<pod-id> | grep -A5 Events

# Information sur le node
kubectl describe node <node-name>

Explication : Le Scheduler a assigné le pod au node en fonction des ressources disponibles (CPU, mémoire) et des contraintes éventuelles (nodeSelector, affinity, taints).

Quiz

Quel composant stocke l'état du cluster ?
[ ] A. API Server
[ ] B. etcd
[ ] C. Controller Manager
Quel composant assigne les pods aux nodes ?
[ ] A. Kubelet
[ ] B. Scheduler
[ ] C. Kube-proxy
Quel est le runtime container par défaut depuis K8s 1.24 ?
[ ] A. Docker
[ ] B. containerd
[ ] C. CRI-O
Quelle commande initialise un cluster avec kubeadm ?
[ ] A. kubeadm create
[ ] B. kubeadm init
[ ] C. kubeadm start

Réponses : 1-B, 2-B, 3-B, 4-B

Suivant : Module 2 - Workloads


← Programme	Module 2 : Workloads Fondamentaux →

Retour au Programme