Exécuter des charges de travail Autopilot dans des clusters GKE Standard

Les administrateurs de clusters et les opérateurs d'applications peuvent bénéficier des avantages de Google Kubernetes Engine (GKE) Autopilot, comme les tarifs et les paramètres préconfigurés, dans les clusters en mode Standard. Cette page explique comment utiliser ComputeClasses pour déployer une charge de travail Autopilot dans un cluster Standard. Vous devez déjà connaître les concepts suivants :

À propos des classes de calcul Autopilot

GKE fournit des ressources personnalisées Kubernetes nommées ComputeClasses qui peuvent être déployées dans votre cluster comme n'importe quelle autre ressource Kubernetes. Une ComputeClass définit une liste de configurations de nœuds, comme les types de machines ou les VM Spot. Vous pouvez sélectionner des ComputeClasses dans vos charges de travail, ce qui indique à GKE que tous les nouveaux nœuds doivent utiliser l'une des configurations de cette liste.

Si une charge de travail sélectionne une ComputeClass dont le champ autopilot est activé, GKE exécute les pods en mode Autopilot. Les nœuds créés par GKE sont gérés par Google et incluent de nombreux paramètres de sécurité et fonctionnalités Autopilot par défaut. Pour en savoir plus sur les implications de l'exécution d'une charge de travail Autopilot dans vos clusters Standard, y compris les différences que vous pouvez remarquer lorsque vous déployez ces charges de travail, consultez À propos des charges de travail en mode Autopilot dans GKE Standard.

Types de classes de calcul Autopilot

GKE fournit des ComputeClasses Autopilot intégrées que vous pouvez utiliser pour la plupart des charges de travail à usage général. Vous pouvez également configurer une classe ComputeClass personnalisée nouvelle ou existante pour qu'elle utilise le mode Autopilot. Le type de ComputeClass Autopilot que vous utilisez dépend de la nécessité ou non pour vos charges de travail d'utiliser du matériel spécifique, comme suit :

  • Charges de travail à usage général : utilisez l'une des classes de calcul Autopilot intégrées, qui placent les pods sur la plate-forme de calcul optimisée pour les conteneurs.
  • Charges de travail nécessitant du matériel spécifique : activez le mode Autopilot pour n'importe quelle ComputeClass personnalisée, déployez cette ComputeClass sur le cluster et sélectionnez-la dans vos charges de travail.

Pour en savoir plus sur ces options, quand les utiliser et les tarifs de chacune d'elles, consultez Sélection du matériel dans les ComputeClasses Autopilot.

Tarifs

Les tarifs de GKE Autopilot s'appliquent aux charges de travail et aux nœuds qui utilisent une ComputeClass Autopilot. Le modèle de tarification qui s'applique dépend de l'utilisation d'une ComputeClass Autopilot intégrée ou d'une ComputeClass Autopilot personnalisée. Pour en savoir plus, consultez la section Tarification de l'article "À propos des charges de travail du mode Autopilot dans GKE Standard".

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.
  • Utilisez un cluster GKE Standard qui exécute la version 1.33.1-gke.1107000 ou ultérieure et qui est enregistré dans le canal de publication Rapide. Pour créer un cluster, consultez Créer un cluster régional.
  • Pour éviter que vos charges de travail soient refusées, découvrez les exigences et les contraintes de sécurité d'Autopilot. Pour en savoir plus, consultez Paramètres prédéfinis pour les nœuds Autopilot.

Conditions requises

  • Au moins un pool de nœuds du cluster ne doit pas comporter de taints de nœuds.

    Ce pool de nœuds est nécessaire pour exécuter les pods système GKE Standard qui ne peuvent pas s'exécuter sur les nœuds Autopilot dans les clusters Standard en raison des rejets que GKE ajoute à ces nœuds.

  • Les nœuds GKE protégés sont obligatoires et activés par défaut.

  • Vous devez utiliser un cluster de VPC natif.

