Optimiser les performances des pods Autopilot en choisissant une série de machines

Cette page explique comment placer des charges de travail sur des séries de machines Compute Engine spécifiques pour optimiser les performances de vos charges de travail dans vos clusters Google Kubernetes Engine (GKE) Autopilot.

Assurez-vous de connaître les points suivants :

Fonctionnement de la sélection de la série de machines

Vous pouvez ajouter un sélecteur de nœud cloud.google.com/machine-family à la spécification de votre pod pour qu'Autopilot alloue du matériel Compute Engine spécifique à ce pod. Par exemple, vous pouvez choisir la série de machines C3 pour les pods qui ont besoin de plus de puissance de processeur, ou la série de machines N1 pour les pods qui ont besoin de plus de mémoire. Autopilot provisionne l'un des types de machines prédéfinis de la série de machines sélectionnée pour exécuter votre charge de travail de manière optimale.

En plus d'optimiser les performances des pods, le choix d'une série de machines spécifique offre les avantages suivants :

  • Utilisation efficace des nœuds : par défaut, Autopilot optimise l'utilisation des ressources de nœud en programmant autant de pods que possible qui demandent la même série de machines sur chaque nœud. Cette approche optimise l'utilisation des ressources sur le nœud, ce qui améliore le rapport prix/performances. Si votre charge de travail doit accéder à toutes les ressources du nœud, vous pouvez éventuellement configurer votre charge de travail pour qu'elle demande un pod pour chaque nœud.

  • Charges de travail extensibles : vous pouvez configurer des pods pour qu'ils exploitent la capacité de ressources inutilisée sur le nœud en définissant des limites de ressources supérieures à vos demandes. Pour en savoir plus, consultez la page Configurer l'utilisation intensive des pods dans GKE.

Demander un nœud dédié pour chaque pod

Si vous avez des charges de travail gourmandes en processeur qui nécessitent un accès fiable à toutes les ressources du nœud, vous pouvez configurer votre pod pour qu'Autopilot place un pod qui demande une série de machines sur son propre nœud.

Les nœuds dédiés par pod sont recommandés lorsque vous exécutez des charges de travail à grande échelle et gourmandes en ressources de processeur, telles que des charges de travail d'entraînement de l'IA/ML ou des charges de travail de calcul hautes performances (HPC) par lot.

Choisir entre la planification de plusieurs pods et la planification d'un seul pod

Suivez les conseils ci-dessous pour choisir un comportement de planification des pods en fonction de vos besoins :

Tarifs

La VM sous-jacente et tout le matériel associé vous sont facturés par Compute Engine, avec un supplément pour la gestion et l'évolutivité des nœuds Autopilot. Pour en savoir plus, consultez la page Tarifs de GKE.

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.
  • Assurez-vous de disposer d'un cluster Autopilot existant exécutant la version 1.30.1-gke.1396000 ou ultérieure. Pour créer un cluster, consultez la page Créer un cluster Autopilot.

Sélectionner une série de machines

Cette section explique comment sélectionner une série de machines Compute Engine spécifique dans un pod.

  1. Enregistrez le manifeste suivant sous le nom machine-series-pod.yaml :

    apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 5
        memory: "25Gi"
      limits:
        cpu: 20
        memory: 100Gi

    Remplacez MACHINE_SERIES par la série de machines Compute Engine pour votre pod, par exemple c3. Pour connaître les valeurs acceptées, consultez la section Série de machines compatible dans cette page.

  2. Déployez le pod :

    kubectl apply -f machine-series-pod.yaml

Ce fichier manifeste permet à Autopilot d'optimiser l'utilisation des ressources du nœud en planifiant efficacement d'autres pods qui sélectionnent la même série de machines sur le même nœud si la capacité est disponible.

Utiliser des disques SSD locaux

Les pods qui sélectionnent une série de machines peuvent utiliser des SSD locaux pour le stockage éphémère si vous spécifiez une série de machines qui propose des SSD locaux. Autopilot prend en compte les demandes de stockage éphémères lors du choix d'un type de machine Compute Engine pour le pod.

  1. Enregistrez le manifeste suivant sous le nom local-ssd-pod.yaml :

      apiVersion: v1
  kind: Pod
