Procéder au scaling d'une application

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. Le scaling d'une application consiste à augmenter ou diminuer ce nombre d'instances dupliquées.

Chaque instance dupliquée de votre application représente un pod Kubernetes qui encapsule le ou les conteneurs de votre application.

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.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

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 :

NAME répertorie les noms des objets Deployment présents dans le cluster.
DESIRED affiche 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.
CURRENT affiche le nombre d'instances dupliquées en cours d'exécution.
UP-TO-DATE affiche le nombre d'instances dupliquées qui ont été mises à jour pour atteindre l'état souhaité.
AVAILABLE indique le nombre d'instances dupliquées de l'application qui sont disponibles pour vos utilisateurs.
AGE affiche 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 pods
```
Supprimez 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 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.

Accéder à la page Charges de travail
Dans la liste des charges de travail, cliquez sur le nom de la charge de travail que vous souhaitez faire évoluer.
Cliquez sur Actions > 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 console Google 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.

Accéder à la page Charges de travail
Dans la liste des charges de travail, cliquez sur le nom du déploiement que vous souhaitez faire évoluer automatiquement.
Cliquez sur 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.

Étapes suivantes

Découvrez comment exposer votre application en externe.