GKE-Pods in bestimmten Zonen platzieren

Auf dieser Seite wird beschrieben, wie Sie Google Kubernetes Engine (GKE) anweisen, Ihre Pods mithilfe der zonalen Topologie auf Knoten in bestimmten Google Cloud Zonen auszuführen. Diese Art von Placement ist in folgenden Situationen nützlich:

  • Pods müssen auf Daten zugreifen, die auf einem zonalen nichtflüchtigen Compute Engine-Speicher gespeichert sind.
  • Pods müssen zusammen mit anderen zonalen Ressourcen wie Cloud SQL-Instanzen ausgeführt werden.

Sie können die zonale Platzierung auch mit topologiebezogenem Traffic-Routing verwenden, um die Latenz zwischen Clients und Arbeitslasten zu reduzieren. Weitere Informationen zum topologiebezogenen Traffic-Routing finden Sie unter Topologie-fähiges Routing.

Die Verwendung der zonalen Topologie zur Steuerung der Pod-Platzierung ist ein erweiterter Kubernetes-Mechanismus, den Sie nur verwenden sollten, wenn Ihre Pods in bestimmten Zonen ausgeführt werden müssen. In den meisten Produktionsumgebungen empfehlen wir, nach Möglichkeit regionale Ressourcen zu verwenden. Dies ist die Standardeinstellung in GKE.

Zonale Platzierungsmethoden

Die zonale Topologie ist in Kubernetes mit dem Knotenlabel topology.kubernetes.io/zone: ZONE implementiert. Sie können GKE mit einer der folgenden Methoden anweisen, einen Pod in einer bestimmten Zone zu platzieren:

  • nodeAffinity: Geben Sie in Ihrer Pod-Spezifikation eine nodeAffinity-Regel für eine oder mehrere Google Cloud -Zonen an. Diese Methode ist flexibler als ein nodeSelector, weil Sie damit Pods in mehreren Zonen platzieren können.

  • nodeSelector: Geben Sie einen nodeSelector in Ihrer Pod-Spezifikation für eine einzelne Google Cloud -Zone an.

  • Compute-Klassen: Konfigurieren Sie Ihren Pod für die Verwendung einer GKE-Compute-Klasse. So können Sie eine priorisierte Liste von Sets mit Google Cloud Zonen definieren. Dadurch kann die Arbeitslast dynamisch in die bevorzugten Zonen verschoben werden, wenn in diesen Zonen Knoten verfügbar sind. Weitere Informationen finden Sie unter Benutzerdefinierte Compute-Klassen.

Hinweise

Bei der zonalen Pod-Platzierung mit zonaler Topologie gilt Folgendes:

  • Der Cluster muss sich in derselben Google Cloud Region wie die angeforderten Zonen befinden.
  • In Standardclustern müssen Sie die automatische Knotenbereitstellung verwenden oder Knotenpools mit Knoten in den angeforderten Zonen erstellen. Autopilot-Cluster verwalten diesen Prozess automatisch für Sie.
  • Standardcluster müssen regionale Cluster sein.

Preise

Zonale Topologie ist eine Kubernetes-Planungsfunktion, die ohne zusätzliche Kosten in GKE angeboten wird.

Preisdetails finden Sie unter GKE-Preise.

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 dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
  • Sie benötigen einen GKE-Cluster in derselbenGoogle Cloud -Region wie die Zonen, in denen Sie Ihre Pods platzieren möchten. Informationen zum Erstellen eines neuen Clusters finden Sie unter Autopilot-Cluster erstellen.

Pods mithilfe von nodeAffinity in mehreren Zonen platzieren

Die Knotenaffinität von Kubernetes bietet einen flexiblen Mechanismus zur Planung der Planung, der mehrere Labelselektoren und logische Operatoren unterstützt. Verwenden Sie nodeAffinity, wenn Sie Pods in einer von mehreren Zonen ausführen möchten (z. B. in us-central1-a oder us-central1-f).

  1. Speichern Sie das folgende Manifest als multi-zone-affinity.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-multi-zone
  template:
    metadata:
      labels:
        app: nginx-multi-zone
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: topology.kubernetes.io/zone
                operator: In
                values:
                - us-central1-a
                - us-central1-f

    Dieses Manifest erstellt ein Deployment mit drei Replikaten und platziert die Pods je nach Knotenverfügbarkeit in us-central1-a oder us-central1-f.

    Achten Sie darauf, dass sich Ihr Cluster in der Region us-central1 befindet. Wenn sich Ihr Cluster in einer anderen Region befindet, ändern Sie die Zonen im Feld „Werte“ des Manifests in gültige Zonen in Ihrer Clusterregion.

  2. Erstellen Sie das Deployment:

    kubectl create -f multi-zone-affinity.yaml

    GKE erstellt die Pods in Knoten in einer der angegebenen Zonen. Es können mehrere Pods auf demselben Knoten ausgeführt werden. Optional können Sie die Pod-Anti-Affinität verwenden, um GKE anzuweisen, jeden Pod auf einem separaten Knoten zu platzieren.

