Contrôler les attributs de nœud avec autoscaling à l'aide de classes de calcul personnalisées

Cette page explique comment contrôler l'infrastructure de calcul et le comportement d'autoscaling des clusters Google Kubernetes Engine (GKE) en fonction des besoins spécifiques de vos charges de travail à l'aide de classes de calcul personnalisées. Vous devez déjà bien connaître le concept de classes de calcul personnalisées. Pour en savoir plus, consultez la section À propos des classes de calcul personnalisées.

Cette page s'adresse aux administrateurs de plate-forme qui souhaitent définir de manière déclarative des profils d'auto-scaling pour les nœuds, et aux opérateurs de clusters qui souhaitent exécuter leurs charges de travail sur des classes de calcul spécifiques.

À propos des classes de calcul personnalisées

Les classes de calcul personnalisées sont des ressources personnalisées Kubernetes qui vous permettent de définir les priorités à suivre par GKE lors du provisionnement des nœuds pour exécuter vos charges de travail. Vous pouvez utiliser une classe de calcul personnalisée pour effectuer les opérations suivantes :

  • Indiquez à GKE un ensemble de priorités à suivre de manière séquentielle lors du provisionnement de nœuds, chacun avec des paramètres spécifiques tels qu'une série de machines Compute Engine ou une capacité de ressources minimale.
  • Définir des seuils et des paramètres d'autoscaling pour supprimer les nœuds sous-utilisés et consolider efficacement les charges de travail sur la capacité de calcul existante
  • Indiquez à GKE de remplacer automatiquement les configurations de nœuds "moins préférées" par des configurations de nœuds "plus préférées" pour des performances de charge de travail optimales.

Pour comprendre toutes les options de configuration et leur interaction avec les modes GKE Autopilot et GKE Standard, consultez la page À propos des classes de calcul personnalisées.

Tarifs

La ressource personnalisée ComputeClass est fournie sans frais supplémentaires dans GKE. Les considérations tarifaires suivantes s'appliquent :

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.

Exemple de scénario pour les classes de calcul

Cette page présente un exemple de scénario pour lequel vous définissez une classe de calcul personnalisée. En pratique, vous devez tenir compte des exigences spécifiques de vos charges de travail et de votre organisation, et définir des classes de calcul qui répondent à ces exigences. Pour obtenir une description complète des options des classes de calcul et des informations spécifiques, consultez la page À propos des classes de calcul personnalisées.

Considérons par exemple le scénario suivant :

  • Votre objectif est d'optimiser les coûts de fonctionnement de vos charges de travail.
  • Vos charges de travail sont tolérantes aux pannes et ne nécessitent ni arrêt progressif, ni exécution prolongée.
  • Vos charges de travail nécessitent au moins 64 vCPU pour fonctionner de manière optimale
  • Vous êtes limité à la série de machines N2 Compute Engine

Sur la base de l'exemple de scénario, vous décidez que vous souhaitez une classe de calcul effectuant les opérations suivantes :

  • Donne la priorité aux nœuds Spot N2 disposant d'au moins 64 processeurs virtuels
  • Permet à GKE de revenir à n'importe quel nœud Spot N2, quelle que soit la capacité de calcul
  • Si aucun nœud Spot N2 n'est disponible, permet à GKE d'utiliser des nœuds N2 à la demande
  • Indique à GKE de déplacer vos charges de travail vers des nœuds Spot chaque fois qu'ils sont à nouveau disponibles.

Configurer une classe de calcul en mode Autopilot

Dans GKE Autopilot, vous définissez une classe de calcul, la déployez sur le cluster et interrogez cette classe de calcul dans vos charges de travail. GKE effectue toutes les étapes de configuration des nœuds, comme l'application de libellés et de rejets, à votre place.

Enregistrez le manifeste suivant sous le nom compute-class.yaml :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Configurer une classe de calcul en mode Standard

Dans les clusters en mode GKE Standard, vous devez définir une classe de calcul, après quoi vous devrez peut-être effectuer une configuration manuelle pour vous assurer que les pods de votre classe de calcul sont planifiés comme prévu. La configuration manuelle varie selon que vos pools de nœuds sont automatiquement provisionnés ou non, comme suit :

  • Pools de nœuds gérés par provisionnement automatique des nœuds : aucune configuration manuelle n'est requise. Le provisionnement automatique des nœuds effectue automatiquement les étapes de configuration de la classe de calcul. Pour en savoir plus, consultez la page Provisionnement automatique des nœuds et classes de calcul.
  • Pools de nœuds créés manuellement : une configuration manuelle est requise. Vous devez ajouter des libellés et des rejets de nœuds à vos pools de nœuds créés manuellement pour associer les nœuds à une classe de calcul spécifique. Pour en savoir plus, consultez la page Configurer des pools de nœuds créés manuellement pour une classe de calcul.

Utiliser des classes de calcul avec des pools de nœuds créés manuellement

