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.
# 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.
# 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 -wContexte 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.
# 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-configExplain 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.
# 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/v1Dry 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.
# 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 yamlAide 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.
# 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' >> ~/.bashrcPod
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.
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: AlwaysPod 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.
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.
# 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.
# 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=nginxExec 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.
# 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 :80Suppression 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.
# 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=30sDeployment
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.
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: 80Straté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).
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.
# 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/nginxScale 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).
# 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: 80Mettre à 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.
# 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.yamlStatut 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.
# 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}'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.
# 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.comService 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>.
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 VIPService 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.
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.
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/hostnameService 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.
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.localEndpoints 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.
# 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)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.
# 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.propertiesManifeste 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.
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.
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 missingConsommer 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.
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/configMise à 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.
# 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_LEVELConfigMap 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.
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)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.
# 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.pemManifeste 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.
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 -dEmployer 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.
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: trueEmployer 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.
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 nodeImagePullSecret
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.
# 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.
# 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: passNamespace
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.
# 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=devResourceQuota
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é.
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 namespaceLimitRange
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.
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: 1GiSuppression 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.
# 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-foundNamespaces 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.
# 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.
# 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 # shorthandLabels 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.
# 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.
# 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.
# 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.
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: webAnnotations
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.
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.
# 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.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.
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 nginxFonctionnement 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é.
# 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=5ReplicaSet 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.
# 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 practiceMise à 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.
# 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 resourceChangements 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.
# 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-kindRetirer 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.
# 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 itStatefulSet
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.
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: 10GiIdentité 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.
# 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 reschedulesStockage 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.
# 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-2Dé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).
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 orderMises à 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.
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 templateAssociation 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.
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 nameDaemonSet
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é.
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 automaticallyOrdonnancement 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.
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: ExistsStraté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).
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-systemTaints 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.
# 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 | PreferNoScheduleCas 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.
# 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/containersStatut 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.
# 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-abcdeJob 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.
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/piCompletions 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ù.
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.
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.
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 jobsSuspend 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.
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=backupPlanning 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.
# 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 mathIngress
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.
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: 8080Ingress 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.
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-prodRè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.
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.
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 defaultTypes 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.
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 controllerAnnotations (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.
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 } }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é.
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-xxxxManifeste 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.
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 foundModes 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.
# 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.
# 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.
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é.
# 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 PVStorageClass
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, …).
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 storageclassStorageClass 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).
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.
# 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.
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
# AllowedTopologiesPolitique 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.
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 survivesExtension 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).
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 expandedHelm
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.
# 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-namespacesStructure 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.
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-chartValues 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.
# 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.yamlTemplates 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.
# 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.
# 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.0Retour 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é.
# 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 5mNetworkPolicy
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.
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.
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: 8080Rè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.
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.
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/24Politiques 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.
# --- 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 anywhereTypes 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.
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=webRBAC
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.
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.
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.
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 RoleBindingVerbes, 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.
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.
# 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 devkubectl 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.
# 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-adminSondes (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).
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.
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.
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).
# 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.HealthParamè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.
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 blipsComportement 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é.
# --- 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 dependencyRessources 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.
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 burstDé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.
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 maxLimitRequestRatioHorizontal 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.
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 -wPod 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.
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 prodTaints, 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.
# 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.
# 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.resourcesSnippets Kubernetes associés
Copy-paste ready code for common tasks.
Pod Manifest
Define a standalone Pod with a container, env, and probe.
Deployment & Rollout
Manage a replicated, rolling-updated workload.
Service Types
Expose Pods via ClusterIP, NodePort, and LoadBalancer services.
ConfigMap & Secret
Inject configuration and sensitive data into containers.
Ingress Routing
Route external HTTP traffic to services by host and path.
Labels & Selectors
Tag resources and query them with selectors.
kubectl Basics
Common kubectl commands for everyday operations.
Namespaces
Partition a cluster into isolated virtual clusters.
Was this helpful?