Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Automatisches Erstellen von Knotenpools konfigurieren

Standard

Sie können den Aufwand für die manuelle Infrastrukturverwaltung in GKE-Standardclustern (Google Kubernetes Engine) reduzieren, indem Sie GKE automatisch Knotenpools für ausstehende Pods erstellen lassen. In diesem Dokument erfahren Sie, wie Sie die automatische Erstellung von Knotenpools für Cluster und Arbeitslasten aktivieren, Standardwerte für automatisch erstellte Knoten festlegen und die automatische Erstellung für einige gängige Anwendungsfälle auslösen.

Dieses Dokument richtet sich an Clusteradministratoren, Operatoren und Entwickler, die Infrastruktur in Standard-Clustern verwalten und Arbeitslasten in Standard-Clustern bereitstellen. Weitere Informationen zur Funktionsweise der automatischen Erstellung von Knotenpools und zu den verschiedenen Aktivierungsmethoden (z. B. ComputeClasses und automatische Knotenbereitstellung auf Clusterebene) finden Sie unter Automatische Erstellung von Knotenpools.

Beschränkungen

Für die automatische Erstellung von Knotenpools gelten die folgenden Einschränkungen:

Alle Einschränkungen von Cluster Autoscaler gelten auch für die automatische Erstellung von Knotenpools.
Bei Clustern mit mehr als 200 Knotenpools kann es beim Autoscaling zu einer erhöhten Latenz kommen. Jede Konfiguration, die die Erstellung eines neuen Knotenpools auslöst, z. B. die Arbeitslasttrennung oder die Verwendung mehrerer ComputeClasses, erhöht diese Anzahl. Weitere Informationen zu Clusterlimits finden Sie unter Limits und Best Practices im Abschnitt „Große Cluster planen“.
Alle Ressourcenlimits, die Sie für den Cluster festlegen, wenn Sie die automatische Knotenbereitstellung aktivieren, gelten auch für die Knotenpools, die GKE für ComputeClasses erstellt.
Die folgenden Einstellungen werden von ComputeClasses nicht unterstützt:
- Surge-Upgrades oder Blau/Grün-Upgrades.
- Knotenintegrität und Secure Boot.
Wenn Sie die automatische Erstellung von Knotenpools für eine ComputeClass in GKE-Versionen vor 1.33.3-gke.1136000 aktivieren möchten, müssen Sie auch die automatische Knotenbereitstellung auf Clusterebene aktivieren. Diese Einschränkung gilt nicht für GKE-Versionen ab 1.33.3-gke.1136000.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Voraussetzungen

Sie können die automatische Erstellung von Knotenpools für den gesamten Cluster in jeder GKE-Version mithilfe der automatischen Knotenbereitstellung aktivieren. Wenn Sie eine ComputeClass verwenden möchten, um die automatische Erstellung von Knotenpools auf Arbeitslastebene zu aktivieren, und die automatische Knotenbereitstellung nicht aktivieren möchten, muss Ihr Cluster die GKE-Version 1.33.3-gke.1136000 oder höher haben.

Wenn Sie die automatische Erstellung von Knotenpools für bestimmte Knotenkonfigurationen auslösen möchten, müssen Sie die entsprechenden Versionsanforderungen erfüllen. Weitere Informationen zur Versionsunterstützung für verschiedene Konfigurationen finden Sie in den GKE-Versionshinweisen (neue Funktionen) oder in der Dokumentation für Ihren Anwendungsfall.

Automatische Erstellung auf Arbeitslastebene aktivieren

Sie können die automatische Erstellung von Knotenpools für bestimmte Arbeitslasten im Cluster mithilfe einer ComputeClass aktivieren. Das Feld nodePoolAutoCreation in einer ComputeClass-Spezifikation steuert, ob GKE neue Knotenpools für Pods erstellen kann, die diese ComputeClass auswählen. In GKE-Version 1.33.3-gke.1136000 und höher können Sie die automatische Erstellung von Knotenpools für eine ComputeClass aktivieren, auch wenn die automatische Knotenbereitstellung für den Cluster nicht aktiviert ist. In Versionen vor 1.33.3-gke.1136000 müssen Sie außerdem die automatische Knotenbereitstellung auf Clusterebene aktivieren.

So aktivieren Sie die automatische Erstellung von Knotenpools für eine ComputeClass:

Verwenden Sie einen neuen oder vorhandenen Standardcluster mit Version 1.33.3-gke.1136000 oder höher.

Optional können Sie einen neuen Standardcluster erstellen.
Wenn Ihr Cluster die Anforderungen im vorherigen Schritt nicht erfüllt, aktivieren Sie die automatische Knotenbereitstellung auf Clusterebene.

Speichern Sie die folgende Beispiel-ComputeClass als YAML-Datei:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  -  machineFamily: n4
  -  machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Ersetzen Sie COMPUTE_CLASS durch einen Namen für die neue ComputeClass. Weitere Informationen zu den verfügbaren Feldern in ComputeClasses finden Sie in der ComputeClass CustomResourceDefinition.

Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

Speichern Sie das folgende Beispiel-Deployment, das eine ComputeClass auswählt, als helloweb-deploy.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: "1Gi"

