kubernetes c’est quoi ?

Kubernetes est un système de gestion de conteneurs open source largement utilisé dans le monde de la technologie. Il permet de déployer, de mettre à l’échelle et de gérer facilement des applications et des services dans un environnement informatique distribué.

Kubernetes offre également une grande évolutivité et une haute disponibilité. Il peut facilement gérer l’ajout ou la suppression de nœuds de calcul et s’assurer que les applications et les services restent en ligne même en cas de panne de nœuds individuels.

Minikube

Il existe plusieurs façons de déployer une application ou un service sur Kubernetes. Voici les étapes de base pour déployer une application Spring Boot dans un cluster K8S :

Nous avons besoin de minkube, c’est un outil facilitant l’exécution locale de Kubernetes.

minikube start

Vérifier le statut de minikube et k8s :

minikube status

Ensuite, nous devons permettre à Kubernetes de lire notre repository local de docker :

eval $(minikube docker-env)

Verifier le statut des images docker :

docker images

Jusqu’a maintenant tout va bien 😉, nous allons créer l’image docker de notre application spring boot.

Changez votre reportoire courant et mettez vous dans le repertoire contenant votre application spring boot, ensuite lancer un build de votre image docker :

docker build -t backend:1.0 .

Verifier la creation de l’image :

docker images

Maintenant que l’image Docker est créée, nous pouvons la déployer sur le cluster Kubernetes 😌.

Déploiement avec kubernetes

Création du fichier de déploiement Kubernetes :

apiVersion: apps/v1  
kind: Deployment  
metadata:  
  name: fiabon-backend  
spec:  
  selector:  
    matchLabels:  
      app: fiabon-backend  
  replicas: 2  
  template:  
    metadata:  
      labels:  
        app: fiabon-backend  
    spec:  
      containers:  
        - name: fiabon-backend  
          image: backend.jar:latest  
          imagePullPolicy: IfNotPresent  
          ports:  
            - containerPort: 8081

Explications :

apiVersion : décrit la version du serveur API de K8S kind : le type d’objet K8s que nous utiliserons pour cette spécification metadata : décrit les informations sur l’application replicas : décrit le nombre de pods que nous devons exécuter pour la même application. containers : décrit les spécifications du container comme le nom, l’image et le port exposé.

Maintenant que nous avons créé le fichier de déploiement Kubernetes, nous pouvons le déployer sur le cluster :

kubectl apply -f deployment.yaml

Verifier l’état de déploiement :

kubectl get deployments

Ensuite, puisque nous avons mentionné deux répliques, Kubernetes va créer deux pods (instances) pour notre application.

Verifier le status de nos deux pods :

kubectl get pods

Nous pouvons voir ici que le statut est en “Running”. Verifier les logs de chaque pods :

kubectl logs fiabon-backend-7cf85c9f4b-4k5ls kubectl logs fiabon-backend-7cf85c9f4b-5rplk

L’application est deployée dans notre cluster K8S, mais comme vous pouvez le constater l’application tourne sur sur deux pods différents et deux instances différentes.

Donc la requette va tomber sur quelle instance ? le pod1 (fiabon-backend-7cf85c9f4b-4k5ls) ou le pod 2 (fiabon-backend-7cf85c9f4b-5rplk) 🤔 ?

Pour résoudre ce problème, nous avons besoin d’un mécanisme de répartition de la charge un load balancer .

Configuration de note load balancer loadBalencer.yml :

apiVersion: v1  
kind: Service  
metadata:  
  name: fiabon-backend  
spec:  
  selector:  
    app: fiabon-backend  
  ports:  
    - protocol: "TCP"  
  port: 8081 # Le port sur lequel le service est exécuté dans le cluster.  
  targetPort: 8081 # Le port exposé par le service  
  type: NodePort # type de service

Maintenant que nous avons créé le fichier de service, exposons notre application à l’extérieur du cluster k8s en utilisant la commande ci-dessous :

kubectl apply -f loadbalancer.yaml

Verifier le status de notre loadbalancer :

kubectl get service kubectl get nodes -o wide minikube ip

Verifier le statut de notre kubernetes :

minikube dashboard

ça y est, notre application est sur kubernetes

Il est important de noter que ce processus de déploiement de base ne couvre que les aspects les plus simples de Kubernetes. Il existe de nombreuses autres fonctionnalités et options que vous pouvez utiliser pour configurer et gérer votre application sur Kubernetes, y compris la mise à l’échelle automatique, la gestion des dépendances, la création de déploiements rollback et bien plus encore.