Diese Seite wurde von der Cloud Translation API übersetzt.

Compute-Klassen standardmäßig auf Pods anwenden

Autopilot Standard

Auf dieser Seite erfahren Sie, wie Sie Compute-Klassen standardmäßig auf Google Kubernetes Engine-Pods (GKE) anwenden, für die keine Compute-Klasse explizit ausgewählt wurde. Auf dieser Seite finden Sie eine Anleitung zum Festlegen einer Compute-Klasse als Standard in einem Namespace und für einen gesamten Cluster. Diese Anleitung richtet sich an Clusteradministratoren, die den manuellen Aufwand für die Konfiguration einzelner Arbeitslasten und Knoten reduzieren möchten.

Machen Sie sich vor dem Lesen dieser Seite mit benutzerdefinierten Compute-Klassen vertraut.

Standard-Compute-Klassen

Sie können GKE-Cluster oder bestimmte Namespaces so konfigurieren, dass sie eine Standard-Compute-Klasse haben. Die von Ihnen konfigurierte Standardklasse gilt für alle Pods in diesem Cluster oder Namespace, für die keine andere Compute-Klasse ausgewählt ist. Wenn Sie einen Pod bereitstellen, für den keine Compute-Klasse ausgewählt ist, wendet GKE die Standard-Compute-Klassen in der folgenden Reihenfolge an:

Wenn für den Namespace eine Standard-Compute-Klasse festgelegt ist, ändert GKE die Pod-Spezifikation, um diese Compute-Klasse auszuwählen.
Wenn für den Namespace keine Standard-Compute-Klasse festgelegt ist, wird die Standardklasse auf Clusterebene angewendet. GKE ändert die Pod-Spezifikation nicht.

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 diesen Task 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.
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.

Sie haben einen GKE Autopilot- oder Standardcluster, in dem eine Version ausgeführt wird, die das Festlegen einer Compute-Standardklasse auf Cluster- oder Namespace-Ebene unterstützt. Weitere Informationen finden Sie im Abschnitt Anforderungen.

Aktivieren Sie für Standardcluster die automatische Knotenbereitstellung oder das Cluster-Autoscaling.
Wenn Sie eine benutzerdefinierte Compute-Klasse als Standard für einen Namespace festlegen möchten, stellen Sie eine benutzerdefinierte Compute-Klasse bereit.

Voraussetzungen

Damit Sie eine Compute-Klasse als Standard auf Clusterebene festlegen können, muss auf dem Cluster die GKE-Version 1.33.1-gke.1744000 oder höher ausgeführt werden.
Wenn Sie eine Compute-Klasse als Standard auf Namespace-Ebene nur für Nicht-DaemonSet-Pods festlegen möchten, muss der Cluster die GKE-Version 1.33.1-gke.1788000 oder höher ausführen.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Google Cloud Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren von Standard-Compute-Klassen auf Cluster- oder Namespace-Ebene benötigen:

