À propos des classes de calcul "Équilibrée" et "Scale-Out" dans les clusters Autopilot

Vous pouvez utiliser les ComputeClasses Balanced et Scale-Out dans les clusters Google Kubernetes Engine (GKE) Autopilot pour exécuter des charges de travail nécessitant une capacité de calcul supplémentaire ou des configurations de processeur spécialisées. Cette page est destinée aux administrateurs de cluster qui souhaitent bénéficier d'options de calcul plus flexibles que celles fournies par la configuration par défaut des clusters Autopilot.

Présentation des ComputeClasses "Équilibré" et "Scale-Out"

Par défaut, les pods des clusters GKE Autopilot s'exécutent sur une plate-forme de calcul optimisée pour les conteneurs. Cette plate-forme est idéale pour les charges de travail à usage général, telles que les serveurs Web et les tâches par lot à intensité moyenne. La plate-forme de calcul optimisée pour les conteneurs fournit une configuration matérielle fiable, évolutive et économique capable de gérer les exigences de la plupart des charges de travail.

Si vous avez des charges de travail ayant des exigences matérielles spécifiques (telles que l'exécution de tâches de machine learning ou d'IA, l'exécution de bases de données à trafic élevé en temps réel, ou si vous avez besoin de plates-formes de processeur et d'architectures spécifiques), vous pouvez utiliser ComputeClasses pour provisionner ce matériel.

Dans les clusters Autopilot uniquement, GKE fournit les ComputeClasses sélectionnées suivantes qui vous permettent d'exécuter des pods nécessitant plus de flexibilité que la plate-forme de calcul par défaut optimisée pour les conteneurs :

  • Balanced : offre une capacité maximale de processeur et de mémoire supérieure à celle de la plate-forme de calcul optimisée pour les conteneurs.
  • Scale-Out : désactive le multithreading simultané (SMT) et est optimisé pour le scaling horizontal.

Ces ComputeClasses ne sont disponibles que dans les clusters Autopilot. Semblable à la plate-forme de calcul optimisée pour les conteneurs par défaut, Autopilot gère le dimensionnement des nœuds et l'allocation des ressources en fonction de vos pods en cours d'exécution.

Classes de calcul personnalisées pour plus de flexibilité

Si les ComputeClasses "Équilibré" ou "Scale-out" des clusters Autopilot ne répondent pas aux exigences de votre charge de travail, vous pouvez configurer vos propres ComputeClasses. Vous déployez des ressources personnalisées Kubernetes ComputeClass sur vos clusters avec des ensembles d'attributs de nœud que GKE utilise pour configurer de nouveaux nœuds dans le cluster. Ces ComputeClasses personnalisées peuvent, par exemple, vous permettre de déployer des charges de travail sur le même matériel que les ComputeClasses Balanced ou Scale-Out dans n'importe quel cluster GKE Autopilot ou Standard. Pour en savoir plus, consultez À propos des charges de travail en mode Autopilot dans GKE Standard.

Tarifs

Les pods qui utilisent les ComputeClasses Balanced ou Scale-Out sont facturés en fonction des SKU suivants :

Pour en savoir plus, consultez la page Tarifs de GKE.

Détails techniques sur les configurations "Équilibrée" et "Scale-Out"

Cette section décrit les types de machines et les cas d'utilisation des classes Balanced et Scale-Out. Si vous ne demandez pas de ComputeClass dans vos pods, Autopilot les place par défaut sur la plate-forme de calcul optimisée pour les conteneurs. Il est possible que ek s'affiche comme série de machines de nœud dans vos nœuds Autopilot qui utilisent la plate-forme de calcul optimisée pour les conteneurs. Les machines EK sont des types de machines E2 exclusifs à Autopilot.

Le tableau suivant fournit une présentation technique des ComputeClasses Balanced et Scale-Out.

ComputeClasses "Balanced" et "Scale-Out"
Balanced

Fournit plus de capacité de processeur et de mémoire que les limites maximales de la plate-forme de calcul optimisée pour les conteneurs. Fournit des plates-formes de processeur supplémentaires et permet de définir des plates-formes de processeur minimales pour les pods, telles qu'Intel Ice Lake ou version ultérieure.

  • Processeurs disponibles : AMD EPYC Rome, AMD EPYC Milan, Intel Ice Lake, Intel Cascade Lake
  • Architecture disponible : amd64
  • Série de machines : N2 (processeurs Intel) ou série de machines N2D (processeurs AMD).

Utilisez la classe Balanced pour les applications telles que les suivantes :

  • Serveurs Web
  • Bases de données moyennes à grandes
  • Mise en cache
  • Flux et diffusion de contenus multimédias
  • Stockage Hyperdisk Throughput et Extreme
Scale-Out

