Les Fondamentaux de Kubernetes: Guide Complet pour Orchestrer vos Conteneurs

Kubernetes (K8s) est devenu la plateforme standard pour l’orchestration de conteneurs à grande échelle. Ce guide vous présente les concepts fondamentaux de Kubernetes et comment l’utiliser efficacement pour gérer vos applications conteneurisées.

Qu’est-ce que Kubernetes?

Kubernetes est une plateforme open-source créée par Google pour automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Il fournit un cadre pour exécuter des systèmes distribués de manière résiliente.

Pourquoi Kubernetes?

• Déploiement automatisé: Déploiement et mises à jour sans temps d’arrêt
• Auto-guérison: Redémarrage automatique des conteneurs défaillants
• Mise à l’échelle horizontale: Adaptation automatique de la capacité
• Équilibrage de charge: Distribution du trafic entre les instances
• Orchestration du stockage: Gestion du stockage persistant
• Gestion de configuration: Séparation du code et de la configuration
• Support multi-cloud: Fonctionne sur tous les principaux fournisseurs cloud

Architecture de Kubernetes

L’architecture de Kubernetes est composée de plusieurs composants clés:

Plan de Contrôle (Control Plane)

• API Server: Point d’entrée pour toutes les commandes REST
• etcd: Base de données clé-valeur pour stocker l’état du cluster
• Scheduler: Affecte les pods aux nœuds
• Controller Manager: Maintient l’état souhaité du cluster
• Cloud Controller Manager: Interface avec les APIs des fournisseurs cloud

Nœuds (Nodes)

• Kubelet: Agent qui s’exécute sur chaque nœud, s’assure que les conteneurs fonctionnent
• Kube-proxy: Maintient les règles réseau sur les nœuds
• Container Runtime: Logiciel responsable de l’exécution des conteneurs (Docker, containerd, etc.)

Installation de Kubernetes

Minikube (pour le développement local)

# Installation sur Linux
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 Kubernetes local
minikube start

# Vérifier l'état
minikube status

kubeadm (pour les clusters de production)

# Installation des prérequis
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

# Ajouter la clé GPG et le dépôt Kubernetes
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Installer kubeadm, kubelet et kubectl
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Initialiser le cluster (sur le nœud maître)
sudo kubeadm init --pod-network-cidr=192.168.0.0/16

# Configurer kubectl
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl (outil en ligne de commande)

# Installation sur Linux
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

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

Concepts Fondamentaux de Kubernetes

Pods

Le pod est l’unité de base de Kubernetes, représentant un ou plusieurs conteneurs qui partagent le stockage et le réseau.

# pod.yaml - Exemple de pod simple
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.19
    ports:
    - containerPort: 80

# Créer un pod
kubectl apply -f pod.yaml

# Lister les pods
kubectl get pods

# Décrire un pod
kubectl describe pod nginx-pod

# Supprimer un pod
kubectl delete pod nginx-pod

Deployments

Les deployments permettent de gérer le cycle de vie des pods et des ReplicaSets, facilitant les mises à jour et les rollbacks.

# deployment.yaml - Exemple de déploiement
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.19
        ports:
        - containerPort: 80

# Créer un déploiement
kubectl apply -f deployment.yaml

# Lister les déploiements
kubectl get deployments

# Mettre à jour l'image d'un déploiement
kubectl set image deployment/nginx-deployment nginx=nginx:1.20

# Effectuer un rollback
kubectl rollout undo deployment/nginx-deployment

Services

Les services permettent d’exposer les applications fonctionnant sur un ensemble de pods.

# service.yaml - Exemple de service
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP  # Autres types: NodePort, LoadBalancer, ExternalName

# Créer un service
kubectl apply -f service.yaml

# Lister les services
kubectl get services

# Décrire un service
kubectl describe service nginx-service

Namespaces

Les namespaces fournissent un mécanisme pour isoler les groupes de ressources dans un cluster.

# namespace.yaml - Exemple de namespace
apiVersion: v1
kind: Namespace
metadata:
  name: development

# Créer un namespace
kubectl apply -f namespace.yaml

# Lister les namespaces
kubectl get namespaces

# Créer une ressource dans un namespace spécifique
kubectl apply -f pod.yaml -n development

ConfigMaps et Secrets

Permettent de séparer la configuration des conteneurs.

# configmap.yaml - Exemple de ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database.host: "db.example.com"
  database.port: "5432"

# secret.yaml - Exemple de Secret
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  # Les valeurs doivent être encodées en base64
  database.password: cGFzc3dvcmQxMjM=  # "password123" encodé en base64

