Configurer les vérifications de l’état de Kubernetes

Kubernetes est une plate-forme open source d’orchestration de conteneurs qui permet de gérer et de déployer des applications dans un environnement cloud. Il est utilisé pour automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. C’est un moyen efficace de gérer la santé des applications avec les sondes Kubernetes. Cet article traite des sondes Kubernetes, des différents types disponibles et de la manière de les implémenter dans votre environnement Kubernetes.

Que sont les sondes Kubernetes ?

Les sondes Kubernetes sont des vérifications de l’état utilisées pour surveiller l’état des applications et des services dans un cluster Kubernetes. Ils sont utilisés pour détecter tout problème potentiel avec les applications ou les services et identifier les goulots d’étranglement potentiels des ressources. Les sondes sont configurées pour s’exécuter à intervalles réguliers et envoyer un signal au plan de contrôle Kubernetes si elles détectent des problèmes avec l’application ou le service.

Les sondes Kubernetes sont généralement implémentées à l’aide de l’API Kubernetes, qui leur permet d’interroger l’application ou le service pour obtenir des informations. Ces informations peuvent ensuite être utilisées pour déterminer l’état de santé de l’application ou du service. Les sondes Kubernetes peuvent également être utilisées pour détecter les changements dans l’application ou le service et envoyer une notification au plan de contrôle Kubernetes, qui peut alors prendre des mesures correctives. Les sondes Kubernetes sont une partie importante de la plate-forme Kubernetes, car elles contribuent à garantir le bon fonctionnement des applications et des services. Ils peuvent être utilisés pour détecter les problèmes potentiels avant qu’ils ne deviennent graves, ce qui vous permet de prendre rapidement des mesures correctives.

Un message réussi pour une sonde de préparation indique que le conteneur est prêt à recevoir du trafic. Si une vérification de l’état de préparation réussit, le conteneur est considéré comme prêt et peut commencer à recevoir des demandes d’autres conteneurs, services ou clients externes.

Un message réussi pour une sonde d’activité indique que le conteneur est toujours en cours d’exécution et fonctionne correctement. Si une vérification de la vivacité réussit, le conteneur est considéré comme vivant et sain. Si une sonde d’activité échoue, le conteneur est considéré comme étant dans un état d’échec et Kubernetes tentera de redémarrer le conteneur pour restaurer sa fonctionnalité. Les sondes de préparation et de vivacité renvoient un message réussi avec un code de réponse HTTP de 200-399 ou une connexion socket TCP est réussie. Si la sonde échoue, elle renverra un code de réponse HTTP non-2xx ou une connexion TCP en échec, indiquant que le conteneur n’est pas prêt ou actif.

Un message réussi pour une sonde Kubernetes indique que le conteneur est prêt à recevoir du trafic ou est toujours en cours d’exécution et fonctionne correctement, selon le type de sonde.

Types de sondes Kubernetes

Il existe trois types de sondes :

Sondes de démarrage
Sondes de préparation
Sondes de vivacité

1. Sondes de démarrage

Une sonde de démarrage est utilisée pour déterminer si un conteneur a démarré avec succès. Ce type de sonde est généralement utilisé pour les applications qui mettent plus de temps à démarrer ou pour les conteneurs qui effectuent des tâches d’initialisation avant d’être prêts à recevoir du trafic. La sonde de démarrage est exécutée une seule fois, après la création du conteneur, et elle retardera le démarrage des sondes de préparation et de vivacité jusqu’à ce qu’elle réussisse. Si la sonde de démarrage échoue, le conteneur est considéré comme n’ayant pas démarré et Kubernetes tentera de redémarrer le conteneur.

2. Sondes de préparation

Une sonde de préparation est utilisée pour déterminer si un conteneur est prêt à recevoir du trafic. Ce type de sonde est utilisé pour s’assurer qu’un conteneur est entièrement opérationnel et peut accepter les connexions entrantes avant qu’il ne soit ajouté à l’équilibreur de charge de service. Une sonde de préparation peut être utilisée pour vérifier la disponibilité des dépendances d’une application ou effectuer toute autre vérification indiquant que le conteneur est prêt à servir le trafic. Si la vérification de la préparation échoue, le conteneur est supprimé de l’équilibreur de charge de service jusqu’à ce que la vérification réussisse à nouveau.

3. Sondes de vivacité

Une sonde de vivacité est utilisée pour déterminer si un conteneur est toujours en cours d’exécution et fonctionne correctement. Ce type de sonde est utilisé pour détecter et récupérer des plantages ou des raccrochages de conteneurs. Une sonde de vivacité peut être utilisée pour vérifier la réactivité d’une application ou effectuer toute autre vérification indiquant que le conteneur est toujours vivant et sain. Si la sonde de vivacité échoue, Kubernetes tentera de redémarrer le conteneur pour restaurer sa fonctionnalité.

Chaque type de sonde a ses propres options de configuration, telles que le point de terminaison à vérifier, l’intervalle de sonde et les seuils de réussite et d’échec. En utilisant ces sondes, Kubernetes peut s’assurer que les conteneurs fonctionnent et sont sains et peut prendre les mesures appropriées si un conteneur ne répond pas.

Comment implémenter les sondes Kubernetes

Les sondes Kubernetes peuvent être mises en œuvre de différentes manières :