Erstellen Sie das Deployment im Cluster:
```
kubectl apply -f helloweb-deploy.yaml
```
Rufen Sie eine Liste der Knotenpools in Ihrem Cluster ab, um zu prüfen, ob GKE einen neuen Knotenpool für Ihren Pod erstellt hat:
```
gcloud container node-pools list \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name Ihres Clusters.
- CONTROL_PLANE_LOCATION: die Region oder Zone der Cluster-Steuerungsebene, z. B. us-central1 oder us-central1-a.

Automatische Knotenbereitstellung auf Clusterebene aktivieren

Wenn Sie die automatische Erstellung von Knotenpools für den gesamten GKE-Cluster aktivieren möchten, verwenden Sie die Einstellung Automatische Knotenbereitstellung. Mit der automatischen Knotenbereitstellung kann GKE neue Knotenpools für ausstehende Arbeitslasten im gesamten Cluster erstellen. Dies basiert auf der Konfiguration in der Pod-Spezifikation oder in einer ComputeClass. Sie können die automatische Knotenbereitstellung für neue oder vorhandene Cluster aktivieren.

Bevor Sie die automatische Knotenbereitstellung aktivieren, sollten Sie die Größe des primären IPv4-Adressbereichs Ihres VPC-Subnetzes planen. GKE verwendet diesen IP-Adressbereich als primären Knoten-IP-Adressbereich. Je nach Größe und Umfang Ihres Clusters sind im Standard-IP-Adressbereich für Knoten möglicherweise nicht genügend IP-Adressen vorhanden, um sie neuen Knoten zuzuweisen. Wenn Sie die Größe des IP-Adressbereichs des Knotens nach dem Erstellen des Clusters aktualisieren, müssen Sie die GKE-Cluster-Firewallregeln aktualisieren, um Traffic von den neuen IP-Adressen zuzulassen.

Wenn Sie automatisch erstellte Knotenpools in GKE-Versionen vor 1.33.3-gke.1136000 erhalten möchten, müssen Sie die Schritte in diesem Abschnitt ausführen. Sie können die automatische Knotenbereitstellung auch für einen vorhandenen Cluster aktivieren, indem Sie die Clusterkonfiguration in der Google Cloud Console bearbeiten.

Wählen Sie eine der folgenden Optionen aus, um die automatische Knotenbereitstellung beim Erstellen eines neuen Clusters zu aktivieren:

Console

Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster erstellen auf.
Zur Seite „Kubernetes-Cluster erstellen“
Geben Sie auf der Seite Clustergrundlagen einen Namen und einen Standort für den neuen Cluster an.
Klicken Sie im Navigationsbereich auf Erweiterte Einstellungen.
Klicken Sie in der Zeile Automatische Knotenbereitstellung auf Konfiguration bearbeiten.
Klicken Sie auf das Kästchen Automatische Knotenbereitstellung aktivieren. Der Abschnitt Limits wird angezeigt.
Geben Sie Limits für CPU und Arbeitsspeicher an.
Klicken Sie auf Speichern.
Klicken Sie auf Erstellen.

gcloud

gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only

Ersetzen Sie Folgendes:

CLUSTER_NAME: der Name des Clusters zum Aktivieren der automatischen Knotenbereitstellung
CONTROL_PLANE_LOCATION: die Region oder Zone der Cluster-Steuerungsebene, z. B. us-central1 oder us-central1-a.
MINIMUM_CPU: die Mindestanzahl von Kernen im Cluster
MINIMUM_MEMORY: die Mindestspeicherkapazität im Cluster in GiB.
MAXIMUM_CPU: die maximale Anzahl der Kerne im Cluster Dieses Limit gilt für die Summe der CPU-Kerne auf allen neuen und vorhandenen Knoten im Cluster, einschließlich manuell erstellter Knotenpools.
MAXIMUM_MEMORY: die maximale Speicherkapazität im Cluster in GiB. Dieses Limit gilt für die Summe der Arbeitsspeicherkapazität aller neuen und vorhandenen Knotenpools im Cluster, einschließlich manuell erstellter Knotenpools.

Einstellungen mit einer Konfigurationsdatei für die automatische Knotenbereitstellung konfigurieren

Sie können Ressourcenlimits und Knotenkonfigurationseinstellungen für die automatische Knotenbereitstellung mithilfe einer YAML-Konfigurationsdatei konfigurieren. Mit der Konfigurationsdatei können Sie Standardwerte für automatisch erstellte Knotenpools deklarativ angeben und erweiterte Konfigurationen vornehmen, z. B. die automatische Knotenreparatur aktivieren. Diese Datei hat nichts mit ComputeClasses zu tun, bei denen es sich um benutzerdefinierte Kubernetes-Ressourcen handelt. Stattdessen ist die Konfigurationsdatei eine erweiterbare Alternative zur Verwendung von Befehlszeilen-Flags, um Einstellungen für die automatische Knotenbereitstellung festzulegen. Weitere Informationen finden Sie unter Standardeinstellungen auf Clusterebene mit einer Konfigurationsdatei.

So erstellen und verwenden Sie eine Konfigurationsdatei:

Erstellen Sie in einem Texteditor eine YAML-Datei in einem Pfad, auf den die Google Cloud CLI zugreifen kann.
Fügen Sie die Konfigurationen hinzu, die Sie festlegen oder ändern möchten, wie im folgenden Beispiel:
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: 4
    maximum: 10
  - resourceType: 'memory'
    maximum: 64
  - resourceType: 'nvidia-tesla-t4'
    maximum: 4
management:
  autoRepair: true
  autoUpgrade: true
shieldedInstanceConfig:
  enableSecureBoot: true
  enableIntegrityMonitoring: true
```
In diesem Beispiel gelten die folgenden Einstellungen für die automatische Knotenbereitstellung:
- resourceLimits: Legt Ressourcenlimits für CPU, Arbeitsspeicherkapazität und NVIDIA T4-GPUs im Cluster fest. Diese Limits gelten für die Summe der Ressourcenkapazität im Cluster, einschließlich manuell erstellter Knotenpools.
- management: Aktiviert die automatische Knotenreparatur und das automatische Knotenupgrade für alle neuen automatisch erstellten Knotenpools im Cluster.
- shieldedInstanceConfig: Aktiviert Secure Boot und das Monitoring der Knotenintegrität für alle neuen automatisch erstellten Knotenpools im Cluster.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Nachdem Sie die Konfigurationsdatei auf den Cluster angewendet haben, verwendet GKE die Einstellungen in der Datei für neue automatisch erstellte Knotenpools im Cluster. Diese Einstellungen gelten nicht für vorhandene Knotenpools, die GKE im Cluster erstellt hat.

Ressourcenlimits für die automatische Knotenbereitstellung konfigurieren

Wenn Sie die automatische Knotenbereitstellung auf Clusterebene verwenden, müssen Sie Limits für die Gesamtmenge an Ressourcen konfigurieren, die Ihr Cluster in allen Knotenpools haben kann. Wenn Sie die automatische Knotenbereitstellung für einen Cluster aktivieren möchten, müssen Sie Limits für die CPU- und Arbeitsspeicherkapazität im Cluster angeben. Wenn Sie andere Arten von angehängten Ressourcen wie GPUs und TPUs verwenden möchten, müssen Sie außerdem Limits für diese Ressourcen angeben. Diese Limits sind nur erforderlich, wenn Sie die Einstellung für die automatische Knotenbereitstellung für Ihren Cluster aktivieren. Wenn Sie nur ComputeClasses verwenden, um automatisch erstellte Knotenpools zu erhalten, müssen Sie keine Ressourcenlimits konfigurieren.

Alternativ können Sie Ressourcenlimits konfigurieren, die auf Teilmengen von Knoten abzielen, z. B. Knoten, die für eine ComputeClass erstellt wurden, oder Knoten, die eine bestimmte Maschinenfamilie verwenden. Weitere Informationen finden Sie unter Granulare Ressourcenlimits konfigurieren.

Sie können Ressourcenlimits für die automatische Erstellung von Knotenpools mit einer der folgenden Methoden hinzufügen oder ändern:

Die Google Cloud Console
gcloud CLI-Flags
Konfigurationsdatei auf Clusterebene

Wählen Sie eine der folgenden Optionen aus, um Ressourcenlimits für einen vorhandenen Cluster zu konfigurieren:

Console

Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

Zur Seite "Kubernetes-Cluster"
Klicken Sie auf den Namen des Clusters. Die Seite Clusterdetails wird geöffnet.
Klicken Sie auf den Tab Details.
Klicken Sie im Abschnitt Automatisierung in der Zeile Automatische Knotenbereitstellung auf Bearbeiten. Der Bereich Automatische Knotenbereitstellung bearbeiten wird geöffnet.
Klicken Sie auf das Kästchen Automatische Knotenbereitstellung aktivieren.
Geben Sie im Abschnitt Limits Mindest- und Höchstwerte für die CPU- und Arbeitsspeicherkapazität im Cluster an.
So konfigurieren Sie Limits für eine andere Ressource, z. B. GPUs oder TPUs:
1. Klicken Sie auf Ressource hinzufügen.
2. Wählen Sie in der Drop-down-Liste Ressourcentyp das GPU-Modell oder den TPU-Maschinentyp aus, z. B. NVIDIA A100 80GB oder ct5p.
3. Geben Sie Mindest- und Höchstwerte für die Ressource an.
Optional: Wählen Sie im Abschnitt Knotenpoolstandorte bestimmte Zonen aus, in denen GKE Knoten erstellen soll. Wenn Sie beispielsweise GPU-Arbeitslasten ausführen möchten, wählen Sie Zonen mit hoher Verfügbarkeit für den ausgewählten GPU-Typ aus.
Klicken Sie auf Änderungen speichern.

gcloud

Führen Sie einen der folgenden Befehle aus:

Geben Sie CPU- und Arbeitsspeicherressourcenlimits an:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY
```
Ersetzen Sie Folgendes:
- MINIMUM_CPU: die Mindestanzahl von Kernen im Cluster
- MINIMUM_MEMORY: die Mindestspeicherkapazität im Cluster in GiB.
- MAXIMUM_CPU: die maximale Anzahl der Kerne im Cluster Dieses Limit gilt für die Summe der CPU-Kerne in allen Knotenpools im Cluster, einschließlich manuell erstellter Knotenpools.
- MAXIMUM_MEMORY: die maximale Speicherkapazität im Cluster in GiB. Dieses Limit gilt für die Summe der Arbeitsspeicherkapazität aller Knotenpools im Cluster, einschließlich manuell erstellter Knotenpools.

Geben Sie GPU-Ressourcenlimits an:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --min-accelerator=type=GPU_TYPE,count=MINIMUM_GPU_COUNT \
    --max-accelerator=type=GPU_TYPE,count=MAXIMUM_GPU_COUNT

Ersetzen Sie Folgendes:

GPU_TYPE: der GPU-Typ, für den ein Limit festgelegt werden soll, z. B. nvidia-l4.
MINIMUM_GPU_COUNT: die Mindestanzahl von GPUs des angegebenen Typs, die der Cluster haben kann.
MAXIMUM_GPU_COUNT: die maximale Anzahl von GPUs des angegebenen Typs, die der Cluster haben kann.

Geben Sie TPU-Ressourcenlimits an:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --min-cpu=MINIMUM_CPU \
    --min-memory=MINIMUM_MEMORY \
    --max-cpu=MAXIMUM_CPU \
    --max-memory=MAXIMUM_MEMORY \
    --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
    --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
```
Ersetzen Sie Folgendes:
- TPU_TYPE: der TPU-Typ, für den ein Limit festgelegt werden soll. Folgende Werte werden unterstützt:
  - tpu-v4-podslice: TPU v4.
  - tpu-v5-lite-podslice: TPU v5e mit Maschinentypen, die mit ct5lp- beginnen.
  - tpu-v5p-slice: TPU v5e mit Maschinentypen, die mit ct5p- beginnen.
  - tpu-v6e-slice: TPU Trillium.
- MINIMUM_TPU_COUNT: die Mindestanzahl von TPU-Chips des angegebenen Typs, die der Cluster haben kann. Wenn der von Ihnen angegebene Wert größer als die Anzahl der TPU-Chips in einem TPU-Slice mit mehreren Hosts ist, wird Ihr TPU-Slice möglicherweise nicht herunterskaliert.
- MAXIMUM_TPU_COUNT: die maximale Anzahl von TPU-Chips des angegebenen Typs, die der Cluster haben kann. Geben Sie für TPU-Slices mit mehreren Hosts einen Wert an, der größer als die Anzahl der Chips in jedem Slice ist, damit GKE das Slice atomar skalieren kann. Die Anzahl der Chips in einem Slice ist das Produkt der TPU-Topologie. Wenn die Topologie beispielsweise 2x2x2 ist, beträgt die Anzahl der Chips im Slice 8. Das bedeutet, dass der Wert von MAXIMUM_TPU_COUNT größer als 8 sein muss.

Konfigurationsdatei

Geben Sie in Ihrer Konfigurationsdatei im Feld resourceLimits einen der folgenden Feldsätze an:
- Geben Sie CPU- und Arbeitsspeicherressourcenlimits an:
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
```
  Ersetzen Sie Folgendes:
  - MINIMUM_CPU: die Mindestanzahl von Kernen im Cluster
  - MINIMUM_MEMORY: die Mindestspeicherkapazität im Cluster in GiB.
  - MAXIMUM_CPU: die maximale Anzahl der Kerne im Cluster Dieses Limit gilt für die Summe der CPU-Kerne in allen Knotenpools im Cluster, einschließlich manuell erstellter Knotenpools.
  - MAXIMUM_MEMORY: die maximale Speicherkapazität im Cluster in GiB. Dieses Limit gilt für die Summe der Arbeitsspeicherkapazität aller Knotenpools im Cluster, einschließlich manuell erstellter Knotenpools.
- Geben Sie GPU-Ressourcenlimits an:
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
  - resourceType: 'GPU1_TYPE'
    minimum: MINIMUM_GPU1_COUNT
    maximum: MAXIMUM_GPU1_COUNT
  - resourceType: 'GPU2_TYPE'
    minimum: MINIMUM_GPU2_COUNT
    maximum: MAXIMUM_GPU2_COUNT
```
  Ersetzen Sie Folgendes:
  - GPU1_TYPE,GPU2_TYPE: Die GPU-Typen, für die Limits festgelegt werden sollen, z. B. nvidia-l4.
  - MINIMUM_GPU1_COUNT,MINIMUM_GPU2_COUNT: die Mindestanzahl von GPUs der angegebenen Typen, die der Cluster haben kann.
  - MAXIMUM_GPU1_COUNT,MAXIMUM_GPU2_COUNT: die maximale Anzahl von GPUs der angegebenen Typen, die der Cluster haben kann.
- Geben Sie TPU-Ressourcenlimits an:
```
resourceLimits:
  - resourceType: 'cpu'
    minimum: MINIMUM_CPU
    maximum: MAXIMUM_CPU
  - resourceType: 'memory'
    minimum: MINIMUM_MEMORY
    maximum: MAXIMUM_MEMORY
  - resourceType: 'TPU1_TYPE'
    minimum: MINIMUM_TPU1_COUNT
    maximum: MAXIMUM_TPU1_COUNT
  - resourceType: 'TPU2_TYPE'
    minimum: MINIMUM_TPU2_COUNT
    maximum: MAXIMUM_TPU2_COUNT
```
  Ersetzen Sie Folgendes:
  - TPU1_TYPE,TPU2_TYPE: Die TPU-Typen, für die Limits festgelegt werden sollen. Folgende Werte werden unterstützt:
    - tpu-v4-podslice: TPU v4.
    - tpu-v5-lite-podslice: TPU v5e mit Maschinentypen, die mit ct5lp- beginnen.
    - tpu-v5p-slice: TPU v5e mit Maschinentypen, die mit ct5p- beginnen.
    - tpu-v6e-slice: TPU Trillium.
  - MINIMUM_TPU1_COUNT,MINIMUM_TPU2_COUNT: Die Mindestanzahl von TPU-Chips des angegebenen Typs, die der Cluster haben kann. Wenn der von Ihnen angegebene Wert größer als die Anzahl der TPU-Chips in einem TPU-Slice mit mehreren Hosts ist, wird Ihr TPU-Slice möglicherweise nicht herunterskaliert.
  - MAXIMUM_TPU1_COUNT,MAXIMUM_TPU2_COUNT: Die maximale Anzahl von TPU-Chips des angegebenen Typs, die der Cluster haben kann. Geben Sie für Multi-Host-TPU-Slices einen Wert an, der größer als die Anzahl der Chips in jedem Slice ist, damit GKE das Slice atomar skalieren kann. Die Anzahl der Chips in einem Slice ist das Produkt der TPU-Topologie. Wenn die Topologie für TPU1_TYPE beispielsweise 2x2x2 ist, beträgt die Anzahl der Chips im Slice 8. Das bedeutet, dass der Wert von MAXIMUM_TPU1_COUNT größer als 8 sein muss.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Vorhandene Knotenpools als automatisch erstellt markieren

