Exécuter des charges de travail intensives de processeur avec des performances optimales

Cette page explique comment optimiser les performances des charges de travail intensives de processeur en utilisant des nœuds dédiés pour chaque pod où Google Kubernetes Engine (GKE) place chaque pod sur son propre nœud, avec un accès complet à toutes les ressources du nœud. Pour utiliser ce modèle d'emplacement de pod, demandez la classe de calcul Performance dans vos charges de travail Autopilot.

Avantages de la classe de calcul des performances

Les nœuds dédiés par pod sont parfaits lorsque vous exécutez des charges de travail à grande échelle et gourmandes en ressources de processeur qui peuvent avoir besoin d'accéder à des fonctionnalités de la machine virtuelle (VM) sous-jacente. Par exemple, des charges de travail d'entraînement AI/ML nécessitant une utilisation intensive des processeurs ou des charges de travail par lot hautes performances (HPC).

Les pods sur ces nœuds dédiés présentent les avantages suivants :

  • Performances prévisibles : accédez à toutes les ressources de nœud à tout moment.
  • Charges de travail extensibles : si vous ne définissez pas de limites de ressources dans vos fichiers manifestes, vos pods de classe Performance peuvent utiliser soudainement toute la capacité inutilisée sur le nœud avec un risque minimal de pression d'éviction de nœud Kubernetes.

Fonctionnement des pods de la classe Performance

Vous déployez un pod présentant les caractéristiques suivantes :

  • Sélectionne la classe Performance et une série de machines Compute Engine.
  • Spécifie les demandes de ressources et, dans l'idéal, ne spécifie pas de limites de ressources.

GKE effectue les opérations suivantes :

  • Garantit que le pod déployé demande au moins les ressources minimales pour la classe de calcul.
  • 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.

Compatibilité avec d'autres fonctionnalités de GKE

Vous pouvez utiliser les pods de la classe Performance avec les fonctionnalités suivantes de GKE :

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 de classe Performance qui utilisent la séparation des charges de travail.

Tarification

Votre pod peut utiliser à tout moment l'intégralité de la VM sous-jacente ainsi que tout le matériel associé. Vous êtes facturé par Compute Engine pour ce matériel, 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 initialize 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.

Vous connecter à votre cluster

Utilisez Google Cloud CLI pour vous connecter à votre cluster Autopilot :

gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom du cluster
  • LOCATION : emplacement Compute Engine du cluster.

Déployer un pod de classe Performance

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

    apiVersion: v1
kind: Pod
metadata:
  name: performance-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: Performance
    cloud.google.com/machine-family: MACHINE_SERIES
  containers:
  - name: my-container
    image: "k8s.gcr.io/pause"
    resources:
      requests:
        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 Série de machines compatible dans ce document.

  2. Déployez le pod :

    kubectl apply -f perf-class-pod.yaml

Utiliser des disques SSD locaux dans des pods de classe Performance

Les pods de classe Performance peuvent utiliser des disques SSD locaux pour le stockage éphémère si vous sélectionnez une série de machines incluant un disque SSD local. GKE prend en compte les requêtes de stockage éphémère lors du provisionnement d'un nœud pour le pod de la classe Performance.

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

    apiVersion: v1
kind: Pod
metadata:
  name: performance-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: Performance
    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: 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 perf-class-pod.yaml

Série de machines compatible

La classe de calcul des performances est compatible avec les séries de machines suivantes :

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.

Comment GKE sélectionne une taille de machine

Pour sélectionner une taille 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 du pod de la classe Performance 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 pod de la classe Performance qui sélectionne la série de machines C3. Le nombre total de demandes de ressources, en incluant les objets DaemonSet, est le suivant :

    • 70 vCPU
    • 200 Gio de mémoire

    GKE place le pod sur un nœud sauvegardé par le type de machine c3-standard-88, qui dispose de 88 processeurs virtuels et de 352 Go de mémoire.

  • Exemple 2 : Prenons l'exemple d'un pod de classe Performance qui sélectionne la série de machines C3D et les disques SSD locaux pour le stockage éphémère. 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 processeurs virtuels, 64 Gio de mémoire et 365 Gio de capacité SSD locale.

Étapes suivantes