Kubernetes Mise en route

Note

Cet article a été initialement vérifié par rapport aux notes de version Ubuntu 26.04 LTS d’avril 2026. Les versions des composants Kubernetes et les détails du déploiement de production nécessitent toujours une validation continue par rapport aux MicroK8 et aux mises à jour en amont.

Kubernetes (en abrégé K8s) est la plateforme d’orchestration de conteneurs la plus populaire aujourd’hui, open source par Google et offerte à la CNCF (Cloud Native Computing Foundation). Il automatise le déploiement, la mise à l’échelle et la gestion des applications conteneurisées et constitue la pierre angulaire de l’architecture cloud native moderne.

Ubuntu est l’une des distributions Linux traditionnelles permettant d’exécuter Kubernetes. Canonical propose également MicroK8s - une distribution Kubernetes légère et facile à installer, idéale pour les scénarios de développement, de test et d’informatique de pointe.

Qu’est-ce que les K8 et pourquoi vous en avez besoin

Points douloureux avant les K8

À l’ère de la conteneurisation, Docker a résolu le problème du « packaging et de l’exécution d’applications ». Mais lorsque l’on a des dizaines, voire des centaines de conteneurs à gérer, de nouveaux défis se présentent :

Si un conteneur plante, qui le redémarre automatiquement ?
Lorsque le trafic augmente, comment effectuer une mise à l’échelle automatique ?
Comment les conteneurs se découvrent-ils et communiquent-ils entre eux ?
Comment effectuer des mises à jour progressives sans interruption de service ?
Comment planifier des conteneurs sur plusieurs serveurs ?

Ce que K8 résout

Kubernetes a été conçu pour résoudre exactement ces problèmes :

Fonctionnalité	Description
Auto-guérison	Redémarre automatiquement les conteneurs en panne ; migre les charges de travail lorsque les nœuds échouent
Mise à l’échelle horizontale	Augmente ou diminue automatiquement les instances de conteneur en fonction de la charge
Découverte de services	Les conteneurs s’enregistrent automatiquement et accèdent les uns aux autres via les noms DNS
Mises à jour continues	Remplace progressivement les anciennes versions pour des déploiements sans temps d’arrêt
Équilibrage de charge	Distribue automatiquement le trafic sur plusieurs instances de conteneur
Gestion des configurations	Gestion centralisée des configurations et des secrets des applications

Installation des MicroK8

MicroK8s est l’Kubernetes léger d’Canonical, installé via Snap avec une seule commande.

Installation des MicroK8


# Install MicroK8s
# Choose the latest stable channel; check snap info microk8s for available versions
sudo snap install microk8s --classic --channel=1.33/stable
 
# Add current user to the microk8s group (avoid sudo every time)
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
 
# Re-login for group permissions to take effect
newgrp microk8s
 
# Check installation status
microk8s status --wait-ready

Activation des modules complémentaires courants

Le MicroK8s est livré avec de nombreux modules complémentaires intégrés :


# Enable DNS (internal cluster name resolution -- almost always required)
microk8s enable dns
 
# Enable local storage
microk8s enable hostpath-storage
 
# Enable Dashboard (web management interface)
microk8s enable dashboard
 
# Enable Ingress (HTTP reverse proxy)
microk8s enable ingress
 
# Enable container image registry
microk8s enable registry
 
# Enable multiple add-ons at once
microk8s enable dns hostpath-storage dashboard ingress
 
# View all available add-ons
microk8s status

Configuration de l’alias kubectl

MicroK8s inclut microk8s kubectl, mais le saisir à chaque fois est fastidieux. Vous pouvez créer un alias :


# Option 1: Use an alias
alias kubectl='microk8s kubectl'
echo "alias kubectl='microk8s kubectl'" >> ~/.bashrc
 
# Option 2: Export config for a standalone kubectl installation
microk8s config > ~/.kube/config

kubectl Opérations de base

kubectl est l’outil de ligne de commande permettant d’interagir avec les clusters Kubernetes.

Informations sur les clusters


# View cluster information
kubectl cluster-info
 
# View all nodes
kubectl get nodes
 
# View node details
kubectl describe node <node-name>
 
# View cluster component status
kubectl get componentstatuses

Affichage des ressources


# View all Pods
kubectl get pods
 
# View Pods across all namespaces
kubectl get pods --all-namespaces
# Or shorthand
kubectl get pods -A
 
