Skip to content

Kubernetes Aide-mémoire

Plateforme d'orchestration de conteneurs pour automatiser déploiement et mise à l'échelle.

01

Démarrage

Bases de kubectl

kubectl est la CLI de Kubernetes. get liste les ressources, create en crée, expose crée des services, scale change le nombre de réplicas. describe donne des infos détaillées sur une ressource.

kubernetes
# cluster info
kubectl cluster-info

# list nodes
kubectl get nodes

# list pods (all namespaces)
kubectl get pods --all-namespaces

# create a deployment
kubectl create deployment nginx --image=nginx

# expose deployment as service
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# scale deployment
kubectl scale deployment nginx --replicas=3

# get detailed info
kubectl describe pod <pod-name>

# view logs
kubectl logs <pod-name>

Formatage de sortie

Le flag -o contrôle la sortie. yaml/json montrent la spec complète de la ressource. jsonpath et custom-columns extraient des champs précis pour les scripts. -w surveille les changements en direct. Employez --no-headers dans les scripts pour retirer les noms de colonnes.

kubernetes
# wide format (more columns)
kubectl get pods -o wide

# YAML output
kubectl get pod nginx -o yaml

# JSON output
kubectl get pod nginx -o json

# jsonpath (extract specific fields)
kubectl get pods -o jsonpath='{.items[*].metadata.name}'

# custom columns
kubectl get pods -o custom-columns=NAME:.metadata.name,STATUS:.status.phase

# show labels
kubectl get pods --show-labels

# watch for changes
kubectl get pods -w

Contexte et configuration

Un contexte regroupe l'adresse du cluster, les identifiants utilisateur et le namespace. Les fichiers kubeconfig (défaut ~/.kube/config) les stockent. Plusieurs fichiers se combinent via la variable KUBECONFIG pour gérer de nombreux clusters.

kubernetes
# view current config
kubectl config view

# list contexts
kubectl config get-contexts

# switch context
kubectl config use-context my-cluster

# set default namespace for current context
kubectl config set-context --current --namespace=dev

# show current context
kubectl config current-context

# KUBECONFIG with multiple files
export KUBECONFIG=~/.kube/config:~/.kube/prod-config

Explain et ressources d'API

api-resources liste ce que le cluster gère. explain montre le schéma OpenAPI de toute ressource — inestimable pour écrire du YAML sans quitter le terminal. Employez --recursive pour décharger toute la structure imbriquée.

kubernetes
# list all resource types
kubectl api-resources

# list namespaced vs cluster-scoped
kubectl api-resources --namespaced=true
kubectl api-resources --namespaced=false

# explain a resource's fields
kubectl explain pod
kubectl explain pod.spec.containers
kubectl explain deployment.spec.strategy

# explain with recursion (all nested fields)
kubectl explain pod --recursive

# include description
kubectl explain pod.spec.containers.resources --api-version=apps/v1

Dry run et génération de YAML

--dry-run=client -o yaml est la façon standard d'échafauder des manifestes depuis des commandes impératives. --dry-run=server valide contre le vrai apiserver (webhooks d'admission, schéma) sans persister. Parfait pour amorcer du YAML déclaratif.

kubernetes
# generate YAML without applying
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml

# pipe generated YAML straight to a file
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > nginx.yaml

# apply the generated manifest
kubectl apply -f nginx.yaml

# dry-run against the server (validates with apiserver)
kubectl apply -f nginx.yaml --dry-run=server

# generate a service from a deployment
kubectl create service clusterip my-svc --tcp=80:80 --dry-run=client -o yaml

Aide et autocomplétion

Chaque commande kubectl gère --help avec des exemples. La complétion shell économise énormément de frappe et expose les sous-commandes. L'alias k=kubectl est quasi universel chez les praticiens — combinez-le à la complétion pour la meilleure expérience.

kubernetes
# top-level help
kubectl --help

# subcommand help
kubectl create --help
kubectl explain --help

# generate bash completion
kubectl completion bash > /etc/bash_completion.d/kubectl

# zsh completion
source <(kubectl completion zsh)

# alias k=kubectl with completion
alias k=kubectl
complete -o default -F __start_kubectl k

# shorthand: kubectl -> k
echo 'alias k=kubectl' >> ~/.bashrc
02

Pod

Manifeste de Pod

Un Pod est la plus petite unité déployable, portant un ou plusieurs conteneurs qui partagent réseau et stockage. Les conteneurs d'un pod sont toujours co-programmés sur le même nœud. On crée rarement des pods directement — employez plutôt un Deployment ou un Job.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:1.25
      ports:
        - containerPort: 80
      resources:
        requests:
          cpu: 100m
          memory: 128Mi
        limits:
          cpu: 200m
          memory: 256Mi
  restartPolicy: Always

Pod multi-conteneurs (Sidecar)

Les pods multi-conteneurs partagent le réseau (même IP, même espace de ports) et les volumes. Patterns courants : sidecar (assistant), adapter (transforme la sortie), ambassador (proxy). Le volume partagé emptyDir laisse le sidecar lire les logs écrits par le conteneur principal.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: web-with-logs
spec:
  containers:
    - name: app
      image: nginx
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/nginx
    - name: log-shipper
      image: busybox
      command: ["sh", "-c", "tail -f /var/log/nginx/access.log"]
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/nginx
          readOnly: true
  volumes:
    - name: shared-logs
      emptyDir: {}

Cycle de vie et phases du pod

La phase d'un pod est de haut niveau (Pending, Running, Succeeded, Failed). Les états de conteneur (Waiting/Running/Terminated) donnent le vrai détail — ex. CrashLoopBackOff signifie que le conteneur ne cesse de sortir. Vérifiez le compteur de redémarrages et les événements pour diagnostiquer.

kubernetes
# pod phases: Pending | Running | Succeeded | Failed | Unknown
kubectl get pod nginx

# show status including container states
kubectl get pod nginx -o jsonpath='{.status}'

# container states: Waiting | Running | Terminated
kubectl describe pod nginx

# common Waiting reasons: ImagePullBackOff, CrashLoopBackOff, CreateContainerConfigError
kubectl get pods --field-selector=status.phase=Pending

# restart count reveals crash loops
kubectl get pods -o jsonpath='{.items[*].status.containerStatuses[*].restartCount}'

Statut et événements du pod

Les événements sont le journal d'audit du cluster pour une ressource — ordonnancement, tirage, erreurs de tirage, échecs de liveness. Ils expirent (~1 heure par défaut), capturez-les donc pendant le débogage. describe regroupe les événements avec la spec de la ressource pour un triage rapide.

kubernetes
# full describe (includes Events at the bottom)
kubectl describe pod nginx

# list cluster events sorted by time
kubectl get events --sort-by=.lastTimestamp

# events for a specific namespace
kubectl get events -n default

# watch events live
kubectl get events -w

# filter events by type
kubectl get events --field-selector type=Warning

# events for a specific pod
kubectl get events --field-selector involvedObject.name=nginx

Exec et port-forward

exec exécute des commandes dans un conteneur ; -it alloue un TTY pour les shells. port-forward tunnelise un port local vers un pod/service sans l'exposer publiquement — essentiel pour déboguer des bases ou UI web depuis son ordinateur portable.

kubernetes
# open an interactive shell
kubectl exec -it nginx -- sh

# run a one-off command
kubectl exec nginx -- ls /etc/nginx

# specify container in a multi-container pod
kubectl exec -it web-with-logs -c log-shipper -- sh

# forward a local port to a pod port
kubectl port-forward pod/nginx 8080:80

# forward to a service / deployment
kubectl port-forward svc/nginx 8080:80
kubectl port-forward deployment/nginx 8080:80

# forward to a random local port
kubectl port-forward pod/nginx :80

Suppression et force

Supprimer un pod contrôlé par un Deployment/StatefulSet provoque un remplacement immédiat. --force --grace-period=0 saute la période de grâce du signal TERM et peut laisser des ressources périmées — à employer avec parcimonie. Les pods bloqués en Terminating exigent souvent le retrait d'un finalizer.

kubernetes
# delete a pod (controller will recreate it)
kubectl delete pod nginx

# force delete immediately (bypasses graceful shutdown)
kubectl delete pod nginx --grace-period=0 --force

# delete by label
kubectl delete pods -l app=nginx

# delete all pods in a namespace
kubectl delete pods --all -n default

# delete a pod and wait for it to be gone
kubectl delete pod nginx --wait

# delete with a timeout
kubectl delete pod nginx --timeout=30s
03

Deployment

Manifeste de Deployment

Un Deployment gère des ReplicaSets et offre des mises à jour glissantes et des retours arrière déclaratifs. spec.selector doit correspondre à spec.template.metadata.labels. Le template définit la spec de pod qui se déploie.

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80

Stratégie de mise à jour glissante

RollingUpdate (défaut) remplace graduellement les pods pour un service sans interruption. maxSurge/maxUnavailable contrôlent la vitesse et la disponibilité. Recreate tue tous les pods avant d'en créer — employé quand l'app ne peut faire tourner deux versions à la fois (ex. écrivains à volume unique).

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 10
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%        # extra pods above replicas during update
      maxUnavailable: 25%  # pods allowed down during update
  # alternative: recreate (kills all, then starts new)
  # strategy:
  #   type: Recreate
  selector:
    matchLabels:
      app: nginx
  template:

Retour arrière

Chaque changement du template de pod crée une révision de ReplicaSet. undo ramène le trafic vers un ReplicaSet précédent. pause permet de faire plusieurs corrections entre incréments canary. Employez --record (déprécié) ou des annotations pour tracer les causes de changement.

kubernetes
# view rollout history
kubectl rollout history deployment/nginx

# see details of a specific revision
kubectl rollout history deployment/nginx --revision=2

# undo to the previous revision
kubectl rollout undo deployment/nginx

# undo to a specific revision
kubectl rollout undo deployment/nginx --to-revision=2

# pause/resume a rollout (for canary pauses)
kubectl rollout pause deployment/nginx
kubectl rollout resume deployment/nginx

# check rollout status
kubectl rollout status deployment/nginx

Scale et HPA

HPA met à l'échelle les réplicas selon CPU/mémoire ou métriques personnalisées. Exige metrics-server pour CPU/mem. minReplicas et maxReplicas bornent la mise à l'échelle. L'API v2 gère plusieurs métriques et comportements (stabilisation de la descente).

kubernetes
# scale manually
kubectl scale deployment/nginx --replicas=5

# horizontal pod autoscaler (CPU target)
kubectl autoscale deployment nginx --min=2 --max=10 --cpu-percent=80

# list HPA
kubectl get hpa

# HPA manifest (v2 with custom metrics)
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nginx
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 80

Mettre à jour l'image et redémarrer

set image déclenche un nouveau ReplicaSet et une mise à jour glissante. rollout restart est la façon la plus propre de tirer la dernière image ou rafraîchir la config — il crée un nouveau ReplicaSet avec la même spec. edit ouvre votre $EDITOR pour des corrections ad-hoc.

kubernetes
# update container image
kubectl set image deployment/nginx nginx=nginx:1.26

# update from a specific container
kubectl set image deployment/nginx container=nginx:1.26 --record

# trigger a rollout restart (same image, recreate pods)
kubectl rollout restart deployment/nginx

# edit a deployment in editor
kubectl edit deployment/nginx

# patch a single field
kubectl patch deployment/nginx -p '{"spec":{"replicas":5}}'

# apply a manifest change
kubectl apply -f nginx-deployment.yaml

Statut du Deployment

Un Deployment possède des ReplicaSets ; un seul est actif (replicas>0). Les vieux ReplicaSets passent à zéro pour le retour arrière. pod-template-hash étiquette chaque pod de sa révision. Vérifiez status.conditions pour les signaux Available, Progressing et ReplicaFailure.

kubernetes
# deployment status
kubectl get deployment nginx

# watch rollout
kubectl rollout status deployment/nginx