Nachdem Sie die automatische Knotenbereitstellung auf Clusterebene aktiviert haben, können Sie alle vorhandenen Knotenpools im Cluster als automatisch erstellt markieren. Die GKE verwaltet die Skalierung in diesen Knotenpools, einschließlich des Löschens der Knotenpools, wenn sie leer sind. Sie können manuell erstellte Knotenpools als automatisch erstellt markieren, damit GKE die Knotenpools für Sie verwaltet.

Wenn Sie die automatisierte Bereitstellung und Konfiguration für Ihren Cluster deaktivieren, verwaltet GKE alle vorhandenen automatisch erstellten Knotenpools im Cluster nicht mehr. Wenn Sie die automatisierte Bereitstellung und Konfiguration für den Cluster später wieder aktivieren, setzt GKE die Verwaltung dieser vorhandenen Knotenpools nicht automatisch fort. Sie müssen diese vorhandenen Knotenpools als automatisch erstellt markieren.

Führen Sie den folgenden Befehl aus, um einen vorhandenen Knotenpool als automatisch erstellt zu kennzeichnen:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning

Ersetzen Sie NODE_POOL_NAME durch den Namen des Knotenpools.

Standardeinstellungen für automatisch erstellte Knotenpools konfigurieren

Die GKE verwendet Ihre ComputeClasses und Pod-Spezifikationen, um die Knotentypen zu bestimmen, die Ihre ausstehenden Pods optimal ausführen können. Optional können Sie Standardeinstellungen konfigurieren, die GKE auf automatisch erstellte Knotenpools anwendet, z. B. ein benutzerdefiniertes IAM-Dienstkonto (Identity and Access Management) für die Knoten oder benutzerdefinierte Bootlaufwerkskonfigurationen. Diese Standardeinstellungen überschreiben alle entsprechenden Standardwerte, die Google für Ihre Cluster festlegt. Sie können beispielsweise ein Ubuntu-Knoten-Image als Standard für automatisch erstellte Knotenpools festlegen, wodurch das GKE-Standard-Knoten-Image von Container-Optimized OS überschrieben wird.

Sie können Standardeinstellungen auf Clusterebene mithilfe der automatischen Knotenbereitstellung oder auf Arbeitslastebene in ComputeClasses konfigurieren. Bevor Sie eine Einstellung auf einer dieser Ebenen konfigurieren, sollten Sie Folgendes beachten:

Die Einstellungen auf Clusterebene gelten für alle automatisch erstellten Knotenpools im Cluster. Die ComputeClass-Einstellungen gelten nur für Arbeitslasten, die diese ComputeClass verwenden.
Wenn Sie dieselbe Standardeinstellung in einer ComputeClass und auf Clusterebene angeben, verwendet die GKE die ComputeClass-Einstellung für Arbeitslasten, die die ComputeClass verwenden.
Alle von Ihnen konfigurierten Standardwerte gelten nur für neue automatisch erstellte Knotenpools. Vorhandene Knotenpools sind nicht betroffen.

In den folgenden Abschnitten wird beschrieben, wie Sie bestimmte Standardeinstellungen konfigurieren.

Standardknoten-Image festlegen

Wählen Sie eine der folgenden Optionen aus:

ComputeClass

Verwenden Sie in einem ComputeClass-Manifest das Feld nodePoolConfig.imageType. Dieses Feld ist in der GKE-Version 1.32.4-gke.1198000 und höher verfügbar.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  nodePoolConfig:
    imageType: IMAGE_TYPE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Ersetzen Sie IMAGE_TYPE durch einen Wert für das Knoten-Image. Dies kann einer der folgenden Werte sein:
- cos_containerd: Container-Optimized OS mit containerd.
- ubuntu_containerd: Ubuntu mit containerd.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Verwenden Sie das Flag --autoprovisioning-image-type, um das Standardknoten-Image in der Befehlszeile festzulegen:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-image-type=IMAGE_TYPE

Ersetzen Sie Folgendes:

CLUSTER_NAME ist der Name des Clusters.
IMAGE_TYPE: das Knoten-Image, das einer der folgenden Werte sein kann:
- cos_containerd: Container-Optimized OS mit containerd.
- ubuntu_containerd: Ubuntu mit containerd.

So legen Sie das Standard-Knoten-Image in einer Konfigurationsdatei fest:

Geben Sie in Ihrer Konfigurationsdatei das Feld imageType an:
```
  imageType: 'IMAGE_TYPE'
```
Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Standard-IAM-Dienstkonto für Knoten festlegen

GKE-Knoten verwenden ein IAM-Dienstkonto für Systemaufgaben wie Logging und Monitoring. Wählen Sie eine der folgenden Optionen aus, um das IAM-Dienstkonto für automatisch erstellte Knotenpools zu ändern:

ComputeClass

Verwenden Sie in einem Computeclass-Manifest das Feld nodePoolConfig.serviceAccount. Dieses Feld ist in der GKE-Version 1.31.4-gke.1072000 und höher verfügbar.

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  nodePoolConfig:
    serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Ersetzen Sie Folgendes:

SERVICE_ACCOUNT_NAME: der Name des IAM-Dienstkontos, z. B. my-node-account.
PROJECT_ID: die Projekt-ID des Dienstkontoprojekts.

Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Wenn Sie die gcloud CLI verwenden, um ein Standarddienstkonto für automatisch erstellte Knotenpools zu konfigurieren, müssen Sie auch Zugriffsbereiche angeben, die die Knotenpools für eine korrekte Funktion benötigen.

Wenn Sie das Standarddienstkonto und die Zugriffsbereiche über die Befehlszeile festlegen möchten, verwenden Sie die Flags --autoprovisioning-service-account und --autoprovisioning-scopes:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append

Ersetzen Sie Folgendes:

SERVICE_ACCOUNT_NAME: der Name des IAM-Dienstkontos, z. B. my-node-account.
PROJECT_ID: die Projekt-ID des Dienstkontoprojekts.

So legen Sie das Standarddienstkonto und die Zugriffsbereiche in einer Konfigurationsdatei fest:

Geben Sie in Ihrer Konfigurationsdatei die Felder serviceAccount und scopes an:

serviceAccount: SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
scopes: https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append

Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.

Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Standardzonen für automatisch erstellte Knoten festlegen

Standardmäßig erstellt die GKE Knoten in den folgenden Zonen, je nach Clustertyp:

Regionale Cluster: GKE erstellt Knoten in drei zufälligen Zonen in der Clusterregion.
Zonale Cluster: GKE erstellt Knoten in derselben Zone wie die Cluster-Steuerungsebene.

Sie können manuell eine Liste von Zonen angeben, in denen GKE automatisch Knoten erstellt. Diese Zonen müssen sich in derselben Region wie die Steuerungsebene des Clusters befinden. Wenn Sie beispielsweise einen zonalen Cluster mit der Steuerungsebene in us-central1-a haben, können Sie beliebige Zonen in der Region us-central1 angeben, damit GKE Knoten automatisch erstellt. Wenn Sie die Standardzonen für automatisch erstellte Knoten in einem vorhandenen Cluster ändern, gelten die Änderungen nur für neue Knotenpools, die von GKE erstellt werden.

Wählen Sie eine der folgenden Optionen aus, um die Standardzonen für automatisch erstellte Knoten anzugeben:

ComputeClass

