Kubernetes — Le cours

Guide 03 / 3

Configuration Kubernetes · YAML

Comprendre apiVersion, kind, metadata, spec et les principaux champs de Deployments, Services, ConfigMaps et PVC.

Résultat attendu :

Rédiger et relire un ensemble cohérent de manifestes et prévoir ses conditions d’exécution.

Lecture
0%

01 · Anatomie d’un manifeste

Un manifeste décrit un objet Kubernetes. Les champs sont imbriqués : leur emplacement compte autant que leur nom.

apiVersion

Version du groupe d’API auquel appartient la ressource. Un Deployment utilise apps/v1, un Pod ou Service utilise v1.

apiVersion: apps/v1
À retenir :

Ce champ ne signifie pas « version Kubernetes installée ».

kind

Type d’objet à créer : Deployment, Pod, Service, ConfigMap, Job, etc.

kind: Deployment

metadata.name

Nom unique de l’objet à l’intérieur de son périmètre de nommage.

metadata:
  name: web

metadata.namespace

Namespace cible lorsqu’il s’agit d’une ressource namespacée.

metadata:
  namespace: dev
À retenir :

Le namespace doit déjà exister ou être déclaré ailleurs.

metadata.labels

Étiquettes associées à l’objet, pratiques pour le filtrage et la sélection.

metadata:
  labels:
    app: web

metadata.annotations

Métadonnées complémentaires lisibles par des outils ou contrôleurs.

metadata:
  annotations:
    exemple.fr/owner: formation

spec

Bloc décrivant l’état souhaité. Sa structure dépend du type d’objet (kind).

spec:
  replicas: 2
À retenir :

Un Service et un Deployment n’ont pas les mêmes champs spec.

status

Bloc rempli par le système décrivant la situation observée. Il est normalement consulté, non fourni par l’auteur.

status.readyReplicas: 2
À retenir :

Ne pas inclure status dans les manifestes source.

02 · Décrire les conteneurs d’un Pod

Pour une application durable, ces champs se placent souvent sous spec.template.spec dans un Deployment.

spec.containers[].name

Nom distinctif du conteneur à l’intérieur du Pod ; kubectl peut s’en servir pour cibler les logs.

containers:
  - name: nginx

spec.containers[].image

Image de conteneur à télécharger et exécuter, avec nom et tag ou digest.

image: nginx:stable
À retenir :

Ne pas compter sur latest pour des déploiements reproductibles.

spec.containers[].ports[].containerPort

Indication du port sur lequel l’application dans le conteneur est censée écouter.

ports:
  - containerPort: 80
À retenir :

Déclarer containerPort ne publie pas le Pod vers l’extérieur.

spec.containers[].command / args

command remplace l’ENTRYPOINT de l’image ; args remplace son CMD, selon la configuration de l’image.

command: ["sh", "-c"]
args: ["echo bonjour; sleep 3600"]
À retenir :

Une commande mal définie peut provoquer CrashLoopBackOff.

spec.containers[].env

Déclare des variables d’environnement fournies au processus.

env:
  - name: MODE
    value: "demo"

spec.containers[].envFrom

Importe plusieurs clés d’une ConfigMap ou d’un Secret comme variables d’environnement.

envFrom:
  - configMapRef:
      name: web-config
À retenir :

Les changements d’environnement ne sont pas réinjectés dans un processus déjà lancé.

spec.containers[].resources.requests

Quantité de CPU et mémoire demandée pour la planification ; scheduler utilise ces valeurs pour choisir le nœud.

requests:
  cpu: 100m
  memory: 64Mi

spec.containers[].resources.limits

Plafond de ressources imposé à l’exécution ; CPU peut être limité, mémoire peut provoquer un OOM kill.

limits:
  cpu: 500m
  memory: 256Mi

spec.containers[].readinessProbe

Test périodique qui indique si le Pod peut recevoir du trafic via des Services.

readinessProbe:
  httpGet: {path: /, port: 80}
  periodSeconds: 5

spec.containers[].livenessProbe

Test indiquant si le conteneur doit être redémarré car il ne répond plus correctement.

livenessProbe:
  httpGet: {path: /, port: 80}
  initialDelaySeconds: 10

spec.containers[].startupProbe

Test optionnel qui laisse une application lente achever son démarrage avant les probes usuelles.

startupProbe:
  httpGet: {path: /, port: 80}
  failureThreshold: 30
  periodSeconds: 2

spec.imagePullSecrets

Référence un Secret contenant les identifiants d’accès à un registre privé, lorsque nécessaire.

imagePullSecrets:
  - name: registry-creds

03 · Deployment et autres contrôleurs

Deployment décrit non seulement une image, mais aussi comment la faire tourner et mettre à jour plusieurs fois.

Deployment.spec.replicas

Nombre de Pods souhaités pour l’application, gérés indirectement via un ReplicaSet.

spec:
  replicas: 3

Deployment.spec.selector.matchLabels

Labels permettant au contrôleur de reconnaître quels Pods appartiennent à ce Deployment.