metadata:
  name: local-ssd-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
    cloud.google.com/gke-ephemeral-storage-local-ssd: "true"
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 6
        memory: "25Gi"
        ephemeral: "100Gi"
      limits:
        cpu: 12
        memory: "50Gi"
        ephemeral: "200Gi"

    Remplacez MACHINE_SERIES par une série de machines compatible qui accepte également les disques SSD locaux. Si la série de machines spécifiée n'est pas compatible avec les disques SSD locaux, le déploiement échoue avec une erreur.

  2. Déployez le pod :

    kubectl apply -f local-ssd-pod.yaml

Demander un nœud dédié pour un pod

Si votre pod présente des exigences de performances spécifiques, comme un accès fiable à toutes les ressources de votre nœud, vous pouvez demander un nœud dédié pour chaque pod en spécifiant le sélecteur de nœuds cloud.google.com/compute-class: Performance avec le sélecteur de nœuds de votre série de machines. Cela indique à Autopilot de placer votre pod sur un nouveau nœud qui utilise la série de machines spécifiée et qui est dédié à ce pod. Ce sélecteur de nœud empêche également Autopilot de planifier d'autres pods sur ce nœud.

  1. Enregistrez le manifeste suivant sous le nom dedicated-node-pod.yaml :

    apiVersion: v1
kind: Pod
metadata:
  name: dedicated-node-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
    cloud.google.com/compute-class: Performance
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        cpu: 12
        memory: "50Gi"
        ephemeral: "200Gi"

    Remplacez MACHINE_SERIES par une série de machines compatible qui accepte également la planification d'un Pod par nœud. Si la série de machines spécifiée n'est pas compatible avec la planification d'un pod par nœud, le déploiement échoue et une erreur s'affiche.

  2. Déployez le pod :

    kubectl apply -f dedicated-node-pod.yaml

Lorsque vous déployez ce fichier manifeste, Autopilot effectue les opérations suivantes :

  • Garantit que le pod déployé demande au moins les ressources minimales pour le nœud optimisé pour les performances.
  • Calcule le nombre total de demandes de ressources pour le pod déployé et les DaemonSets du cluster.
  • Provisionne un nœud sauvegardé par la série de machines sélectionnée.
  • Modifie le fichier manifeste du pod avec une combinaison de sélecteurs de nœuds et de tolérances pour garantir que le pod s'exécute sur son propre nœud.

Série de machines compatible

Le sélecteur machine-family est compatible avec les séries de machines suivantes :

(toujours groupé)

Pour comparer ces séries de machines et leurs cas d'utilisation, consultez la section Comparaison des séries de machines dans la documentation Compute Engine.

Compatibilité avec d'autres fonctionnalités de GKE

Vous pouvez utiliser des pods qui sélectionnent des séries de machines avec les fonctionnalités et capacités GKE suivantes :

Les pods Spot et les pods avec une durée d'exécution étendue s'excluent mutuellement. GKE n'applique pas de demandes de ressources minimales plus élevées pour les pods dédiés par nœud, même s'ils utilisent la séparation des charges de travail.

Comment GKE sélectionne un type de machine

Pour sélectionner un type de machine dans la série de machines spécifiée, GKE calcule le total des demandes de processeur, de mémoire et de stockage éphémère des pods et des DaemonSets qui seront exécutés sur le nouveau nœud. GKE arrondit ces valeurs au type de machine Compute Engine disponible le plus proche compatible avec tous ces totaux.

  • Exemple 1 : Prenons l'exemple d'un déploiement avec quatre instances répliquées qui sélectionne la série de machines C3D. Vous ne demandez pas de nœuds dédiés par pod. Les requêtes de ressources de chaque instance répliquée sont les suivantes :

    • 500m vCPU
    • 1 Gio de mémoire

    Autopilot place tous les pods sur un nœud sauvegardé par le type de machine c3d-standard-4, qui dispose de 4 vCPU et de 16 Go de mémoire.

  • Exemple 2 : Prenons l'exemple d'un pod qui sélectionne la série de machines C3D et les disques SSD locaux pour le stockage éphémère. Vous demandez un nœud dédié pour le pod. Le nombre total de demandes de ressources, en incluant les objets DaemonSet, est le suivant :

    • 12 vCPU
    • 50 Gio de mémoire
    • 200 Gio d'espace de stockage éphémère

    GKE place le pod sur un nœud qui utilise le type de machine c3d-standard-16-lssd, qui dispose de 16 vCPU, 64 Gio de mémoire et 365 Gio de capacité SSD locale.

Étape suivante