Déployez Votre Première Application avec Kubernetes

Débutez avec Kubernetes en apprenant à déployer votre première application Nginx. Suivez notre guide étape par étape pour découvrir les objets namespaces, deployments et services

Kubernetes est devenu un outil incontournable pour orchestrer et gérer des applications conteneurisées à grande échelle. Si vous débutez avec Kubernetes, vous vous demandez peut-être comment déployer et gérer vos applications de manière efficace.

Cet article vous guidera à travers le processus de déploiement de votre première application sur Kubernetes, en utilisant des configurations simples et des commandes essentielles.

L’objectif est de vous fournir une compréhension pratique des concepts fondamentaux tout en vous permettant de voir rapidement les résultats de votre travail.

Prérequis

Avant de plonger dans ce tutoriel sur Kubernetes, assurez-vous de préparer votre environnement. Suivez le guide ci-dessous pour configurer Docker Desktop et obtenir un cluster Kubernetes fonctionnel en local :

Création de la Configuration de l’Application

Définition d'un Namespace

Dans Kubernetes, un Namespace est une manière de diviser et d’isoler les ressources au sein d’un même cluster. Il permet de créer des environnements virtuels séparés pour différents projets, équipes ou applications, tout en utilisant les mêmes ressources physiques sous-jacentes.

Nous allons créer un namespace nommé nginx :

$ kubectl create namespace nginx
$ kubectl get namespace nginx
NAME    STATUS   AGE
nginx   Active   5s

Définition d'un Deployment

Pour déployer une application dans Kubernetes, vous devez créer un fichier YAML qui définit les spécifications de votre Deployment. Voici un exemple de manifeste Kubernetes pour déployer une application NGINX :

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

deployment.yaml

Explication du manifeste deployment.yaml :

apiVersion: Spécifie la version de l'API Kubernetes utilisée pour ce Deployment. Ici, apps/v1 est la version stable et recommandée pour les objets de type Deployment
kind : Indique le type de l'objet Kubernetes à créer. Dans ce cas, un Deployment est défini, ce qui permet de déployer des applications à l'échelle
metadata : Les métadonnées fournissent des informations descriptives sur le Deployment.
- name : Le champ name définit le nom du Deployment comme nginx-deployment
spec : Définit le nombre de réplicas (instances) de pods que le Deployment doit maintenir. Ici, trois réplicas du pod seront créés et maintenus pour assurer la haute disponibilité.
- replicas : Définit le nombre de réplicas (instances) de pods que le Deployment doit maintenir. Ici, trois réplicas du pod seront créés et maintenus pour assurer la haute disponibilité.
- selector : Le sélecteur est utilisé pour associer les pods créés par ce Deployment. Les pods doivent avoir un label app=nginx pour être gérés par ce Deployment.
  - matchLabels : Le sélecteur est utilisé pour associer les pods créés par ce Deployment. Les pods doivent avoir un label app=nginx pour être gérés par ce Deployment.
- template : Le template définit la configuration des pods créés par le Deployment. Les pods auront le label app=nginx pour correspondre au sélecteur.
- spec :
  - containers :
    - name : Nom du conteneur, ici nommé nginx.
    - image : Image Docker utilisée pour le conteneur. L'image nginx:latest est la version la plus récente de l'image officielle NGINX
    - ports:
      - containerPort : Port sur lequel le conteneur écoute. Le port 80 est utilisé pour les applications web et le trafic HTTP

Définition d'un Service

Pour exposer les pods exécutant Nginx au sein de votre cluster Kubernetes, vous pouvez utiliser un Service pour créer un point d’accès réseau stable. Voici un exemple de définition d’un Service Kubernetes :

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  labels:
    app: nginx
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

service.yaml

Explication du fichier service.yaml

apiVersion : Spécifie la version de l'API Kubernetes utilisée pour ce Service. Ici, v1 est la version stable et recommandée pour les objets de type Service.
kind : Spécifie la version de l'API Kubernetes utilisée pour ce Service. Ici, v1 est la version stable et recommandée pour les objets de type Service.
metadata : Les métadonnées fournissent des informations descriptives sur le Service. Le champ name définit le nom du Service comme nginx-service.
spec :
- selector : Le sélecteur détermine quels pods seront ciblés par ce Service. Les pods doivent avoir le label app=nginx pour que le Service les inclue.
- ports :
  - protocol : Protocole de communication utilisé par le Service, ici TCP.
  - port : Port sur lequel le Service écoute les requêtes entrantes.
  - targetPort : Port sur lequel les requêtes seront envoyées aux pods. Le targetPort correspond au port exposé par les conteneurs dans les pods.
- type : Expose le Service uniquement à l'intérieur du cluster Kubernetes. Les pods peuvent accéder au Service par un nom DNS interne.

Déploiement de l’Application

Utilisez la commande suivante pour appliquer la configuration du Deployment :

$ kubectl apply -f deployment.yaml -n nginx

Vérifiez que le Deployment et les Pods sont créés avec les commandes :

$ kubectl get -l app=nginx -n nginx deployments
NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           5s

$ kubectl get pods -l -n nginx app=nginx
NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7c79c4bf97-2q4k2   1/1     Running   0          28s
nginx-deployment-7c79c4bf97-bjfzm   1/1     Running   0          28s
nginx-deployment-7c79c4bf97-gf7d2   1/1     Running   0          28s

Appliquez la configuration du Service avec la commande suivante :

$ kubectl apply -f service.yaml

Vérifiez que le Service est correctement créé avec la commande :

$ kubectl get svc -l app=nginx
NAME    TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
nginx   ClusterIP   10.111.119.187   <none>        80/TCP    4s

Vérification de l'Application

Pour accéder à l’application, utilisez un port-forwarding temporaire pour rediriger le trafic du port local vers le port du service Kubernetes :

$ kubectl port-forward service/nginx-service 8080:80

Dans un autre terminal, exécuter la commande suivante :

$ kubectl logs -l app=nginx -f

Ouvrez votre navigateur et rendez-vous sur http://localhost:8080

💡

Normalement, vous devez accéder à la page du serveur NGINX dans votre navigateur. Les logs NGINX doivent défiler dans le terminal où vous avez entré la commande kubectl logs

Conclusion

En suivant cet article, vous avez appris à déployer une application dans un Namespace en utilisant les objets Deployment et Service dans Kubernetes. Vous avez vu comment créer et appliquer des configurations YAML pour gérer les Pods et exposer l’application au réseau.

Vous avez également découvert les commandes essentielles pour vérifier et dépanner votre déploiement. Ces connaissances vous permettent de débuter avec Kubernetes et de déployer des applications de manière évolutive et efficace.

Pour aller plus loin, explorez des concepts plus avancés comme les ConfigMaps, les Secrets, et les stratégies de mise à jour des Deployments pour optimiser encore davantage la gestion de vos applications Kubernetes.