# View Pod details (wide output)
kubectl get pods -o wide
 
# View all Deployments
kubectl get deployments
 
# View all Services
kubectl get services
# Or shorthand
kubectl get svc
 
# View all resources
kubectl get all

Détails et journaux des ressources


# View Pod details
kubectl describe pod <pod-name>
 
# View Pod logs
kubectl logs <pod-name>
 
# Follow logs in real-time
kubectl logs -f <pod-name>
 
# View logs for a specific container in a multi-container Pod
kubectl logs <pod-name> -c <container-name>
 
# Execute commands inside a Pod
kubectl exec -it <pod-name> -- /bin/bash

Concepts de base

Cosse

Un Pod est la plus petite unité déployable dans Kubernetes. Un Pod contient un ou plusieurs conteneurs qui partagent la mise en réseau et le stockage.


# pod-example.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80


# Create a Pod
kubectl apply -f pod-example.yaml
 
# Check Pod status
kubectl get pod nginx-pod
 
# Delete a Pod
kubectl delete pod nginx-pod

Déploiement

Un déploiement gère le nombre de réplicas de pods, les mises à jour propagées et les restaurations. En pratique, vous ne créerez presque jamais de pods directement : vous les gérez via des déploiements.


# deployment-example.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.27
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"


# Deploy the application
kubectl apply -f deployment-example.yaml
 
# View deployment status
kubectl get deployment nginx-deployment
 
# Scale up/down
kubectl scale deployment nginx-deployment --replicas=5
 
# View rolling update status
kubectl rollout status deployment nginx-deployment
 
# Update image version
kubectl set image deployment/nginx-deployment nginx=nginx:1.28
 
# Rollback to previous version
kubectl rollout undo deployment nginx-deployment
 
# View update history
kubectl rollout history deployment nginx-deployment

Service

Un service fournit un point de terminaison de réseau stable pour un ensemble de pods. Les adresses IP des pods changent de manière dynamique, tandis qu’un service fournit un point d’accès fixe.


# service-example.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Descriptions des types de services :

Taper	Description
IP de cluster	Défaut; accessible uniquement au sein du cluster
Port de nœud	Ouvre un port sur chaque nœud ; accessible de l’extérieur
Équilibreur de charge	Utilise l’équilibreur de charge du fournisseur de cloud


# Create a Service
kubectl apply -f service-example.yaml
 
# View the Service
kubectl get svc nginx-service
 
# Expose a service with NodePort
kubectl expose deployment nginx-deployment --type=NodePort --port=80

Déployer votre première application

Déployons une application Web complète du début à la fin.

Étape 1 : Créer un déploiement


# Quickly create using the command line
kubectl create deployment hello-app --image=gcr.io/google-samples/hello-app:1.0
 
# Verify the Pod is running
kubectl get pods -l app=hello-app

Étape 2 : exposer le service


# Create a NodePort Service
kubectl expose deployment hello-app --type=NodePort --port=8080
 
# View the assigned port
kubectl get svc hello-app

Étape 3 : Accédez à l’application


# Get the access URL
# MicroK8s runs locally by default, so use localhost
NODE_PORT=$(kubectl get svc hello-app -o jsonpath='{.spec.ports[0].nodePort}')
echo "Access URL: http://localhost:$NODE_PORT"
 
# Test access
curl http://localhost:$NODE_PORT

Étape 4 : Mise à l’échelle


# Scale to 3 replicas
kubectl scale deployment hello-app --replicas=3
 
# View all Pods
kubectl get pods -l app=hello-app

Étape 5 : Nettoyer


# Delete the Service and Deployment
kubectl delete svc hello-app
kubectl delete deployment hello-app

Gestion des packages de barre

Helm est le gestionnaire de packages pour Kubernetes, similaire à apt de Ubuntu. Il utilise des Charts (packages) pour définir, installer et mettre à niveau des applications Kubernetes complexes.

Installation de la barre


# Option 1: Install via Snap
sudo snap install helm --classic
 
# Option 2: Install via official script
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 
# Verify installation
helm version

Utiliser la barre


# Add the official stable repository
helm repo add bitnami https://charts.bitnami.com/bitnami
 
# Update repository index
helm repo update
 
# Search for Charts
helm search repo nginx
helm search repo mysql
 
# Install an application (Redis example)
helm install my-redis bitnami/redis
 
# View installed Releases
helm list
 
# View Release status
helm status my-redis
 
