Retour au cours

déployer une application simple sur kubernetes

Objectif

Ce projet a pour but de mettre en pratique les concepts de Deployment et de Service pour déployer et exposer une application web simple. Nous utiliserons une image Docker publique (nginxdemos/hello) qui est un petit serveur web affichant quelques informations sur le conteneur.

Le Scénario

Nous allons déployer cette application web et nous assurer qu’elle est :

  1. Résistante aux pannes : en demandant à Kubernetes de toujours maintenir plusieurs copies (répliques) en cours d’exécution.
  2. Accessible : en créant un point d’entrée réseau stable pour accéder à notre application.

Les Étapes

Nous allons créer deux fichiers YAML : un pour le Deployment et un pour le Service.

1. Le Deployment (deployment.yaml)

Cet objet dira à Kubernetes comment lancer notre application.

Fichier deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app-deployment
spec:
  # On demande 2 répliques de notre application
  replicas: 2
  selector:
    matchLabels:
      app: hello-app
  # C'est le modèle du Pod que le Deployment doit créer
  template:
    metadata:
      labels:
        app: hello-app # Le label que le selector utilise
    spec:
      containers:
      - name: hello-container
        image: nginxdemos/hello:latest # Une image simple qui lance un serveur web
        ports:
        - containerPort: 80 # Le conteneur écoute sur le port 80
  • replicas: 2 : On demande à Kubernetes de s’assurer qu’il y a toujours 2 Pods de cette application qui tournent.
  • selector et labels : C’est le lien. Le Deployment gère tous les Pods qui ont le label app: hello-app.

2. Le Service (service.yaml)

Cet objet va créer un point d’accès réseau unique pour nos 2 Pods.

Fichier service.yaml :

apiVersion: v1
kind: Service
metadata:
  name: hello-app-service
spec:
  # Le type NodePort rend le service accessible depuis l'extérieur du cluster
  # sur un port spécifique de chaque Node. Idéal pour le test en local.
  type: NodePort
  selector:
    app: hello-app # Le service envoie le trafic vers les Pods avec ce label
  ports:
  - protocol: TCP
    port: 80 # Le port sur lequel le service est joignable à l'intérieur du cluster
    targetPort: 80 # Le port sur lequel les conteneurs écoutent
  • selector: app: hello-app : C’est ainsi que le Service sait vers quels Pods envoyer le trafic.
  • type: NodePort : Expose le service sur un port aléatoire (généralement > 30000) sur l’adresse IP de chaque Node du cluster.

Déploiement et Vérification

(Ces commandes supposent que vous avez un cluster Kubernetes local comme minikube ou k3d qui tourne).

1. Appliquer la configuration

Placez les deux fichiers YAML dans un dossier, et exécutez :

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

2. Vérifier les objets créés

# Lister les deployments
kubectl get deployment

# Lister les pods (vous devriez en voir 2)
kubectl get pods

# Lister les services
kubectl get service

La sortie de kubectl get service vous montrera le port qui a été assigné, par exemple 80:31567/TCP.

3. Accéder à l’application

Si vous utilisez minikube, la commande suivante est très pratique pour ouvrir l’URL du service directement dans votre navigateur :

minikube service hello-app-service

Sinon, vous pouvez trouver l’IP de votre Node (minikube ip) et y accéder avec le port assigné (ex: http://<IP_DU_NODE>:31567).

À chaque fois que vous rafraîchirez la page, la requête pourra être envoyée à l’un ou l’autre des deux Pods. Vous verrez le nom du Pod changer sur la page web affichée.

4. Nettoyer

Pour supprimer tout ce que vous avez créé :

kubectl delete -f deployment.yaml
kubectl delete -f service.yaml

Exercices

  1. Mise à l’échelle :

    • Utilisez la commande kubectl scale pour changer le nombre de répliques de votre hello-app-deployment à 5.
    • kubectl scale deployment hello-app-deployment --replicas=5
    • Observez les nouveaux Pods se créer avec kubectl get pods -w (l’option -w observe les changements en temps réel).

  2. Simulation de panne :

    • Listez vos Pods.
    • Supprimez-en un manuellement : kubectl delete pod <nom-d-un-pod>.
    • Listez à nouveau les Pods immédiatement. Vous verrez que Kubernetes en a automatiquement créé un nouveau pour le remplacer et maintenir l’état désiré de 5 répliques.

  3. Mise à jour de l’image :

    • Modifiez votre deployment.yaml pour utiliser une autre version de l’image, par exemple nginxdemos/hello:plain-text.
    • Ré-appliquez le fichier : kubectl apply -f deployment.yaml.
    • Observez la mise à jour progressive (“rolling update”) avec kubectl get pods -w. Kubernetes va créer de nouveaux Pods et supprimer les anciens un par un, sans interrompre le service.

Sujets abordés