Déployer un autoscaler de cluster auto-hébergé

Ce document explique comment désactiver l'autoscaler de cluster géré par Google Kubernetes Engine (GKE) et déployer un autoscaler de cluster auto-hébergé dans votre cluster Standard à l'aide de Helm. Le déploiement d'un autoscaler de cluster auto-hébergé vous permet de personnaliser les options d'autoscaling, de tester des paramètres expérimentaux ou d'exécuter des builds personnalisés à partir du dépôt d'autoscaler de cluster GKE Open Source.

Ce document est destiné aux administrateurs de plate-forme qui gèrent le scaling et l'infrastructure des clusters, et qui ont besoin d'un contrôle précis des paramètres de l'autoscaler, au-delà de ce que fournit l'autoscaler de cluster géré par GKE.

Conditions requises et limites

  • Un autoscaler de cluster auto-hébergé n'est compatible qu'avec les clusters GKE Standard exécutant la version 1.37.2-gke.1042000 ou une version ultérieure.
  • Un autoscaler de cluster auto-hébergé n'est pas compatible avec les clusters Autopilot, les clusters Standard contenant des pools de nœuds gérés par Autopilot ou les clusters Standard utilisant le mode Autopilot pour les ComputeClasses.
  • Votre cluster doit comporter au moins un nœud de calcul en cours d'exécution à tout moment pour héberger le pod de l'autoscaler de cluster auto-hébergé. Un cluster qui exécute un autoscaler de cluster auto-hébergé ne peut pas effectuer un scaling à la baisse jusqu'à zéro nœud au total.
  • Vous êtes responsable du déploiement, de la mise à jour et de la surveillance de la charge de travail de l'autoscaler de cluster auto-hébergé. Cloud Customer Care ne résout pas les problèmes liés aux déploiements d'autoscaler de cluster auto-hébergés ou personnalisés. Pour bénéficier de l'assistance de Customer Care pour les problèmes d'autoscaling, revenez à l'autoscaler de cluster géré par GKE.
  • Si l'autoscaling géré par GKE est désactivé, GKE n'émet pas d'événements de visibilité de l'autoscaler de cluster du plan de contrôle vers le flux de journaux container.googleapis.com/cluster-autoscaler-visibility. Consultez plutôt les journaux et les métriques de scaling directement à partir du pod de l'autoscaler de cluster autohébergé.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
  • Activer l'API Google Kubernetes Engine
  • Pour utiliser la Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Rôles requis

Pour obtenir les autorisations nécessaires pour désactiver l'autoscaling géré, configurer les ressources Identity and Access Management (IAM) et déployer l'autoscaler de cluster autohébergé, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Désactiver l'autoscaler de cluster géré par GKE

Avant de déployer un autoscaler de cluster auto-hébergé, vous devez désactiver l'autoscaler de cluster géré par GKE dans le plan de contrôle pour éviter les conditions de concurrence entre les deux instances d'autoscaler. La désactivation de l'autoscaler de cluster géré par GKE empêche le plan de contrôle de faire évoluer les nœuds. Toutefois, GKE conserve vos configurations d'autoscaling de pool de nœuds et vos ComputeClasses existantes afin que l'autoscaler de cluster auto-hébergé puisse agir sur celles-ci.