Verwenden Sie in einem ComputeClass-Manifest das Feld spec.priorityDefaults.location.zones. Dieses Feld ist in der GKE-Version 1.33.1-gke.1545000 und höher verfügbar.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorityDefaults:
    location:
      zones: ['ZONE1','ZONE2','...']
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Ersetzen Sie ZONE1,ZONE2,... durch eine durch Kommas getrennte Liste der Standardzonen für automatisch erstellte Knoten, z. B. us-central1-a','us-central1-b', 'us-central1-f'. GKE verwendet diese Zonen, wenn bestimmte Regeln im Feld spec.priorities keine explizite Liste von Zonen enthalten.
Optional: Wenn Sie TPU-VMs bereitstellen, verwenden Sie eine KI-Zone wie us-central1-ai1a. KI-Zonen sind spezielle Standorte, die für KI-/ML-Arbeitslasten in Google Cloud -Regionen optimiert sind.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Verwenden Sie das Flag --autoprovisioning-locations, um die Standardzonen für die automatische Erstellung von Knotenpools in der Befehlszeile festzulegen:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-locations=ZONE1,ZONE2,...

Ersetzen Sie ZONE1,ZONE2,... durch eine durch Kommas getrennte Liste der Standardzonen für automatisch erstellte Knoten, z. B. us-central1-a','us-central1-b', 'us-central1-f'.

So legen Sie die Standardzonen für die automatische Erstellung von Knotenpools mithilfe einer Konfigurationsdatei fest:

Geben Sie das Feld autoprovisioningLocations in der Konfigurationsdatei an:
```
autoprovisioningLocations:
- ZONE1
- ZONE2
```
Ersetzen Sie ZONE1,ZONE2 durch die Standardzonen für automatisch erstellte Knoten, z. B. „us-central1-a“ und „us-central1-b“.

Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Kundenverwaltete Verschlüsselungsschlüssel für die Verschlüsselung des Bootlaufwerks festlegen

Sie können in Cloud Key Management Service einen vom Kunden verwalteten Verschlüsselungsschlüssel (CMEK) angeben, den GKE zum Verschlüsseln der Bootlaufwerke von Knoten in automatisch erstellten Knotenpools verwendet. Sie müssen den Schlüssel erstellen, bevor Sie ihn mit der automatischen Erstellung von Knotenpools verwenden können. Wählen Sie eine der folgenden Optionen aus, um einen CMEK für Ihre Knoten-Bootlaufwerke festzulegen:

ComputeClass

In ComputeClasses müssen Sie den Schlüssel in jeder Prioritätsregel im Feld spec.priorities der ComputeClass angeben.

Verwenden Sie in einem ComputeClass-Manifest das Feld priorities.storage.bootDiskKMSKey:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: n4
    storage:
      bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
  - machineFamily: n4d
    storage:
      bootDiskKMSKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Ersetzen Sie Folgendes:

KEY_PROJECT_ID: die Projekt-ID des Projekts, das den Schlüssel enthält.
KEY_LOCATION: der Speicherort des Schlüsselbunds.
KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält
KEY_NAME: der Name des Schlüssels

Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Geben Sie das Feld bootDiskKmsKey in der Konfigurationsdatei an:
```
bootDiskKmsKey: projects/KEY_PROJECT_ID/locations/KEY_LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME
```
Ersetzen Sie Folgendes:
- KEY_PROJECT_ID: die Projekt-ID des Projekts, das den Schlüssel enthält.
- KEY_LOCATION: der Speicherort des Schlüsselbunds.
- KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält
- KEY_NAME: der Name des Schlüssels
Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Knotenintegrität und Secure Boot konfigurieren

Sie können Secure Boot und Integritätsmonitoring für automatisch erstellte Knotenpools nur mithilfe der Konfigurationsdatei für die automatische Knotenbereitstellung aktivieren.

Geben Sie das Feld shieldedInstanceConfig in der Konfigurationsdatei an:
```
shieldedInstanceConfig:
  enableSecureBoot: true
  enableIntegrityMonitoring: true
```
Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Automatische Knotenreparatur und automatische Upgrades konfigurieren

Sie können die Einstellungen für automatische Knotenreparaturen und automatische Knotenupgrades in automatisch erstellten Knotenpools ändern. Diese Funktionen sind in allen GKE-Clustern und -Knotenpools standardmäßig aktiviert. Wir empfehlen, diese Funktionen aktiviert zu lassen, um die Zuverlässigkeit und Stabilität Ihrer Cluster zu verbessern.

Wählen Sie eine der folgenden Optionen aus, um die Einstellungen für die automatische Knotenreparatur und das automatische Knotenupgrade zu ändern:

ComputeClass

Verwenden Sie in einem ComputeClass-Manifest das Feld autoRepair und das Feld autoUpgrade im Feld spec.nodePoolConfig. Diese Felder sind in der GKE-Version 1.34.0-gke.2201000 und höher verfügbar.

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  nodePoolConfig:
    autoRepair: true
    autoUpgrade: true
  priorities:
  - machineFamily: n4
  - machineFamily: n4d
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Wenn Sie die Einstellungen für die automatische Reparatur und das automatische Upgrade über die Befehlszeile aktivieren möchten, verwenden Sie die Flags --enable-autoprovisioning-autorepair und --enable-autoprovisioning-autoupgrade:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-autorepair \
    --enable-autoprovisioning-autoupgrade

Verwenden Sie die Flags --no-enable-autoprovisioning-autorepair und --no-enable-autoprovisioning-autoupgrade, um die Einstellungen für die automatische Reparatur und das automatische Upgrade in der Befehlszeile zu deaktivieren:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --no-enable-autoprovisioning-autorepair \
    --no-enable-autoprovisioning-autoupgrade

So ändern Sie die Einstellungen für die automatische Reparatur und das automatische Upgrade von Knoten mithilfe einer Konfigurationsdatei:
1. Geben Sie die Felder management.autoRepair und management.autoUpgrade in der Konfigurationsdatei an:
```
management:
  autoRepair: true
  autoUpgrade: true
```
  Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
2. Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME ist der Name des Clusters.
  - PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Einstellungen für Surge-Upgrades konfigurieren

Sie können Surge-Upgrade-Einstellungen in automatisch erstellten Knotenpools angeben. Surge-Upgrades sind die Standard-Knotenupgradestrategie von GKE. Wenn Sie die Einstellungen für Surge-Upgrades ändern möchten, müssen Sie die automatische Knotenbereitstellung auf Clusterebene konfigurieren.

Verwenden Sie die Flags --autoprovisioning-max-surge-upgrade und --autoprovisioning-max-unavailable-upgrade, um die Einstellungen für das Surge-Upgrade in der Befehlszeile anzugeben:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-max-surge-upgrade=MAX_SURGE \
    --autoprovisioning-max-unavailable-upgrade=MAX_UNAVAILABLE
```
Ersetzen Sie Folgendes:
- MAX_SURGE: die maximale Anzahl von Knoten, die während eines Upgrades dem Knotenpool hinzugefügt werden können
- MAX_UNAVAILABLE: die maximale Anzahl von Knoten im Knotenpool, die während Upgrades gleichzeitig nicht verfügbar sind
So legen Sie Surge-Upgrade-Einstellungen mithilfe einer Konfigurationsdatei fest:
1. Geben Sie die Felder upgradeSettings.maxSurgeUpgrade und upgradeSettings.maxUnavailableUpgrade in der Konfigurationsdatei an:
```
upgradeSettings:
  maxSurgeUpgrade: MAX_SURGE
  maxUnavailableUpgrade: MAX_UNAVAILABLE