# show ReplicaSets owned by the deployment
kubectl get rs -l app=nginx

# show pods across all revisions
kubectl get pods -l app=nginx --show-labels

# pod-template-hash label distinguishes revisions
# kubectl get pods -l app=nginx,pod-template-hash=xxxx

# conditions: Available, Progressing, ReplicaFailure
kubectl get deployment nginx -o jsonpath='{.status.conditions}'
04

Service

Types de Service

Un Service fournit une IP/DNS stable qui répartit la charge sur un ensemble de pods. ClusterIP est le défaut (dans le cluster uniquement). NodePort et LoadBalancer exposent vers l'extérieur. ExternalName est un alias DNS, pas un proxy.

kubernetes
# four service types:
# - ClusterIP (default): reachable inside the cluster
# - NodePort: exposed on each node's IP at a static port
# - LoadBalancer: cloud-provisioned external LB
# - ExternalName: DNS CNAME to an external host

# quick create
kubectl expose deployment nginx --port=80 --type=ClusterIP
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# external name (no proxying, pure DNS)
kubectl create service externalname my-svc --external-name=db.example.com

Service ClusterIP

ClusterIP donne une IP virtuelle et un nom DNS stables dans le cluster. Le sélecteur matche les labels de pods ; kube-proxy programme iptables/IPVS pour répartir la charge sur les endpoints. Résolvez via <svc>.<ns>.svc.cluster.local ou simplement <svc>.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: ClusterIP
  selector:
    app: nginx
  ports:
    - name: http
      port: 80          # service port
      targetPort: 80    # container port
      protocol: TCP
# DNS: nginx.default.svc.cluster.local
# short names also work: nginx, nginx.default
# kube-dns / CoreDNS resolves the service VIP

Service NodePort

NodePort ouvre le même port statique (30000-32767) sur chaque nœud. Le trafic vers n'importe quel nœud:nodePort atteint un pod (kube-proxy peut rediriger vers un pod d'un autre nœud). Utile quand on ne peut provisionner un LB cloud ; associez à un LB externe pour la HA.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080   # optional, 30000-32767 range
# reachable at <any-node-ip>:30080
# also still reachable via clusterIP:80

# get assigned nodePort
kubectl get svc nginx -o jsonpath='{.spec.ports[*].nodePort}'

Service LoadBalancer

LoadBalancer demande au fournisseur cloud de provisionner un load balancer externe pointant vers les nœuds. externalTrafficPolicy: Local préserve l'IP source du client (pas de SNAT) mais saute la répartition inter-nœuds. STATUS montre l'IP externe assignée une fois prêt.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
  # cloud-specific annotations
  # annotations:
  #   service.beta.kubernetes.io/aws-load-balancer-type: nlb
  #   service.beta.kubernetes.io/azure-load-balancer-internal: "true"
  # externalTrafficPolicy: Local preserves client IP
  externalTrafficPolicy: Local
# status.ingress shows the external IP/hostname

Service headless

Un service headless (clusterIP: None) n'a pas de VIP — le DNS renvoie directement les IP de pods. Requis par StatefulSet pour que chaque pod reçoive un nom DNS stable (pod-0.svc, pod-1.svc). Aussi employé par les clients qui veulent découvrir eux-mêmes tous les backends.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: nginx-headless
spec:
  clusterIP: None       # makes it headless
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
# DNS returns pod IPs directly (not a VIP)
# A records: nginx-headless.default.svc.cluster.local
#   -> 10.1.0.5, 10.1.0.6, 10.1.0.7
# used by StatefulSet for stable pod DNS:
#   <pod-name>.<svc-name>.default.svc.cluster.local

Endpoints et EndpointSlices

Endpoints/EndpointSlices listent les IP de pods qui reçoivent réellement le trafic — seuls les pods Ready apparaissent. Si un service n'a pas d'endpoints, les pods ne matchent pas le sélecteur ou ne sont pas Ready. EndpointSlices (v1) passent mieux à l'échelle pour les énormes services et sont le défaut.

kubernetes
# view endpoints backing a service
kubectl get endpoints nginx

# endpoint slices (newer, more scalable)
kubectl get endpointslices -l kubernetes.io/service-name=nginx

# endpoints track pods that match the selector
# AND pass readiness checks
kubectl describe endpoints nginx

# a service with no ready pods has no endpoints
# - check pod readiness if traffic is refused
# - EndpointSlices are grouped by address type (IPv4/IPv6)

# manually managed endpoints (selector-less service)
05

ConfigMap

Créer un ConfigMap

Les ConfigMaps stockent la configuration non sensible en paires clé-valeur. --from-literal pour des valeurs en ligne, --from-file pour intégrer des fichiers entiers (le nom du fichier devient la clé). Utile pour découpler la config des images sans recompiler.

kubernetes
# from literal values
kubectl create configmap app-config \
  --from-literal=LOG_LEVEL=debug \
  --from-literal=ENABLE_FEATURE=true

# from a file (key = filename, value = contents)
kubectl create configmap app-config --from-file=app.properties

# from a directory (one key per file)
kubectl create configmap app-config --from-file=configs/

# from an env file
kubectl create configmap app-config --from-env-file=app.env

# from a file with a custom key
kubectl create configmap app-config --from-file=custom-key=app.properties

Manifeste de ConfigMap