# Install with custom configuration
helm install my-nginx bitnami/nginx \
  --set replicaCount=3 \
  --set service.type=NodePort
 
# Install with a values file for custom configuration
helm install my-app bitnami/nginx -f custom-values.yaml
 
# Upgrade a Release
helm upgrade my-redis bitnami/redis --set auth.enabled=false
 
# Rollback
helm rollback my-redis 1
 
# Uninstall a Release
helm uninstall my-redis

Créer votre propre graphique


# Create a new Chart template
helm create my-chart
 
# Directory structure
# my-chart/
#   Chart.yaml      # Chart metadata
#   values.yaml     # Default configuration values
#   templates/       # K8s resource templates
#     deployment.yaml
#     service.yaml
#     ingress.yaml
 
# Validate the Chart
helm lint my-chart/
 
# Dry-run install (no actual deployment)
helm install my-release my-chart/ --dry-run --debug
 
# Package the Chart
helm package my-chart/

Tableau de commandes de référence rapide

Opération	Commande
Afficher l’état du cluster	`kubectl cluster-info`
Afficher tous les modules	`kubectl get pods -A`
Afficher les journaux des pods	`kubectl logs POD_NAME`
Entrez un Pod	`kubectl exec -it POD_NAME -- bash`
Créer une ressource	`kubectl apply -f file.yaml`
Supprimer une ressource	`kubectl delete -f file.yaml`
Augmenter	`kubectl scale deployment NAME --replicas=N`
Mettre à jour l’image	`kubectl set image deployment/NAME container=image`
Restauration	`kubectl rollout undo deployment/NAME`
Redirection de port	`kubectl port-forward pod/NAME 8080:80`
Afficher l’utilisation des ressources	`kubectl top pods`
Statut des MicroK8	`microk8s status`
Les MicroK8 démarrent	`microk8s start`
Les MicroK8 s’arrêtent	`microk8s stop`

Considérations relatives à la production

Warning

MicroK8s est excellent pour l’apprentissage et le développement, mais lorsque vous utilisez Kubernetes en production, gardez ces points à l’esprit :

Cluster haute disponibilité : la production nécessite au moins 3 nœuds de plan de contrôle pour éviter les points de défaillance uniques
Limites de ressources : définissez toujours resources.requests et resources.limits pour chaque conteneur afin d’empêcher une application de consommer toutes les ressources du nœud.
Politiques réseau : configurez NetworkPolicy pour restreindre la communication de pod à pod selon le principe du moindre privilège.
Autorisations RBAC : n’exécutez pas d’applications avec des privilèges d’administrateur de cluster ; créer des ServiceAccounts dédiés pour chaque service
Sécurité des images : utilisez uniquement des registres d’images fiables, analysez régulièrement les images à la recherche de vulnérabilités et évitez d’utiliser la balise latest.
Sauvegarder etcd : etcd stocke toutes les données d’état du cluster – des sauvegardes régulières sont essentielles
Surveillance et alerte : déployez Prometheus + Grafana pour surveiller l’état du cluster
Collecte de journaux : utilisez EFK (Elasticsearch + Fluentd + Kibana) ou Loki pour l’agrégation des journaux

Pour une assistance de niveau entreprise, envisagez Charmed Kubernetes de Canonical ou les services K8s gérés de fournisseurs de cloud (par exemple, AWS EKS, Google GKE, Azure AKS).

Dépannage courant


# Pod stuck in Pending state
kubectl describe pod <pod-name>
# Usually caused by insufficient resources or node selector mismatch
 
# Pod in CrashLoopBackOff
kubectl logs <pod-name> --previous
# View logs from the previous crash
 
# Cannot pull image (ImagePullBackOff)
kubectl describe pod <pod-name>
# Check if the image name is correct and whether image pull credentials are needed
 
# Service inaccessible
kubectl get endpoints <service-name>
# Verify that the Service selector matches the Pod labels
 
# DNS resolution failure
kubectl run test --image=busybox --rm -it -- nslookup kubernetes.default
# Check if CoreDNS is running properly

Après avoir maîtrisé le contenu ci-dessus, vous aurez la possibilité d’exécuter et de gérer les charges de travail de base Kubernetes sur Ubuntu. Au fur et à mesure que votre expérience se développe, vous pouvez explorer davantage ConfigMap, Secret, PersistentVolume, Ingress, CronJob et d’autres types de ressources.