Kubernetes est un système open-source d'orchestration de conteneurs, conçu pour automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées. Son architecture est basée sur un modèle client-serveur distribué, principalement composé d'un Control Plane et de Worker Nodes. Comprenons en détail chaque composant et leurs interactions.
Le Control Plane est le cerveau du cluster. Il prend toutes les décisions et maintient l'état désiré du cluster.
Rôle : Point d'entrée unique pour toutes les opérations du cluster
Fonctionnalités :
Communication :
kubectl ──HTTPS──► API Server ──► etcd
│
kubelet ◄──────────┘
Controller Manager ──► API Server
Scheduler ──────────► API Server
Mise en Pratique :
# Voir les endpoints API disponibles
kubectl api-versions
# Explorer les ressources disponibles
kubectl api-resources
# Diagnostiquer l'API Server
kubectl cluster-info
Rôle : Base de données distribuée clé-valeur stockant tout l'état du cluster
Fonctionnalités :
Données stockées :
Criticité : etcd est le point critique - si etcd est perdu, le cluster est perdu !
Mise en Pratique :
# Sur un cluster kubeadm, explorer etcd avec etcdutl (outil recommandé), n'est pas forcément installé par défaut
sudo etcdutl --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 /registry/pods --prefix --keys-only
# Alternative avec etcdctl (version legacy)
sudo 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 /registry/pods --prefix --keys-only
Rôle : Assigne les nouveaux Pods aux Nodes appropriés
Processus de Scheduling :
Filtrage : Éliminer les Nodes inadéquats
Scoring : Classer les Nodes éligibles
Binding : Assigner le Pod au Node optimal
Facteurs de Décision :
Mise en Pratique :
Lancer un déploiement :
# Lancer un déploiement puis :
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
labels:
app: nginx
spec:
replicas: 3
selector:
matchLabels:
app: nginx
template:
metadata:
labels:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.29.5
ports:
- containerPort: 80
Puis regarder les informations/events :
# Voir les événements de scheduling
kubectl get events --sort-by='.lastTimestamp'
kubectl get nodes
kubectl get pod -o wide
Rôle : Exécute les boucles de contrôle qui maintiennent l'état désiré
Contrôleurs principaux :
Boucle de Contrôle :
1. Observer l'état actuel
2. Comparer avec l'état désiré
3. Prendre des actions correctives
4. Répéter indéfiniment
Mise en Pratique :
# Voir les contrôleurs en action
kubectl describe deployment nginx-deployment
# Observer la recréation automatique
kubectl delete pod <nom-du-pod-dans-deployment>
kubectl get pods -w
Rôle : Interface avec les APIs des fournisseurs cloud
Fonctionnalités par Cloud :
Exemple d'intégration :
apiVersion: v1
kind: Service
metadata:
name: web-service
spec:
type: LoadBalancer # Le Cloud Controller provisionne automatiquement
ports:
- port: 80
selector:
app: web
Les Worker Nodes sont les machines de travail qui exécutent vos applications.
Rôle : Agent Kubernetes sur chaque Node
Responsabilités :
Interactions :
API Server ──► kubelet : "Lance ce Pod"
kubelet ──► Container Runtime : "Crée ces conteneurs"
kubelet ──► API Server : "Statut des Pods"
Configuration :
# Exemple de configuration kubelet
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
maxPods: 110
podCIDR: "10.244.0.0/24"
clusterDNS: ["10.96.0.10"]
clusterDomain: "cluster.local"
Rôle : Proxy réseau gérant la communication
Modes de Fonctionnement :
Pour l'installer il faut les packages nécessaires + modifier la configmap kube-proxy. Nous ne verrons pas celà dans cette formation.
Fonctionnalités :
Mise en Pratique :
# Voir les règles iptables créées par kube-proxy
sudo iptables -t nat -L | grep kubernetes
# Voir les services exposés
kubectl get services
Rôle : Exécute et gère les conteneurs
Runtimes Supportés :
Interface CRI :
kubelet ──► CRI ──► Container Runtime ──► Linux Kernel
(Container Runtime Interface)
Création d'un Deployment :
1. kubectl ──► API Server : "Crée ce Deployment"
2. API Server ──► etcd : "Stocke ce Deployment"
3. Controller Manager observe ──► API Server
4. Controller Manager ──► API Server : "Crée un ReplicaSet"
5. Controller Manager ──► API Server : "Crée des Pods"
6. Scheduler observe ──► API Server
7. Scheduler ──► API Server : "Assigne Pods aux Nodes"
8. kubelet observe ──► API Server
9. kubelet ──► Container Runtime : "Lance les conteneurs"
10. kubelet ──► API Server : "Rapporte le statut"
TLS mutuel : Tous les composants communiquent en HTTPS avec certificats
Certificats principaux :
# 1. Voir tous les composants système
kubectl get pods -n kube-system
# 2. Détailler un composant
kubectl describe pod kube-scheduler-<node> -n kube-system
# 3. Voir les logs d'un composant
kubectl logs kube-apiserver-<node> -n kube-system
# 4. Vérifier la santé du cluster
kubectl get componentstatuses # Déprécié mais informatif
# 5. Voir la configuration du cluster
kubectl cluster-info dump
Le Cloud Controller Manager permet l'intégration native avec l'infrastructure cloud :
Provisioning automatique :
# Ce manifeste déclenche automatiquement :
# - Création d'un LoadBalancer AWS ELB
# - Configuration des health checks
# - Routage du trafic vers les Pods
apiVersion: v1
kind: Service
metadata:
name: web-app
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: nlb
spec:
type: LoadBalancer
ports:
- port: 80
targetPort: 8080
selector:
app: web-app
Métriques disponibles :
Dans le module suivant, nous explorerons les méthodes d'installation de Kubernetes et créerons notre premier cluster.
TP associé : TP 2 : Architecture et Communication
Ce que vous avez appris :
Ce qui vous attend :