Fournit un calcul monothread par cœur et un scaling horizontal.

  • Processeurs disponibles : Ampere Altra Arm ou AMD EPYC Milan
  • Architecture disponible : arm64 ou amd64
  • Série de machines : T2A (Arm) ou T2D (x86).
  • Fonctionnalités supplémentaires :
    • Le mode SMT est désactivé. Un processeur virtuel équivaut donc à un cœur physique.
    • Vitesse d'horloge maximale de 3,5 GHz.

Utilisez la classe Scale-Out pour les applications telles que les suivantes :

  • Serveurs Web
  • Microservices conteneurisés
  • Traitement de journaux de données
  • Applications Java à grande échelle
  • Stockage Hyperdisk Throughput

Sélection de ComputeClass dans les charges de travail

Pour utiliser une ComputeClass pour une charge de travail GKE, vous devez sélectionner la ComputeClass dans le fichier manifeste de la charge de travail à l'aide d'un sélecteur de nœuds pour le libellé cloud.google.com/compute-class.

L'exemple de fichier manifeste Deployment suivant sélectionne une ComputeClass :

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 d'une ComputeClass, par exemple Balanced ou Scale-Out. Vous ne pouvez sélectionner qu'une seule ComputeClass par charge de travail.

Lorsque vous déployez la charge de travail, GKE effectue les opérations suivantes :

  • Provisionne automatiquement les nœuds sauvegardés par la configuration spécifiée pour exécuter vos pods.
  • Ajoute automatiquement des libellés de nœud et des rejets aux nouveaux nœuds pour éviter que d'autres pods ne planifient ces nœuds. Les rejets sont propres à chaque ComputeClass. Si vous sélectionnez également une architecture de processeur, GKE ajoute un rejet distinct unique à cette architecture.
  • Ajoute automatiquement des tolérances correspondant aux rejets appliqués à vos pods déployés, ce qui permet à GKE de placer ces pods sur les nouveaux nœuds.

Par exemple, si vous demandez la ComputeClass Scale-Out pour un pod :

  1. Autopilot ajoute un rejet spécifique à Scale-Out pour ces nœuds.
  2. Autopilot ajoute une tolérance pour ce rejet aux pods Scale-Out.

Les pods qui ne demandent pas Scale-Out ne recevront pas la tolérance. Par conséquent, GKE ne planifie pas ces pods sur les nœuds Scale-Out.

Si vous ne demandez pas explicitement une ComputeClass dans la spécification de votre charge de travail, Autopilot planifie les pods sur les nœuds qui utilisent la plate-forme de calcul optimisée pour les conteneurs par défaut. La plupart des charges de travail à usage général peuvent s'exécuter sans problème sur cette plate-forme.

Demander une architecture de processeur

Dans certains cas, vos charges de travail peuvent être créées pour une architecture spécifique, telle que Arm. La ComputeClass Scale-Out est compatible avec plusieurs architectures de processeur. Vous pouvez demander une architecture spécifique avec votre requête ComputeClass en spécifiant un libellé dans votre sélecteur de nœud ou votre règle d'affinité de nœud, comme dans l'exemple suivant :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-arm
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-arm
  template:
    metadata:
      labels:
        app: nginx-arm
    spec:
      nodeSelector:
        cloud.google.com/compute-class: COMPUTE_CLASS
        kubernetes.io/arch: ARCHITECTURE
      containers:
      - name: nginx-arm
        image: nginx
        resources:
          requests:
            cpu: 2000m
            memory: 2Gi

Remplacez ARCHITECTURE par l'architecture de processeur de votre choix, telle que arm64 ou amd64. Vous ne pouvez sélectionner qu'une seule architecture dans votre charge de travail. La classe de calcul que vous sélectionnez doit être compatible avec l'architecture que vous avez spécifiée.

Si vous ne demandez pas explicitement une architecture, Autopilot utilise l'architecture par défaut de la ComputeClass.

Architecture Arm sur Autopilot

Autopilot accepte les requêtes pour les nœuds qui utilisent l'architecture de processeur Arm. Les nœuds Arm sont plus rentables que les nœuds x86 similaires tout en offrant des améliorations de performances. Pour savoir comment demander des nœuds Arm, consultez la page Déployer des charges de travail Autopilot sur l'architecture Arm.

Assurez-vous d'utiliser les images appropriées dans vos déploiements. Si vos pods utilisent des images Arm et que vous ne demandez pas de nœuds Arm, Autopilot planifie les pods sur les nœuds x86, et ceux-ci plantent. De même, si vous utilisez accidentellement des images x86, mais que vous demandez des nœuds Arm pour les pods, ceux-ci planteront.

Requêtes de ressources par défaut, minimales et maximales

Lorsque vous choisissez une ComputeClass pour vos charges de travail Autopilot, veillez à spécifier les requêtes de ressources qui répondent aux requêtes minimales et maximales de cette ComputeClass. Pour en savoir plus sur les requêtes par défaut, ainsi que sur les requêtes minimales et maximales pour chaque ComputeClass, consultez Requêtes et limites de ressources dans GKE Autopilot.

Étapes suivantes