Cette section explique comment définir une classe de calcul dans un cluster qui n'utilise que des pools de nœuds créés manuellement.

  1. Enregistrez le manifeste suivant sous le nom compute-class.yaml :

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true

  2. Créez un pool de nœuds à l'échelle automatique qui utilise des VM Spot et associez-le à la classe de calcul :

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-standard-64 \
    --spot \
    --enable-autoscaling \
    --max-nodes=9 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

    Remplacez les éléments suivants :

    • LOCATION : emplacement de votre cluster.
    • CLUSTER_NAME : nom de votre cluster existant.

  3. Créez un pool de nœuds avec autoscaling avec des VM à la demande et associez-le à la classe de calcul :

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-standard-64 \
    --enable-autoscaling \
    --max-nodes=9 \
    --num-nodes=0 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

Lorsque vous déployez des pods qui nécessitent cette classe de calcul et que de nouveaux nœuds doivent être créés, GKE donne la priorité à la création de nœuds dans le pool de nœuds cost-optimized-pool. Si aucun nouveau nœud ne peut être créé, GKE en crée dans le pool de nœuds on-demand-pool.

Pour en savoir plus sur la manière dont les pools de nœuds créés manuellement interagissent avec les classes de calcul personnalisées, consultez la page Configurer des pools de nœuds créés manuellement pour l'utilisation des classes de calcul.

Utiliser des classes de calcul avec des pools de nœuds provisionnés automatiquement

Cette section explique comment définir une classe de calcul dans un cluster qui utilise le provisionnement automatique des nœuds.

Enregistrez le manifeste suivant sous le nom compute-class.yaml :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Lorsque vous déployez des pods qui nécessitent cette classe de calcul et que de nouveaux nœuds doivent être créés, GKE donne la priorité à la création de nœuds dans les éléments de l'ordre du champ priorities. Si nécessaire, GKE crée des pools de nœuds qui répondent aux exigences matérielles de la classe de calcul.

Pour en savoir plus sur le fonctionnement du provisionnement automatique des nœuds avec des classes de calcul personnalisées, consultez la section Provisionnement automatique des nœuds et classes de calcul.

Personnaliser les seuils d'autoscaling pour la consolidation des nœuds

Par défaut, GKE supprime les nœuds sous-utilisés et replanifie vos charges de travail sur d'autres nœuds disponibles. Vous pouvez personnaliser davantage les seuils et le délai au bout duquel un nœud peut être supprimé à l'aide du champ autoscalingPolicy dans la définition de la classe de calcul, comme dans l'exemple suivant :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  autoscalingPolicy:
    consolidationDelayMinutes : 5
    consolidationThreshold    : 70

Dans cet exemple, un nœud peut être supprimé s'il n'utilise pas 70 % de sa capacité de processeur et de mémoire disponible pendant plus de cinq minutes. Pour obtenir la liste des paramètres disponibles, consultez la section Définir les paramètres d'autoscaling pour le regroupement des nœuds.

Déployer une classe de calcul dans un cluster

Après avoir défini une classe de calcul, déployez-la sur le cluster :

kubectl apply -f compute-class.yaml

Cette classe de calcul est prête à être utilisée dans le cluster . Vous pouvez demander la classe de calcul dans les spécifications du pod ou, si vous le souhaitez, la définir comme classe de calcul par défaut dans un espace de noms spécifique.

Définir une classe de calcul par défaut pour un espace de noms

Lorsque vous définissez une classe de calcul par défaut pour un espace de noms, GKE utilise cette classe de calcul pour créer des nœuds pour tous les pods que vous déployez dans cet espace de noms. Si un pod demande explicitement une classe de calcul différente, la requête au niveau du pod remplace la valeur par défaut de l'espace de noms.

Pour définir une classe de calcul comme classe de calcul par défaut pour un espace de noms spécifique, procédez comme suit :

  1. Créez un espace de noms :

    kubectl create namespace cost-optimized-ns

  2. Étiquetez l'espace de noms avec la classe de calcul :

    kubectl label namespaces cost-optimized-ns \
    cloud.google.com/default-compute-class=cost-optimized

Demander une classe de calcul dans une charge de travail

Pour demander une classe de calcul dans une charge de travail, ajoutez un sélecteur de nœud pour cette classe de calcul dans le fichier manifeste.

  1. Enregistrez le manifeste suivant sous le nom cc-workload.yaml :

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: custom-workload
spec:
  replicas: 2
  selector:
    matchLabels:
      app: custom-workload
  template:
    metadata:
      labels:
        app: custom-workload
    spec:
      nodeSelector:
        cloud.google.com/compute-class: cost-optimized
      containers:
      - name: test
        image: gcr.io/google_containers/pause
        resources:
          requests:
            cpu: 1.5
            memory: "4Gi"

  2. Déployer la charge de travail :

    kubectl apply -f cc-workload.yaml

Lorsque vous déployez cette charge de travail, GKE ajoute automatiquement une tolérance aux pods correspondant au rejet de nœud de la classe de calcul demandée. Cette tolérance garantit que seuls les pods qui demandent la classe de calcul s'exécutent sur les nœuds de la classe de calcul.

Étape suivante