Retour au cours

objets kubernetes : pods, deployments et services

Objectifs

  • Comprendre le rôle des trois objets les plus importants : Pod, Deployment, et Service.
  • Lire et écrire une définition YAML simple pour un Deployment et un Service.
  • Déployer une application simple en utilisant un Deployment.
  • Exposer cette application à l’intérieur du cluster avec un Service.

Kubernetes fonctionne en manipulant des “objets” qui représentent l’état désiré de votre système. Voici les trois que vous utiliserez constamment.

1. Pod : L’unité de base

Le Pod est la plus petite unité de calcul que vous pouvez créer et gérer dans Kubernetes.

  • Il peut contenir un ou plusieurs conteneurs. Dans 95% des cas, il n’en contient qu’un seul.
  • Important : Les Pods sont considérés comme éphémères. S’ils plantent ou si leur Nœud (Node) tombe en panne, ils ne sont pas redémarrés automatiquement. On ne crée donc presque jamais de Pods directement. On utilise un objet de plus haut niveau pour les gérer : le Deployment.

2. Deployment : Le gestionnaire de Pods

Le Deployment est l’objet que vous utiliserez pour déployer votre application. Son travail est de s’assurer que le nombre de copies de votre Pod est toujours conforme à ce que vous avez demandé.

  • Il gère un ReplicaSet (un autre objet qui gère les répliques).
  • Si un Pod tombe, le ReplicaSet en crée immédiatement un nouveau pour le remplacer. C’est la haute disponibilité.
  • Il gère les mises à jour. Quand vous changez la version de l’image Docker, le Deployment va progressivement remplacer les anciens Pods par les nouveaux sans interrompre le service (“Rolling Update”).

Exemple de Deployment en YAML

# deployment.yaml
apiVersion: apps/v1
kind: Deployment        # Le type d'objet
metadata:
  name: mon-app-nginx  # Le nom de notre deployment
spec:
  replicas: 3           # On veut 3 copies de notre pod
  selector:
    matchLabels:
      app: nginx        # Lie le deployment aux pods avec ce label
  template:             # C'est la description du Pod à créer
    metadata:
      labels:
        app: nginx      # Le label qui permet au selector de le trouver
    spec:
      containers:
      - name: nginx-container
        image: nginx:1.23 # L'image Docker à utiliser
        ports:
        - containerPort: 80

3. Service : Exposer les Pods

Les Pods d’un Deployment peuvent être créés, détruits et remplacés à tout moment. Leurs adresses IP ne sont donc pas stables. Comment les autres applications peuvent-elles leur parler ? C’est le rôle du Service.

Un Service fournit une adresse IP stable et un nom DNS unique à l’intérieur du cluster pour un groupe de Pods. Il agit comme un mini “load balancer” interne. Il utilise les labels pour savoir à quels Pods il doit envoyer le trafic.

Exemple de Service en YAML

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: mon-service-nginx
spec:
  selector:
    app: nginx  # Envoie le trafic à tous les Pods ayant le label 'app: nginx'
  ports:
    - protocol: TCP
      port: 80        # Le port sur lequel le service écoute
      targetPort: 80  # Le port des conteneurs cibles
  type: ClusterIP   # Le type de service
  • type: ClusterIP : (Par défaut) Expose le service sur une IP interne, accessible uniquement depuis le cluster.

Comment les utiliser ensemble

  1. Vous écrivez le fichier deployment.yaml.
  2. Vous écrivez le fichier service.yaml.
  3. Vous les appliquez au cluster : 
    kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
  4. Le Deployment crée les Pods.
  5. Le Service détecte les Pods grâce à leurs labels et commence à router le trafic vers eux.

Bonnes pratiques

  • Utilisez toujours des Deployments pour vos applications “stateless”. Ne gérez jamais de Pods manuellement.
  • Utilisez des labels clairs et cohérents. C’est le mécanisme central qui relie les différents objets Kubernetes entre eux.
  • Définissez chaque objet dans son propre fichier YAML pour plus de clarté.

Exercices

  1. Créez un Deployment :

    • Écrivez un fichier apache-deployment.yaml.
    • Il doit définir un Deployment nommé web-apache qui lance 2 répliques de l’image Docker httpd:2.4-alpine.
    • Donnez aux Pods le label app: apache.

  2. Créez un Service :

    • Écrivez un fichier apache-service.yaml.
    • Il doit définir un Service nommé web-apache-svc qui cible les Pods avec le label app: apache.
    • Il doit exposer le port 80.

  3. Déployez et vérifiez (si vous avez un cluster local) :

    • Appliquez les deux fichiers avec kubectl apply.
    • Utilisez kubectl get deployment, kubectl get pods et kubectl get service pour voir les objets créés.
    • Utilisez kubectl describe pod <nom-d-un-pod> pour voir les détails d’un des Pods créés.

Sujets abordés