La première consiste à utiliser l’API Kubernetes pour interroger l’application ou le service afin d’obtenir des informations. Ces informations peuvent ensuite être utilisées pour déterminer l’état de santé de l’application ou du service.
La deuxième méthode consiste à utiliser le protocole HTTP pour envoyer une requête à l’application ou au service. Cette requête peut être utilisée pour détecter si une application ou un service est réactif, ou s’il met trop de temps à répondre.
La troisième méthode consiste à utiliser des sondes personnalisées pour détecter des conditions spécifiques dans une application ou un service. Les sondes personnalisées peuvent être utilisées pour détecter des éléments tels que l’utilisation des ressources, des réponses lentes ou des modifications dans l’application ou le service.

Une fois que vous avez décidé du type de sonde que vous utiliserez, vous pouvez ensuite configurer la sonde à l’aide de l’API Kubernetes. Vous pouvez spécifier la fréquence de la sonde, le type de sonde et les paramètres de la sonde. Une fois la sonde configurée, vous pouvez la déployer sur le cluster Kubernetes.

Aujourd’hui, je vais vous montrer comment configurer les vérifications de l’état de votre application déployée sur Kubernetes avec le protocole HTTP pour vérifier si l’application est prête, en ligne et démarrée conformément à nos exigences.

Conditions préalables

Un cluster Kubernetes de n’importe quel fournisseur de cloud. Vous pouvez même utiliser Minikube ou Kind pour créer un cluster à nœud unique.
Docker Desktop pour conteneuriser l’application.
Docker Hub pour pousser l’image du conteneur vers le registre Docker.
Node.js installé, car nous utiliserons un exemple d’application Node.js.

Didacticiel

Fourchez l’exemple d’application ici.
Entrez dans le dossier principal de l’application avec la commande :
- cd Kubernetes-Probes-Tutorial
Installez les dépendances avec la commande :
Exécutez l’application localement à l’aide de la commande :

Vous devriez voir l’application s’exécuter sur le port 3000.

Dans le dossier de l’application, vous devriez voir le Dockerfile avec le contenu de code suivant :

# Use an existing node image as base image
FROM node:14-alpine

# Set the working directory in the container
WORKDIR /app

# Copy package.json and package-lock.json to the container
COPY package*.json ./

# Install required packages
RUN npm install

# Copy all files to the container
COPY . .

# Expose port 3000
EXPOSE 3000

# Start the application
CMD [ "npm", "start" ]

Ce Dockerfile consiste à créer une image conteneur de notre application et à la pousser vers le Docker Hub.

Ensuite, créez et transférez votre image vers le Docker Hub à l’aide de la commande suivante :

docker buildx build --platform=linux/arm64 --platform=linux/amd64  -t docker.io/Docker Hub username/image name:tag --push  -f ./Dockerfile .

Vous pouvez voir l’image poussée sur votre compte Docker Hub sous les référentiels.

Ensuite, déployez les fichiers manifestes. Dans le dossier de l’application, vous remarquerez un deployment.yaml fichier avec vérifications/sondes de santé incluses, telles que les sondes de préparation et de vivacité.

Note: nous avons utilisé notre nom d’image poussé dans le fichier YAML :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: notes-app-deployment
  labels:
    app: note-sample-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: note-sample-app
  template:
    metadata:
      labels:
        app: note-sample-app
    spec:
      containers:
      - name: note-sample-app-container
        image: pavansa/note-sample-app
        resources:
          requests:
            cpu: "100m"
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 3000
        readinessProbe:
          httpGet:
            path: /
            port: 3000
        livenessProbe:
          httpGet:
            path: /
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5

Vous pouvez voir l’image utilisée et les contrôles de santé configurés dans le fichier YAML ci-dessus.

Nous sommes tous prêts avec notre fichier YAML. En supposant que vous ayez un cluster en cours d’exécution, déployons le fichier manifeste mentionné ci-dessus avec la commande :

kubectl apply -f deployment.yaml

Vous devriez voir le déploiement réussi du fichier : « deployment.apps/notes-app-deployment créé.”

Vérifions l’état du pod avec la commande suivante pour nous assurer que les pods sont en cours d’exécution :

Décrivons un pod à l’aide de la commande suivante :

kubectl describe pod notes-app-deployment-7fb6f5d74b-hw5fn

Tu peux voir le « Vivacité et préparation” lorsque vous décrivez les pods.

Ensuite, vérifions la section des événements.

Vous pouvez voir les différents événements, tels que « programmé, » « tiré, » « créé, » et « commencé.” Tous les événements de pod ont réussi.

Conclusion

Les sondes Kubernetes sont une partie importante de la plate-forme Kubernetes, car elles contribuent à garantir le bon fonctionnement des applications et des services. Ils peuvent être utilisés pour détecter les problèmes potentiels avant qu’ils ne deviennent graves, ce qui vous permet de prendre rapidement des mesures correctives.

Les sondes Kubernetes sont de deux types :

Sondes de vivacité
Sondes de préparation

Avec des sondes personnalisées qui peuvent être utilisées pour détecter des conditions spécifiques dans une application ou un service. La mise en œuvre des sondes Kubernetes est un processus simple qui peut être effectué à l’aide de l’API Kubernetes.

Si vous cherchez un moyen d’assurer la santé de vos applications et services, les sondes Kubernetes sont la solution. Alors, assurez-vous d’implémenter les sondes Kubernetes dans votre environnement Kubernetes dès aujourd’hui !

Configurer les vérifications de l’état de Kubernetes – DZone

Leave A Reply Cancel Reply