```
  Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
2. Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME ist der Name des Clusters.
  - PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

Die von Ihnen angegebenen Surge-Upgrade-Einstellungen gelten nur, wenn Ihr Cluster Surge-Upgrades verwendet, um automatisch erstellte Knotenpools zu aktualisieren. Führen Sie den folgenden Befehl aus, um Ihre Knotenupgrade-Strategie auf Surge-Upgrades für neue, automatisch erstellte Knotenpools umzustellen:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-surge-upgrade

Wenn Sie die Upgradestrategie wechseln, verwendet GKE alle Einstellungen, die Sie zuvor für diese Upgradestrategie konfiguriert haben.

Blau/Grün-Upgrades für neue automatisch erstellte Knotenpools verwenden

Sie können Ihre Knotenupgrade-Strategie für alle neuen automatisch erstellten Knotenpools auf Blau/Grün-Upgrades umstellen und die Standardeinstellungen für Blau/Grün-Upgrades anpassen. Wenn Sie Ihre Upgradestrategie ändern möchten, müssen Sie die automatische Knotenbereitstellung auf Clusterebene konfigurieren. Alle Änderungen, die Sie vornehmen, gelten nur für neue automatisch erstellte Knotenpools. Sie können auch vorhandene automatisch erstellte Knotenpools für die Verwendung von Blau/Grün-Upgrades aktualisieren. Sie können automatisch skalierte Blau/Grün-Upgrades (Vorabversion) nicht mit automatisch erstellten Knotenpools verwenden.

Führen Sie den folgenden Befehl aus, um Blau/Grün-Upgrades und die GKE-Standardeinstellungen für neue, automatisch erstellte Knotenpools zu verwenden:

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION
    --enable-autoprovisioning \
    --enable-autoprovisioning-blue-green-upgrade

Führen Sie den folgenden Befehl aus, um Blau/Grün-Upgrades zu verwenden und Ihre eigenen Standardeinstellungen für neue, automatisch erstellte Knotenpools zu konfigurieren:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --enable-autoprovisioning-blue-green-upgrade \
    --autoprovisioning-node-pool-soak-duration=NODE_POOL_SOAK_DURATION \
    --autoprovisioning-standard-rollout-policy=batch-node-count=BATCH_NODE_COUNT,batch-soak-duration=BATCH_SOAK_DURATION
```
Ersetzen Sie Folgendes:
- NODE_POOL_SOAK_DURATION: Die Dauer in Sekunden, die GKE nach dem Leeren aller Knotenbatches im blauen Pool wartet, bevor der blaue Pool gelöscht wird. Der Standardwert ist 3600.
- BATCH_NODE_COUNT: Die Anzahl der Knoten, die während der blauen Poolleerungsphase in einem Batch geleert werden sollen. Der Standardwert ist 1. Wenn Sie den Wert 0 angeben, überspringt GKE die Phase zum Leeren des blauen Pools.
- BATCH_SOAK_DURATION: Die Dauer in Sekunden, die GKE wartet, bis ein Batch-Draining-Vorgang gestartet wird, nachdem der vorherige Draining-Vorgang abgeschlossen wurde. Der Standardwert ist 0.

Benutzerdefinierte Bootlaufwerke für Knoten konfigurieren

Wählen Sie eine der folgenden Optionen aus, um den Typ und die Größe der Bootlaufwerke anzugeben, die GKE an jede Knoten-VM in einem automatisch erstellten Knotenpool anhängt:

ComputeClass

Verwenden Sie die Felder bootDiskType und bootDiskSize im Feld spec.priorities.storage in einer ComputeClass:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineType: n4-standard-16
    storage:
      bootDiskType: BOOT_DISK_TYPE
      bootDiskSize: BOOT_DISK_SIZE
  - machineType: n4d-standard-16
    storage:
      bootDiskType: BOOT_DISK_TYPE
      bootDiskSize: BOOT_DISK_SIZE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Hinweis: Wenn Sie die Einstellung bootDiskSize in einer ComputeClass konfigurieren möchten, ohne Werte für die Felder machineType oder GPU anzugeben, müssen Sie die GKE-Version 1.34.1-gke.1431000 oder höher verwenden.

Ersetzen Sie Folgendes:
- BOOT_DISK_TYPE: der Laufwerkstyp, der als Bootlaufwerk für den Knoten verwendet werden soll. Der von Ihnen angegebene Wert muss vom Compute Engine-Maschinentyp unterstützt werden, den GKE für diese Prioritätsregel verwendet. Der Wert muss einer der folgenden sein:
  - pd-balanced: abgestimmter nichtflüchtiger Speicher.
  - pd-standard: nichtflüchtiger Standardspeicher.
  - pd-ssd: Nichtflüchtiger SSD-Speicher (Leistung).
  - hyperdisk-balanced: Google Cloud Hyperdisk Balanced.
- BOOT_DISK_SIZE: die Größe des Bootlaufwerks des Knotens in GiB. Der Mindestwert beträgt 10.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

gcloud

Geben Sie in Ihrer Konfigurationsdatei die Felder diskSizeGb und diskType an:
```
diskSizeGb: BOOT_DISK_SIZE
diskType: BOOT_DISK_TYPE
```
Ersetzen Sie Folgendes:
- BOOT_DISK_TYPE: der Laufwerkstyp, der als Bootlaufwerk für den Knoten verwendet werden soll. Der von Ihnen angegebene Wert muss vom Compute Engine-Maschinentyp unterstützt werden, den GKE für diese Prioritätsregel verwendet. Der Wert muss einer der folgenden sein:
  - pd-balanced: abgestimmter nichtflüchtiger Speicher.
  - pd-standard: nichtflüchtiger Standardspeicher.
  - pd-ssd: Nichtflüchtiger SSD-Speicher (Leistung).
  - hyperdisk-balanced: Google Cloud Hyperdisk Balanced.
- BOOT_DISK_SIZE: die Größe des Bootlaufwerks des Knotens in GiB. Der Mindestwert beträgt 10.
Wenn Ihre Konfigurationsdatei andere Einstellungen enthält, ändern Sie diese nicht. Alle Änderungen oder Entfernungen in der Konfigurationsdatei ändern auch die entsprechenden Einstellungen auf Clusterebene.
Stellen Sie GKE die Konfigurationsdatei bereit, indem Sie das Flag --autoprovisioning-config-file und das Flag --enable-autoprovisioning für einen neuen oder vorhandenen Cluster angeben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-autoprovisioning \
    --autoprovisioning-config-file=PATH_TO_CONFIGURATION_FILE
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name des Clusters.
- PATH_TO_CONFIGURATION_FILE: der Pfad zur Konfigurationsdatei.

GKE reserviert einen Teil des Knoten-Bootlaufwerks für die Systemfunktionalität und für sitzungsspezifischen Speicher. Weitere Informationen finden Sie unter Flüchtiger Speicher mit Bootlaufwerk des Knotens.

Automatisch erstellte Knotenpools für häufige Szenarien konfigurieren

In den folgenden Abschnitten erfahren Sie, wie Sie automatisch erstellte Knotenpools für bestimmte gängige GKE-Anwendungsfälle anfordern. Weitere Informationen zu zusätzlichen Anwendungsfällen und unterstützten Konfigurationen finden Sie in der Dokumentation für Ihren spezifischen Anwendungsfall.

Maschinenserie oder Maschinentyp auswählen

Wählen Sie eine der folgenden Optionen aus, um eine unterstützte Compute Engine-Maschinenserie oder einen unterstützten Maschinentyp auszuwählen:

ComputeClass