data porte des valeurs chaînes (chaque clé devient une variable d'env ou un fichier au montage). Les chaînes multi-lignes emploient les scalaires bloc YAML (|). binaryData accepte le base64 pour les blobs binaires. La limite totale est de 1 Mio par ConfigMap.

kubernetes
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  LOG_LEVEL: "debug"
  ENABLE_FEATURE: "true"
  application.yml: |
    server:
      port: 8080
    logging:
      level: debug
binaryData:
  # base64-encoded binary values
  logo.png: iVBORw0KGgoAAAANSUhEUg...

Consommer comme variables d'environnement

envFrom injecte chaque clé du ConfigMap comme variable d'env d'un coup. env avec configMapKeyRef choisit des clés individuelles. optional: true laisse le pod démarrer même si le ConfigMap n'existe pas. Les mises à jour du ConfigMap ne rafraîchissent PAS les variables d'env des pods en cours.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      env:
        - name: LOG_LEVEL
          valueFrom:
            configMapKeyRef:
              name: app-config
              key: LOG_LEVEL
      envFrom:
        - configMapRef:
            name: app-config      # injects all keys as env vars
              optional: true      # pod starts even if CM missing

Consommer comme volume

Monter un ConfigMap comme volume projette chaque clé en fichier. Les mises à jour du ConfigMap finissent par se refléter dans les fichiers montés (réglé par la période de sync du kubelet) — mais les apps doivent les relire. Les montages subPath épinglent une seule clé et ne se mettent PAS à jour.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      volumeMounts:
        - name: config
          mountPath: /etc/config
          readOnly: true
  volumes:
    - name: config
      configMap:
        name: app-config
        items:                       # optional: pick subset
          - key: application.yml
            path: app.yml            # rename file
        defaultMode: 0644
# each ConfigMap key becomes a file under /etc/config

Mise à jour et rechargement

Les fichiers de ConfigMap montés se rafraîchissent automatiquement (après sync du kubelet), mais les variables d'env sont immuables pour la vie du pod — redémarrez les pods pour prendre en compte les changements d'env. rollout restart est la façon la plus propre de propager les mises à jour de config à un Deployment.

kubernetes
# edit the configmap
kubectl edit configmap app-config

# patch a single key
kubectl patch configmap app-config \
  --type merge -p '{"data":{"LOG_LEVEL":"info"}}'

# mounted files update within ~kubelet sync period (default 60s)
# but env vars do NOT update in running pods

# force pods to pick up new config by rolling them
kubectl rollout restart deployment/app

# verify the new value on a pod
kubectl exec app -- printenv LOG_LEVEL

ConfigMap immuable

Mettre immutable: true fige le ConfigMap — tout changement exige delete + recreate. Cela réduit drastiquement le trafic de surveillance kubelet-apiserver pour les grosses configs stables (un gain de scalabilité majeur à grande échelle). Courant en production pour les configs d'app versionnées avec l'image.

kubernetes
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
immutable: true
data:
  LOG_LEVEL: "debug"
# once immutable, the only change allowed is delete + recreate
# benefits: kubelet does not watch it, lower apiserver load
# useful for large, stable configs in production

# make it mutable again
kubectl patch configmap app-config -p '{"immutable":false}'
# (this fails if currently immutable — must delete instead)
06

Secret

Créer un Secret

Les Secrets stockent des données sensibles encodées en base64 (PAS chiffrées au repos par défaut — activez le chiffrement au repos en production). Employez generic/Opaque pour des données arbitraires, docker-registry pour les tirages d'images, tls pour le TLS d'Ingress. Ne commitez jamais de YAML de Secret dans git.

kubernetes
# generic (opaque) from literals
kubectl create secret generic db-creds \
  --from-literal=username=admin \
  --from-literal=password='S3cur3!'

# from a file (e.g. SSH key, certificate)
kubectl create secret generic ssh-key --from-file=ssh-privatekey=~/.ssh/id_rsa

# docker registry secret (for private image registries)
kubectl create secret docker-registry regcred \
  --docker-server=registry.example.com \
  --docker-username=user \
  --docker-password=pass \
  [email protected]

# TLS secret from cert/key files
kubectl create secret tls my-tls \
  --cert=fullchain.pem \
  --key=privkey.pem

Manifeste de Secret

Les valeurs de data doivent être encodées en base64 (echo -n 'value' | base64). stringData est une commodité qui accepte le texte clair et fusionne dans data à l'apply. type Opaque est le défaut ; les types spécialisés (kubernetes.io/tls, kubernetes.io/dockerconfigjson) valident les clés.

kubernetes
apiVersion: v1
kind: Secret
metadata:
  name: db-creds
type: Opaque
data:
  username: YWRtaW4=         # base64 of "admin"
  password: UzNjdXIzIQ==     # base64 of "S3cur3!"
# stringData accepts plaintext (auto-encoded on apply)
stringData:
  api-key: "live-key-xyz"
# encode on the command line:
# echo -n 'admin' | base64
# decode:
# echo 'YWRtaW4=' | base64 -d

Employer un Secret comme variable d'environnement

Consommer des secrets comme variables d'env est identique aux ConfigMaps mais emploie secretKeyRef/secretRef. Notez que les variables d'env sont visibles via /proc/1/environ et par tout processus du conteneur — préférez les montages en volume pour les données très sensibles.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      env:
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-creds
              key: password
      envFrom:
        - secretRef:
            name: db-creds      # injects all keys
              optional: true

Employer un Secret comme volume

Les secrets montés se projettent en fichiers dans un volume tmpfs (mémoire) — jamais écrits sur le disque du nœud. defaultMode 0400 restreint l'accès. Les secrets montés SE mettent à jour quand le Secret change (après sync du kubelet), contrairement aux secrets en variables d'env.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      volumeMounts:
        - name: secrets
          mountPath: /etc/secrets
          readOnly: true
  volumes:
    - name: secrets
      secret:
        secretName: db-creds
        defaultMode: 0400       # restrict permissions
        items:
          - key: password
            path: db-password   # written to /etc/secrets/db-password
# memory-backed tmpfs, never written to disk on the node

ImagePullSecret

imagePullSecrets s'authentifie auprès des registres privés lors du tirage d'images. L'attacher à un ServiceAccount l'applique à chaque pod utilisant ce SA — le pattern préféré. Le type de secret docker-registry produit automatiquement la charge .dockerconfigjson correcte.

kubernetes
# attach to a pod
apiVersion: v1
kind: Pod
metadata:
  name: private-app
spec:
  imagePullSecrets:
    - name: regcred
  containers:
    - name: app
      image: registry.example.com/myapp:1.0

# attach to a service account (auto-applied to all pods using it)
kubectl patch serviceaccount default \
  -p '{"imagePullSecrets":[{"name":"regcred"}]}'

# verify
kubectl get sa default -o jsonpath='{.imagePullSecrets}'

Types de Secret

Les types de secrets spécialisés activent validation et intégration : tls pour Ingress, dockerconfigjson pour les tirages d'images, service-account-token auto-monté dans les pods. Employer le bon type garantit que les clés sont validées et consommées par les bons contrôleurs.

kubernetes
# Opaque (default) — arbitrary key-value
type: Opaque

# kubernetes.io/service-account-token — auto for SAs
type: kubernetes.io/service-account-token

# kubernetes.io/dockerconfigjson — registry auth
type: kubernetes.io/dockerconfigjson
data:
  .dockerconfigjson: <base64>

# kubernetes.io/tls — for Ingress TLS
type: kubernetes.io/tls
data:
  tls.crt: <base64>
  tls.key: <base64>

# kubernetes.io/basic-auth
type: kubernetes.io/basic-auth
stringData:
  username: admin
  password: pass
07

Namespace

Créer un namespace

Les namespaces partitionnent un cluster pour plusieurs équipes ou environnements (dev/stage/prod). Les noms de ressources doivent être uniques dans un namespace. Certaines ressources (Nodes, PV, StorageClasses) sont à portée de cluster et non namespacées.

kubernetes
# imperative
kubectl create namespace dev

# declarative
apiVersion: v1
kind: Namespace
metadata:
  name: dev
  labels:
    environment: development
    team: platform

# apply
kubectl apply -f namespace.yaml

# list namespaces
kubectl get namespaces

# set default namespace for current context
kubectl config set-context --current --namespace=dev

ResourceQuota

ResourceQuota plafonne l'usage agrégé de ressources d'un namespace — totaux CPU/mémoire requests/limits, comptes d'objets (pods, PVC, services, deployments). Essentiel pour les clusters multi-locataires pour qu'une équipe ne prive pas les autres. Les pods sans requests explicites sont rejetés dès que le quota est posé.

kubernetes
apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-quota
  namespace: dev
spec:
  hard:
    requests.cpu: "10"
    requests.memory: 20Gi
    limits.cpu: "20"
    limits.memory: 40Gi
    pods: "50"
    services.loadbalancers: "2"
    persistentvolumeclaims: "10"
    count/deployments.apps: "5"
# limits total aggregate resource use in the namespace

LimitRange

LimitRange fixe des défauts et bornes par ressource : requests/limits par défaut pour les pods qui ne les précisent pas, plus min/max pour contraindre les valeurs excessives. S'accorde avec ResourceQuota — sans requests par défaut, le quota rejetterait tout pod qui oublie de les définir.

kubernetes
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: dev
spec:
  limits:
    - type: Container
      default:               # default limits (if unset)
        cpu: 500m
        memory: 512Mi
      defaultRequest:        # default requests (if unset)
        cpu: 100m
        memory: 128Mi
      max:                   # max allowed limits
        cpu: "2"
        memory: 2Gi
      min:                   # min allowed requests
        cpu: 50m
        memory: 64Mi
    - type: PersistentVolumeClaim
      max:
        storage: 100Gi
      min:
        storage: 1Gi

Suppression de namespace et finalizers

Supprimer un namespace cascade toutes ses ressources. Un namespace bloqué en Terminating porte généralement un finalizer qui ne peut aboutir — un APIService indisponible (ex. metrics-server) ou un CRD dont le contrôleur a disparu. Retirer le finalizer force la fin mais peut fuiter des ressources externes.

kubernetes
# delete a namespace (cascades all resources in it)
kubectl delete namespace dev

# if stuck in Terminating, inspect finalizers
kubectl get namespace dev -o yaml

# remove finalizer to force completion (DANGEROUS)
kubectl patch namespace dev -p '{"metadata":{"finalizers":null}}'

# resources that block deletion:
# - APIService unavailable (metrics-server removed)
# - custom resources whose CRD is gone
# - PVCs with attached PVs

# check what's still in the namespace
kubectl api-resources --verbs=list --namespaced -o name \
  | xargs -n 1 kubectl get -n dev --ignore-not-found

Namespaces par défaut

kube-system fait tourner le plan de contrôle et les add-ons (DNS, kube-proxy, CNI). kube-public porte les données d'amorçage lisibles par les utilisateurs non authentifiés. kube-node-lease stocke les battements de cœur des nœuds en objets Lease pour la performance. default est où atterrissent vos charges si vous ne précisez pas de namespace.

kubernetes
# built-in namespaces
kubectl get namespaces
# NAME              STATUS   AGE
# default           Active   30d   <- user workloads land here
# kube-system       Active   30d   <- control plane / addons
# kube-public       Active   30d   <- publicly readable (bootstrap)
# kube-node-lease   Active   30d   <- node heartbeats (leases)

# kube-system holds:
# - kube-dns / CoreDNS
# - kube-proxy
# - metrics-server
# - CNI, CSI, cloud provider controllers

# kube-public is readable by all (used for cluster info discovery)

Namespacé vs à portée de cluster

La plupart des ressources de charge sont namespacées ; l'infrastructure (nodes, PV, StorageClasses, ClusterRoles) est à portée de cluster. Un Service ne peut viser que des pods de son propre namespace. -A est le raccourci de --all-namespaces — essentiel pour une visibilité sur tout le cluster.

kubernetes
# which resources are namespaced?
kubectl api-resources --namespaced=true
kubectl api-resources --namespaced=false

# namespaced: pods, services, deployments, configmaps, secrets
# cluster-scoped: nodes, namespaces, PVs, StorageClasses, ClusterRoles

# access across namespaces:
# - a Service selector only matches pods in the SAME namespace
# - cross-namespace refs require special controllers (e.g. external-dns)

# list resources across all namespaces
kubectl get pods --all-namespaces
kubectl get pods -A   # shorthand
08

Labels et sélecteurs

Syntaxe des labels

Les labels sont des paires clé-valeur servant à identifier et regrouper les ressources. Les clés peuvent porter un préfixe optionnel (sous-domaine DNS, ex. app.kubernetes.io/). Les labels servent au requêtage/filtrage, contrairement aux annotations destinées aux métadonnées arbitraires non identifiantes.

kubernetes
# labels are key=value pairs
# key: prefix (optional DNS subdomain) + name
# value: string, up to 63 chars

metadata:
  labels:
    app: nginx
    tier: frontend
    env: prod
    app.kubernetes.io/name: nginx
    app.kubernetes.io/version: "1.25"

# view labels
kubectl get pods --show-labels

# add/overwrite a label
kubectl label pod nginx env=prod
kubectl label pod nginx env=staging --overwrite

# remove a label (trailing dash)
kubectl label pod nginx env-

Sélecteurs d'égalité et d'ensemble

Deux saveurs de sélecteurs : par égalité (=, ==, !=) et par ensemble (in, notin, exists, !exists). Plusieurs conditions séparées par des virgules sont des ET. Services et Deployments emploient des sélecteurs d'égalité en YAML ; kubectl -l accepte les deux.

kubernetes
# equality-based: = == !=
kubectl get pods -l app=nginx
kubectl get pods -l env!=dev
kubectl get pods -l 'app=nginx,env=prod'   # AND of conditions

# set-based: in, notin, exists
kubectl get pods -l 'env in (prod,staging)'
kubectl get pods -l 'env notin (dev)'
kubectl get pods -l 'tier'                 # key exists
kubectl get pods -l '!canary'              # key does not exist

# combine equality and set-based
kubectl get pods -l 'app=nginx,env in (prod,staging)'

Étiqueter les ressources

label mute les métadonnées identifiantes — employez-le pour tout ce que les sélecteurs doivent matcher. annotate est pour les métadonnées non identifiantes (owner, ticket, description, indices d'outils). Les nœuds sont couramment étiquetés d'indices de topologie ou de matériel pour piloter l'ordonnancement.

kubernetes
# label a pod
kubectl label pod nginx app=nginx tier=web

# label all pods matching a selector
kubectl label pods -l app=oldapp app=newapp --overwrite

# label a node (for scheduling hints)
kubectl label node node-1 disktype=ssd

# remove a node label
kubectl label node node-1 disktype-

# list nodes by label
kubectl get nodes -l disktype=ssd

# annotate (non-identifying metadata)
kubectl annotate pod nginx owner=alice
kubectl annotate pod nginx description="web server"

Sélecteurs dans les manifestes

En YAML, les sélecteurs emploient matchLabels (égalité) et matchExpressions (par ensemble avec In/NotIn/Exists/DoesNotExist). Pour un Deployment, le sélecteur est immuable après création — et les labels du template de pod doivent le matcher. Les Services ne gèrent que matchLabels.

kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  selector:
    matchLabels:            # equality-based
      app: nginx
    matchExpressions:       # set-based (optional)
      - key: env
        operator: In
        values: [prod, staging]
      - key: tier
        operator: Exists
  template:
    metadata:
      labels:
        app: nginx          # MUST match selector
        env: prod
        tier: web

Annotations

Les annotations portent des métadonnées non identifiantes employées par les outils — kubectl apply stocke la config last-applied, cert-manager lit les indices d'émetteur, Prometheus la config de scraping, les contrôleurs y gardent l'état de déploiement. Contrairement aux labels, les valeurs d'annotation peuvent être de gros blobs JSON.

kubernetes
metadata:
  annotations:
    kubernetes.io/change-cause: "bump nginx to 1.26"
    prometheus.io/scrape: "true"
    prometheus.io/port: "9090"
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"apps/v1",...}
    cert-manager.io/cluster-issuer: "letsencrypt-prod"

# view annotations
kubectl get pod nginx -o jsonpath='{.metadata.annotations}'

# annotate
kubectl annotate pod nginx owner=team-platform

# remove an annotation (trailing dash)
kubectl annotate pod nginx owner-

Labels recommandés

Les labels app.kubernetes.io/* sont un vocabulaire partagé pour que les outils (Helm, operators, dashboards) regroupent toutes les ressources d'une application. name+instance identifient de façon unique une release ; component/part-of décrivent la hiérarchie ; managed-by/created-by tracent l'appartenance.

kubernetes
# shared recommended labels (app.kubernetes.io/*)
metadata:
  labels:
    app.kubernetes.io/name: nginx
    app.kubernetes.io/instance: nginx-prod
    app.kubernetes.io/version: "1.25"
    app.kubernetes.io/component: web
    app.kubernetes.io/part-of: storefront
    app.kubernetes.io/managed-by: helm
    app.kubernetes.io/created-by: controller-manager

# Helm applies these automatically; kubectl doesn't.
# They unify how tooling identifies an application's resources
# across Deployments, Services, Ingresses, ConfigMaps, etc.
09

ReplicaSet

Manifeste de ReplicaSet

Un ReplicaSet maintient un ensemble stable de pods répliques matchant un sélecteur — il recrée les pods supprimés ou défaillants. On emploie presque toujours un Deployment à la place, qui enveloppe un ReplicaSet et ajoute mises à jour glissantes et retours arrière.

kubernetes
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
# kubectl get rs
# kubectl describe rs nginx

Fonctionnement du ReplicaSet

Le contrôleur ReplicaSet rapproche le compte de pods désiré du réel à l'aide du sélecteur. Chaque pod reçoit un ownerReference pointant vers le RS — c'est pourquoi kubectl get pod montre « Owned by ReplicaSet/nginx ». Mettre à l'échelle ne fait que changer le compte désiré.

kubernetes
# the controller loop:
# 1. count pods matching selector
# 2. if fewer than replicas -> create from template
# 3. if more than replicas -> delete excess (arbitrary order)

# owned-by reference on each pod
kubectl get pod -l app=nginx -o jsonpath='{.items[*].metadata.ownerReferences}'

# if you delete a pod, the RS creates a new one immediately
kubectl delete pod <pod-name>
kubectl get pods -l app=nginx

# scale by editing replicas
kubectl scale rs nginx --replicas=5

ReplicaSet vs ReplicationController

ReplicationController (la primitive v1 d'origine) ne gère que les sélecteurs d'égalité et est déprécié. ReplicaSet (apps/v1) ajoute les sélecteurs d'ensemble. En pratique, employez Deployment — il gère les ReplicaSets pour vous et offre mises à jour glissantes/retours arrière.

kubernetes
# ReplicationController (v1, legacy): equality-only selectors
# ReplicaSet (apps/v1, modern): set-based selectors (in, notin, exists)

# ReplicationController is deprecated; do not use.
apiVersion: v1
kind: ReplicationController      # legacy
# ...
# ReplicaSet is the successor:
apiVersion: apps/v1
kind: ReplicaSet                 # modern
# ...
# Deployment wraps ReplicaSet and is the recommended primitive:
apiVersion: apps/v1
kind: Deployment                 # use this in practice

Mise à l'échelle manuelle

kubectl scale change le champ replicas. Si un HPA cible la même ressource, il l'emportera sur la mise à l'échelle manuelle au prochain rapprochement. Préférez kubectl scale pour les cas ponctuels et HPA pour les charges élastiques continues.

kubernetes
# scale a replicaset directly
kubectl scale rs nginx --replicas=5

# scale via patch
kubectl patch rs nginx -p '{"spec":{"replicas":5}}'

# scale multiple resources at once
kubectl scale deployment nginx deployment web --replicas=3

# scale by referencing a file
kubectl scale --replicas=5 -f nginx.yaml

# the autoscaler (HPA) will override manual scaling
# if it targets the same resource

Changements de template et adoption

Contrairement à un Deployment, un ReplicaSet nu ne déploie pas les changements du template de pod — seuls les pods nouvellement créés (après suppression/mise à l'échelle) reçoivent la nouvelle spec. Un ReplicaSet adopte tout pod orphelin matchant son sélecteur, ce qui peut surprendre.

kubernetes
# changing the pod template does NOT update existing pods
# (unlike a Deployment, a bare ReplicaSet won't roll out)
kubectl edit rs nginx   # change image -> new pods use it, old ones don't

# delete old pods to force them onto the new template
kubectl delete pods -l app=nginx

# a ReplicaSet will ADOPT existing pods that match its selector
# even pods created independently — useful (and dangerous)

# orphaned pods (no owner) matching the selector are taken over
kubectl get pods -l app=nginx --show-kind

Retirer des pods d'un ReplicaSet

Pour retirer un pod sans que le ReplicaSet le recrée, passez le RS à 0 d'abord, ou retirez les ownerReferences du pod pour que le RS ne le possède plus. Utile pour déboguer une instance précise ou extraire des logs avant le nettoyage.

kubernetes
# detaching a pod from its ReplicaSet (so it isn't replaced)
kubectl patch pod <pod-name> \
  -p '{"metadata":{"ownerReferences":[]}}'

# now deleting this pod won't trigger a replacement,
# because the RS no longer owns it

# or scale the RS to 0 first, then delete
kubectl scale rs nginx --replicas=0
kubectl delete pod <pod-name>

# useful for debugging a specific failing pod instance
# without the RS immediately recreating it
10

StatefulSet

Manifeste de StatefulSet

StatefulSet donne aux pods une identité stable (nom, hostname, stockage) et un déploiement/mise à l'échelle ordonné. Exige un serviceName headless. volumeClaimTemplates crée un PVC dédié par pod — donc même si pod-0 est reprogrammé, il rattache le même volume.

kubernetes
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql          # required: headless service
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql:8
          ports:
            - containerPort: 3306
          volumeMounts:
            - name: data
              mountPath: /var/lib/mysql
  volumeClaimTemplates:       # one PVC per pod
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 10Gi

Identité stable

Chaque pod reçoit un nom ordinal stable (mysql-0, mysql-1, …) et un nom DNS stable via le service headless. Quand un nœud tombe, pod-0 est reprogrammé ailleurs mais garde son nom et rattache son volume — critique pour les bases en cluster qui dépendent d'une appartenance stable.

kubernetes
# pods are named <statefulset-name>-<ordinal>
# mysql-0, mysql-1, mysql-2
kubectl get pods -l app=mysql

# each pod has stable DNS (via the headless service):
#   mysql-0.mysql.default.svc.cluster.local
#   mysql-1.mysql.default.svc.cluster.local

# stable hostname inside the pod:
kubectl exec mysql-0 -- hostname
# -> mysql-0

# ordinal index also exposed:
kubectl exec mysql-0 -- sh -c 'echo $HOSTNAME'
# -> mysql-0

# pod identity persists across reschedules

Stockage stable

volumeClaimTemplates génère un PVC par pod avec un nom prévisible (data-mysql-0, …). Les PVC survivent à la suppression des pods et du StatefulSet — cela prévient la perte de données mais exige de supprimer explicitement les PVC pour récupérer le stockage. Le même volume se rattache toujours au même pod ordinal.

kubernetes
# one PVC per pod, named <volumeClaimTemplate-name>-<pod-name>
kubectl get pvc
# NAME        STATUS   VOLUME       CAPACITY   ...
# data-mysql-0   Bound   pvc-aaa      10Gi
# data-mysql-1   Bound   pvc-bbb      10Gi
# data-mysql-2   Bound   pvc-ccc      10Gi

# when pod-0 is rescheduled, it re-binds data-mysql-0
# deleting the StatefulSet does NOT delete PVCs by default
# (protects from accidental data loss)

# to actually delete the data:
kubectl delete pvc data-mysql-0 data-mysql-1 data-mysql-2

Déploiement ordonné et gestion des pods

OrderedReady (défaut) crée les pods strictement dans l'ordre 0→1→2 et les supprime en sens inverse — requis par les systèmes qui exigent un primaire amorcé avant les réplicas. Parallel crée/supprime tous les pods simultanément — plus rapide pour les magasins shardés symétriques (Cassandra, Elasticsearch).

kubernetes
spec:
  podManagementPolicy: OrderedReady   # default: strict order
  # podManagementPolicy: Parallel      # create/delete all at once

  replicas: 3
  # OrderedReady: create pod-0, then pod-1, then pod-2 (each waits for Ready)
  # deletion is reverse: pod-2, pod-1, pod-0

  # Parallel: all pods created/deleted simultaneously
  # identity and storage remain stable either way

# check policy
kubectl get statefulset mysql -o jsonpath='{.spec.podManagementPolicy}'

# parallel is great for sharded stores that don't need bootstrap order

Mises à jour glissantes

Les mises à jour glissantes de StatefulSet vont dans l'ordre ordinal inverse (N-1 vers 0). partition permet de canary d'abord les pods de plus haut ordinal. OnDelete met les mises à jour en pause jusqu'à suppression manuelle d'un pod — utile pour des migrations contrôlées. Les déploiements sont plus lents qu'avec des Deployments à cause de l'ordre.

kubernetes
spec:
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      partition: 2          # only pods with ordinal >= 2 update
      maxUnavailable: 1     # (default 1) allowed down
  # type: OnDelete  -> only update when pod is manually deleted

# partition enables canaries: set partition=N to update
# only the top N pods; lower to 0 to roll out to all.

kubectl rollout status statefulset/mysql
# waits for all pods to be updated

# StatefulSets also support rollout history/undo,
# but only when the change is in the pod template

Association au service headless

Le service headless (clusterIP: None) référencé par spec.serviceName est ce qui rend le DNS stable par pod possible. Sans lui, le StatefulSet ne créera pas de pods. Les clients résolvent le nom du service en round-robin, ou pod-0.svc pour épingler un primaire. N'oubliez pas de créer le Service.

kubernetes
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  clusterIP: None         # headless
  selector:
    app: mysql
  ports:
    - port: 3306
---
# StatefulSet references this service via spec.serviceName
# this gives each pod a stable DNS:
#   mysql-0.mysql.default.svc.cluster.local

# clients can:
# - resolve mysql -> any pod IP (load-balanced by DNS round-robin)
# - resolve mysql-0.mysql -> pod-0's IP (pin to a specific replica)

# required: serviceName MUST match the headless service name
11

DaemonSet

Manifeste de DaemonSet

Un DaemonSet fait tourner exactement un pod par nœud (selon ses contraintes d'ordonnancement). Parfait pour les agents au niveau nœud : collecteurs de logs, supervision, stockage, CNI, contrôleurs d'ingress. Les nouveaux nœuds reçoivent automatiquement un pod ; les nœuds supprimés voient le leur ramassé.

kubernetes
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: log-agent
  namespace: kube-system
  labels:
    app: log-agent
spec:
  selector:
    matchLabels:
      app: log-agent
  template:
    metadata:
      labels:
        app: log-agent
    spec:
      containers:
        - name: agent
          image: fluent-bit:2.2
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
      # one pod per (matching) node automatically

Ordonnancement des nœuds

nodeSelector est la contrainte la plus simple (tous les key=value doivent matcher). nodeAffinity ajoute les opérateurs In/NotIn/Exists et des règles preferred/required. Les DaemonSets les respectent comme tout pod — combinés aux tolerations, on peut faire tourner des agents aussi sur les nœuds de contrôle taintés.

kubernetes
spec:
  template:
    spec:
      nodeSelector:                # simplest: must match all
        disktype: ssd

      # more flexible affinity
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: kubernetes.io/os
                    operator: In
                    values: [linux]

      # only run on nodes labeled role=logging
      nodeSelector:
        role: logging

      tolerations:                 # tolerate tainted nodes
        - key: node-role.kubernetes.io/control-plane
          operator: Exists

Stratégie de mise à jour

RollingUpdate (défaut) met à jour les pods nœud par nœud, borné par maxUnavailable (nombre ou %). OnDelete met les mises à jour en pause jusqu'à suppression manuelle de chaque pod — utile quand un contrôle nœud par nœud est requis. maxSurge vaut 0 par défaut (les DaemonSets veulent rarement des pods en plus).

kubernetes
spec:
  updateStrategy:
    type: RollingUpdate           # default
    rollingUpdate:
      maxUnavailable: 1           # how many nodes update at once
      maxSurge: 0                 # (default 0) no extra pods
  # type: OnDelete               # only update when old pod is deleted

# trigger an update (e.g. new image)
kubectl set image daemonset/log-agent agent=fluent-bit:2.3

# watch rollout
kubectl rollout status daemonset/log-agent -n kube-system

# rollout restart (recreate pods on every node)
kubectl rollout restart daemonset/log-agent -n kube-system

Taints et tolerations

Les taints repoussent les pods ; les tolerations permettent à certains pods de les ignorer. Les nœuds de plan de contrôle sont taintés NoSchedule pour que les charges utilisateur n'y atterrissent pas — les agents de niveau nœud le tolèrent pour tourner partout. NoExecute évince aussi les pods intolérants déjà en cours.

kubernetes
# inspect a node's taints
kubectl describe node node-1 | grep Taints
# Taints: node-role.kubernetes.io/control-plane:NoSchedule

# tolerate control-plane so the agent runs there too
spec:
  template:
    spec:
      tolerations:
        - key: node-role.kubernetes.io/control-plane
          operator: Exists
          effect: NoSchedule
        - key: node.kubernetes.io/disk-pressure
          operator: Exists
          effect: NoExecute

# taint effects: NoSchedule | NoExecute | PreferNoSchedule

Cas d'usage des DaemonSets

Les DaemonSets sont la forme de déploiement standard de l'infrastructure de niveau nœud. Ils exigent souvent un accès privilégié (hostNetwork, hostPID, hostPath) pour leur travail — accordez ces droits délibérément et seulement à des images de confiance. N'employez jamais un DaemonSet pour des charges d'app qui doivent monter horizontalement.

kubernetes
# classic DaemonSet workloads (node-level agents):
# - log collection:        fluent-bit, filebeat, promtail
# - monitoring:            node-exporter, datadog-agent
# - networking:            kube-proxy, CNI plugins, ingress controllers
# - storage:               CSI node plugins, Rook/Ceph
# - security:              Falco, Tetragon, runtime security
# - GPU/FPGA drivers:      nvidia-device-plugin

# storage / device plugins often need:
spec:
  template:
    spec:
      hostNetwork: true        # use node network namespace
      hostPID: true            # see node processes
      hostPath:                # mount node paths
        - path: /var/log
        - path: /var/lib/docker/containers

Statut du DaemonSet

DESIRED égale le nombre de nœuds matchant les contraintes d'ordonnancement ; CURRENT/READY montrent combien de pods existent et passent le readiness. -o wide est le moyen le plus simple de voir sur quel nœud chaque pod a atterri. Les DaemonSets gèrent l'historique/undo de déploiement comme les Deployments.

kubernetes
# desired = number of matching nodes
kubectl get daemonset log-agent -n kube-system
# NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE
# log-agent    5         5         5       5            5

# show which nodes a DaemonSet pod landed on
kubectl get pods -n kube-system -l app=log-agent -o wide

# rollout history
kubectl rollout history daemonset/log-agent -n kube-system

# rollback
kubectl rollout undo daemonset/log-agent -n kube-system

# check a per-node pod's logs
kubectl logs -n kube-system log-agent-abcde
12

Job et CronJob

Manifeste de Job

Un Job fait tourner des pods jusqu'à ce qu'un nombre précis se termine avec succès (completions). restartPolicy doit valoir Never ou OnFailure (pas Always — c'est pour les charges de longue durée). backoffLimit plafonne les reprises ; activeDeadlineSeconds plafonne la durée totale.

kubernetes
apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  completions: 1              # how many successful pods needed
  parallelism: 1              # how many run concurrently
  backoffLimit: 6             # retries before marking Failed
  activeDeadlineSeconds: 600  # hard timeout
  template:
    spec:
      restartPolicy: Never    # OnFailure | Never
      containers:
        - name: pi
          image: perl
          command: ["perl", "-Mbignum=bpi", "-wle", "print bpi(2000)"]
# kubectl get jobs
# kubectl logs job/pi

Completions et parallelism du Job

completions = combien de pods réussis satisfont le Job ; parallelism = combien tournent en parallèle. Les Jobs indexés assignent à chaque pod un ordinal (variable d'env JOB_COMPLETION_INDEX) — parfait pour le traitement par lots shardé où chaque pod détient une tranche. NonIndexed (défaut) exige seulement N succès, peu importe d'où.

kubernetes
spec:
  completions: 5         # 5 successful pods total
  parallelism: 2         # 2 pods run at a time
  backoffLimit: 4
  # default completionMode: NonIndexed (any 5 successes)
  completionMode: Indexed
  # Indexed: pods get 0..N-1 in JOB_COMPLETION_INDEX env,
  # useful for sharded work (each pod handles one shard)

  template:
    spec:
      restartPolicy: OnFailure
      containers:
        - name: worker
          image: worker:1.0

# set via kubectl
kubectl create job pi --image=perl -- perl -Mbignum=bpi -wle "print bpi(2000)"

Backoff et timeouts du Job

backoffLimit réessaie les pods échoués (backoff exponentiel). activeDeadlineSeconds est le plafond dur — atteint, le Job est marqué Failed même s'il reste des reprises. ttlSecondsAfterFinished nettoie automatiquement les Jobs terminés. podFailurePolicy (1.31+) permet d'échouer vite sur certains codes de sortie ou d'ignorer les évictions volontaires.

kubernetes
spec:
  backoffLimit: 6            # default 6, retries on failure
  activeDeadlineSeconds: 3600  # hard wall, even if retries remain
  ttlSecondsAfterFinished: 86400  # auto-delete Job 1 day after done
  startingDeadlineSeconds: 300  # (CronJob only) miss window

  # pod failure handling (v1.31+):
  podFailurePolicy:
    rules:
      - action: FailJob
        onExitCodes:
          operator: In
          values: [42]      # exit 42 -> don't retry, fail fast
      - action: Count
        onPodConditions:
          - type: DisruptionTarget   # don't count voluntary evictions

  template:

Manifeste de CronJob

Un CronJob crée des Jobs selon un planning cron (5 champs : minute heure jour mois jour de semaine). concurrencyPolicy contrôle les exécutions qui se chevauchent : Forbid saute une nouvelle exécution si la précédente tourne encore ; Replace tue l'ancienne et démarre la nouvelle. timeZone (1.27+) supprime le besoin d'arithmétique UTC.

kubernetes
apiVersion: batch/v1
kind: CronJob
metadata:
  name: backup
spec:
  schedule: "0 2 * * *"          # 5-field cron: 02:00 daily
  timeZone: "Asia/Shanghai"
  concurrencyPolicy: Forbid      # Allow | Forbid | Replace
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  startingDeadlineSeconds: 200
  jobTemplate:
    spec:
      backoffLimit: 2
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: backup
              image: backup:1.0
# kubectl get cronjob
# kubectl get jobs

Suspend et historique du CronJob

suspend: true met un CronJob en pause sans le supprimer — pratique pendant les incidents. Les limites d'historique gardent la liste de Jobs gérable (défaut 3 succès / 1 échec). kubectl create job --from=cronjob/X exécute le template immédiatement, parfait pour les déclenchements manuels ou le rattrapage des exécutions manquées.

kubernetes
spec:
  schedule: "*/5 * * * *"
  suspend: true                # pause without deleting the CronJob
  successfulJobsHistoryLimit: 3   # default 3
  failedJobsHistoryLimit: 1       # default 1

# toggle suspend
kubectl patch cronjob backup -p '{"spec":{"suspend":true}}'
kubectl patch cronjob backup -p '{"spec":{"suspend":false}}'

# trigger a one-off run immediately
kubectl create job --from=cronjob/backup manual-backup

# clean up old jobs manually
kubectl delete jobs -l job-name=backup

Planning du CronJob et cas limites

Cron standard à 5 champs. Quand jour-du-mois et jour-de-semaine sont tous deux restreints, cron se déclenche sur L'UN OU L'AUTRE (sémantique OU) — un piège classique. Si l'heure prévue d'un CronJob est manquée au-delà de startingDeadlineSeconds, cette exécution est sautée plutôt que rattrapée.

kubernetes
# cron syntax (5 fields):
# ┌───────────── minute (0-59)
# │ ┌───────────── hour (0-23)
# │ │ ┌───────────── day of month (1-31)
# │ │ │ ┌───────────── month (1-12)
# │ │ │ │ ┌───────────── day of week (0-6, Sun=0)
# "*/5 * * * *"      every 5 minutes
# "0 2 * * *"        daily at 02:00
# "0 0 * * 0"        weekly Sunday midnight
# "0 0 1 * *"        monthly on the 1st
# "30 3-5 * * *"     03:30, 04:30, 05:30

# gotchas:
# - day-of-month AND day-of-week both set => OR (not AND)
# - if startingDeadlineSeconds is missed, the run is skipped
# - control-plane restart can skip a tick if the schedule is missed
# - cron interprets literal fields; prefer timeZone over UTC math
13

Ingress

Manifeste d'Ingress

Ingress expose des routes HTTP/HTTPS de l'extérieur du cluster vers des Services, géré par un contrôleur d'Ingress (nginx, traefik, ALB, …). ingressClassName choisit quel contrôleur le traite. Chaque règle mappe un hôte + chemin vers un backend service+port.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api
                port:
                  number: 8080

Ingress avec TLS

Les entrées tls lient un secret TLS (type kubernetes.io/tls, portant tls.crt + tls.key) à un ou plusieurs hôtes. Le contrôleur d'Ingress termine le TLS et proxyse le HTTP simple vers le backend. cert-manager peut émettre et renouveler automatiquement des certs Let's Encrypt selon l'annotation cluster-issuer.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-tls
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - app.example.com
        - www.example.com
      secretName: web-tls-secret   # kubernetes.io/tls secret
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: web
                port:
                  number: 80

# auto-issue certs with cert-manager:
# annotations:
#   cert-manager.io/cluster-issuer: letsencrypt-prod

Règles d'Ingress et backend par défaut

defaultBackend traite le trafic qui ne matche aucune règle (pas d'hôte ou chemin non matché). Plusieurs règles permettent à un Ingress de router de nombreux hôtes virtuels. Chaque règle peut porter plusieurs backends de chemins — un seul Ingress peut frontaler toute la topologie de routage d'une application.

kubernetes
spec:
  ingressClassName: nginx
  defaultBackend:                # catch-all for unmatched traffic
    service:
      name: default-svc
      port:
        number: 80
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service: { name: api, port: { number: 8080 } }
    - host: blog.example.com     # different host -> different svc
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service: { name: blog, port: { number: 80 } }

IngressClass

Un IngressClass déclare un contrôleur (ex. k8s.io/ingress-nginx). Les Ingress y réfèrent via spec.ingressClassName pour que plusieurs contrôleurs coexistent. Une seule classe peut être marquée défaut avec l'annotation is-default-class — les nouveaux Ingress sans classe explicite l'emploient.

kubernetes
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: nginx
  annotations:
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  controller: k8s.io/ingress-nginx

# an Ingress picks a class via spec.ingressClassName
# (replaces the deprecated kubernetes.io/ingress.class annotation)

# multiple IngressClasses in one cluster:
# - nginx    (community ingress-nginx)
# - traefik  (Traefik controller)
# - alb      (AWS ALB)
# only one IngressClass can be marked default

Types de chemins

Exact matche le chemin verbatim ; Prefix matche des segments entiers de chemin (/api matche /api et /api/foo mais pas /apix). ImplementationSpecific délègue au contrôleur — ex. regex nginx. Préférez toujours Prefix ou Exact pour un comportement portable ; ImplementationSpecific vous lie à un contrôleur.

kubernetes
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api/v1
            pathType: Exact        # only /api/v1 (exact match)
            backend: ...
          - path: /api
            pathType: Prefix       # /api, /api/, /api/x (prefix match)
            backend: ...
          - path: /old
            pathType: ImplementationSpecific  # controller decides
            backend: ...

# Prefix matches path segments, not raw string prefix:
# /api   matches /api, /api/, /api/x  but NOT /apix
# Exact  matches the path verbatim
# ImplementationSpecific defers to the controller

Annotations (contrôleur Nginx)

Les annotations propres au contrôleur configurent un comportement au-delà de la spec Ingress standard. ingress-nginx en a des dizaines : rewrite-target, ssl-redirect, body-size, timeouts, CORS, basic auth, extraits de configuration. Elles sont spécifiques au contrôleur — porter vers un autre contrôleur signifie les réécrire.

kubernetes
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web
  annotations:
    kubernetes.io/ingress.class: nginx          # legacy form
    nginx.ingress.kubernetes.io/rewrite-target: /$2
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "50m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
    nginx.ingress.kubernetes.io/cors-allow-origin: "https://app.example.com"
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: basic-auth
    nginx.ingress.kubernetes.io/configuration-snippet: |
      more_set_headers "X-Frame-Options: DENY";
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /v1(/|$)(.*)
            pathType: ImplementationSpecific
            backend:
              service: { name: api, port: { number: 8080 } }
14

Volume (PV/PVC)

Manifeste de PersistentVolume

Un PersistentVolume (PV) est un morceau de stockage à portée de cluster, provisionné par un admin ou dynamiquement par une StorageClass. accessModes décrit comment il peut être monté. reclaimPolicy contrôle le sort du stockage quand le PVC est libéré.

kubernetes
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-1
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce        # RWO: one node R/W
  persistentVolumeReclaimPolicy: Retain   # Retain | Delete | Recycle
  storageClassName: manual
  hostPath:                # for dev only (single node)
    path: /mnt/data
  # nfs:
  #   server: 10.0.0.1
  #   path: /export/data
  # csi:
  #   driver: ebs.csi.aws.com
  #   volumeHandle: vol-xxxx

Manifeste de PersistentVolumeClaim

Un PersistentVolumeClaim (PVC) est une demande de stockage namespacée. Le contrôleur le lie à un PV correspondant (accessModes, capacité suffisante, même StorageClass). Avec une StorageClass par défaut, laisser storageClassName vide déclenche le provisionnement dynamique.

kubernetes
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-claim
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: manual
  resources:
    requests:
      storage: 5Gi
  volumeMode: Filesystem     # Filesystem | Block
  selector:                  # optional: filter PVs by labels
    matchLabels:
      disktype: ssd
# kubectl get pvc
# STATUS: Pending -> Bound once a matching PV is found

Modes d'accès

Les accessModes décrivent la sémantique de montage — mais le support réel dépend du backend de stockage. EBS/GCE PD/Azure Disk sont RWO seulement. RWX (lecture/écriture multi-nœuds) exige NFS, CephFS ou un système de fichiers distribué. RWOP (1.27+) restreint à un seul pod, même sur le même nœud.

kubernetes
# four access modes (support is driver-specific):
# - ReadWriteOnce  (RWO):  mounted R/W by ONE node
# - ReadOnlyMany   (ROX):  mounted R/O by MANY nodes
# - ReadWriteMany  (RWX):  mounted R/W by MANY nodes
# - ReadWriteOncePod (RWOP): mounted R/W by ONE pod (1.27+)

# examples by backend:
# AWS EBS, GCE PD, Azure Disk:  RWO only
# NFS:                          RWO, ROX, RWX
# CephFS, Portworx:             RWO, RWX
# Block volumes:                RWO

# RWX is required for pods on different nodes
# to share the same volume (e.g. read-only assets)

Politique de récupération

Retain garde les données par prudence — il faut effacer et re-lier le PV manuellement. Delete (défaut du provisionnement dynamique) efface le PV et le stockage sous-jacent quand le PVC disparaît. Recycle est déprécié. Un PV Released avec Retain exige que son claimRef soit vidé avant re-lier.

kubernetes
# what happens when a PVC is deleted:
# - Retain:   PV stays, data preserved; PV must be manually
#             reclaimed (delete data, then delete PV) before reuse
# - Delete:   PV and the underlying storage are deleted (dynamic only)
# - Recycle:  deprecated; ran scrub on the volume

# change policy on an existing PV
kubectl patch pv pv-1 -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'

# a released PV (PVC deleted, policy Retain) is stuck:
#   phase=Released, claimRef still set
# to reuse: clear claimRef
kubectl patch pv pv-1 --type json -p '[{"op":"remove","path":"/spec/claimRef"}]'

PVC dans un pod

Montez un PVC comme tout volume via persistentVolumeClaim.claimName. subPath monte un sous-répertoire — pratique pour partager un volume entre pods/chemins. Les volumes RWO peuvent être montés par plusieurs pods mais seulement sur le même nœud ; le montage inter-nœuds cause des erreurs de multi-attach.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: db
spec:
  volumes:
    - name: data
      persistentVolumeClaim:
        claimName: data-claim
  containers:
    - name: db
      image: postgres:16
      volumeMounts:
        - name: data
          mountPath: /var/lib/postgresql/data
          subPath: pgdata       # mount a subdirectory of the volume

# a PVC is namespaced and bound to ONE PV
# RWO PVCs can be mounted by multiple pods on the SAME node
# (e.g. one writer, several readers on that node)

Provisionnement statique vs dynamique

Le provisionnement statique exige que les admins précréent les PV — bien pour NFS mais pénible à grande échelle. Le provisionnement dynamique laisse un PVC déclencher la création de volume à la demande via le provisioner d'une StorageClass. Les clusters modernes emploient presque toujours le dynamique ; le statique reste réservé au stockage partagé/hérité.

kubernetes
# STATIC: admin pre-creates PVs; PVCs bind to them.
#   Good for: pre-existing NFS exports, manual capacity planning.

# DYNAMIC: PVC requests storage; StorageClass provisions a PV
#   automatically (AWS EBS, GCE PD, Ceph, local-path, etc.)

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dynamic-claim
spec:
  storageClassName: ebs-sc      # triggers dynamic provisioning
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 20Gi

# no PV exists -> provisioner creates one -> binds to PVC
# kubectl get pvc dynamic-claim -> Bound
# kubectl get pv -> shows the dynamically-created PV
15

StorageClass

Manifeste de StorageClass

Une StorageClass décrit une « saveur » de stockage provisionné dynamiquement : le provisioner (driver CSI), les paramètres (type de disque, chiffrement, fsType) et les politiques. Les PVC y réfèrent via spec.storageClassName. Un cluster possède typiquement plusieurs classes (SSD rapide, HDD en masse, NFS, …).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
  fsType: ext4
  encrypted: "true"
reclaimPolicy: Delete            # Retain | Delete
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
mountOptions:
  - noatime
# kubectl get storageclass

StorageClass par défaut

Une seule StorageClass peut être la défaut (annotation is-default-class: true). Les PVC qui omettent storageClassName l'emploient automatiquement — commode pour les utilisateurs qui ne se soucient pas du backend reçu. Employez kubectl get sc pour voir quelle classe est marquée (default).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standard
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer

# a PVC with no storageClassName uses the default
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: auto
spec:
  accessModes: ["ReadWriteOnce"]
  resources:
    requests:
      storage: 5Gi
# (no storageClassName set -> uses 'standard')

Provisioners

kubernetes.io/no-provisioner signifie liaison statique seulement (pas de création dynamique). Tout le vrai provisionnement dynamique passe par des drivers CSI — les fournisseurs cloud livrent les leurs (ebs.csi.aws.com, etc.), et les options auto-hébergées (Longhorn, Rook/Ceph, local-path) couvrent le bare metal. Les paramètres sont entièrement propres au provisioner.

kubernetes
# built-in (no external driver): only static binding
provisioner: kubernetes.io/no-provisioner

# cloud CSI drivers (dynamic):
provisioner: ebs.csi.aws.com          # AWS EBS
provisioner: pd.csi.storage.gke.io    # GCE PD
provisioner: disk.csi.azure.com       # Azure Disk
provisioner: nfs.csi.k8s.io           # NFS

# popular self-hosted:
provisioner: driver.longhorn.io       # Longhorn
provisioner: rook-ceph.ceph.com       # Rook/Ceph
provisioner: rancher.io/local-path    # local-path (dev)

# parameters are provisioner-specific
# (e.g. AWS: type=gp3|iops=3000|encrypted=true)

Mode de liaison des volumes

Immediate lie le PVC dès sa création — risqué pour les disques zonaux car le pod pourrait atterrir dans une autre zone. WaitForFirstConsumer diffère la liaison jusqu'à ce qu'un pod consomme réellement le PVC, le volume atterrit donc dans la bonne zone. Employez toujours WaitForFirstConsumer pour les disques cloud zonaux.

kubernetes
spec:
  volumeBindingMode: WaitForFirstConsumer
  # ^ default for many CSI drivers
  # alternatives:
  # volumeBindingMode: Immediate

# Immediate: PVC binds/provisions as soon as created
#   risk: volume created in zone A, pod scheduled in zone B
#   -> multi-attach / cross-zone latency issues

# WaitForFirstConsumer: delays binding until a pod using the PVC
#   is scheduled. The PV is then created in the pod's zone.
#   REQUIRED for topology-constrained backends (EBS, etc.)

# topology constraints come from the CSI driver via
# AllowedTopologies

Politique de récupération par StorageClass

StorageClass.reclaimPolicy fixe la politique de chaque PV qu'elle provisionne dynamiquement. Delete (défaut) détruit le volume quand le PVC est supprimé — efficace mais dangereux pour les données de production. Pour sauver les données, passez le PV en Retain avant de supprimer le PVC, ou employez une classe Retain dès le départ.

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-temp
provisioner: ebs.csi.aws.com
reclaimPolicy: Delete            # default for dynamic volumes
# reclaimPolicy: Retain          # keep data after PVC delete

# the StorageClass policy becomes the PV's policy
# when a PV is dynamically provisioned

# to preserve data, either:
# 1. use a Retain StorageClass
# 2. patch the dynamically-created PV to Retain before deleting PVC:
kubectl patch pv pvc-xxxx -p '{"spec":{"persistentVolumeReclaimPolicy":"Retain"}}'

# then delete PVC safely; data survives

Extension de volume

Mettre allowVolumeExpansion: true laisse les utilisateurs agrandir un PVC en éditant spec.resources.requests.storage. Le driver CSI étend le volume sous-jacent, puis le kubelet étend le système de fichiers au prochain montage. Le rétrécissement n'est jamais géré. La plupart des drivers CSI cloud gèrent l'extension en ligne (sans démontage).

kubernetes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-sc
provisioner: ebs.csi.aws.com
allowVolumeExpansion: true       # must be true to resize

# then resize by editing the PVC's requested size
kubectl patch pvc data-claim -p '{"spec":{"resources":{"requests":{"storage":"50Gi"}}}}'

# status.conditions shows Resizing / FileSystemResizePending
kubectl describe pvc data-claim

# requirements:
# - StorageClass.allowVolumeExpansion = true
# - driver supports online expansion (most CSI drivers do)
# - shrinking is NOT supported (only grow)
# - FilesystemResize happens after the PV is expanded
16

Helm

Install et release Helm

Helm empaquette les manifestes Kubernetes en « chart » et les gère comme une « release ». install crée une release ; upgrade applique les changements ; upgrade --install est idempotent. Les releases sont tracées par un Secret/ConfigMap dans le namespace — c'est ainsi que fonctionne le retour arrière.

kubernetes
# add and update a chart repo
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

# search for charts
helm search repo nginx
helm search hub wordpress   # searches Artifact Hub

# install a chart (creates a release)
helm install my-nginx bitnami/nginx --namespace web --create-namespace

# upgrade an existing release
helm upgrade my-nginx bitnami/nginx --set replicaCount=3

# upgrade + install in one idempotent command
helm upgrade --install my-nginx bitnami/nginx -f values.yaml

# uninstall
helm uninstall my-nginx -n web

# list releases
helm list -n web
helm list --all-namespaces

Structure d'un chart

Un chart est un répertoire de YAML templété plus des défauts. Chart.yaml porte les métadonnées ; values.yaml les défauts ; templates/ les templates Go rendus avec ces valeurs. helm create échafaude un chart fonctionnel. helm lint attrape les erreurs de schéma/template avant publication.

kubernetes
my-chart/
├── Chart.yaml          # chart metadata (name, version, apiVersion)
├── values.yaml         # default values (overridable)
├── charts/             # chart dependencies (subcharts)
├── templates/          # Go-templated YAML
│   ├── deployment.yaml
│   ├── service.yaml
│   ├── _helpers.tpl    # named templates (partials)
│   └── NOTES.txt       # post-install notes
├── templates.yaml      # (optional) CRDs to install before templates
└── README.md

# create a new chart skeleton
helm create my-chart

# lint a chart
helm lint my-chart

# package into a .tgz
helm package my-chart

Values et surcharges

values.yaml porte les défauts du chart. Surchargez avec --set (pour les scalaires) ou -f (pour des fichiers entiers). helm show values liste chaque clé acceptée par un chart. helm template rend les manifestes sans toucher au cluster — essentiel pour prévisualiser ce qu'une release appliquera réellement.

kubernetes
# values.yaml (chart defaults)
image:
  repository: nginx
  tag: "1.25"
replicaCount: 2
service:
  type: ClusterIP
  port: 80

# override on the command line
helm upgrade --install web my-chart \
  --set replicaCount=5 \
  --set image.tag=1.26 \
  --set service.type=LoadBalancer

# override from a file
helm upgrade --install web my-chart -f prod-values.yaml

# see all values a chart supports
helm show values bitnami/nginx

# rendered output (debug, no install)
helm template web my-chart -f prod-values.yaml

Templates et objets intégrés

Les templates emploient la syntaxe de template Go avec les fonctions Sprig. .Release.Name rend chaque install unique ; .Values expose les valeurs du chart ; .Chart lit Chart.yaml. La fonction default fournit des replis. Un nommage sûr au rendu via .Release.Name laisse un chart tourner en plusieurs releases dans le même namespace.

kubernetes
# built-in template objects:
#   .Values         chart values (after overrides)
#   .Release        release metadata (Name, Namespace, Service, Revision, IsInstall, IsUpgrade)
#   .Chart          Chart.yaml contents
#   .Files          files in the chart
#   .Capabilities   cluster capabilities (KubeVersion, APIVersions)
#   .Template       current template info

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-app
  labels:
    app.kubernetes.io/instance: {{ .Release.Name }}
    app.kubernetes.io/managed-by: {{ .Release.Service }}
spec:
  replicas: {{ .Values.replicaCount | default 1 }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}

Dépôt Helm

Helm 3 gère à la fois les dépôts de charts HTTP classiques et les registres OCI (helm push/pull oci://…). OCI est la voie moderne, compatible signature. helm repo update rafraîchit les index ; lancez-le toujours avant upgrade pour obtenir les dernières versions de charts. Artifact Hub (helm search hub) indexe les charts publics.

kubernetes
# add a chart repository
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo add jetstack https://charts.jetstack.io

# list configured repos
helm repo list

# update repo indexes
helm repo update

# remove a repo
helm repo remove bitnami

# push to OCI registry (Helm 3+)
helm registry login registry.example.com
helm package my-chart
helm push my-chart-0.1.0.tgz oci://registry.example.com/charts

# pull an OCI chart
helm pull oci://registry.example.com/charts/my-chart --version 0.1.0

Retour arrière et historique

Chaque install/upgrade crée une révision numérotée stockée en Secret. helm rollback bascule instantanément vers une révision précédente — la fonctionnalité tueuse de Helm face à un simple kubectl apply. helm get values montre ce qui a réellement été déployé, inestimable pour déboguer un état dérivé.

kubernetes
# view release history
helm history my-nginx -n web

# rollback to a previous revision
helm rollback my-nginx 1 -n web

# get rendered manifests of a deployed release
helm get manifest my-nginx -n web

# get the values used at install/upgrade
helm get values my-nginx -n web
helm get values my-nginx -n web --all   # incl. chart defaults

# get all info (hooks, manifest, values, notes)
helm get all my-nginx -n web

# wait for resources to be ready on install/upgrade
helm upgrade --install my-nginx bitnami/nginx --wait --timeout 5m
17

NetworkPolicy

Manifeste de NetworkPolicy

Une NetworkPolicy est une règle de pare-feu pour les pods. Un podSelector vide sélectionne tous les pods du namespace ; une liste de règles vide refuse tout le trafic de ce type. Les NetworkPolicies sont additives — un pod est autorisé si UNE politique le permet. Elles exigent un CNI compatible ; flannel simple les ignore.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: prod
spec:
  podSelector: {}             # selects ALL pods in the namespace
  policyTypes:
    - Ingress
    - Egress
  # no ingress/egress rules => deny all traffic of that type
# effect: pods in 'prod' can't send or receive ANY traffic
# until another policy explicitly allows it

# REQUIRES a CNI that supports NetworkPolicy
# (Calico, Cilium, Weave, kube-router; NOT flannel alone)

Règles d'ingress

Les règles d'ingress autorisent le trafic ENTRANT vers les pods sélectionnés. Les entrées from sont des OU ; les ports aussi. podSelector matche les pods du même namespace ; namespaceSelector matche des namespaces entiers (employez le label kubernetes.io/metadata.name auto-ajouté). Les combiner dans un même item fait des ET.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web
  namespace: prod
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:               # pods in same namespace
            matchLabels:
              app: gateway
        - namespaceSelector:         # whole other namespace
            matchLabels:
              kubernetes.io/metadata.name: monitoring
        - ipBlock:                   # external CIDR
            cidr: 10.0.0.0/8
      ports:
        - protocol: TCP
          port: 8080

Règles d'egress

Les règles d'egress contrôlent vers quoi les pods sélectionnés peuvent parler. Piège courant : un egress default-deny casse la résolution DNS et les pods n'atteignent plus kube-dns. Autorisez toujours UDP/TCP 53 vers le namespace kube-system avant de refuser tout le reste. ipBlock.except creuse des exceptions.

kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-egress-dns
  namespace: prod
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector: {}     # any namespace (kube-dns)
      ports:
        - protocol: UDP
          port: 53
    - to:
        - ipBlock:
            cidr: 0.0.0.0/0
            except:
              - 10.0.0.0/8          # allow internet, deny internal
      ports:
        - protocol: TCP
          port: 443

# WARNING: egress deny-all blocks DNS and breaks pods.
# Always allow kube-dns first.

Sélecteurs et sélection de namespace

Un podSelector nu matche les pods du namespace propre à la politique. Un namespaceSelector matche des namespaces entiers. Préciser podSelector ET namespaceSelector dans un même item fait des ET (pods avec label X dans le namespace Y) — les placer en items séparés fait des OU. ipBlock matche les IP externes.

kubernetes
spec:
  podSelector:                       # selects pods in THIS namespace
    matchLabels:
      app: web
  ingress:
    - from:
        # SAME namespace, matching pods
        - podSelector:
            matchLabels:
              app: gateway

        # DIFFERENT namespace (whole namespace)
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: monitoring

        # BOTH: pods in another namespace with specific labels
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: backend
          podSelector:
            matchLabels:
              app: api

        # external IP range
        - ipBlock:
            cidr: 192.168.1.0/24

Politiques par défaut (deny/allow all)

Les politiques default-deny (règles vides) verrouillent un namespace pour que seules des listes d'autorisation explicites ouvrent des trous. Appliquez deny-all ingress + deny-all egress comme base, puis ajoutez des politiques d'autorisation ciblées. Une entrée ingress: [{}] vide autorise tout l'ingress — l'échappatoire pour sortir du blocage.

kubernetes
# --- DEFAULT DENY INGRESS (in a namespace) ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Ingress]
---
# --- DEFAULT DENY EGRESS ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-egress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Egress]
---
# --- ALLOW ALL INGRESS (whitelist opt-out) ---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-ingress
  namespace: prod
spec:
  podSelector: {}
  policyTypes: [Ingress]
  ingress:
    - {}      # allow from anywhere

Types de politiques et comportement par défaut

Les NetworkPolicies sont additives — dès qu'une politique sélectionne un pod, ce type de trafic devient default-deny pour le pod sauf règle explicite. Sans aucune politique, tout est ouvert. Listez les politiques matchant les labels d'un pod pour voir ce qui gouverne son trafic.

kubernetes
spec:
  policyTypes:
    - Ingress
    - Egress
  # if omitted, defaults are inferred:
  #   - Ingress is always present (a policy always affects ingress)
  #   - Egress is implied if any egress rule exists

# key behaviors:
# - policies are ADDITIVE: a pod is allowed if ANY matching
#   policy permits the traffic
# - if NO policy selects a pod => all traffic allowed (default open)
# - if at least one policy selects a pod => default deny for that type
#   unless an explicit rule allows it

# inspect effective policies for a pod
kubectl get networkpolicy -n prod -l app=web
18

RBAC

Role (namespacé)

Un Role accorde des permissions sur des ressources namespacées dans un seul namespace. rules liste apiGroups, resources et verbs. pods/log est une sous-ressource ; pods/exec exige le verbe create (car exec crée une sous-ressource). Employez '*' comme joker pour toute valeur.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: dev
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/log"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["pods/exec"]
    verbs: ["create"]
# a Role grants permissions WITHIN one namespace
# verbs: get, list, watch, create, update, patch, delete, deletecollection, "*"
# apiGroups: "" (core), "apps", "batch", "rbac.authorization.k8s.io", ...

RoleBinding

Un RoleBinding accorde un Role (ou un ClusterRole, restreint à un namespace) à des sujets : Users, Groups ou ServiceAccounts. La liaison vit dans le namespace où s'appliquent les permissions. roleRef est immuable — pour changer le Role référencé, supprimez et recréez la liaison.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: dev
subjects:
  - kind: User
    name: alice
    apiGroup: rbac.authorization.k8s.io
  - kind: ServiceAccount
    name: my-sa
    namespace: dev
  - kind: Group
    name: dev-team
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
# binds the Role to users, groups, or service accounts
# RoleBinding can also reference a ClusterRole (scoped to its namespace)

ClusterRole et ClusterRoleBinding

Un ClusterRole accorde des permissions sur des ressources à portée de cluster (nodes, namespaces, PV) — les Roles ne peuvent y toucher. Les ClusterRoles peuvent aussi être liés dans n'importe quel namespace via un RoleBinding pour la réutilisation (définir une fois, lier plusieurs fois). ClusterRoleBinding accorde un ClusterRole sur tout le cluster.

kubernetes
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: node-reader
rules:
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: read-nodes
subjects:
  - kind: ServiceAccount
    name: monitor
    namespace: kube-system
roleRef:
  kind: ClusterRole
  name: node-reader
  apiGroup: rbac.authorization.k8s.io
# ClusterRole grants cluster-scoped resources (nodes, PVs, namespaces)
# or can be reused across namespaces via a RoleBinding

Verbes, ressources et groupes d'API

Les apiGroups regroupent les ressources — core est '' (chaîne vide) ; apps porte Deployments/StatefulSets ; batch les Jobs/CronJobs. Les sous-ressources (pods/log, pods/exec, pods/portforward) sont des permissions séparées. resourceNames restreint une règle à des instances précises. nonResourceURLs couvre /healthz, /metrics, etc.

kubernetes
rules:
  - apiGroups: [""]                        # core API group
    resources: ["pods", "services", "configmaps", "secrets"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["apps"]
    resources: ["deployments", "replicasets", "statefulsets"]
    verbs: ["*"]
  - apiGroups: ["batch"]
    resources: ["jobs", "cronjobs"]
    verbs: ["create", "delete", "get"]
  - apiGroups: [""]
    resources: ["pods/log", "pods/exec", "pods/portforward"]
    verbs: ["get", "create"]
  - nonResourceURLs: ["/healthz", "/healthz/*"]   # non-resource URLs
    verbs: ["get"]

# resourceNames: restrict to specific instances
  - apiGroups: [""]
    resources: ["configmaps"]
    resourceNames: ["my-config"]
    verbs: ["get"]

ServiceAccount

Un ServiceAccount est une identité pour les pods. Assignez-le via serviceAccountName ; le token se monte automatiquement à /var/run/secrets/kubernetes.io/serviceaccount. Depuis 1.24, les SA n'ont plus de Secrets de token permanents — employez kubectl create token pour des tokens à durée limitée. automountServiceAccountToken: false renonce au montage.

kubernetes
# create a service account
kubectl create serviceaccount my-sa -n dev

# assign a RoleBinding (see RoleBinding example)
# mount the SA in a pod
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  serviceAccountName: my-sa
  automountServiceAccountToken: false   # opt out of token mount
  containers:
    - name: app
      image: myapp:1.0

# short-lived tokens (1.24+) - no permanent secret
kubectl create token my-sa -n dev --duration=1h

# list SAs
kubectl get sa -n dev

kubectl auth can-i

kubectl auth can-i vérifie les permissions RBAC de l'utilisateur courant (ou usurpé) — essentiel pour déboguer les erreurs « forbidden ». --list montre chaque verbe/ressource autorisé. --as usurpe un utilisateur/SA pour les tests. Les rôles intégrés (view, edit, admin, cluster-admin) couvrent les besoins courants.

kubernetes
# check if you can do something
kubectl auth can-i create pods -n dev
kubectl auth can-i delete deployments -n prod

# check on behalf of another user/SA
kubectl auth can-i list secrets --as=system:serviceaccount:dev:my-sa -n dev

# check all allowed verbs on a resource
kubectl auth can-i --list --as=alice -n dev

# whoami (1.25+)
kubectl auth whoami

# reconcile: detect over-privileged bindings
kubectl get rolebindings,clusterrolebindings --all-namespaces -o wide

# common built-in cluster roles:
#   view, edit, admin, cluster-admin
19

Sondes (Liveness/Readiness/Startup)

Sonde liveness

Une sonde liveness indique au kubelet quand redémarrer un conteneur. Si elle échoue failureThreshold fois consécutives, le kubelet tue le conteneur et la politique de redémarrage s'applique. Employez-la pour sortir de blocages ou d'états irrécupérables — pas pour vérifier des dépendances (c'est le rôle du readiness).

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      livenessProbe:
        httpGet:
          path: /healthz
          port: 8080
        initialDelaySeconds: 15
        periodSeconds: 10
        timeoutSeconds: 2
        failureThreshold: 3
        successThreshold: 1
# if the probe fails failureThreshold times in a row,
# kubelet kills and restarts the container (per restartPolicy)

Sonde readiness

Une sonde readiness contrôle si le pod reçoit du trafic des Services. Un échec de readiness retire l'IP du pod des endpoints — mais ne le redémarre PAS. Employez-la pour l'échauffement (ne pas router avant d'être prêt) et pour drainer le trafic pendant des défaillances passagères ou un arrêt gracieux.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: myapp:1.0
      readinessProbe:
        httpGet:
          path: /ready
          port: 8080
        initialDelaySeconds: 5
        periodSeconds: 5
        failureThreshold: 3
# a failing readiness probe REMOVES the pod from service endpoints,
# but does NOT restart the container.
# use to drain traffic during deploys, warm-up, or transient outages.

Sonde startup

Une sonde startup (1.18+) sert aux apps lentes à démarrer (Java, serveurs anciens). Tant qu'elle tourne, liveness et readiness sont désactivées — un démarrage lent n'est donc pas tué par liveness. Une fois la startup réussie, liveness/readiness s'activent. Employez une longue fenêtre failureThreshold × periodSeconds pour le démarrage.

kubernetes
apiVersion: v1
kind: Pod
metadata:
  name: slow-app
spec:
  containers:
    - name: app
      image: myapp:1.0
      startupProbe:
        httpGet:
          path: /startup
          port: 8080
        failureThreshold: 30
        periodSeconds: 10      # up to 300s to start
      livenessProbe:
        httpGet:
          path: /healthz
          port: 8080
        periodSeconds: 10
# while the startup probe runs, liveness/readiness are disabled.
# once startup succeeds, liveness/readiness take over.

Handlers de sonde

Trois types de handler : httpGet (succès = HTTP 2xx/3xx), tcpSocket (succès = connexion TCP), exec (succès = sortie 0). La sonde gRPC (1.27+ GA) est l'option propre pour les services gRPC. Préférez httpGet — il permet à l'app de signaler « sain mais occupé » (503) sans redémarrage. exec est fragile (exige shell/binaires dans l'image).

kubernetes
# three handler types:

# 1. HTTP GET (most common) - success = 200-399
livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
    httpHeaders:
      - name: X-Custom
        value: probe
    scheme: HTTP

# 2. TCP socket - success = port open
livenessProbe:
  tcpSocket:
    port: 3306

# 3. Exec - success = exit code 0
livenessProbe:
  exec:
    command:
      - /bin/sh
      - -c
      - "pg_isready -h localhost"

# gRPC (1.24+, alpha -> GA): use grpc probe
livenessProbe:
  grpc:
    port: 9090
    service: my.package.Health

Paramètres de sonde

initialDelaySeconds retarde la première sonde — mais une sonde startup est une façon plus propre de gérer les démarrages lents. periodSeconds est la cadence ; failureThreshold × periodSeconds est la durée pendant laquelle un pod peut être malsain avant action. Serrez-les pour un basculement rapide, assouplissez-les pour la tolérance. terminationGracePeriodSeconds plafonne l'arrêt.

kubernetes
livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 15   # wait before first probe (after start)
  periodSeconds: 10         # probe every 10s
  timeoutSeconds: 2         # max time per probe
  successThreshold: 1       # consecutive successes to mark OK
  failureThreshold: 3       # consecutive failures to mark failed
  terminationGracePeriodSeconds: 30  # (liveness) grace before SIGKILL

# tuning tips:
# - set initialDelaySeconds > typical startup time
# - OR use a startup probe instead (cleaner)
# - shorter period = faster reaction, more load
# - higher failureThreshold = more tolerant of blips

Comportement en cas d'échec de sonde

L'échec de liveness tue et redémarre le conteneur en place (sans reprogrammation). L'échec de readiness retire seulement le pod des Services — sans redémarrage. L'échec de startup se comporte comme liveness. Le clignotement de liveness vient souvent de sondes dépendant de services aval lents — gardez les vérifications de santé locales et bon marché.

kubernetes
# --- LIVENESS FAIL ---
#   container killed -> restarted (per restartPolicy: Always/OnFailure)
#   pod stays on the same node (NOT rescheduled)
#   CrashLoopBackOff if it keeps failing

# --- READINESS FAIL ---
#   pod stays running, but is REMOVED from Service endpoints
#   no traffic until it succeeds again
#   NOT restarted by kubelet

# --- STARTUP FAIL ---
#   container killed and restarted (like liveness)
#   liveness/readiness never activate
#   after failureThreshold × periodSeconds, pod is stuck restarting

# check probe results:
kubectl describe pod app | grep -A5 "Last State"
kubectl get pod app -o jsonpath='{.status.containerStatuses[*].state}'

# common cause of flapping: liveness probe hitting a slow dependency
20

Ressources et kubectl avancé

Requests et limits

requests sont ce que l'ordonnanceur réserve (un pod n'est programmé que si un nœud a des requests disponibles) — réglez-les sur vos besoins en régime stable. limits sont des plafonds durs : le CPU est étranglé, la mémoire est OOMKilled. cpu est en cœurs (500m = 0,5), memory en octets (Mi/Gi). Réglez toujours les deux en production.

kubernetes
spec:
  containers:
    - name: app
      image: myapp:1.0
      resources:
        requests:           # what the scheduler guarantees (reservation)
          cpu: 250m          # 250 millicores = 0.25 core
          memory: 256Mi      # 256 mebibytes
          ephemeral-storage: 1Gi
        limits:             # hard ceiling (enforced)
          cpu: "1"           # 1 core
          memory: 512Mi
          ephemeral-storage: 2Gi

# cpu limit: throttled (cfs quota)
# memory limit: OOMKilled if exceeded
# ephemeral-storage limit: evicted if exceeded
# request only (no limit): best-effort burst

Défauts de LimitRange

LimitRange applique des requests/limits par défaut aux pods qui ne les précisent pas — critique quand un ResourceQuota exige des requests. max/min bornent la taille d'un conteneur unique. maxLimitRequestRatio plafonne l'explosion d'un conteneur au-dessus de sa request, prévenant les voisins bruyants.

kubernetes
apiVersion: v1
kind: LimitRange
metadata:
  name: defaults
  namespace: prod
spec:
  limits:
    - type: Container
      default:               # applied as LIMITS when not set
        cpu: 500m
        memory: 512Mi
      defaultRequest:        # applied as REQUESTS when not set
        cpu: 100m
        memory: 128Mi
      max:                   # max allowed LIMITS
        cpu: "4"
        memory: 8Gi
      min:                   # min allowed REQUESTS
        cpu: 50m
        memory: 64Mi
      maxLimitRequestRatio:  # limit/request ratio cap (burst cap)
        cpu: "4"

# a pod with no resources gets default/defaultRequest applied
# a pod with limit=4cpu, request=50m would breach maxLimitRequestRatio

Horizontal Pod Autoscaler

HPA met à l'échelle les réplicas selon des métriques (CPU/mémoire via metrics-server, ou custom/external via Prometheus Adapter). behavior (v2) règle l'agressivité : stabilizationWindowSeconds prévient le clignotement, policies plafonnent le taux par minute. La montée est généralement rapide/agressive ; la descente volontairement lente.

kubernetes
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web
  minReplicas: 3
  maxReplicas: 50
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization          # avg across pods
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
  behavior:                          # (v2) scale up/down tuning
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 50                  # max 50% down per minute
          periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 60

# requires metrics-server for CPU/memory
kubectl get hpa web -w

Pod Disruption Budget

Un PodDisruptionBudget limite combien de pods d'un ensemble peuvent être évincés volontairement à la fois — protégeant la disponibilité pendant les drains de nœuds et actions du cluster-autoscaler. Employez minAvailable ou maxUnavailable (pas les deux). Il ne protège PAS des interruptions involontaires (panne matérielles) — seuls les réplicas le font.

kubernetes
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: web-pdb
  namespace: prod
spec:
  minAvailable: 2            # at least 2 pods always available
  # OR
  # maxUnavailable: 1        # at most 1 down at a time
  selector:
    matchLabels:
      app: web
# PDB protects against VOLUNTARY disruptions:
#   - kubectl drain (node maintenance)
#   - cluster autoscaler evictions
#   - kubectl delete pod (controller-managed)
# It does NOT prevent INVOLUNTARY disruptions (node failure, kernel panic).

# check PDB status
kubectl get pdb -n prod
kubectl describe pdb web-pdb -n prod

Taints, tolerations et affinity

Les taints repoussent les pods ; les tolerations permettent à certains pods de les ignorer — employez-les pour dédier des nœuds (GPU, ingress, plan de contrôle). nodeAffinity préfère/exige certains nœuds. podAntiAffinity disperse les réplicas sur des domaines de topologie (hôtes, zones) pour la HA. Retirez un taint avec un tiret final sur la même clé+effet.

kubernetes
# taint a node
kubectl taint nodes node-1 dedicated=gpu:NoSchedule

# tolerate the taint so a pod can schedule there
spec:
  tolerations:
    - key: dedicated
      operator: Equal
      value: gpu
      effect: NoSchedule

# prefer specific nodes
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 100
          preference:
            matchExpressions:
              - key: disktype
                operator: In
                values: [ssd]
    podAntiAffinity:               # spread replicas across nodes
      requiredDuringSchedulingIgnoredDuringExecution:
        - topologyKey: kubernetes.io/hostname
          labelSelector:
            matchLabels:
              app: web

# remove a taint
kubectl taint nodes node-1 dedicated=gpu:NoSchedule-

kubectl avancé (patch/wait/top/debug)

patch gère les types JSON, strategic-merge et merge. wait bloque jusqu'à ce qu'une condition soit remplie — parfait pour les scripts. top montre CPU/mémoire en direct (exige metrics-server). kubectl debug attache un conteneur éphémère à un pod en cours (idéal pour les images distroless) ou ouvre un shell sur un nœud.

kubernetes
# JSON patch (precise field ops)
kubectl patch deployment web --type json -p \
  '[{"op":"replace","path":"/spec/replicas","value":3}]'

# strategic merge patch (default for k8s objects)
kubectl patch svc web -p '{"spec":{"type":"NodePort"}}'

# wait for a condition
kubectl wait --for=condition=Ready pod/web --timeout=60s
kubectl wait --for=delete pod/web --timeout=30s

# resource usage (needs metrics-server)
kubectl top nodes
kubectl top pods -n prod
kubectl top pod web --containers

# ephemeral debug container (1.25+)
kubectl debug -it web --image=busybox --target=web
# debug a node
kubectl debug node/node-1 -it --image=ubuntu

# run a one-off pod
kubectl run tmp --rm -it --image=alpine -- sh

# explain a field
kubectl explain pod.spec.containers.resources

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.