selector:
  matchLabels:
    app: web
À retenir :

Doit correspondre aux labels du template ; sélecteur immuable dans de nombreux cas.

Deployment.spec.template

Modèle de Pod que Kubernetes utilise pour créer les répliques. Contient metadata et spec du Pod.

template:
  metadata:
    labels: {app: web}
  spec:
    containers: ...

Deployment.spec.strategy

Stratégie de mise à jour. RollingUpdate remplace progressivement les Pods, Recreate les renouvelle ensemble.

strategy:
  type: RollingUpdate

maxSurge / maxUnavailable

Avec RollingUpdate, maxSurge autorise des Pods supplémentaires ; maxUnavailable borne ceux qui peuvent manquer pendant la mise à jour.

rollingUpdate:
  maxSurge: 1
  maxUnavailable: 0

Pod.spec.restartPolicy

Indique quand redémarrer les conteneurs d’un Pod. Pour un Pod de Deployment, Always est imposé.

restartPolicy: Always
À retenir :

Job permet aussi OnFailure ou Never.

Job.spec.template / backoffLimit

Le Job utilise un modèle de Pod et peut limiter le nombre de tentatives en cas d’échec.

backoffLimit: 3

CronJob.spec.schedule

Expression cron à cinq champs permettant de créer des Jobs selon un calendrier.

schedule: "0 2 * * *"
À retenir :

Vérifier le fuseau horaire via timeZone si nécessaire.

04 · Services, ports et entrée HTTP

Le Service choisit les Pods grâce aux labels et sépare l’adresse stable des instances éphémères.

Service.spec.type

Définit l’exposition du Service : ClusterIP par défaut, NodePort, LoadBalancer ou ExternalName.

type: ClusterIP

Service.spec.selector

Labels des Pods vers lesquels router le trafic.

selector:
  app: web
À retenir :

Ne sélectionne aucun Pod si les labels diffèrent.

Service.spec.ports[].port

Port du Service que les clients appellent, par exemple 80.

ports:
  - port: 80

Service.spec.ports[].targetPort

Port du conteneur ou port nommé vers lequel le Service redirige le trafic.

targetPort: 80
À retenir :

port et targetPort peuvent être différents.

Service.spec.ports[].nodePort

Port accessible sur les nœuds avec type NodePort ; doit être dans la plage configurée.

nodePort: 30080
À retenir :

N’ouvre pas automatiquement les pare-feu du système.

Ingress.spec.ingressClassName

Nom de la classe d’Ingress utilisée pour choisir le contrôleur approprié.

ingressClassName: nginx
À retenir :

Un contrôleur d’Ingress doit exister et gérer cette classe.

Ingress.spec.rules

Définit des hôtes et chemins HTTP qui envoient vers des Services du cluster.

rules:
  - host: web.exemple.test

Ingress.spec.tls

Associe des hôtes TLS à un Secret de certificat pour servir HTTPS.

tls:
  - hosts: [web.exemple.test]
    secretName: web-tls

05 · Configuration et stockage

Il faut distinguer configuration applicative, secrets et données qui doivent survivre à la disparition d’un Pod.

ConfigMap.data

Ensemble clé-valeur pour des paramètres non sensibles, consommés par des Pods.

data:
  MODE: "production"

Secret.stringData / data

stringData accepte du texte brut à l’entrée ; data porte des valeurs encodées en base64.

stringData:
  PASSWORD: exemple-fictif
À retenir :

Ne jamais committer de vrais secrets. Base64 n’est pas du chiffrement.

spec.volumes

Déclare les volumes disponibles dans le Pod : emptyDir, Secret, ConfigMap, PVC, etc.

volumes:
  - name: cache
    emptyDir: {}

volumeMounts

Définit où un volume déclaré est visible dans un conteneur.

volumeMounts:
  - name: cache
    mountPath: /tmp/cache

persistentVolumeClaim.claimName

Lie un volume du Pod à un PVC déjà déclaré, pour un stockage persistant.

volumes:
  - name: donnees
    persistentVolumeClaim:
      claimName: donnees-pvc

PVC.spec.accessModes

Demande les modes d’accès pris en charge par le stockage, par exemple ReadWriteOnce.

accessModes: [ReadWriteOnce]
À retenir :

RWO ne signifie pas forcément « un seul Pod » ; voir la sémantique du volume.

PVC.spec.resources.requests.storage

Quantité de stockage demandée au système de stockage.

resources:
  requests:
    storage: 2Gi

PVC.spec.storageClassName

Nom de la classe de stockage demandée ; sa disponibilité dépend du cluster.

storageClassName: standard
À retenir :

Sans provisionneur ni PV compatible, un PVC peut rester Pending.

06 · Sécurité et placement

Ces champs influencent l’identité du processus, les permissions des workloads et leur placement sur les nœuds.

securityContext.runAsNonRoot

Demande que le processus ne s’exécute pas avec l’UID 0 dans le conteneur.

securityContext:
  runAsNonRoot: true
