Reservierte zonale Ressourcen nutzen

Auf dieser Seite erfahren Sie, wie Sie reservierte zonale Compute Engine-Ressourcen in bestimmten GKE-Arbeitslasten nutzen. Diese Kapazitätsreservierungen bieten Ihnen ein hohes Maß an Sicherheit, dass bestimmte Hardware für Ihre Arbeitslasten verfügbar ist.

Machen Sie sich mit den Konzepten von Compute Engine-Reservierungen vertraut, z. B. mit den Typen für Nutzung, Freigabe und Bereitstellung. Weitere Informationen finden Sie unter Zonale Reservierungen von Compute Engine-Ressourcen.

Diese Seite richtet sich an folgende Nutzer:

• Anwendungsoperatoren, die Arbeitslasten bereitstellen, die so schnell wie möglich ausgeführt werden sollen, in der Regel mit spezieller Hardware wie GPUs.
• Plattformadministratoren, die ein hohes Maß an Sicherheit haben möchten, dass Arbeitslasten auf optimierter Hardware ausgeführt werden, die sowohl Anwendungs- als auch Organisationsanforderungen erfüllt.

Reservierungsverbrauch in GKE

Mit Compute Engine-Kapazitätsreservierungen können Sie bestimmte Hardwarekonfigurationen in Google Cloud Zonen bereitstellen, entweder sofort oder zu einem bestimmten zukünftigen Zeitpunkt. Sie können diese reservierte Kapazität dann in GKE nutzen.

Je nach GKE-Betriebsmodus können Sie die folgenden Reservierungstypen nutzen:

• Autopilot-Modus: nur bestimmte Reservierungen.
• Standardmodus: bestimmte Reservierungen oder eine beliebige übereinstimmende Reservierung.

Wenn Sie Reservierungen zum Erstellen Ihrer Ressourcen nutzen möchten, müssen Sie eine Reservierungsaffinität wie any oder specific angeben.

Optionen für die Nutzung von Reservierungen in GKE

Mit GKE können Sie Reservierungen direkt in einzelnen Arbeitslasten nutzen, indem Sie Kubernetes-nodeSelectors in Ihrem Arbeitslastmanifest verwenden oder Knotenpools im Standardmodus erstellen, die die Reservierung nutzen. Auf dieser Seite wird beschrieben, wie Sie Reservierungen direkt in einzelnen Ressourcen auswählen.

Sie können GKE auch so konfigurieren, dass Reservierungen bei Skalierungsvorgängen verwendet werden, bei denen neue Knoten erstellt werden. Verwenden Sie dazu benutzerdefinierte Compute-Klassen. Mit benutzerdefinierten Compute-Klassen können Plattformadministratoren eine Hierarchie von Knotenkonfigurationen für GKE definieren, die bei der Knotenskalierung priorisiert werden sollen, damit Arbeitslasten auf der ausgewählten Hardware ausgeführt werden.

Sie können Reservierungen in der Konfiguration Ihrer benutzerdefinierten Compute-Klasse angeben, sodass jede GKE-Arbeitslast, die diese benutzerdefinierte Compute-Klasse verwendet, GKE anweist, die angegebenen Reservierungen für diese Compute-Klasse zu nutzen.

Weitere Informationen finden Sie auf der Seite „Benutzerdefinierte Compute-Klassen“ unter Compute Engine-Reservierungen nutzen.

Hinweise

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 gcloud components update ab.

Kapazitätsreservierungen in Autopilot-Clustern aufnehmen

Autopilot-Cluster unterstützen die Nutzung von Ressourcen aus Compute Engine-Kapazitätsreservierungen intern im selben Projekt oder in einem freigegebenen Projekt. Setzen Sie dafür die Eigenschaft „consumption_type“ der Zielreservierung auf specific und wählen Sie diese Reservierung in Ihrem Manifest explizit aus. Wenn Sie keine Reservierung explizit angeben, wird Autopilot-Cluster Reservierungen nicht aufnehmen. Weitere Informationen zu den Arten des Reservierungsverbrauchs finden Sie unter Funktionsweise von Reservierungen.

Für diese Reservierungen gelten flexible Compute-Rabatte für zugesicherte Nutzung. Sie müssen eine der Compute-Klassen Accelerator oder Performance nutzen, um Kapazitätsreservierungen in Anspruch zu nehmen.