Pour désactiver l'autoscaler de cluster géré par GKE, procédez comme suit :

  • Pour désactiver l'autoscaler de cluster géré par GKE sur un cluster Standard existant, exécutez la commande suivante :

    gcloud beta container clusters update CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --disable-managed-autoscaling
    

    Si la fédération d'identité de charge de travail pour GKE n'est pas déjà activée sur le cluster et sur au moins un pool de nœuds pour héberger le pod de l'autoscaler de cluster auto-hébergé, exécutez les commandes suivantes :

    gcloud container clusters update CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --workload-pool=PROJECT_ID.svc.id.goog
    gcloud container node-pools update NODEPOOL_NAME \
        --cluster=CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --workload-metadata=GKE_METADATA
        ```
    
  • Pour créer un cluster Standard avec l'autoscaler de cluster géré par GKE déjà désactivé, exécutez la commande suivante :

    gcloud beta container clusters create CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --cluster-version=CLUSTER_VERSION \
        --workload-pool=PROJECT_ID.svc.id.goog \
        --disable-managed-autoscaling
    

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom de votre cluster Standard.
  • CONTROL_PLANE_LOCATION : région ou zone Compute Engine du plan de contrôle de votre cluster. Indiquez une région pour les clusters régionaux ou une zone pour les clusters zonaux.
  • PROJECT_ID : ID de votre projet Google Cloud .
  • NODEPOOL_NAME : nom d'un pool de nœuds existant pour héberger le pod de l'autoscaler de cluster auto-hébergé.
  • CLUSTER_VERSION : version de GKE pour le nouveau cluster, qui doit être 1.37.2-gke.1042000 ou ultérieure.

Pour vérifier que l'autoscaler de cluster géré par GKE est désactivé sur votre cluster, exécutez la commande suivante :

gcloud beta container clusters describe CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --format="value(autoscaling.managedAutoscalingDisabled)"

Le résultat est True.

Configurer les autorisations IAM pour l'autoscaler de cluster auto-hébergé

L'autoscaler de cluster auto-hébergé nécessite des autorisations IAM pour gérer les groupes d'instances Compute Engine et lire les métadonnées de cluster dans votre projet.

Accordez ces autorisations à l'autoscaler en créant un rôle IAM personnalisé suivant le principe du moindre privilège et en l'associant au compte de service Kubernetes de l'autoscaler avec Workload Identity Federation for GKE :

  1. Récupérez votre numéro de projet :

    gcloud projects describe PROJECT_ID \
        --format="value(projectNumber)"
    

    Enregistrez la valeur de sortie en tant que PROJECT_NUMBER pour l'utiliser lors des étapes suivantes.

  2. Enregistrez la définition de rôle IAM personnalisée suivante dans un fichier gcp-role.yaml :

    title: Self Hosted Cluster Autoscaler Role
    description: Least privilege role for self-hosted CA to manage GKE clusters
    stage: BETA
    includedPermissions:
    - compute.acceleratorTypes.list
    - compute.instanceGroupManagers.get
    - compute.instanceGroupManagers.list
    - compute.instanceGroupManagers.update
    - compute.instanceTemplates.get
    - compute.instances.delete
    - compute.instances.get
    - compute.instances.list
    - compute.instances.setMetadata
    - compute.machineTypes.get
    - compute.machineTypes.list
    - compute.regions.get
    - compute.regions.list
    - compute.reservations.list
    - compute.resourcePolicies.list
    - compute.zoneOperations.get
    - compute.zones.get
    - compute.zones.list
    - container.clusters.get
    - container.clusters.update
    - container.operations.get
  3. Créez le rôle IAM personnalisé selfHostedClusterAutoscaler dans votre projet :

    gcloud iam roles create selfHostedClusterAutoscaler \
        --project=PROJECT_ID \
        --file=gcp-role.yaml
    
  4. Créez un compte de service IAM nommé selfhosted-autoscaler :

    gcloud iam service-accounts create selfhosted-autoscaler \
        --project=PROJECT_ID
    
  5. Attribuez le rôle IAM personnalisé au compte de service IAM selfhosted-autoscaler :

    gcloud projects add-iam-policy-binding PROJECT_ID \
        --member="serviceAccount:selfhosted-autoscaler@PROJECT_ID.iam.gserviceaccount.com" \
        --role="projects/PROJECT_ID/roles/selfHostedClusterAutoscaler"
    
  6. Si votre cluster utilise le provisionnement automatique des nœuds ou des ComputeClasses personnalisées pour créer des pools de nœuds, attribuez le rôle Utilisateur du compte de service (roles/iam.serviceAccountUser) au compte de service selfhosted-autoscaler. Exécutez la commande suivante pour chaque compte de service IAM utilisé par vos nouveaux nœuds :

    gcloud iam service-accounts add-iam-policy-binding NODE_SA_EMAIL \
        --project=PROJECT_ID \
        --role="roles/iam.serviceAccountUser" \
        --member="serviceAccount:selfhosted-autoscaler@PROJECT_ID.iam.gserviceaccount.com"
    

    Remplacez NODE_SA_EMAIL par l'adresse e-mail du compte de service IAM utilisé par vos nœuds. Attribuez ce rôle au compte de service par défaut du provisionnement automatique des nœuds et à tout compte de service que vous spécifiez dans une ComputeClass. Sauf si vous configurez un compte de service personnalisé, le provisionnement automatique des nœuds utilise le compte de service Compute Engine par défaut, PROJECT_NUMBER-compute@developer.gserviceaccount.com.

  7. Autorisez le compte de service Kubernetes selfhosted-autoscaler dans l'espace de noms kube-system à emprunter l'identité du compte de service IAM :

    gcloud iam service-accounts add-iam-policy-binding selfhosted-autoscaler@PROJECT_ID.iam.gserviceaccount.com \
        --project=PROJECT_ID \
        --role="roles/iam.workloadIdentityUser" \
        --member="serviceAccount:PROJECT_ID.svc.id.goog[kube-system/selfhosted-autoscaler]"
    

Déployer l'autoscaler de cluster autohébergé à l'aide de Helm

Déployez l'autoscaler de cluster autohébergé à l'aide du chart Helm dans le répertoire charts/cluster-autoscaler du dépôt de l'autoscaler de cluster GKE Open Source :

  1. Récupérez l'ID de votre cluster :

    gcloud container clusters describe CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --project=PROJECT_ID \
        --format="value(id)"
    

    Enregistrez la valeur de sortie en tant que CLUSTER_ID pour le fichier de configuration Helm.

  2. Clonez le dépôt de l'autoscaler de cluster GKE :

    git clone https://github.com/GoogleCloudPlatform/cluster-autoscaler.git
    
  3. Créez et transférez l'image de conteneur de l'autoscaler de cluster vers votre registre de conteneurs :

    cd cluster-autoscaler
    make release \
        REGISTRY=REGISTRY_PATH \
        TAG=IMAGE_TAG
    

    Remplacez les éléments suivants :

    • REGISTRY_PATH : chemin d'accès de base de votre registre de conteneurs, par exemple LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY. La commande make release crée et transfère l'image vers REGISTRY_PATH/cluster-autoscaler:IMAGE_TAG.
    • IMAGE_TAG : tag de votre image de conteneur, par exemple 37.234.0.

    Pour en savoir plus sur la création de l'image de conteneur, consultez le dépôt de l'autoscaler de cluster GKE.

  4. Accédez au répertoire du chart Helm :

    cd charts/cluster-autoscaler
    
  5. Créez un fichier my-values.yaml pour configurer l'identité de votre cluster, le compte de service de la fédération d'identité de charge de travail pour GKE et les paramètres de l'autoscaler :

    image:
      repository: "REGISTRY_PATH/cluster-autoscaler"
      tag: "IMAGE_TAG"
    
    cluster:
      name: "CLUSTER_NAME"
      hash: "CLUSTER_ID"
      projectNumber: "PROJECT_NUMBER"
      location: "CONTROL_PLANE_LOCATION"
      regional: IS_REGIONAL
    
    nodeSelector:
      iam.gke.io/gke-metadata-server-enabled: "true"
    
    serviceAccount:
      name: "selfhosted-autoscaler"
      gcpWorkloadIdentity: "selfhosted-autoscaler@PROJECT_ID.iam.gserviceaccount.com"
    
    config:
      autoscalingProfile: AUTOSCALING_PROFILE
    

    Remplacez les éléments suivants :

    • REGISTRY_PATH : chemin d'accès de base de votre registre de conteneurs d'une étape précédente, par exemple LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY.
    • IMAGE_TAG : tag de l'image de conteneur que vous avez transférée à l'étape précédente, par exemple 37.234.0. Si vous omettez le champ image.tag, le chart Helm utilise par défaut la valeur appVersion que vous avez définie lors de l'empaquetage du chart.
    • CLUSTER_ID : ID du cluster que vous avez récupéré lors d'une étape précédente.
    • PROJECT_NUMBER : numéro de projet que vous avez récupéré lors d'une étape précédente.
    • IS_REGIONAL : true si votre cluster est régional, ou false si votre cluster est zonal.
    • AUTOSCALING_PROFILE : profil d'autoscaling à appliquer. Spécifiez le profil default pour un scaling équilibré ou le profil optimizeUtilization pour réduire la capacité des nœuds sous-utilisés de manière plus agressive. Pour obtenir la liste complète des options et paramètres configurables, consultez le fichier values.yaml par défaut sur GitHub.
  6. Empaquetez le chart Helm avec la version du composant d'autoscaler de cluster que vous souhaitez exécuter, puis installez le chart dans l'espace de noms kube-system :

    helm package \
        --version=CA_VERSION \
        --app-version=CA_VERSION .
    helm upgrade --install selfhosted-ca \
        cluster-autoscaler-CA_VERSION.tgz \
        --namespace=kube-system \
        -f my-values.yaml
    

    Remplacez CA_VERSION par la version du composant d'autoscaler de cluster au format <minor>.<ca-version>.<patch>, par exemple 37.234.0. Le graphique utilise cette version pour déterminer les tests d'autoscaler à activer à partir du fichier values.yaml.

Vérifier le déploiement de l'autoscaler de cluster auto-hébergé

Après avoir installé le chart Helm, vérifiez que le pod de l'autoscaler de cluster auto-hébergé est en cours d'exécution et qu'il surveille activement votre cluster :

  1. Vérifiez que le pod de l'autoscaler de cluster auto-hébergé est à l'état Running :

    kubectl get pods -n kube-system \
        -l app.kubernetes.io/instance=selfhosted-ca
    

    Le résultat ressemble à ce qui suit :

    NAME                                                READY   STATUS    RESTARTS   AGE
    selfhosted-ca-cluster-autoscaler-6d4b7c9f8b-x9v2k   1/1     Running   0          2m
    
  2. Inspectez les journaux du pod de l'autoscaler de cluster auto-hébergé pour vérifier qu'il démarre sans erreur d'authentification :

    kubectl logs -n kube-system \
        -l app.kubernetes.io/instance=selfhosted-ca \
        --tail=50
    
  3. Vérifiez le ConfigMap cluster-autoscaler-status pour afficher l'état actuel du scaling signalé par l'autoscaler :

    kubectl get configmap cluster-autoscaler-status \
        -n kube-system -o yaml
    

Revenir à l'autoscaler de cluster géré par GKE

Pour revenir à l'autoscaler de cluster géré par GKE, supprimez votre déploiement auto-hébergé avant de réactiver l'autoscaling géré dans le plan de contrôle :

  1. Désinstallez la version Helm de l'autoscaler de cluster auto-hébergé :

    helm uninstall selfhosted-ca --namespace=kube-system
    
  2. Réactivez l'autoscaler de cluster géré par GKE sur votre cluster :

    gcloud beta container clusters update CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --enable-managed-autoscaling
    
  3. Vérifiez que l'autoscaler de cluster géré par GKE est activé :

    gcloud beta container clusters describe CLUSTER_NAME \
        --location=CONTROL_PLANE_LOCATION \
        --format="value(autoscaling.managedAutoscalingDisabled)"
    

    Le résultat est vide ou False.

Étapes suivantes