À retenir :

L’image doit être compatible avec un utilisateur non-root.

securityContext.allowPrivilegeEscalation

Empêche, lorsque pris en charge, qu’un processus obtienne de nouveaux privilèges à l’exécution.

allowPrivilegeEscalation: false

securityContext.readOnlyRootFilesystem

Monte le système de fichiers racine du conteneur en lecture seule.

readOnlyRootFilesystem: true
À retenir :

Prévoir des volumes pour les chemins devant rester modifiables.

securityContext.capabilities.drop

Permet de retirer des capacités Linux non nécessaires au processus.

capabilities:
  drop: ["ALL"]

spec.serviceAccountName

Associe au Pod une identité de workload Kubernetes, utilisée notamment pour ses demandes à l’API.

serviceAccountName: lecteur-pods
À retenir :

Ne pas accorder plus de permissions que nécessaire.

RBAC Role / RoleBinding

Role décrit des règles dans un namespace ; RoleBinding accorde ce rôle à un sujet.

resources: ["pods"]
verbs: ["get", "list"]
À retenir :

ClusterRole et ClusterRoleBinding concernent les permissions réutilisables ou à portée cluster.

nodeSelector / affinity

Contraignent ou orientent la sélection d’un nœud selon ses labels ou des relations entre Pods.

nodeSelector:
  kubernetes.io/os: linux

tolerations / taints

Un taint permet de repousser certains Pods ; une toleration autorise un Pod compatible à être planifié malgré ce taint.

tolerations:
  - key: dedicated
    operator: Equal
    value: lab
    effect: NoSchedule
À retenir :

La toleration n’oblige pas à choisir ce nœud.

NetworkPolicy.spec.podSelector

Détermine quels Pods du namespace sont soumis à une NetworkPolicy.

podSelector:
  matchLabels: {app: db}
À retenir :

L’application exige un CNI compatible.

07 · Confusions fréquentes

Certaines propriétés ressemblent à celles de Docker Compose, mais le comportement de Kubernetes est différent.

containerPort ≠ exposition publique

containerPort décrit le port du conteneur ; un Service, puis éventuellement Ingress ou Gateway, définit l’accès réseau voulu.

containerPort: 80 ≠ LoadBalancer

Labels ≠ noms de services

Les selectors relient Services, Deployments et Pods selon des labels ; ce sont ces correspondances qui déterminent le routage.

Service selector.app = Pod label.app

Readiness ≠ liveness

Readiness évite d’envoyer du trafic à un Pod pas prêt ; liveness déclenche un redémarrage en cas d’échec.

/ready → trafic ; /live → redémarrage

Request ≠ limit

Request sert à la planification ; limit plafonne l’utilisation à l’exécution.

100m CPU de request, 500m de limit

Secret ≠ chiffrement garanti

Un Secret sépare les informations sensibles, mais ses données base64 peuvent être lisibles sans chiffrement au repos ni RBAC adaptés.

Protéger etcd + accès API + Git

Deployment ≠ StatefulSet

Deployment convient à des services interchangeables ; StatefulSet fournit des identités stables, souvent utiles aux charges avec stockage attaché.

web → Deployment ; base distribuée → StatefulSet

08 · Manifestes complets

Ces fichiers complets correspondent aux annexes du guide PDF et sont copiables dans les fiches du site.

deployment.yaml

Déclare deux répliques Nginx avec ressources réservées et un test de disponibilité HTTP.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: dev
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:stable
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 100m
              memory: 64Mi
            limits:
              memory: 256Mi
          readinessProbe:
            httpGet:
              path: /
              port: 80
            periodSeconds: 5
À retenir :

À appliquer après création du namespace dev.

service.yaml

Crée un point d’accès interne stable vers les Pods portant le label app: web.

apiVersion: v1
kind: Service
metadata:
  name: web
  namespace: dev
spec:
  type: ClusterIP
  selector:
    app: web
  ports:
    - name: http
      port: 80
      targetPort: 80
À retenir :

Le Service ne fonctionnera que si le sélecteur correspond aux labels des Pods.

configmap.yaml

Crée deux paramètres applicatifs non confidentiels dans le namespace dev.

apiVersion: v1
kind: ConfigMap
metadata:
  name: web-config
  namespace: dev
data:
  APP_MODE: "demo"
  LOG_LEVEL: "info"

pvc.yaml

Demande 2 Gi de stockage persistant ; le provisionnement dépend de la configuration du cluster.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: donnees-pvc
  namespace: dev
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 2Gi
# La StorageClass disponible dépend du cluster.
À retenir :

Vérifier kubectl get storageclass, puis kubectl get pvc -n dev.

job.yaml

Exécute une tâche ponctuelle puis termine ; ne sert pas à héberger un serveur HTTP.

apiVersion: batch/v1
kind: Job
metadata:
  name: essai
  namespace: dev
spec:
  backoffLimit: 2
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: test
          image: busybox:1.36
          command: ["sh", "-c", "echo TP Kubernetes"]