• Bevor Sie beginnen, erstellen Sie einen Autopilot-Cluster, auf dem die folgenden Versionen ausgeführt werden:

  • Für die Nutzung reservierter Beschleuniger wie GPUs: 1.28.6-gke.1095000 oder höher
  • So führen Sie Pods auf einer bestimmten Maschinenserie aus und jeder Pod auf einem eigenen Knoten: 1.28.6-gke.1369000 und höher oder Version 1.29.1-gke.1575000 und höher.

Kapazitätsreservierungen für Autopilot erstellen

Autopilot-Pods können Reservierungen mit der Eigenschaft specific für den Verbrauchstyp im selben Projekt wie der Cluster oder in einer freigegebenen Reservierung aus einem anderen Projekt nutzen. Sie können die reservierte Hardware aufnehmen, indem Sie in Ihrem Manifest explizit auf diese Reservierung verweisen. Sie können Reservierungen in Autopilot für die folgenden Hardwaretypen nutzen:

• Einer der folgenden GPU-Typen:

  • nvidia-b200: NVIDIA B200 (180 GB)
  • nvidia-h200-141gb: NVIDIA H200 (141 GB)
  • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
  • nvidia-h100-80gb: NVIDIA H100 (80 GB)
  • nvidia-a100-80gb: NVIDIA A100 (80 GB)
  • nvidia-tesla-a100: NVIDIA A100 (80 GB)
  • nvidia-l4; NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4

• Eine der folgenden TPU-Typen:

  • tpu-v6e-slice: TPU v6e-Slice
  • tpu-v5p-slice: TPU v5p-Slice
  • tpu-v5-lite-podslice: TPU v5 lite-Podslice
  • tpu-v5-lite-device: TPU v5-Lite-Gerät
  • tpu-v4-lite-device: TPU v4 Lite-Gerät
  • tpu-v4-podslice: TPU v4-Podslice
  • tpu-v3-device: TPU v3-Gerät
  • tpu-v3-slice: TPU v3-Podslice

Informationen zum Erstellen einer Kapazitätsreservierung finden Sie in den folgenden Ressourcen. Die Reservierung muss die folgenden Anforderungen erfüllen:

• Die Maschinentypen, Beschleunigertypen und Beschleunigeranzahlen entsprechen dem, was Ihre Arbeitslasten benötigen.

• Für die Reservierung wird der Verbrauchstyp bestimmt verwendet. In der gcloud CLI müssen Sie beispielsweise das --require-specific-reservation-Flag angeben, wenn Sie die Reservierung erstellen.

• Reservierung für ein Einzelprojekt erstellen

• Freigegebene Reservierung erstellen

GKE hängt automatisch alle lokalen SSDs aus der ausgewählten spezifischen Reservierung an Ihren Knoten an. Sie müssen keine einzelnen lokalen SSDs in Ihrem Arbeitslastmanifest auswählen. Wenn die von Ihnen ausgewählte Reservierung beispielsweise zwei lokale SSDs enthält, werden an die Knoten, die GKE aus dieser Reservierung erstellt, zwei lokale SSDs angehängt.

Eine bestimmte Reservierung im selben Projekt in Autopilot nutzen

In diesem Abschnitt erfahren Sie, wie Sie eine bestimmte Kapazitätsreservierung nutzen, die sich im selben Projekt wie Ihr Cluster befindet. Sie können kubectl oder Terraform verwenden.

resource "kubernetes_pod_v1" "default_pod" {
  metadata {
    name = "specific-same-project-pod"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Performance"
      "cloud.google.com/machine-family"       = "c3"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_pod.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "8Gi"
          ephemeral-storage = "1Gi"
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_pod
  ]
}

resource "kubernetes_pod_v1" "default_accelerator" {
  metadata {
    name = "specific-same-project-accelerator"
  }

  spec {
    node_selector = {
      "cloud.google.com/compute-class"        = "Accelerator"
      "cloud.google.com/gke-accelerator"      = "nvidia-l4"
      "cloud.google.com/reservation-name"     = google_compute_reservation.specific_accelerator.name
      "cloud.google.com/reservation-affinity" = "specific"
    }

    container {
      name  = "my-container"
      image = "registry.k8s.io/pause"

      resources {
        requests = {
          cpu               = 2
          memory            = "7Gi"
          ephemeral-storage = "1Gi"
          "nvidia.com/gpu"  = 1

        }
        limits = {
          "nvidia.com/gpu" = 1
        }
      }

      security_context {
        allow_privilege_escalation = false
        run_as_non_root            = false

        capabilities {
          add  = []
          drop = ["NET_RAW"]
        }
      }
    }

    security_context {
      run_as_non_root     = false
      supplemental_groups = []

      seccomp_profile {
        type = "RuntimeDefault"
      }
    }
  }

  depends_on = [
    google_compute_reservation.specific_accelerator
  ]
}