Geben Sie in einem ComputeClass-Manifest eines der folgenden Felder im Feld spec.priorities an. Sie können beide Felder im selben ComputeClass-Manifest angeben, aber nicht in derselben Prioritätsregel.
- Wenn Sie eine Maschinenreihe auswählen möchten, geben Sie das Feld machineFamily in einer Prioritätsregel an:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineFamily: MACHINE_SERIES
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
  Ersetzen Sie MACHINE_SERIES durch eine Compute Engine-Maschinenserie, z. B. n4.
- Wenn Sie einen Maschinentyp auswählen möchten, geben Sie das Feld machineType in einer Prioritätsregel an:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machineType: MACHINE_TYPE
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
  Ersetzen Sie MACHINE_TYPE durch einen Compute Engine-Maschinentyp, z. B. c4-standard-96. In GKE-Version 1.33.2-gke.1111000 und höher können Sie in diesem Feld auch benutzerdefinierte Maschinentypen angeben.
Sie können das Feld machineFamily und das Feld machineType nicht in derselben Prioritätsregel angeben.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.
ComputeClass in einer Arbeitslast auswählen

Pod-Spezifikation

Wählen Sie in einem Pod-Manifest eines der folgenden Knotenlabels aus:
- Verwenden Sie das Knotenlabel cloud.google.com/machine-family, um eine Maschinenserie auszuwählen:
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
  Ersetzen Sie MACHINE_SERIES durch eine Compute Engine-Maschinenserie, z. B. n4.
- Verwenden Sie die Knotenlabels cloud.google.com/machine-family und node.kubernetes.io/instance-type, um einen vordefinierten Maschinentyp auszuwählen:
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: MACHINE_SERIES
    node.kubernetes.io/instance-type: MACHINE_TYPE
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
  Ersetzen Sie MACHINE_TYPE durch einen Compute Engine-Maschinentyp in der angegebenen Maschinenreihe. Wenn Sie beispielsweise n4 für MACHINE_SERIES angeben, können Sie n4-standard-80 für MACHINE_TYPE angeben.
  
  In GKE-Version 1.33.2-gke.1111000 können Sie in diesem Feld auch benutzerdefinierte Maschinentypen angeben.
Erstellen Sie den Pod:
```
kubectl apply -f PATH_TO_POD_MANIFEST
```
Ersetzen Sie PATH_TO_POD_MANIFEST durch den Pfad zum Pod-Manifest.

GPUs auswählen

Wählen Sie eine der folgenden Optionen aus, um GPUs für automatisch erstellte Knotenpools anzufordern:

ComputeClass

Geben Sie in einem ComputeClass-Manifest das Feld spec.priorities.gpu an:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - gpu:
      type: GPU_TYPE
      count: GPU_COUNT
      driverVersion: DRIVER_VERSION
  whenUnsatisfiable: DoNotScaleUp
  nodePoolAutoCreation:
    enabled: true
```
Ersetzen Sie Folgendes:
- GPU_TYPE: der GPU-Typ, der angehängt werden soll, z. B. nvidia-l4.
- GPU_COUNT: die Anzahl der GPUs, die an jeden Knoten angehängt werden sollen. Dieser Wert muss mindestens 1 sein.
- DRIVER_VERSION: die zu installierende GPU-Treiberversion. Dieser Wert muss default oder latest sein. Für dieses Feld ist die GKE-Version 1.31.1-gke.1858000 oder höher erforderlich.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.

Wählen Sie die ComputeClass in einer GPU-Arbeitslast aus, wie im folgenden Beispiel:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: nvidia-l4-class
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
      nvidia.com/gpu: 1

Pod-Spezifikation

Wenn Sie GPUs in Ihren Pod-Spezifikationen auswählen möchten, müssen Sie die automatische Knotenbereitstellung auf Clusterebene konfigurieren und Ressourcenlimits für diesen GPU-Typ festlegen. So konfigurieren Sie GPU-Ressourcenlimits und wählen GPUs in Ihren Pods aus:

Konfigurieren Sie Ressourcenlimits auf Clusterebene für die GPUs, die Sie verwenden möchten, wie im Abschnitt Ressourcenlimits für die automatische Erstellung von Knotenpools konfigurieren beschrieben.
Wählen Sie GPUs mithilfe von Knotenlabels in der Pod-Spezifikation aus:
```
apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: GPU_COUNT
    cloud.google.com/gke-gpu-driver-version: DRIVER_VERSION
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
      nvidia.com/gpu: GPU_QUANTITY
```
Ersetzen Sie Folgendes:
- GPU_TYPE: der GPU-Typ, der angehängt werden soll, z. B. nvidia-l4.
- GPU_COUNT: die Anzahl der GPUs, die an jeden Knoten angehängt werden sollen. Dieser Wert muss mindestens 1 sein.
- DRIVER_VERSION: die zu installierende GPU-Treiberversion. Dieser Wert muss default oder latest sein. In GKE-Version 1.32.2-gke.1297000 und höher installiert GKE automatisch die Treiberversion default. Für dieses Knotenlabel ist die GKE-Version 1.29.2-gke.1108000 oder höher erforderlich. Weitere Informationen finden Sie unter Treiber mithilfe der automatischen Knotenbereitstellung mit GPUs installieren.
- GPU_QUANTITY: Die Anzahl der GPUs, die an den Pod angehängt werden sollen. Dieser Wert muss kleiner oder gleich dem Wert von GPU_COUNT sein.

TPUs auswählen

Sie können TPUs in ComputeClasses oder Pod-Spezifikationen anfordern. In diesem Abschnitt wird davon ausgegangen, dass Sie mit der Cloud TPU-Auswahl vertraut sind und den TPU-Typ, die Topologie und die Anzahl der TPUs kennen, die Sie verwenden möchten. Die Schritte, die Sie ausführen, hängen davon ab, wie Sie TPUs auswählen:

ComputeClasses: Weitere Informationen finden Sie unter TPUs mit benutzerdefinierten Compute-Klassen bereitstellen.
Pod-Spezifikation:
1. Konfigurieren Sie Ressourcenlimits auf Clusterebene für die TPUs, die Sie verwenden möchten, wie im Abschnitt Ressourcenlimits für die automatische Erstellung von Knotenpools konfigurieren beschrieben.
2. Konfigurieren Sie Selektoren und Ressourcenanfragen in Ihren Pod-Spezifikationen, wie unter Arbeitslast auf TPU-Slice-Knoten ausführen beschrieben.

Laufzeit automatisch erstellter Knoten begrenzen

Sie können eine maximale Dauer angeben, nach der die GKE die automatisch erstellten Knoten beendet. Für dieses Zeitlimit gelten die Compute Engine-Einschränkungen.

Wählen Sie eine der folgenden Optionen aus:

ComputeClass

Verwenden Sie in einem ComputeClass-Manifest das Feld spec.priorities.maxRunDurationSeconds. Dieses Feld ist in der GKE-Version 1.32.1-gke.1159000 und höher verfügbar.
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS
spec:
  priorities:
  - machine-family: n4
    maxRunDurationSeconds: MAX_RUN_DURATION
  whenUnsatisfiable: DoNotScaleUp
  nodePoolAutoCreation:
    enabled: true
```
Ersetzen Sie MAX_RUN_DURATION durch die Zeit in Sekunden, die automatisch erstellte Knoten ausgeführt werden können, bevor GKE die Knoten beendet.
Wenden Sie das ComputeClass-Manifest auf den Cluster an:
```
kubectl apply -f PATH_TO_COMPUTECLASS_MANIFEST
```
Ersetzen Sie PATH_TO_COMPUTECLASS_MANIFEST durch den Pfad zur ComputeClass-Manifestdatei.
ComputeClass in einer Arbeitslast auswählen