Limites

  • Seul le canal de publication rapide est accepté.
  • Pour mettre à jour les ressources ComputeClass existantes dans le cluster afin qu'elles utilisent le mode Autopilot, vous devez recréer cette ComputeClass avec une spécification mise à jour. Pour en savoir plus, consultez Activer Autopilot pour une ComputeClass personnalisée existante.
  • Vous ne pouvez pas utiliser la règle de priorité podFamily dans vos propres ComputeClasses. Cette règle n'est disponible que dans les classes de calcul Autopilot intégrées.
  • Les ComputeClasses Autopilot intégrées ne permettent pas d'activer les nœuds GKE confidentiels pour l'ensemble de votre cluster. Si vous activez les nœuds Confidential GKE Node pour le cluster, tous les nouveaux pods qui sélectionnent les ComputeClasses Autopilot intégrées restent indéfiniment à l'état Pending.

Rôles et autorisations requis

Pour obtenir les autorisations nécessaires pour déployer des ComputeClasses, demandez à votre administrateur de vous accorder le rôle IAM Développeur Kubernetes Engine (roles/container.developer) sur votre cluster ou projet . Pour en savoir plus sur l'attribution de rôles, consultez la page 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.

Sélectionner une ComputeClass Autopilot dans une charge de travail

Pour sélectionner une ComputeClass Autopilot dans une charge de travail, utilisez un sélecteur de nœuds pour le libellé cloud.google.com/compute-class. Il s'agit du même libellé que celui que vous utilisez pour sélectionner une autre ComputeClass dans GKE. Les étapes suivantes vous montrent comment créer un exemple de déploiement qui sélectionne une ComputeClass et comment vérifier que les pods s'exécutent en mode Autopilot :

  1. Enregistrez l'exemple de Déploiement suivant en tant que autopilot-cc-deployment.yaml :

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      nodeSelector:
        # Replace with the name of a compute class
        cloud.google.com/compute-class: COMPUTE_CLASS 
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: "250m"
            memory: "4Gi"

    Remplacez COMPUTE_CLASS par le nom de la classe de calcul à utiliser. Cette valeur peut être l'une des suivantes :

  2. Déployer la charge de travail :

    kubectl apply -f autopilot-cc-deployment.yaml

  3. Pour vérifier que les pods utilisent Autopilot, vérifiez les noms des nœuds hôtes :

    kubectl get pods -l=app=hello -o wide

    Le résultat ressemble à ce qui suit :

    NAME                       READY   STATUS    RESTARTS   AGE     IP             NODE                                         NOMINATED NODE   READINESS GATES
helloweb-79b9f6f75-5wwc9   1/1     Running   0          152m    10.102.1.135   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>
helloweb-79b9f6f75-9skb9   1/1     Running   0          4d3h    10.102.0.140   gk3-cluster-1-nap-10abc8ya1-632bac02-hjl6   <none>           <none>
helloweb-79b9f6f75-h7bdv   1/1     Running   0          152m    10.102.1.137   gk3-cluster-1-nap-10abc8ya1-f66c6cef-wg5g   <none>           <none>

    Dans ce résultat, le préfixe gk3- dans la colonne Nœud indique que le nœud est géré par Autopilot.

Configurer une ComputeClass Autopilot personnalisée

Vous pouvez configurer des ComputeClasses personnalisées pour utiliser Autopilot. Utilisez une ComputeClass Autopilot personnalisée si vos charges de travail nécessitent du matériel spécifique pour s'exécuter de manière optimale, comme des GPU ou une série de machines Compute Engine spécifique.

Si vos charges de travail ne nécessitent pas de matériel spécifique, nous vous recommandons d'utiliser l'une des ComputeClasses Autopilot intégrées. Pour sélectionner une ComputeClass Autopilot intégrée, consultez la section précédente Sélectionner une ComputeClass Autopilot dans une charge de travail.