Kubernetes Engine-Entwickler (roles/container.developer)
Standardmäßige Compute-Klasse auf Clusterebene aktualisieren: Administrator für Kubernetes Engine-Cluster (roles/container.clusterAdmin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Konfigurieren von Standard-Compute-Klassen auf Cluster- oder Namespace-Ebene erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Standard-Compute-Klassen auf Cluster- oder Namespace-Ebene zu konfigurieren:

container.customResourceDefinitions.create
container.customResourceDefinitions.update
container.customResourceDefinitions.get
container.customResourceDefinitions.list
container.namespaces.get
container.namespaces.list
container.pods.get
container.nodes.get
container.nodes.list
container.deployments.create
container.deployments.get
Labels zu Namespaces hinzufügen: container.namespaces.update
Aktivieren Sie die Standard-Compute-Klasse auf Clusterebene: container.clusters.update

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Compute-Standardklasse für einen Namespace konfigurieren

Sie können jeden Kubernetes-Namespace in Ihrem Cluster mit dem Namen einer Compute-Klasse annotieren, die als Standard verwendet werden soll. Wenn für einen Pod, der in diesem Namespace bereitgestellt wird, noch keine Compute-Klasse ausgewählt ist, ändert GKE die Pod-Spezifikation, um die Standardklasse im Namespace auszuwählen. Sie können eine beliebige benutzerdefinierte oder integrierte Compute-Klasse als Standard festlegen.

Wenn Sie eine Compute-Klasse standardmäßig auf alle Pods in einem Namespace anwenden möchten, fügen Sie diesem Namespace das Label cloud.google.com/default-compute-class hinzu:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME
```
Ersetzen Sie Folgendes:
- NAMESPACE_NAME: der Name des Namespace, der aktualisiert werden soll.
- COMPUTECLASS_NAME: Der Name der Compute-Klasse, die als Standard für den Namespace festgelegt werden soll.
Wenn der Befehl mit der folgenden Fehlermeldung fehlschlägt, hat der Namespace bereits eine Standard-Compute-Klasse:
```
error: 'cloud.google.com/default-compute-class' already has a value, and --overwrite is false
```
Aktualisieren Sie die Compute-Standardklasse für den Namespace, um diesen Fehler zu beheben.
Wenn Sie standardmäßig eine Compute-Klasse auf alle Nicht-DaemonSet-Pods in einem Namespace anwenden möchten, fügen Sie diesem Namespace das Label cloud.google.com/default-compute-class-non-daemonset hinzu:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME
```
Wenn der Befehl mit der folgenden Fehlermeldung fehlschlägt, hat der Namespace bereits eine Standard-Compute-Klasse für Nicht-DaemonSet-Pods:
```
error: 'cloud.google.com/default-compute-class-non-daemonset' already has a value, and --overwrite is false
```
Aktualisieren Sie die Compute-Standardklasse für den Namespace, um diesen Fehler zu beheben.

Vorhandene Compute-Standardklasse in einem Namespace aktualisieren

Führen Sie einen der folgenden Befehle aus, um die vorhandene Standard-Compute-Klasse für einen Namespace zu überschreiben:

Aktualisieren Sie die Standard-Compute-Klasse für alle Pods im Namespace:
```
kubectl label namespaces NAMESPACE_NAME   \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME \
    --overwrite
```
Ersetzen Sie Folgendes:
- NAMESPACE_NAME: der Name des Namespace, der aktualisiert werden soll.
- COMPUTECLASS_NAME: Der Name der Compute-Klasse, die als neuer Standard für den Namespace festgelegt werden soll.

Überschreiben Sie die Standard-Compute-Klasse für Nicht-DaemonSet-Pods im Namespace:

kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME \
    --overwrite

Compute-Standardklasse für einen Cluster konfigurieren

In diesem Abschnitt erfahren Sie, wie Sie eine Compute-Klasse als Standard für Ihren Cluster festlegen. Bei Standard-Compute-Klassen auf Clusterebene müssen Sie keine Knotenmarkierungen und Knotenlabels für vorhandene Knotenpools im Cluster manuell angeben. GKE skaliert keine Knotenpools, die Knotenmarkierungen für Compute-Klassen haben. Wenn Sie manuell ein Label für die Compute-Klasse default hinzufügen, kann GKE diesen Knotenpool skalieren. Diese manuelle Konfiguration ist jedoch nicht erforderlich, um eine Standard-Compute-Klasse auf Clusterebene zu verwenden.

Wenn Sie eine Standard-Compute-Klasse auf Clusterebene für einen Cluster festlegen möchten, führen Sie den Befehl gcloud container clusters update mit dem Flag --enable-default-compute-class aus:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-default-compute-class
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name Ihres Clusters.
- CONTROL_PLANE_LOCATION: Der Standort der Cluster-Steuerungsebene, z. B. us-central1.
Sie können dieses Flag auch angeben, wenn Sie einen Autopilot- oder Standardcluster erstellen.
Speichern Sie das folgende Manifest, in dem ein ComputeClass mit dem Namen default definiert wird:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
In diesem Beispielmanifest werden Knoten angefordert, die N4-Instanzen verwenden. Wenn N4-Instanzen nicht verfügbar sind, werden stattdessen N2-Instanzen angefordert. Sie können die Compute-Klasse default mit einem der verfügbaren Felder in der CustomResourceDefinition „ComputeClass“ konfigurieren.
Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f PATH_TO_MANIFEST
```
Ersetzen Sie PATH_TO_MANIFEST durch den Pfad zum Manifest für die Compute-Klasse.

Nachdem Sie eine Standard-Compute-Klasse auf Clusterebene festgelegt haben, skaliert GKE Knotenpools, die beide der folgenden Anforderungen erfüllen:

Die Knotenkonfiguration ist dieselbe wie die Konfiguration der Compute-Klasse default.
Der Knotenpool hat keine Taints oder Labels für eine andere Rechenklasse. GKE kann Knotenpools skalieren, die eine Markierung und ein Label für die Compute-Klasse default haben.

Wenn beispielsweise die Compute-Klasse default die N4-Maschinenserie angibt, kann GKE einen vorhandenen Knotenpool skalieren, der N4-Instanzen verwendet und keine Taints oder Labels für eine andere Compute-Klasse hat.

Verhalten der Standard-Compute-Klasse prüfen

So prüfen Sie, ob die Standard-Compute-Klasse, die Sie für einen Namespace oder einen Cluster festgelegt haben, wie erwartet funktioniert:

Sehen Sie sich das folgende Beispiel-Deployment an:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
      tier: web
  template:
    metadata:
      labels:
        app: hello
        tier: web
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 200m

Bei diesem Deployment wird keine Compute-Klasse explizit angefordert.

Erstellen Sie das Deployment:
```
kubectl apply --namespace=NAMESPACE_NAME \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/quickstarts/hello-app/manifests/helloweb-deployment.yaml
```
Ersetzen Sie NAMESPACE_NAME durch einen der folgenden Werte, je nachdem, was Sie bestätigen möchten:
- Der Name eines Namespace mit einer Standard-Compute-Klasse.
- Der Name eines Namespace, für den keine Standard-Compute-Klasse festgelegt ist.
Es kann einige Zeit dauern, bis GKE neue Knoten zum Ausführen der Pods erstellt.

Ermitteln Sie die Knoten, auf denen die Pods des Beispiel-Deployments ausgeführt werden:

kubectl get pods --namespace=NAMESPACE_NAME \
    --selector=app=hello -o=wide

Die Ausgabe sieht etwa so aus:

NAME                        READY   STATUS    RESTARTS   AGE     IP          NODE                                                  NOMINATED NODE   READINESS GATES
helloweb-7795fbf856-58n5l   1/1     Running   0          9m21s   10.52.2.3   gke-cluster-1-nap-n2-highcpu-2-3muqi8-f213e529-rx7d   <none>           <none>

Rufen Sie die Knotenlabels ab:
```
kubectl get node NODE_NAME --show-labels \
    | grep "cloud.google.com/compute-class"
```
Ersetzen Sie NODE_NAME durch den Namen des Knotens aus der Ausgabe des vorherigen Schritts.

Die Ausgabe sieht etwa so aus:
```
NODE_NAME   Ready    <none>   22m   v1.32.4-gke.1236007
# lines are omitted from this output
cloud.google.com/compute-class=COMPUTECLASS_NAME,cloud.google.com/gke-boot-disk=pd-balanced,cloud.google.com/gke-container-runtime=containerd
```
Der Wert in COMPUTECLASS_NAME ist einer der folgenden:
- Standard-Compute-Klasse auf Clusterebene: default für Knoten, die von GKE Autopilot oder durch automatische Knotenbereitstellung erstellt wurden. Knoten in vorhandenen manuell erstellten Knotenpools haben möglicherweise nicht das Label cloud.google.com/compute-class.
- Standard-Compute-Klasse auf Namespace-Ebene: Der Name der Compute-Klasse, die Sie als Standard für den Namespace konfiguriert haben.

Standard-Compute-Klasse deaktivieren

Wenn Sie die Standard-Compute-Klasse in einem Namespace oder Cluster deaktivieren möchten, haben Sie folgende Möglichkeiten:

Wenn Sie die Standard-Compute-Klasse auf Namespace-Ebene für alle Pods deaktivieren möchten, entfernen Sie das Label cloud.google.com/default-compute-class aus dem Namespace:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-
```
Das Zeichen - am Ende des Labelschlüssels entfernt alle Labels mit diesem Schlüssel aus dem Namespace-Objekt in der Kubernetes API.
Wenn Sie die Standard-Compute-Klasse auf Namespace-Ebene für Nicht-DaemonSet-Pods deaktivieren möchten, entfernen Sie das Label cloud.google.com/default-compute-class-non-daemonset aus dem Namespace:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-non-daemonset-
```
Verwenden Sie den Befehl gcloud container clusters update mit dem Flag --no-enable-default-compute-class, um die Standard-Compute-Klasse auf Clusterebene zu deaktivieren:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-default-compute-class
```

Nächste Schritte

Weitere Informationen zu benutzerdefinierten Compute-Klassen in GKE