Eine bestimmte freigegebene Reservierung in Autopilot nutzen

In diesem Abschnitt werden die folgenden Begriffe verwendet:

• Inhaberprojekt: das Projekt, zu dem die Reservierung gehört, und sie für andere Projekte freigibt.
• Nutzerprojekt: Das Projekt, in dem die Arbeitslasten ausgeführt werden, die die freigegebene Reservierung nutzen.

Damit eine freigegebene Reservierung genutzt werden kann, müssen Sie dem GKE-Dienst-Agent Zugriff auf die Reservierung in dem Projekt gewähren, das die Reservierung besitzt. Gehen Sie dazu so vor:

1. Erstellen Sie im Inhaberprojekt eine benutzerdefinierte IAM-Rolle mit der Berechtigung compute.reservations.list:

   gcloud iam roles create ROLE_NAME \
       --project=OWNER_PROJECT_ID \
       --permissions='compute.reservations.list'
   

   Ersetzen Sie Folgendes:

   • ROLE_NAME: ein Name für die neue Rolle.
   • OWNER_PROJECT_ID: die Projekt-ID des Projekts, zu dem die Kapazitätsreservierung gehört.

2. Gewähren Sie dem GKE-Dienst-Agent im Nutzerprojekt Zugriff, um freigegebene Reservierungen im Inhaberprojekt aufzulisten:

   gcloud projects add-iam-policy-binding OWNER_PROJECT_ID \
       --project=OWNER_PROJECT_ID \
       --member=serviceAccount:service-CONSUMER_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com \
       --role='projects/OWNER_PROJECT_ID/roles/ROLE_NAME'
   

   Ersetzen Sie CONSUMER_PROJECT_NUMBER durch die numerische Projektnummer Ihres Nutzerprojekts. Informationen zum Ermitteln dieser Nummer finden Sie in der Resource Manager-Dokumentation unter Projekte identifizieren.

3. Speichern Sie das folgende Manifest als shared-autopilot.yaml. Dieses Manifest enthält nodeSelectors, die GKE anweisen, eine bestimmte freigegebene Reservierung zu verwenden.

   VM-Instanzen

   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/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 2
           memory: "4Gi"
   

   Ersetzen Sie Folgendes:

   • MACHINE_SERIES: eine Maschinenserie, die den Maschinentyp der VMs in Ihrer spezifischen Kapazitätsreservierung enthält. Wenn Ihre Reservierung beispielsweise für c3-standard-4-Maschinentypen gilt, geben Sie c3 im Feld MACHINE_SERIES an.
   • RESERVATION_NAME: der Name der Compute Engine-Kapazitätsreservierung.
   • OWNER_PROJECT_ID: die Projekt-ID des Projekts, zu dem die Kapazitätsreservierung gehört.

   GPU-Beschleuniger

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-same-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: ACCELERATOR
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           nvidia.com/gpu: QUANTITY
   

   Ersetzen Sie Folgendes:

   • ACCELERATOR: der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Dies muss einer der folgenden Werte sein:
     • nvidia-b200: NVIDIA B200 (180 GB)
     • nvidia-h200-141gb: NVIDIA H200 (141 GB)
     • nvidia-h100-mega-80gb: NVIDIA H100 Mega (80 GB)
     • nvidia-h100-80gb: NVIDIA H100 (80 GB)
     • nvidia-a100-80gb: NVIDIA A100 (80 GB)
     • nvidia-tesla-a100: NVIDIA A100 (80 GB)
     • nvidia-l4; NVIDIA L4
     • nvidia-tesla-t4: NVIDIA T4
   • RESERVATION_NAME: der Name der Compute Engine-Kapazitätsreservierung.
   • OWNER_PROJECT_ID: die Projekt-ID des Projekts, zu dem die Kapazitätsreservierung gehört.
   • QUANTITY: Die Anzahl der GPUs, die dem Container zugewiesen werden sollen. Muss eine unterstützte Menge für die angegebene GPU sein, wie unter Unterstützte GPU-Mengen beschrieben.

   TPU-Beschleuniger

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-shared-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-tpu-accelerator: ACCELERATOR
       cloud.google.com/gke-tpu-topology: TOPOLOGY
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-project: OWNER_PROJECT_ID
       cloud.google.com/reservation-affinity: "specific"
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           google.com/tpu: QUANTITY
   

   Ersetzen Sie Folgendes:

   • ACCELERATOR: Der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Muss einer der folgenden Werte sein:
     • tpu-v6e-slice: TPU v6e-Slice
     • tpu-v5p-slice: TPU v5p-Slice
     • tpu-v5-lite-podslice: TPU v5 lite-Podslice
     • tpu-v5-lite-device: TPU v5-Lite-Gerät
     • tpu-v4-lite-device: TPU v4 Lite-Gerät
     • tpu-v4-podslice: TPU v4-Podslice
     • tpu-v3-device: TPU v3-Gerät
     • tpu-v3-slice: TPU v3-Podslice
   • TOPOLOGY: Die TPU-Topologie.
   • RESERVATION_NAME: der Name der Compute Engine-Kapazitätsreservierung.
   • OWNER_PROJECT_ID: die Projekt-ID des Projekts, zu dem die Kapazitätsreservierung gehört.
   • QUANTITY: Die Anzahl der TPUs, die an den Container angehängt werden sollen. Muss mit der TPU-Topologie übereinstimmen.

