Cette page explique comment faire évoluer une application déployée dans Google Kubernetes Engine (GKE).
Présentation
Lorsque vous déployez une application dans GKE, vous définissez le nombre d'instances dupliquées de cette application que vous souhaitez exécuter. Chaque instance dupliquée de votre application représente un pod Kubernetes qui encapsule le ou les conteneurs de votre application.
Le scaling d'une application consiste à augmenter ou à diminuer le nombre d'instances dupliquées de charge de travail, ou à ajuster les ressources disponibles pour les instances dupliquées sur place. Il existe deux méthodes pour mettre à l'échelle une application :
- Le scaling horizontal, qui consiste à augmenter ou diminuer le nombre de répliques de charge de travail.
- Scaling vertical, qui consiste à ajuster les ressources disponibles pour les répliques sur place.
Avant de commencer
Avant de commencer, effectuez les tâches suivantes :
- Activez l'API Google Kubernetes Engine. Activer l'API Google Kubernetes Engine
- Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande
gcloud components update.
Inspecter une application
Avant de procéder au scaling de votre application, vous devez inspecter celle-ci afin de vérifier son état.
Pour voir toutes les applications déployées sur votre cluster, exécutez la commande suivante :
kubectl get CONTROLLER
Remplacez CONTROLLER par deployments, statefulsets ou un autre type d'objet contrôleur.
Par exemple, si vous exécutez kubectl get deployments alors que vous avez créé un seul déploiement, le résultat de la commande devrait ressembler à ce qui suit :
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
my-app 1 1 1 1 10m
Cette commande génère des résultats similaires pour tous les objets à de légères différences près. Pour les objets Deployment, la sortie comporte six colonnes :
NAMErépertorie les noms des objets Deployment présents dans le cluster.DESIREDaffiche le nombre d'instances dupliquées souhaité, c'est-à-dire l'état souhaité de l'application tel que vous l'avez défini lors de la création de l'objet Deployment.CURRENTaffiche le nombre d'instances dupliquées en cours d'exécution.UP-TO-DATEaffiche le nombre d'instances dupliquées qui ont été mises à jour pour atteindre l'état souhaité.AVAILABLEindique le nombre d'instances dupliquées de l'application qui sont disponibles pour vos utilisateurs.AGEaffiche la durée d'exécution de l'application dans le cluster.
Dans cet exemple, il n'y a qu'un seul objet Deployment, nommé my-app. Celui-ci n'a qu'une seule instance dupliquée, car son état souhaité a été défini sur une instance dupliquée. Vous définissez l'état souhaité au moment de la création, et vous pouvez le modifier à tout moment en faisant le scaling de l'application.
Inspecter les objets StatefulSet
Avant d'effectuer le scaling d'un objet StatefulSet, vous devez l'inspecter en exécutant la commande suivante :
kubectl describe statefulset my-app
Dans le résultat de cette commande, vérifiez le champ Pods Status. Si la valeur Failed est supérieure à 0, le scaling risque d'échouer.
Si un objet StatefulSet semble non opérationnel, procédez comme suit :
Obtenez la liste des pods et identifiez ceux qui ne sont pas opérationnels :
kubectl get podsSupprimez le pod non opérationnel :
kubectl delete POD_NAME
Toute tentative de scaling d'un objet StatefulSet non opérationnel peut entraîner l'indisponibilité de celui-ci.
Procéder au scaling d'une application
Les sections suivantes décrivent les différentes méthodes dont vous disposez pour faire le scaling d'une application.
La commande kubectl scale est la méthode de scaling la plus rapide. Une autre méthode peut cependant vous sembler préférable dans certaines situations, par exemple lors de la mise à jour de fichiers de configuration ou en cas de modifications effectuées sur place.
kubectl scale
La commande kubectl scale vous permet de modifier instantanément le nombre d'instances dupliquées dont vous souhaitez disposer pour exécuter votre application.
Avec la commande kubectl scale, vous spécifiez le nouveau nombre d'instances dupliquées en définissant l'option --replicas. Par exemple, pour procéder au scaling de l'objet my-app afin de le porter à quatre instances dupliquées, exécutez la commande suivante en remplaçant CONTROLLER par deployment, statefulset ou un autre type d'objet contrôleur :
kubectl scale CONTROLLER my-app --replicas 4
Si l'opération aboutit, la sortie de cette commande doit ressembler à ceci : deployment
"my-app" scaled.
Ensuite, exécutez la commande suivante :
kubectl get CONTROLLER my-app
Le résultat devrait ressembler à ce qui suit :
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
my-app 4 4 4 4 15m
kubectl patch
À partir de la version 1.33 de Kubernetes, vous pouvez utiliser la commande kubectl patch pour mettre à l'échelle verticalement votre charge de travail en mettant à jour les ressources attribuées à un conteneur, sans recréer le pod. Pour en savoir plus, y compris sur les limites, consultez la documentation Kubernetes sur le redimensionnement des ressources de processeur et de mémoire.
Pour utiliser la commande kubectl patch, spécifiez la demande de ressource mise à jour sous l'indicateur --patch. Par exemple, pour mettre à l'échelle my-app à 800 mCPUs, exécutez la commande suivante :
kubectl patch pod my-app --subresource resize --patch \
'{"spec":{"containers":[{"name":"pause", "resources":{"requests":{"cpu":"800m"}, "limits":{"cpu":"800m"}}}]}}'
kubectl apply
La commande kubectl apply permet d'appliquer un nouveau fichier de configuration à un objet contrôleur existant. kubectl
apply est utile pour apporter plusieurs modifications à une ressource, et convient tout particulièrement aux utilisateurs qui préfèrent gérer leurs ressources dans des fichiers de configuration.
Lorsque vous effectuez un scaling à l'aide de kubectl apply, le fichier de configuration que vous fournissez doit inclure un nouveau nombre d'instances dupliquées dans le champ replicas de la spécification de l'objet.
Voici une version mise à jour du fichier de configuration pour l'exemple d'objet my-app. Cet exemple présente un objet Deployment : si vous utilisez un autre type de contrôleur, tel qu'un objet StatefulSet, modifiez le champ kind en conséquence. Cet exemple fonctionne mieux sur un cluster comportant au moins trois nœuds.
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
replicas: 3
selector:
matchLabels:
app: app
template:
metadata:
labels:
app: app
spec:
containers:
- name: my-container
image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
Dans ce fichier, la valeur du champ replicas est 3. L'application de ce fichier de configuration fera évoluer l'objet my-app jusqu'à trois instances dupliquées.
Pour appliquer un fichier de configuration mis à jour, exécutez la commande suivante :
kubectl apply -f config.yaml
Ensuite, exécutez la commande suivante :
kubectl get CONTROLLER my-app
Le résultat devrait ressembler à ce qui suit :
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
my-app 3 3 3 3 15m
Console
Pour effectuer le scaling d'une charge de travail dans la console Google Cloud , procédez comme suit :
Accédez à la page Charges de travail dans la console Google Cloud .
Dans la liste des charges de travail, cliquez sur le nom de la charge de travail que vous souhaitez faire évoluer.
Cliquez sur listActions > Effectuer le scaling > Modifier les instances dupliquées
Saisissez le nouveau nombre d'instances dupliquées pour la charge de travail.
Cliquez sur Faire évoluer.
Activer l'autoscaling des déploiements
Vous pouvez activer l'autoscaling des déploiements en fonction de l'utilisation du processeur par les pods, à l'aide de la commande kubectl
autoscale ou à partir du menu "Charges de travail" de GKE dans la consoleGoogle Cloud .
kubectl autoscale
La commande kubectl autoscale crée un objet HorizontalPodAutoscaler (ou HPA) qui cible une ressource spécifiée (appelée objectif de scaling) et la fait évoluer si nécessaire. Le HPA ajuste périodiquement le nombre d'instances dupliquées de l'objectif de scaling de façon à respecter la valeur d'utilisation moyenne du processeur que vous spécifiez.
Lorsque vous exécutez la commande kubectl autoscale, vous spécifiez un nombre maximal et un nombre minimal d'instances dupliquées pour votre application, ainsi qu'un objectif d'utilisation du processeur. Par exemple, pour définir les nombres maximal et minimal d'instances dupliquées sur 6 et 4, avec un objectif d'utilisation du processeur de 50 %, exécutez la commande suivante :
kubectl autoscale deployment my-app --max 6 --min 4 --cpu-percent 50
Dans cette commande, l'option --max est obligatoire. L'option --cpu-percent correspond à l'objectif d'utilisation du processeur sur l'ensemble des pods. Cette commande ne fait pas évoluer immédiatement le déploiement jusqu'à six instances dupliquées, sauf en cas d'exigence systémique préalable.
Après l'exécution de la commande kubectl autoscale, l'objet HorizontalPodAutoscaler est créé et commence à cibler l'application. En cas de modification de la charge, cet objet augmente ou réduit le nombre d'instances dupliquées de l'application.
Pour obtenir la liste des objets HorizontalPodAutoscaler de votre cluster, exécutez la commande suivante :
kubectl get hpa
Pour afficher un objet HorizontalPodAutoscaler spécifique dans votre cluster, exécutez la commande suivante :
kubectl get hpa HPA_NAME
Remplacez HPA_NAME par le nom de votre objet HorizontalPodAutoscaler.
Pour afficher la configuration d'un objet HorizontalPodAutoscaler, procédez comme suit :
kubectl get hpa HPA_NAME -o yaml
La sortie de la commande ressemble à ceci :
apiVersion: v1
items:
- apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
creationTimestamp: ...
name: HPA_NAME
namespace: default
resourceVersion: "664"
selfLink: ...
uid: ...
spec:
maxReplicas: 10
minReplicas: 1
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: HPA_NAME
targetCPUUtilizationPercentage: 50
status:
currentReplicas: 0
desiredReplicas: 0
kind: List
metadata: {}
resourceVersion: ""
selfLink: ""
Dans cet exemple de sortie, le champ targetCPUUtilizationPercentage contient la valeur de pourcentage 50 spécifiée dans l'exemple concernant la commande kubectl autoscale.
Pour afficher une description détaillée d'un objet HorizontalPodAutoscaler spécifique du cluster, procédez comme suit :
kubectl describe hpa HPA_NAME
Vous pouvez modifier l'objet HorizontalPodAutoscaler en appliquant un nouveau fichier de configuration via la commande kubectl apply, ou en exécutant les commandes kubectl edit ou kubectl patch.
Pour supprimer un objet HorizontalPodAutoscaler, procédez comme suit :
kubectl delete hpa HPA_NAME
Console
Pour activer l'autoscaling d'un déploiement, procédez comme suit :
Accédez à la page Charges de travail dans la console Google Cloud .
Dans la liste des charges de travail, cliquez sur le nom du déploiement que vous souhaitez faire évoluer automatiquement.
Cliquez sur list Actions > Évoluer automatiquement.
Saisissez le nombre maximal d'instances dupliquées et, le cas échéant, le nombre minimal d'instances dupliquées du déploiement.
Sous Métriques d'autoscaling, sélectionnez et configurez les métriques selon vos besoins.
Cliquez sur Évoluer automatiquement.
Procéder à l'autoscaling avec des métriques personnalisées
Vous pouvez procéder au scaling de vos objets Déploiement en fonction de métriques personnalisées exportées à partir de Cloud Monitoring.
Pour apprendre à utiliser des métriques personnalisées afin de procéder à l'autoscaling de déploiements, consultez le tutoriel Autoscaling des déploiements avec des métriques personnalisées.