# Créer un ConfigMap
kubectl apply -f configmap.yaml

# Créer un Secret
kubectl apply -f secret.yaml

# Utiliser un ConfigMap dans un pod
spec:
  containers:
  - name: app
    image: app:1.0
    envFrom:
    - configMapRef:
        name: app-config

Utilisation des Volumes

Les volumes permettent de stocker des données au-delà de la durée de vie d’un pod.

# pvc.yaml - Exemple de PersistentVolumeClaim
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

# pod-with-volume.yaml - Pod utilisant un volume
apiVersion: v1
kind: Pod
metadata:
  name: data-pod
spec:
  containers:
  - name: data-container
    image: nginx
    volumeMounts:
    - mountPath: "/data"
      name: data-volume
  volumes:
  - name: data-volume
    persistentVolumeClaim:
      claimName: data-pvc

Gestion de l’Ingress

L’Ingress expose les services HTTP et HTTPS depuis l’extérieur du cluster.

# ingress.yaml - Exemple d'Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /app
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

# Installer un contrôleur Ingress (exemple avec NGINX)
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/cloud/deploy.yaml

# Créer un Ingress
kubectl apply -f ingress.yaml

Débogage des Applications

Logs et shell interactif

# Afficher les logs d'un pod
kubectl logs nginx-pod

# Exécuter une commande dans un pod
kubectl exec -it nginx-pod -- /bin/bash

# Suivre les logs en temps réel
kubectl logs -f nginx-pod

Diagnostic des problèmes

# Vérifier l'état d'un pod
kubectl get pod nginx-pod -o wide

# Décrire un pod pour voir les événements
kubectl describe pod nginx-pod

# Vérifier les nœuds
kubectl get nodes
kubectl describe node <node-name>

Gestion des Ressources

Limites de ressources

# resource-limits.yaml - Exemple de limites de ressources
apiVersion: v1
kind: Pod
metadata:
  name: resource-pod
spec:
  containers:
  - name: app
    image: app:1.0
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Horizontal Pod Autoscaler (HPA)

# hpa.yaml - Exemple d'autoscaling
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app-deployment
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

# Créer un HPA
kubectl apply -f hpa.yaml

# Lister les HPAs
kubectl get hpa

Sécurité dans Kubernetes

RBAC (Contrôle d’Accès Basé sur les Rôles)

# role.yaml - Exemple de rôle
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

# rolebinding.yaml - Exemple de liaison de rôle
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Network Policies

# network-policy.yaml - Exemple de politique réseau
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-network-policy
spec:
  podSelector:
    matchLabels:
      role: db
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: app
    ports:
    - protocol: TCP
      port: 5432

Meilleures Pratiques pour Kubernetes

1. Utiliser des déploiements plutôt que des pods individuels
2. Définir des limites de ressources pour tous les conteneurs
3. Configurer des sondes de disponibilité (liveness et readiness probes)
4. Implémenter le scaling horizontal pour les charges variables
5. Séparer les environnements avec des namespaces
6. Utiliser des labels et annotations pour organiser les ressources
7. Implémenter des politiques réseau pour sécuriser les communications
8. Configurer le RBAC pour limiter les accès
9. Utiliser des Secrets pour les données sensibles
10. Mettre en place une stratégie de sauvegarde pour etcd

Outils complémentaires pour Kubernetes

Helm (gestionnaire de paquets)

# Installation de Helm
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

# Ajouter un dépôt
helm repo add bitnami https://charts.bitnami.com/bitnami

# Installer une application
helm install my-release bitnami/wordpress

Kustomize (gestion de configuration)

# kustomization.yaml - Exemple de configuration Kustomize
resources:
- deployment.yaml
- service.yaml

namespace: my-namespace

commonLabels:
  app: my-app
  environment: production

# Appliquer une configuration Kustomize
kubectl apply -k ./

Prometheus et Grafana (monitoring)

# Installation via Helm
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack

Conclusion

Kubernetes est devenu l’outil standard pour l’orchestration de conteneurs grâce à sa flexibilité, sa robustesse et son écosystème riche. Comprendre ses concepts fondamentaux est essentiel pour gérer efficacement des applications modernes à grande échelle.

En maîtrisant Kubernetes, vous pourrez:

• Déployer des applications à l’échelle
• Garantir une haute disponibilité
• Optimiser l’utilisation des ressources
• Simplifier les opérations
• Fournir un modèle déclaratif pour la gestion d’infrastructure

La courbe d’apprentissage de Kubernetes peut être abrupte, mais l’investissement en vaut la peine pour toute équipe travaillant avec des architectures basées sur des conteneurs.