4. Stellen Sie den Pod bereit:

   kubectl apply -f shared-autopilot.yaml
   

Autopilot verwendet die reservierte Kapazität in der angegebenen Reservierung, um einen neuen Knoten zum Platzieren des Pods bereitzustellen.

Einen bestimmten Reservierungsblock in Autopilot nutzen

In diesem Abschnitt wird beschrieben, wie Sie einen bestimmten Kapazitätsreservierungsblock nutzen, der sich im selben Projekt wie Ihr Cluster oder in einem freigegebenen Projekt befindet. Diese Funktion ist nur für bestimmte Beschleuniger verfügbar. Mit kubectl können Sie Ihren Pod so konfigurieren, dass er den Reservierungsblock nutzt.

1. Speichern Sie das folgende Manifest als reservation-block-autopilot.yaml. Dieses Manifest enthält Knotenselektoren, die eine bestimmte Reservierung nutzen.

   Lokales Projekt

   apiVersion: v1
   kind: Pod
   metadata:
     name: specific-same-project-pod
   spec:
     nodeSelector:
       cloud.google.com/gke-accelerator: ACCELERATOR
       cloud.google.com/reservation-name: RESERVATION_NAME
       cloud.google.com/reservation-affinity: "specific"
       cloud.google.com/reservation-blocks: RESERVATION_BLOCKS_NAME
     
     containers:
     - name: my-container
       image: "k8s.gcr.io/pause"
       resources:
         requests:
           cpu: 12
           memory: "50Gi"
           ephemeral-storage: "200Gi"
         limits:
           nvidia.com/gpu: QUANTITY
   

   Ersetzen Sie Folgendes:

   • ACCELERATOR: Der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Muss einer der folgenden Werte sein:
     • nvidia-b200: NVIDIA B200 (180 GB)
     • nvidia-h200-141gb: NVIDIA H200 (141 GB)
   • RESERVATION_NAME: der Name der Compute Engine-Kapazitätsreservierung.
   • RESERVATION_BLOCKS_NAME: Der Name des Compute Engine-Kapazitätsreservierungsblocks.
   • QUANTITY: Die Anzahl der GPUs, die an den Container angehängt werden sollen. Muss eine unterstützte Menge für die angegebene GPU sein, wie unter Unterstützte GPU-Mengen beschrieben.

   Fügen Sie für Reservierungen, die einem anderen Projekt gehören, cloud.google.com/reservation-project: OWNER_PROJECT_ID dem Feld spec.nodeSelector hinzu. Ersetzen Sie OWNER_PROJECT_ID durch die Projekt-ID des Projekts, zu dem die Kapazitätsreservierung gehört.

2. Stellen Sie den Pod bereit:

   kubectl apply -f reservation-block-autopilot.yaml
   

   Autopilot verwendet die reservierte Kapazität im angegebenen Reservierungsblock, um einen neuen Knoten zum Platzieren des Pods bereitzustellen.