Créer une classe ComputeClass Autopilot personnalisée

  1. Enregistrez l'exemple de fichier manifeste ComputeClass suivant sous le nom autopilot-n2-class.yaml :

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: autopilot-n2-class
spec:
  autopilot:
    enabled: true
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  whenUnsatisfiable: DoNotScaleUp

    Ce fichier manifeste comprend les champs suivants :

    • autopilot : active le mode Autopilot pour ComputeClass. Si vous spécifiez ce champ dans une ComputeClass que vous déployez sur un cluster Autopilot, GKE l'ignore.
    • priorities : définit un tableau de trois configurations différentes de la famille de machines N2.
    • activeMigration : permet à GKE de migrer les pods vers des configurations plus haut dans la liste des priorités lorsque des ressources deviennent disponibles.
    • whenUnsatisfiable : la valeur de DoNotScaleUp dans ce champ oblige GKE à utiliser l'une des règles du champ priorities pour les nouveaux nœuds. Si aucune de ces règles de priorité ne peut être respectée, GKE laisse le pod dans l'état Pending jusqu'à ce que des ressources soient disponibles. DoNotScaleUp est la valeur par défaut et recommandée pour ce champ.

  2. Déployez la ComputeClass :

    kubectl apply -f autopilot-n2-class.yaml

  3. Vérifiez que la ComputeClass existe :

    kubectl get computeclasses

    Le résultat ressemble à ce qui suit :

    NAME                  AGE
autopilot-n2-class    3s

Activer Autopilot pour une ComputeClass personnalisée existante

Vous pouvez activer Autopilot dans les ComputeClasses personnalisées existantes qui se trouvent dans un cluster Standard et dont le champ nodePoolAutoCreation.enabled de la spécification est défini sur true. L'activation d'Autopilot dans une classe de calcul d'un cluster Autopilot n'a aucun effet, car l'ensemble du cluster utilise le mode Autopilot.

Une fois que vous avez activé Autopilot pour une ComputeClass existante, GKE utilise Autopilot pour exécuter les nouveaux pods qui sélectionnent la ComputeClass. Si vous avez des pods existants sur des nœuds standards qui sélectionnent la ComputeClass Autopilot, ces pods n'utilisent Autopilot que lorsqu'ils sont recréés.

Pour mettre à jour une ComputeClass personnalisée existante afin d'utiliser le mode Autopilot, procédez comme suit :

  1. Dans un éditeur de texte, mettez à jour le fichier manifeste de votre ComputeClass existante pour ajouter le champ spec.autopilot :

    spec:
  autopilot:
    enabled: true

  2. Remplacez la ressource ComputeClass existante dans l'API Kubernetes par la spécification mise à jour :

    kubectl replace --force -f PATH_TO_UPDATED_MANIFEST

    Remplacez PATH_TO_UPDATED_MANIFEST par le chemin d'accès à votre fichier manifeste mis à jour.

  3. Pour déclencher la création de nœuds, recréez les charges de travail qui utilisent la classe de calcul.

Une fois le fichier manifeste mis à jour appliqué, tous les nouveaux nœuds que GKE crée pour cette ComputeClass utilisent Autopilot. GKE ne modifie aucun nœud existant créé avant la mise à jour.

Vérifier que votre charge de travail utilise Autopilot

  • Obtenez la liste des pods de votre cluster à l'aide de la commande kubectl get :

    kubectl get pods --output=custom-columns=Pod:.metadata.name,Node:.spec.nodeName

    Le résultat ressemble à ce qui suit :

    Pod                         Node
helloweb-84c865764b-nzhxt   gk3-cluster-1-pool-3-68fc8dca-t54b
# lines omitted for clarity

    Le préfixe gk3- dans le nom du nœud indique que le pod s'exécute en mode Autopilot.

Appliquer une ComputeClass Autopilot par défaut

GKE vous permet de définir une ComputeClass comme classe par défaut pour un espace de noms. La classe par défaut de l'espace de noms s'applique à tous les pods de cet espace de noms qui ne sélectionnent pas explicitement une autre ComputeClass. Définir une ComputeClass Autopilot comme classe par défaut signifie que vous pouvez exécuter tous les pods d'un espace de noms en mode Autopilot par défaut, sauf si la charge de travail sélectionne une autre option.

Pour en savoir plus, consultez Configurer une ComputeClass par défaut pour un espace de noms.

Étapes suivantes