Pods mit einem nodeSelector in einer einzelnen Zone platzieren

Wenn Sie Pods in einer einzelnen Zone platzieren möchten, verwenden Sie einen nodeSelector in der Pod-Spezifikation. Ein nodeSelector entspricht einer nodeAffinity-Regel requiredDuringSchedulingIgnoredDuringExecution, in der eine einzelne Zone angegeben ist.

  1. Speichern Sie das folgende Manifest als single-zone-selector.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-singlezone
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-singlezone
  template:
    metadata:
      labels:
        app: nginx-singlezone
    spec:
      nodeSelector:
        topology.kubernetes.io/zone: "us-central1-a"
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

    Dieses Manifest weist GKE an, alle Replikate im Deployment in der Zone us-central1-a zu platzieren.

  2. Erstellen Sie das Deployment:

    kubectl create -f single-zone-selector.yaml

Pod-Platzierung in ausgewählten Zonen mit einer Compute-Klasse priorisieren

GKE-Compute-Klassen bieten einen Kontrollmechanismus, mit dem Sie eine Liste von Prioritäten für die Knotenkonfiguration definieren können. Mit zonalen Einstellungen können Sie die Zonen definieren, in denen GKE Pods platzieren soll. Zum Definieren von zonalen Einstellungen in Compute-Klassen ist die GKE-Version 1.33.1-gke.1545000 oder höher erforderlich.

Im folgenden Beispiel wird eine Compute-Klasse erstellt, in der eine Liste bevorzugter Zonen für Pods angegeben wird.

Bei diesen Schritten wird davon ausgegangen, dass sich Ihr Cluster in der Region us-central1 befindet. Wenn sich Ihr Cluster in einer anderen Region befindet, ändern Sie die Werte der Zonen im Manifest in gültige Zonen in Ihrer Clusterregion.

  1. Speichern Sie das folgende Manifest als zones-custom-compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: zones-custom-compute-class
spec:
  priorities:
  - location:
    zones: [us-central1-a, us-central1-b]
  - location:
    zones: [us-central1-c]
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true
  whenUnsatisfiable: ScaleUpAnyway

    Das Manifest für diese Compute-Klasse ändert das Skalierungsverhalten so:

    1. GKE versucht, Pods entweder in us-central1-a oder in us-central1-b zu platzieren.
    2. Wenn in us-central1-a und us-central1-b keine Kapazität verfügbar ist, versucht GKE, Pods in us-central1-c zu platzieren.
    3. Wenn in us-central1-c keine Kapazität verfügbar ist, sorgt das Feld whenUnsatisfiable: ScaleUpAnyway dafür, dass GKE die Pods in einer beliebigen verfügbaren Zone in der Region platziert.
    4. Wenn eine Zone mit höherer Priorität in der Compute-Klasse später verfügbar wird, sorgt das Feld activeMigration.optimizeRulePriority: true dafür, dass GKE die Pods aus allen Zonen mit niedrigerer Priorität in diese Zone verschiebt. Bei dieser Migration wird das Budget für Pod-Störungen verwendet, um die Dienstverfügbarkeit sicherzustellen.

  2. Benutzerdefinierte Compute-Klasse erstellen:

    kubectl create -f zones-custom-compute-class.yaml

    GKE erstellt eine benutzerdefinierte Compute-Klasse, auf die Ihre Arbeitslasten verweisen können.

  3. Speichern Sie das folgende Manifest als custom-compute-class-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-zonal-preferences
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx-zonal-preferences
  template:
    metadata:
      labels:
        app: nginx-zonal-preferences
    spec:
      nodeSelector:
        cloud.google.com/compute-class: "zones-custom-compute-class"
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

  4. Erstellen Sie das Deployment:

    kubectl create -f custom-compute-class-deployment.yaml

Pod-Platzierung prüfen

Um die Pod-Platzierung zu überprüfen, listen Sie die Pods auf und prüfen Sie die Knotenlabels. Mehrere Pods können auf einem einzelnen Knoten ausgeführt werden. Wenn Sie also „nodeAffinity“ verwenden, werden möglicherweise keine Pods in mehreren Zonen angezeigt.

  1. Listen Sie Ihre Pods auf:

    kubectl get pods -o wide

    Die Ausgabe ist eine Liste der ausgeführten Pods und des entsprechenden GKE-Knotens.

  2. Beschreiben Sie die Knoten:

    kubectl describe node NODE_NAME | grep "topology.kubernetes.io/zone"

    Ersetzen Sie NODE_NAME durch den Namen des Knotens.

    Die Ausgabe sieht in etwa so aus:

    topology.kubernetes.io/zone: us-central1-a

Wenn Sie möchten, dass GKE Ihre Pods gleichmäßig auf mehrere Zonen verteilt, um das Failover über mehrere fehlerhafte Domains hinweg zu verbessern, verwenden Sie topologySpreadConstraints.

Nächste Schritte