Fehlerbehebung bei der Nutzung von Reservierungen in Autopilot

• Achten Sie darauf, dass die Maschinentypen, Beschleunigertypen, lokalen SSD-Konfigurationen und Beschleunigeranzahlen mit den Anforderungen Ihrer Arbeitslasten übereinstimmen. Eine vollständige Liste der Eigenschaften, die übereinstimmen müssen, finden Sie unter Compute Engine-Eigenschaften für Kapazitätsreservierungen.
• Achten Sie darauf, dass die Reservierung mit einer bestimmten Affinität erstellt wird.
• Wenn Sie freigegebene Reservierungen verwenden, muss der GKE-Dienst-Agent im Nutzerprojekt die Berechtigung haben, freigegebene Reservierungen im Inhaberprojekt aufzulisten.

Reservierte Instanzen in GKE Standard nutzen

Sie können den Nutzungsmodus für die Reservierung mit dem Flag --reservation-affinity angeben, wenn Sie einen Cluster oder Knotenpool erstellen.

Jede übereinstimmende Reservierung nutzen

Sie können eine Reservierung und Instanzen erstellen, die eine beliebige Reservierung nutzen, indem Sie die gcloud CLI oder Terraform verwenden.

resource "google_compute_reservation" "any_reservation" {
  name = "any-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 3

    instance_properties {
      machine_type = "e2-medium"
    }
  }
}

resource "google_container_cluster" "default" {
  name     = "gke-standard-zonal-cluster"
  location = "us-central1-a"

  initial_node_count = 1

  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }

  depends_on = [
    google_compute_reservation.any_reservation
  ]
}

resource "google_container_node_pool" "any_node_pool" {
  name     = "gke-standard-zonal-any-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 3
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "ANY_RESERVATION"
    }
  }
}

Eine bestimmte Reservierung für ein einzelnes Projekt nutzen

Wenn Sie eine bestimmte Reservierung nutzen möchten, setzen Sie das Reservierungsaffinitäts-Flag auf --reservation-affinity=specific und geben Sie den spezifischen Reservierungsnamen an. In diesem Modus müssen Instanzen Kapazität aus der angegebenen Reservierung in der Zone nutzen. Die Anfrage schlägt fehl, wenn die Reservierung nicht über ausreichende Kapazität verfügt.

Führen Sie die folgenden Schritte aus, um eine Reservierung und Instanzen zu erstellen, die eine bestimmte Reservierung nutzen: Sie können die gcloud CLI oder Terraform verwenden.

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

Eine bestimmte freigegebene Reservierung nutzen

Führen Sie die folgenden Schritte aus, um eine bestimmte freigegebene Reservierung zu erstellen und zu nutzen. Sie können die gcloud CLI oder Terraform verwenden.

1. Führen Sie die Schritte unter Erstellen und Ändern von freigegebenen Reservierungen für Projekte zulassen und beschränken aus.

resource "google_compute_reservation" "specific_reservation" {
  name = "specific-reservation"
  zone = "us-central1-a"

  specific_reservation {
    count = 1

    instance_properties {
      machine_type = "e2-medium"
    }
  }

  specific_reservation_required = true
}

resource "google_container_node_pool" "specific_node_pool" {
  name     = "gke-standard-zonal-specific-node-pool"
  cluster  = google_container_cluster.default.name
  location = google_container_cluster.default.location

  initial_node_count = 1
  node_config {
    machine_type = "e2-medium"

    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key                      = "compute.googleapis.com/reservation-name"
      values                   = [google_compute_reservation.specific_reservation.name]
    }
  }

  depends_on = [
    google_compute_reservation.specific_reservation
  ]
}

Weitere wichtige Aspekte der Nutzung einer bestimmten Reservierung

Wenn ein Knotenpool mit einer Affinität zu einer bestimmten Reservierung erstellt wird, einschließlich Standardknotenpools während der Clustererstellung, ist seine Größe über die gesamte Lebensdauer des Knotenpools auf die Kapazität der spezifischen Reservierung beschränkt. Dies betrifft die folgenden GKE-Features:

• Cluster mit mehreren Zonen: In regionalen oder multizonalen Clustern können sich Knoten eines Knotenpools über mehrere Zonen erstrecken. Da Reservierungen immer in nur einer Zone liegen, sind mehrere Reservierungen erforderlich. Wenn Sie einen Knotenpool erstellen möchten, der eine bestimmte Reservierung in diesen Clustern nutzt, müssen Sie in jeder Zone des Knotenpools eine bestimmte Reservierung mit exakt demselben Namen und denselben Maschineneigenschaften erstellen.
• Cluster-Autoscaling und Knotenpool-Upgrades: Wenn Sie in der spezifischen Reservierung keine zusätzliche Kapazität haben, schlagen Knotenpool-Upgrades oder die automatische Skalierung des Knotenpools möglicherweise fehl, da beide Vorgänge das Erstellen zusätzlicher Instanzen erfordern. Dieses Problem können Sie so beheben: Ändern Sie die Größe der Reservierung oder geben Sie einige von deren gebundenen Ressourcen frei.

GPU-Reservierungen nutzen

Wenn Sie einen Standardknotenpool erstellen möchten, der eine GPU-Reservierung oder eine beliebige Reservierung nutzt, bei der sich die Kapazität in einer einzelnen Zone befindet, müssen Sie das Flag --node-locations angeben, wenn Sie einen Knotenpool hinzufügen. Wenn Sie einen regionalen Standard-Cluster oder einen multizonalen Standard-Cluster erstellen, können Sie die Knotenstandorte angeben. So wird sichergestellt, dass GKE Knoten nur in einer Zone erstellt, in der Sie GPU-Kapazität reserviert haben.

Eine detaillierte Anleitung zum Erstellen eines Knotenpools mit GPUs finden Sie unter GPU-Knotenpool erstellen.

TPU-Reservierungen nutzen

Wenn Sie einen Standardknotenpool erstellen möchten, der eine TPU-Reservierung nutzt, müssen Sie beim Hinzufügen eines Knotenpools das Flag --node-locations angeben. Wenn Sie einen regionalen Standardcluster oder einen multizonalen Standardcluster erstellen, wird durch die Angabe der Knotenstandorte dafür gesorgt, dass GKE Knoten nur in einer Zone erstellt, in der Sie TPU-Kapazität reserviert haben.

TPU-Reservierungen unterscheiden sich von anderen Maschinentypen. Die folgenden TPU-spezifischen Aspekte sollten Sie beim Erstellen von TPU-Reservierungen berücksichtigen:

• Wenn Sie TPUs in GKE verwenden, ist SPECIFIC der einzige unterstützte Wert für das Flag --reservation-affinity.

Eine detaillierte Anleitung zum Erstellen eines Knotenpools mit TPUs finden Sie unter TPU-Knotenpool erstellen.

Knoten ohne Nutzung von Reservierungen erstellen

Wenn Sie die Nutzung von Ressourcen aus Reservierungen explizit verhindern möchten, setzen Sie die Affinität auf --reservation-affinity=none.

1. Erstellen Sie einen Cluster, der keine Reservierung nutzt:

   gcloud container clusters create CLUSTER_NAME --reservation-affinity=none
   

   Ersetzen Sie CLUSTER_NAME durch den Namen des zu erstellenden Clusters.

2. Erstellen Sie einen Knotenpool, der keine Reservierung nutzt:

   gcloud container node-pools create NODEPOOL_NAME \
       --cluster CLUSTER_NAME \
       --reservation-affinity=none
   

   Ersetzen Sie NODEPOOL_NAME durch den Namen des zu aktualisierenden Knotenpools.

Verfügbare Reservierungen zwischen Zonen

Wenn Sie Knotenpools verwenden, die in mehreren Zonen mit Reservierungen ausgeführt werden, die nicht zwischen Zonen übereinstimmen, können Sie das Flag --location_policy=ANY verwenden. Dadurch wird sichergestellt, dass neue Knoten, die dem Cluster hinzugefügt werden, in der Zone erstellt werden, die noch nicht verwendete Reservierungen hat.

Bereinigen

So vermeiden Sie, dass Ihrem Cloud-Rechnungskonto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden:

1. Löschen Sie die erstellten Cluster mit dem folgenden Befehl für jeden Cluster:

   gcloud container clusters delete CLUSTER_NAME
   

2. Löschen Sie die von Ihnen erstellten Reservierungen mit dem folgenden Befehl für jede Reservierung:

   gcloud compute reservations delete RESERVATION_NAME
   

Nächste Schritte

• Zonale Compute Engine-Ressourcen reservieren
• Knotenpools
• Cluster Autoscaler
• Weitere Informationen zu Knotenupgrade-Strategien