Pod-Spezifikation

Verwenden Sie in Ihrem Pod-Manifest eine Knotenauswahl für das Knotenlabel cloud.google.com/gke-max-run-duration-seconds. Dieses Knotenlabel ist in GKE-Version 1.31.2-gke.1518000 und höher verfügbar.
```
apiVersion: v1
kind: Pod
metadata:
  name: machine-series-pod
spec:
  nodeSelector:
    cloud.google.com/machine-family: n4
    cloud.google.com/gke-max-run-duration-seconds: MAX_RUN_DURATION
  containers:
  - name: hello-app
    image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
```
Ersetzen Sie MAX_RUN_DURATION durch die Zeit in Sekunden, die automatisch erstellte Knoten ausgeführt werden können, bevor GKE die Knoten beendet.
Erstellen Sie den Pod:
```
kubectl apply -f PATH_TO_POD_MANIFEST
```
Ersetzen Sie PATH_TO_POD_MANIFEST durch den Pfad zum Pod-Manifest.

Mindest-CPU-Plattform angeben

Die automatische Knotenbereitstellung unterstützt das Erstellen von Knotenpools mit einer angegebenen Mindest-CPU-Plattform. Sie können die Mindest-CPU-Plattform auf Arbeitslastebene (empfohlen) oder auf Clusterebene angeben.

Automatische Erstellung von Knotenpools deaktivieren

In den folgenden Abschnitten wird beschrieben, wie Sie die automatische Erstellung von Knotenpools für bestimmte Knotenpools oder für den gesamten Cluster deaktivieren. Sie können die automatische Erstellung von Knotenpools in einer ComputeClass auch deaktivieren, indem Sie im Feld nodePoolAutoCreation.enabled der ComputeClass den Wert false angeben. Wir empfehlen jedoch nicht, die automatische Erstellung für ComputeClasses zu deaktivieren, da die automatische Erstellung ein Hauptvorteil von ComputeClasses ist, mit dem Sie Funktionen wie die aktive Migration und Fallback-Prioritäten nutzen können.

Automatische Erstellung für bestimmte Knotenpools deaktivieren

Sie können verhindern, dass GKE die Knoten in vorhandenen automatisch erstellten Knotenpools verwaltet. Diese Aktion hat folgende Auswirkungen:

Cluster Autoscaler erstellt oder löscht keine Knoten mehr in diesem Knotenpool. Wenn Sie möchten, dass GKE die Knoten automatisch skaliert, können Sie Cluster Autoscaler für diesen Knotenpool separat aktivieren.
Die GKE löscht den Knotenpool nicht, wenn die Anzahl der Knoten null ist.
Die GKE platziert weiterhin ausstehende Pods auf vorhandenen Knoten in diesem Knotenpool, die verfügbar sind. Wenn die automatische Knotenbereitstellung für den Cluster noch aktiviert ist, kann GKE bei Bedarf auch neue Knotenpools für ausstehende Pods erstellen.

Führen Sie den folgenden Befehl aus, um die automatische Erstellung für einen bestimmten Knotenpool zu deaktivieren:

gcloud container node-pools update NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Automatische Knotenbereitstellung für den Cluster deaktivieren

Sie können die automatische Erstellung von Knotenpools für den gesamten Cluster deaktivieren, indem Sie die Clustereinstellung für die automatische Knotenbereitstellung deaktivieren. Diese Aktion hat folgende Auswirkungen:

Cluster Autoscaler erstellt und löscht keine Knoten mehr in vorhandenen automatisch erstellten Knotenpools. Manuell erstellte Knotenpools, die Cluster Autoscaling verwenden, sind nicht betroffen.
Die GKE erstellt nicht automatisch neue Knotenpools für ausstehende Arbeitslasten. Überwachen Sie Ihren Cluster, um hängende Pods zu vermeiden.
Wenn der Cluster die folgenden Anforderungen erfüllt, erstellt die GKE weiterhin neue Knotenpools für ComputeClasses, die die automatische Erstellung ermöglichen:
- Verwendet die GKE-Version 1.33.3-gke.1136000 oder höher.
Wenn der Cluster diese Anforderungen nicht erfüllt, erstellt GKE keine neuen Knotenpools für ComputeClasses, die die automatische Erstellung aktivieren.

Wenn Sie die Einstellung für die automatische Knotenbereitstellung auf Clusterebene später wieder aktivieren, aktiviert GKE die automatische Erstellung von Knotenpools für vorhandene Knotenpools nicht wieder. Sie müssen einzelne Knotenpools als automatisch erstellt markieren.

Wählen Sie eine der folgenden Optionen aus, um die Einstellung für die automatische Knotenbereitstellung auf Clusterebene zu deaktivieren:

Console

Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

Zur Seite "Kubernetes-Cluster"
Klicken Sie auf den Namen des Clusters, den Sie ändern möchten. Die Seite Clusterdetails wird geöffnet.
Klicken Sie auf den Tab Details.
Klicken Sie im Abschnitt Automatisierung in der Zeile Automatische Knotenbereitstellung auf Bearbeiten. Der Bereich Automatische Knotenbereitstellung bearbeiten wird angezeigt.
Entfernen Sie das Häkchen bei Automatische Knotenbereitstellung aktivieren.
Klicken Sie auf Änderungen speichern.

gcloud

gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-autoprovisioning

Automatisches Erstellen von Knotenpools konfigurieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Beschränkungen

Hinweis

Voraussetzungen

Automatische Erstellung auf Arbeitslastebene aktivieren

Automatische Knotenbereitstellung auf Clusterebene aktivieren

Console

gcloud

Einstellungen mit einer Konfigurationsdatei für die automatische Knotenbereitstellung konfigurieren

Ressourcenlimits für die automatische Knotenbereitstellung konfigurieren

Console

gcloud

Konfigurationsdatei

Vorhandene Knotenpools als automatisch erstellt markieren

Standardeinstellungen für automatisch erstellte Knotenpools konfigurieren

Standardknoten-Image festlegen

ComputeClass

gcloud

Standard-IAM-Dienstkonto für Knoten festlegen

ComputeClass

gcloud

Standardzonen für automatisch erstellte Knoten festlegen

ComputeClass

gcloud

Kundenverwaltete Verschlüsselungsschlüssel für die Verschlüsselung des Bootlaufwerks festlegen

ComputeClass

gcloud

Knotenintegrität und Secure Boot konfigurieren

Automatische Knotenreparatur und automatische Upgrades konfigurieren

ComputeClass

gcloud

Einstellungen für Surge-Upgrades konfigurieren

Blau/Grün-Upgrades für neue automatisch erstellte Knotenpools verwenden

Benutzerdefinierte Bootlaufwerke für Knoten konfigurieren

ComputeClass

gcloud

Automatisch erstellte Knotenpools für häufige Szenarien konfigurieren

Maschinenserie oder Maschinentyp auswählen

ComputeClass

Pod-Spezifikation

GPUs auswählen

ComputeClass

Pod-Spezifikation

TPUs auswählen

Laufzeit automatisch erstellter Knoten begrenzen

ComputeClass

Pod-Spezifikation

Mindest-CPU-Plattform angeben

Automatische Erstellung von Knotenpools deaktivieren

Automatische Erstellung für bestimmte Knotenpools deaktivieren

Automatische Knotenbereitstellung für den Cluster deaktivieren

Console

gcloud

Nächste Schritte

Automatisches Erstellen von Knotenpools konfigurieren