Qu'est-ce que Kubectl Autoscale ?
L'autoscaling est la principale fonctionnalité du cluster Kubernetes qui permet aux ressources de se mettre à jour automatiquement sans avoir à le faire manuellement. La mise à jour manuelle des ressources exigeantes est un processus très coûteux en temps et en ressources. La mise à l'échelle automatique de Kubernetes fournit une fonction automatique pour optimiser les ressources.
L'autoscaler peut créer et détruire le nombre de nœuds selon les besoins. Autoscale réduit le gaspillage de ressources. La mise à l'échelle automatique de Kubectl choisit automatiquement les pods qui s'exécutent actuellement dans le cluster Kubernetes.
Il existe deux types de mise à l'échelle : (1) HorizontalPodScaler et (2) Vertical scaler. L'échelle horizontale est différente de l'échelle verticale. Le HorizontalPodScaler aide à diminuer ou à augmenter les pods en cas de besoin. D'autre part, le scaler vertical utilise des ressources telles que le processeur et la mémoire.
Voici toutes les étapes que vous pouvez suivre dans votre système et voir le résultat pour une meilleure compréhension.
Étape 1 : Démarrage d'un cluster Minikube
Dans la première étape, démarrez l'outil minikube pour exécuter le cluster Kubernetes afin que nous puissions exécuter la commande 'kubectl autoscale'. Vous pouvez configurer vos nœuds, vos pods et même un cluster dans l'environnement Kubernetes à l'aide du cluster minikube. Pour ce faire, utilisez la commande suivante pour garder le minikube en mode actif :
~$ commencer minikube
Comme vous pouvez le voir dans la capture d'écran de sortie suivante, cette commande active le cluster minikube et rend l'environnement Kubernetes utilisable :
Étape 2 : Obtenir les détails du module
Dans cette étape, le cluster Kubernetes s'exécute correctement. Maintenant, nous obtenons les détails du pod dans le cluster. Le pod dans Kubernetes est la collection d'unités qui partagent des ressources. Le script suivant est exécuté en exécutant la commande suivante dans votre cluster minikube :
~$ kubectl obtenir des podsEn utilisant la commande précédente qui est 'kubectl get pods', nous pouvons obtenir la liste de tous les pods qui s'exécutent dans le cluster Kubernetes.
Après avoir exécuté la commande 'get pods', nous obtenons le résultat suivant :
Étape 3 : Obtenir les déploiements de pod
Dans la commande précédente 'kubectl get pods', nous obtenons les détails des pods. Maintenant, nous utilisons la commande « get deployment » pour obtenir la liste des déploiements créés. Le script suivant est exécuté à cet effet :
~$ kubectl obtenir des déploiementsAprès avoir exécuté la commande, la capture d'écran suivante montre le résultat :
Étape 4 : Déploiement de mise à l'échelle automatique
La commande autoscale est utilisée pour effectuer la sélection d'automatisation des pods qui s'exécutent dans le cluster. En déployant l'autoscale dans le cluster, nous insérons et résilions automatiquement le nombre de nœuds. Le script suivant est exécuté dans le cluster minikube et affiche le nom du fichier, le nombre minimum de pods et le nombre maximum de pods, où les pods doivent être compris entre 2 et 10 :
~$ kubectl déploiement de mise à l'échelle automatique nginx1-deployment1 --min = 2 --max = dixAprès l'exécution de la commande, la sortie suivante est générée :
Étape 5 : Créer un fichier YAML Kubernetes
Dans cette étape, vous apprendrez à créer le fichier YAML dans le cluster. Le fichier YAML est utile pour le déploiement et les tests d'application. Il existe différents types dans Kubernetes pour créer et modifier le fichier.
Dans cet article, nous utilisons la commande 'nano' pour créer le fichier YAML car c'est le moyen le plus simple et le meilleur choix pour les débutants.
Suivez les étapes indiquées ici pour créer un fichier YAML à l'aide de nano :
- Pour créer un nouveau fichier ou modifier un fichier existant, accédez à l'emplacement du répertoire souhaité.
- Tapez 'nano'. Après cela, écrivez le nom du fichier. Par exemple, si vous souhaitez créer un nouveau nom de fichier, écrivez le nom - 'deploo.yaml'.
Exécutez le script suivant et créez un fichier YAML dans le répertoire du projet :
~$ nano deploo.yamlAprès avoir créé le fichier 'deploo.yaml', l'étape suivante consiste à configurer le fichier YAML. Nous l'expliquons dans l'étape suivante.
Étape 6 : Contenu du fichier YAML
Dans cette étape, nous pouvons facilement configurer le serveur Apache et les fichiers PHP. Avant d'utiliser HorizontalPodScaler, nous devons configurer le moniteur de charge de travail. Comme le morceau de code suivant montre le kind:deployment, le port du navigateur Web est 90 et la limite CPU est 200m.
Vous pouvez voir les informations complètes du fichier 'deploo.yaml' ici :
apiVersion : applications/v1type : Déploiement
métadonnées :
nom : php
spécification :
sélecteur :
matchLabels :
courir : php-apache
modèle :
métadonnées :
Étiquettes :
courir : php-apache
spécification :
conteneurs :
- nom : php
image : registre.k8s.io/hpa-exemple
ports :
- conteneurPort : 90
ressources :
limites :
CPU : 200m
demandes :
CPU : 100m
---
apiVersion : v1
type : Service
métadonnées :
nom : php
Étiquettes :
courir : php-apache
spécification :
ports :
- port : 70
sélecteur :
courir : php-apache
Étape 7 : Créer le déploiement
Dans cette étape, créons le fichier YAML nommé 'deploo.yaml'. Le script suivant est exécuté dans le cluster minikube :
~$ kubectl create -f deploo.yamlLa sortie de la commande susmentionnée que nous avons exécutée peut être vue dans la capture d'écran qui suit. Le résultat indique que le fichier YAML a été créé :
Étape 8 : Créer le HorizontalPodScaler
Dans cette étape, nous allons vous montrer la commande pour créer le HorizontalPodAutoscaler. Les pods sont insérés et terminés automatiquement en fonction de la demande. Elle est distincte de la mise à l'échelle verticale, dans laquelle les ressources CPU et mémoire sont affectées par mise à l'échelle automatique. Le script suivant est exécuté dans le cluster minikube :
~$ déploiement de mise à l'échelle automatique de kubectl php -- CPU - pour cent = cinquante -- min = dix –max = vingtIci, vous pouvez voir que nous avons défini les valeurs minimum et maximum sur 10 et 20.
Ci-joint le résultat de la commande précédente :
Étape 9 : Vérifiez le HorizontalPodScaler
Dans cette étape, nous vérifions l'état actuel de HorizontalPodAutoscaler qui vient d'être créé. La commande suivante est exécutée :
~$ kubectl obtenir hpaConclusion
L'une des fonctionnalités les plus utiles de Kubernetes est le 'kubectl autoscale' qui fournit des mises à jour automatiques des ressources dans le cluster Kubernetes. L'autoscaler aide lorsqu'un cluster doit augmenter le nombre de pods ou diminuer le nombre de pods. Dans cet article, nous avons appris les deux méthodes de mise à l'échelle automatique - l'une est l'autoscaler par défaut et l'autre est le HorizontalPodScaler.
Tout d'abord, nous avons déployé les pods et les avons déclarés. Ensuite, nous avons créé l'autoscaler et configuré le serveur Apache pour déployer le moniteur de charge de travail avant HorizontalPodScaler. Après cela, nous avons créé un fichier YAML et le HorizontalPodScaler. Cet article s'est concentré sur les étapes détaillées de création, de configuration et de déploiement de Kubernetes à mise à l'échelle automatique.