Hochverfügbare Containeranwendung bereitstellen

In diesem Dokument wird beschrieben, wie Sie eine hochverfügbare Kubernetes-Containeranwendung in Google Distributed Cloud (GDC) mit Air Gap bereitstellen. Um Ausfallsicherheit zu gewährleisten, müssen Sie Ihre Anwendung über mehrere Zonen hinweg bereitstellen und die Speicherreplikation so konfigurieren, dass die Anwendung und ihre Daten im Falle unerwarteter Ausfallzeiten oder lokaler Katastrophen wiederhergestellt werden können.

Dieses Dokument richtet sich an Anwendungsentwickler, die für die Erstellung resilienter Containerarbeitslasten verantwortlich sind.

Weitere Informationen finden Sie unter Dokumentation zu Zielgruppen für GDC mit Air Gap.

Ziele

  • Erstellen Sie einen Kubernetes-Cluster in zwei oder mehr Zonen in Ihrem GDC-Universum.
  • Globales Load Balancing konfigurieren
  • Containerarbeitslasten in jedem zonalen Kubernetes-Cluster bereitstellen
  • Speicher bereitstellen und an Ihre Pods anhängen.
  • Konfigurieren Sie die Speicherreplikation entweder mit Blockspeicher oder Objektspeicher.

Hinweis

Zur Vorbereitung auf die Aufgaben in diesem Dokument müssen Sie die erforderlichen Berechtigungen einholen und Ihre Umgebung prüfen.

IAM-Rollen und -Berechtigungen anfordern

Wenden Sie sich an Ihren IAM-Organisationsadministrator, um die folgenden Rollen anzufordern:

  • Namespace-Administrator (namespace-admin): Erstellen und Bearbeiten von Containerarbeitslasten in einem freigegebenen Cluster.
  • Nutzercluster-Administrator (user-cluster-admin): Erstellen und Bearbeiten von freigegebenen Clustern.
  • User Cluster Developer (user-cluster-developer): Erstellen und Bearbeiten von Knotenpools in einem freigegebenen Cluster.
  • Harbor-Instanzadministrator (harbor-instance-admin): Harbor-Instanzen, Harbor-Projekte und Container-Images erstellen und bearbeiten.
  • Project Network Policy Admin (global-project-networkpolicy-admin): Erstellen und Bearbeiten von projektbezogenen Netzwerkrichtlinien über Zonen hinweg.
  • Global Load Balancer Admin (global-load-balancer-admin): Globale Load Balancer erstellen und bearbeiten.
  • Globaler Administrator für Volume-Replikation (app-volume-replication-admin-global): Verwaltet die Volume-Replikationsbeziehung für Blockspeicherressourcen.
  • Bucket-Projektadministrator (global-project-bucket-admin): Erstellen und Bearbeiten von Speicher-Buckets mit zwei Regionen.

Weitere Informationen finden Sie unter Rollenbeschreibungen.

Umgebung vorbereiten

Prüfen Sie, ob die folgenden Tools und Konfigurationen in Ihrer Air-Gap-Umgebung vorhanden sind:

Kubernetes-Cluster in mehreren Zonen erstellen

Wenn Sie eine hochverfügbare Containeranwendung erstellen möchten, müssen Sie in jeder Zone Ihres GDC-Universums einen separaten freigegebenen Kubernetes-Cluster erstellen.

Weitere Informationen zu den verfügbaren Clusterkonfigurationsoptionen finden Sie unter Kubernetes-Clusterkonfigurationen.

Console

  1. Wählen Sie im Navigationsmenü Kubernetes Engine > Cluster aus.

  2. Klicken Sie auf Cluster erstellen.

  3. Geben Sie im Feld Name einen Namen für den Cluster ein.

  4. Wählen Sie die Kubernetes-Version für den Cluster aus.

  5. Wählen Sie die Zone aus, in der der Cluster erstellt werden soll.

  6. Klicken Sie auf Projekt anhängen und wählen Sie ein vorhandenes Projekt aus, das Sie an Ihren Cluster anhängen möchten. Klicken Sie dann auf Speichern. Sie können Projekte nach dem Erstellen des Clusters auf der Seite Projektdetails anhängen oder trennen. Sie müssen ein Projekt an Ihren Cluster anhängen, bevor Sie Containerarbeitslasten darin bereitstellen können.

  7. Klicken Sie auf Weiter.

  8. Konfigurieren Sie die Netzwerkeinstellungen für Ihren Cluster. Sie können diese Netzwerkeinstellungen nach dem Erstellen des Clusters nicht mehr ändern. Das standardmäßige und einzige unterstützte Internetprotokoll für Kubernetes-Cluster ist Internet Protocol Version 4 (IPv4).

    1. Geben Sie die Größe des IP-Adresspools des Load Balancers an, z. B. 20.

    2. Wählen Sie den zu verwendenden Dienst-CIDR (Classless Inter-Domain Routing) aus. Ihren bereitgestellten Diensten wie Load Balancern werden IP-Adressen aus diesem Bereich zugewiesen.

    3. Wählen Sie den Pod-CIDR aus, der verwendet werden soll. Der Cluster weist Ihren Pods und VMs IP-Adressen aus diesem Bereich zu.

    4. Klicken Sie auf Weiter.

  9. Prüfen Sie die Details des automatisch generierten Standardknotenpools für den Cluster. Klicken Sie auf Bearbeiten, um den Standardknotenpool zu ändern.

  10. Wenn Sie weitere Knotenpools erstellen möchten, wählen Sie Knotenpool hinzufügen aus. Wenn Sie den Standardknotenpool bearbeiten oder einen neuen Knotenpool hinzufügen, können Sie ihn mit den folgenden Optionen anpassen:

    1. Weisen Sie dem Knotenpool einen Namen zu. Sie können den Namen nicht mehr ändern, nachdem Sie den Knotenpool erstellt haben.
    2. Geben Sie die Anzahl der Worker-Knoten an, die im Knotenpool erstellt werden sollen.
    3. Wählen Sie die Maschinenklasse aus, die am besten zu Ihren Arbeitslastanforderungen passt. Sehen Sie sich die Liste der folgenden Einstellungen an:

      • Maschinentyp
      • CPU
      • Arbeitsspeicher
    4. Klicken Sie auf Speichern.

    5. Klicken Sie auf Erstellen, um den Cluster zu erstellen.

  11. Wiederholen Sie diese Schritte für jede Zone in Ihrem GDC-Universum. Achten Sie darauf, dass sich in jeder Zone, die Sie für Ihre HA-Strategie verwenden möchten, ein Kubernetes-Cluster befindet.

API

Wenn Sie einen neuen Kubernetes-Cluster direkt über die API erstellen möchten, wenden Sie eine benutzerdefinierte Ressource auf jede GDC-Zone an.

  1. Erstellen Sie eine benutzerdefinierte Cluster-Ressource und stellen Sie sie auf dem Management API-Server für Ihre Zone bereit:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: cluster.gdc.goog/v1
    kind: Cluster
    metadata:
      name: CLUSTER_NAME
      namespace: platform
    spec:
      clusterNetwork:
        podCIDRSize: POD_CIDR
        serviceCIDRSize: SERVICE_CIDR
      initialVersion:
        kubernetesVersion: KUBERNETES_VERSION
      nodePools:
      - machineTypeName: MACHINE_TYPE
        name: NODE_POOL_NAME
        nodeCount: NUMBER_OF_WORKER_NODES
        taints: TAINTS
        labels: LABELS
        acceleratorOptions:
          gpuPartitionScheme: GPU_PARTITION_SCHEME
      releaseChannel:
        channel: UNSPECIFIED
    EOF
    

    Ersetzen Sie Folgendes:

    • MANAGEMENT_API_SERVER: der kubeconfig-Pfad des zonalen Management API-Servers. Weitere Informationen finden Sie unter Zum zonalen Kontext wechseln.
    • CLUSTER_NAME ist der Name des Clusters. Der Clustername darf nicht mit -system enden. Das Suffix -system ist für Cluster reserviert, die von GDC erstellt wurden.
    • POD_CIDR: die Größe der Netzwerkbereiche, aus denen virtuelle IP-Adressen (VIP) für Pods zugewiesen werden. Wenn keine Angabe gemacht wird, wird der Standardwert 21 verwendet.
    • SERVICE_CIDR: die Größe der Netzwerkbereiche, aus denen Dienst-VIPs zugewiesen werden. Wenn nicht festgelegt, wird der Standardwert 23 verwendet.
    • KUBERNETES_VERSION: die Kubernetes-Version des Clusters, z. B. 1.26.5-gke.2100. Eine Liste der verfügbaren Kubernetes-Versionen, die konfiguriert werden können, finden Sie unter Verfügbare Kubernetes-Versionen für einen Cluster auflisten.
    • MACHINE_TYPE: der Maschinentyp für die Worker-Knoten des Knotenpools. Sehen Sie sich die verfügbaren Maschinentypen an, um zu erfahren, was konfiguriert werden kann.
    • NODE_POOL_NAME ist der Name des Knotenpools.
    • NUMBER_OF_WORKER_NODES: die Anzahl der Worker-Knoten, die im Knotenpool bereitgestellt werden sollen.
    • TAINTS: Die Markierungen, die auf die Knoten dieses Knotenpools angewendet werden sollen. Dieses Feld ist optional.
    • LABELS: die Labels, die auf die Knoten dieses Knotenpools angewendet werden sollen. Sie enthält eine Liste von Schlüssel/Wert-Paaren. Dieses Feld ist optional.
    • GPU_PARTITION_SCHEME: Das GPU-Partitionierungsschema, wenn Sie GPU-Arbeitslasten ausführen, z. B. mixed-2. Die GPU wird nicht partitioniert, wenn dieses Feld nicht festgelegt ist. Informationen zu verfügbaren MIG-Profilen (Multi-Instanz-GPU) finden Sie unter Unterstützte MIG-Profile.
  2. Wiederholen Sie den vorherigen Schritt für jede Zone, in der Ihre Containeranwendung für Ihre HA-Strategie gehostet werden soll.

Load Balancer konfigurieren

Erstellen Sie Load Balancer, um den Traffic zwischen Ihren Pods in verschiedenen Zonen zu verteilen. Sie können sowohl interne als auch externe Load Balancer global konfigurieren, um dafür zu sorgen, dass Clientanfragen an fehlerfreie Zonen weitergeleitet werden.

Globalen internen Load Balancer erstellen

Interne Load Balancer (ILB) stellen Dienste innerhalb der Organisation über einen internen IP-Adresspool bereit, der der Organisation zugewiesen ist. Ein ILB-Dienst ist von keinem Endpunkt außerhalb der Organisation aus zugänglich.

Führen Sie die folgenden Schritte aus, um einen globalen ILB für Ihre Containerarbeitslasten zu erstellen.

gdcloud

Erstellen Sie mit der gdcloud CLI einen ILB, der auf Pod-Arbeitslasten ausgerichtet ist.

Dieser ILB ist auf alle Arbeitslasten im Projekt ausgerichtet, die dem im Backend-Objekt definierten Label entsprechen. Die benutzerdefinierte Ressource Backend muss auf eine Zone beschränkt sein.

So erstellen Sie einen ILB mit der gdcloud CLI:

  1. Erstellen Sie in jeder Zone, in der Ihre Pods ausgeführt werden, eine zonale Backend-Ressource, um den Endpunkt für den ILB zu definieren:

    gdcloud compute backends create BACKEND_NAME \
        --labels=LABELS \
        --project=PROJECT \
        --cluster-name=CLUSTER_NAME \
        --zone=ZONE
    

    Ersetzen Sie Folgendes:

    • BACKEND_NAME: der ausgewählte Name für die Backend-Ressource, z. B. my-backend.
    • LABELS: Der Selektor, der definiert, welche Endpunkte zwischen Pods für diese Backend-Ressource verwendet werden sollen, z. B. app=web.
    • PROJECT: Name Ihres Projekts
    • CLUSTER_NAME: der Kubernetes-Cluster, auf den der Bereich der definierten Selektoren beschränkt ist. Wenn dieses Feld nicht angegeben ist, werden alle Endpunkte mit dem angegebenen Label ausgewählt. Dieses Feld ist optional.
    • ZONE: die Zone, die für diesen Aufruf verwendet werden soll. Führen Sie gdcloud config set core/zone ZONE aus, um das Zonen-Flag für alle Befehle, die es erfordern, voreinzustellen. Das Zonen-Flag ist nur in Umgebungen mit mehreren Zonen verfügbar. Dieses Feld ist optional.

    Wiederholen Sie diesen Schritt für jede Zone in Ihrem GDC-Universum.

  2. Erstellen Sie eine globale BackendService-Ressource:

    gdcloud compute backend-services create BACKEND_SERVICE_NAME \
        --project=PROJECT \
        --target-ports=TARGET_PORTS \
        --global
    

    Ersetzen Sie Folgendes:

    • BACKEND_SERVICE_NAME: Der Name des Backend-Dienstes.
    • PROJECT: Name Ihres Projekts
    • TARGET_PORTS: eine durch Kommas getrennte Liste von Zielports, die dieser Backend-Dienst übersetzt. Jeder Zielport gibt das Protokoll, den Port in der Weiterleitungsregel und den Port auf der Backend-Instanz an. Sie können mehrere Zielports angeben. Dieses Feld muss das Format protocol:port:targetport haben, z. B. TCP:80:8080. Dieses Feld ist optional.
  3. Fügen Sie die Ressource BackendService der zuvor erstellten Ressource Backend in jeder Zone hinzu:

    gdcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
        --backend-zone=ZONE \
        --backend=BACKEND_NAME \
        --project=PROJECT \
        --global
    

    Ersetzen Sie Folgendes:

    • BACKEND_SERVICE_NAME: der Name des globalen Backend-Dienstes.
    • ZONE: die Zone des Backends.
    • BACKEND_NAME: der Name des zonalen Backends.
    • PROJECT: Name Ihres Projekts

    Führen Sie diesen Schritt für jedes zuvor erstellte zonale Backend aus.

  4. Erstellen Sie eine interne ForwardingRule-Ressource, die die virtuelle IP-Adresse (VIP) definiert, unter der der Dienst verfügbar ist:

    gdcloud compute forwarding-rules create FORWARDING_RULE_INTERNAL_NAME \
        --backend-service=BACKEND_SERVICE_NAME \
        --cidr=CIDR \
        --ip-protocol-port=PROTOCOL_PORT \
        --load-balancing-scheme=INTERNAL \
        --project=PROJECT \
        --global
    

    Ersetzen Sie Folgendes:

    • FORWARDING_RULE_INTERNAL_NAME: der Name der Weiterleitungsregel.
    • CIDR: der CIDR-Bereich, der für die Weiterleitungsregel verwendet werden soll. Dieses Feld ist optional. Wenn Sie nichts angeben, wird automatisch ein IPv4/32-CIDR aus dem globalen IP-Adresspool reserviert. Geben Sie den Namen einer Subnet-Ressource im selben Namespace wie diese Weiterleitungsregel an. Eine Subnet-Ressource stellt die Anfrage- und Zuweisungsinformationen eines globalen Subnetzes dar. Weitere Informationen zu Subnet-Ressourcen finden Sie unter Subnetze verwalten.
    • PROTOCOL_PORT: das Protokoll und der Port, die in der Weiterleitungsregel verfügbar gemacht werden sollen. Dieses Feld muss das Format ip-protocol=TCP:80 haben. Der freigegebene Port muss mit dem Port übereinstimmen, den die tatsächliche Anwendung im Container freigibt.
  5. Prüfen Sie die Ready-Bedingung für jedes der erstellten Objekte, um den konfigurierten ILB zu validieren. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP:

    1. Rufen Sie die Weiterleitungsregel auf, um die zugewiesene VIP abzurufen:

      gdcloud compute forwarding-rules describe FORWARDING_RULE_INTERNAL_NAME --global
      
    2. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP an dem Port, der im Feld in der Weiterleitungsregel angegeben ist:

      curl http://FORWARDING_RULE_VIP:PORT
      

    Ersetzen Sie Folgendes:

    • FORWARDING_RULE_VIP: die VIP der Weiterleitungsregel.
    • PORT: die Portnummer der Weiterleitungsregel.

API

Erstellen Sie einen ILB, der Containerarbeitslasten mithilfe der KRM API als Ziel hat. Dieser ILB ist auf alle Arbeitslasten im Projekt ausgerichtet, die dem im Backend-Objekt definierten Label entsprechen. So erstellen Sie einen globalen ILB mit der KRM API:

  1. Erstellen Sie eine Backend-Ressource, um die Endpunkte für den internen Load Balancer zu definieren. Erstellen Sie Backend-Ressourcen für jede Zone, in der die Containerarbeitslasten platziert sind:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      clusterName: CLUSTER_NAME
      endpointsLabels:
        matchLabels:
          app: APP_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • MANAGEMENT_API_SERVER: der kubeconfig-Pfad des kubeconfig-Pfads des zonalen Management API-Servers. Weitere Informationen finden Sie unter Zu einem zonalen Kontext wechseln.
    • PROJECT: Name Ihres Projekts
    • BACKEND_NAME: der Name der Backend-Ressource.
    • CLUSTER_NAME: der Kubernetes-Cluster, auf den der Bereich der definierten Selektoren beschränkt ist. Wenn dieses Feld nicht angegeben ist, werden alle Endpunkte mit dem angegebenen Label ausgewählt. Dieses Feld ist optional.
    • APP_NAME: der Name Ihrer Containeranwendung.

    Sie können für jede Zone dieselbe Backend-Ressource verwenden oder Backend-Ressourcen mit unterschiedlichen Label-Sätzen für jede Zone erstellen.

  2. Erstellen Sie ein BackendService-Objekt mit der zuvor erstellten Backend-Ressource. Achten Sie darauf, die Ressource HealthCheck anzugeben:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: BackendService
    metadata:
      namespace: PROJECT
      name: BACKEND_SERVICE_NAME
    spec:
      backendRefs:
      - name: BACKEND_NAME
        zone: ZONE
      healthCheckName: HEALTH_CHECK_NAME
      targetPorts:
      - port: PORT
        protocol: PROTOCOL
        targetPort: TARGET_PORT
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: der kubeconfig-Pfad des globalen API-Servers.
    • PROJECT: Name Ihres Projekts
    • BACKEND_SERVICE_NAME: der ausgewählte Name für Ihre BackendService-Ressource.
    • HEALTH_CHECK_NAME: der Name der zuvor erstellten HealthCheck-Ressource.
    • BACKEND_NAME: der Name der zonalen Backend-Ressource.
    • ZONE: die Zone, in der sich die Backend-Ressource befindet. Sie können im Feld backendRefs mehrere Back-Ends angeben. Beispiel:

      - name: my-backend-1
        zone: us-east1-a
      - name: my-backend-2
        zone: us-east1-b
      

      Das Feld targetPorts ist optional. Diese Ressource listet Ports auf, die von dieser BackendService-Ressource übersetzt werden. Wenn Sie dieses Objekt verwenden, geben Sie Werte für Folgendes an:

    • PORT: der vom Dienst bereitgestellte Port.

    • PROTOCOL: das Layer-4-Protokoll, mit dem der Traffic übereinstimmen muss. Es werden nur TCP und UDP unterstützt.

    • TARGET_PORT: der Port, in den der Wert übersetzt wird, z. B. 8080. Der Wert kann in einem bestimmten Objekt nicht wiederholt werden.

      Ein Beispiel für targetPorts könnte so aussehen:

      targetPorts:
        - port: 80
          protocol: TCP
          targetPort: 8080
      
  3. Erstellen Sie eine interne ForwardingRule-Ressource, die die virtuelle IP-Adresse (VIP) definiert, unter der der Dienst verfügbar ist.

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ForwardingRuleInternal
    metadata:
      namespace: PROJECT
      name: FORWARDING_RULE_INTERNAL_NAME
    spec:
      cidrRef:
        name: CIDR_NAME
      ports:
      - port: PORT
        protocol: PROTOCOL
      backendServiceRef:
        name: BACKEND_SERVICE_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: der kubeconfig-Pfad des globalen API-Servers.
    • PROJECT: Name Ihres Projekts
    • FORWARDING_RULE_INTERNAL_NAME: der ausgewählte Name für Ihre ForwardingRuleInternal-Ressource.
    • CIDR_NAME: der Name des CIDR, der für die Weiterleitungsregel verwendet werden soll. Dieses Feld ist optional. Wenn Sie nichts angeben, wird automatisch ein IPv4/32-CIDR aus dem globalen IP-Adresspool reserviert. Geben Sie den Namen einer Subnet-Ressource im selben Namespace wie diese Weiterleitungsregel an. Eine Subnet-Ressource stellt die Anfrage- und Zuweisungsinformationen eines globalen Subnetzes dar. Weitere Informationen zu Subnet-Ressourcen finden Sie unter Subnetze verwalten.
    • PORT: der Port, der in der Weiterleitungsregel verfügbar gemacht werden soll. Verwenden Sie das Feld ports, um ein Array von L4-Ports anzugeben, für die Pakete an die Backends weitergeleitet werden, die mit dieser Weiterleitungsregel konfiguriert sind. Es muss mindestens ein Port angegeben werden. Verwenden Sie das Feld port, um eine Portnummer anzugeben. Der freigegebene Port muss mit dem Port übereinstimmen, den die eigentliche Anwendung im Container freigibt.
    • PROTOCOL: das Protokoll, das für die Weiterleitungsregel verwendet werden soll, z. B. TCP. Ein Eintrag im ports-Array muss so aussehen:

      ports:
      - port: 80
        protocol: TCP
      
  4. Prüfen Sie die Ready-Bedingung für jedes der erstellten Objekte, um den konfigurierten ILB zu validieren. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP:

    1. Rufen Sie die VIP ab:

      kubectl get forwardingruleinternal -n PROJECT
      

      Die Ausgabe sieht etwa so aus:

      NAME           BACKENDSERVICE                  CIDR              READY
      ilb-name       BACKEND_SERVICE_NAME            192.0.2.0/32      True
      
    2. Testen Sie den Traffic mit einer curl-Anfrage an die VIP am Port, der im Feld in der Weiterleitungsregel angegeben ist:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Ersetzen Sie Folgendes:

      • FORWARDING_RULE_VIP: die VIP der Weiterleitungsregel.
      • PORT: die Portnummer des Felds in der Weiterleitungsregel.

Globalen externen Load Balancer erstellen

Externe Load Balancer (ELB) stellen Dienste für den Zugriff von außerhalb der Organisation über die IP-Adressen eines Pools bereit, die der Organisation aus dem größeren instanzexternen IP-Adresspool zugewiesen wurden.

Führen Sie die folgenden Schritte aus, um einen globalen ELB für Ihre Containerarbeitslasten zu erstellen.

gdcloud

Verwenden Sie die gdcloud CLI, um einen globalen ELB zu erstellen, der auf alle Arbeitslasten im Projekt abzielt, die dem im Backend-Objekt definierten Label entsprechen. Die benutzerdefinierte Ressource Backend muss auf eine Zone beschränkt sein.

  1. Damit ELB-Dienste funktionieren, müssen Sie eine eigene benutzerdefinierte Richtlinie für die eingehende Datenübertragung (ProjectNetworkPolicy) konfigurieren und anwenden, um Traffic zu den Arbeitslasten dieses ELB-Dienstes zuzulassen. Netzwerkrichtlinien steuern den Zugriff auf Ihre Arbeitslasten, nicht auf den Load Balancer selbst. ELBs stellen Arbeitslasten für Ihr Kundennetzwerk bereit. Daher sind explizite Netzwerkrichtlinien erforderlich, um externen Traffic zum Arbeitslastport, z. B. 8080, zuzulassen.

    Geben Sie die externe CIDR-Adresse an, um Traffic zu den Arbeitslasten dieses ELB zuzulassen:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ProjectNetworkPolicy
    metadata:
      namespace: PROJECT
      name: allow-inbound-traffic-from-external
    spec:
      policyType: Ingress
      subject:
        subjectType: UserWorkload
      ingress:
      - from:
        - ipBlock:
            cidr: CIDR
        ports:
        - protocol: TCP
          port: PORT
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: der kubeconfig-Pfad des globalen API-Servers. Wenn Sie noch keine kubeconfig-Datei für den globalen API-Server generiert haben, finden Sie weitere Informationen unter kubeconfig-Datei manuell generieren.
    • PROJECT: Name Ihres Projekts
    • CIDR: der externe CIDR-Bereich, über den auf den ELB zugegriffen werden muss. Diese Richtlinie ist erforderlich, da der externe Load Balancer Direct Server Return (DSR) verwendet. Dadurch wird die externe Quell-IP-Adresse beibehalten und der Load Balancer auf dem Rückgabepfad umgangen. Weitere Informationen finden Sie unter Globale Firewallregel für eingehenden Traffic für organisationsinternen Traffic erstellen.
    • PORT: der Backend-Port auf den Pods hinter dem Load Balancer. Dieser Wert befindet sich im Feld .spec.ports[].targetPortfield des Manifests für die Ressource Service. Dieses Feld ist optional.

    Mit dieser Konfiguration erhalten alle Ressourcen in Projekten Zugriff auf den angegebenen CIDR-Bereich.

  2. Erstellen Sie in jeder Zone eine Backend-Ressource, um den Endpunkt für den ELB zu definieren:

    gdcloud compute backends create BACKEND_NAME \
      --labels=LABELS \
      --project=PROJECT \
      --cluster-name=CLUSTER_NAME \
      --zone=ZONE
    

    Ersetzen Sie Folgendes:

    • BACKEND_NAME: der Name der Backend-Ressource, z. B. my-backend.
    • LABELS: Ein Selektor, der definiert, welche Endpunkte zwischen Pods für diese Backend-Ressource verwendet werden sollen, z. B. app=web.
    • PROJECT: Name Ihres Projekts
    • CLUSTER_NAME: der Kubernetes-Cluster, auf den der Bereich der definierten Selektoren beschränkt ist. Wenn dieses Feld nicht angegeben ist, werden alle Endpunkte mit dem angegebenen Label ausgewählt. Dieses Feld ist optional.
    • ZONE: die Zone, die für diesen Aufruf verwendet werden soll. Führen Sie gdcloud config set core/zone ZONE aus, um das Zonen-Flag für alle Befehle, die es erfordern, voreinzustellen. Das Zonen-Flag ist nur in Umgebungen mit mehreren Zonen verfügbar. Dieses Feld ist optional.

    Sie können für jede Zone dieselbe Backend-Ressource verwenden oder Backend-Ressourcen mit unterschiedlichen Label-Sätzen für jede Zone erstellen.

  3. Erstellen Sie eine globale BackendService-Ressource:

    gdcloud compute backend-services create BACKEND_SERVICE_NAME \
      --project=PROJECT \
      --target-ports=TARGET_PORTS \
      --health-check=HEALTH_CHECK_NAME \
      --global
    

    Ersetzen Sie Folgendes:

    • BACKEND_SERVICE_NAME: der ausgewählte Name für diesen Backend-Dienst.
    • PROJECT: Name Ihres Projekts
    • TARGET_PORTS: eine durch Kommas getrennte Liste von Zielports, die dieser Backend-Dienst übersetzt. Jeder Zielport gibt das Protokoll, den Port in der Weiterleitungsregel und den Port auf der Backend-Instanz an. Sie können mehrere Zielports angeben. Dieses Feld muss das Format protocol:port:targetport haben, z. B. TCP:80:8080. Dieses Feld ist optional.
    • HEALTH_CHECK_NAME: der Name der Systemdiagnoseressource. Dieses Feld ist optional.
  4. Fügen Sie die globale BackendService-Ressource der zuvor erstellten zonalen Backend-Ressource hinzu:

    gdcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
      --backend=BACKEND_NAME \
      --backend-zone=ZONE \
      --project=PROJECT \
      --global
    

    Führen Sie diesen Schritt für jedes zuvor erstellte zonale Backend aus.

  5. Erstellen Sie eine externe ForwardingRule-Ressource, die die VIP definiert, unter der der Dienst verfügbar ist:

    gdcloud compute forwarding-rules create FORWARDING_RULE_EXTERNAL_NAME \
      --backend-service=BACKEND_SERVICE_NAME \
      --cidr=CIDR \
      --ip-protocol-port=PROTOCOL_PORT \
      --load-balancing-scheme=EXTERNAL \
      --project=PROJECT \
      --global
    

    Ersetzen Sie Folgendes:

    • FORWARDING_RULE_EXTERNAL_NAME: der Name für die Weiterleitungsregel.
    • CIDR: der CIDR-Bereich, der für die Weiterleitungsregel verwendet werden soll. Dieses Feld ist optional. Wenn Sie nichts angeben, wird automatisch ein IPv4/32-CIDR aus dem globalen IP-Adresspool reserviert. Geben Sie den Namen einer Subnet-Ressource im selben Namespace wie diese Weiterleitungsregel an. Eine Subnet-Ressource stellt die Anfrage- und Zuweisungsinformationen eines globalen Subnetzes dar. Weitere Informationen zu Subnet-Ressourcen finden Sie unter Subnetze verwalten.
    • PROTOCOL_PORT: das Protokoll und der Port, die in der Weiterleitungsregel verfügbar gemacht werden sollen. Dieses Feld muss das Format ip-protocol=TCP:80 haben. Der freigegebene Port muss mit dem Port übereinstimmen, den die eigentliche Anwendung im Container freigibt.
    • PROJECT: Name Ihres Projekts
  6. Prüfen Sie die Ready-Bedingung für jedes der erstellten Objekte, um den konfigurierten ELB zu validieren. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP:

    1. Rufen Sie die Weiterleitungsregel auf, um die zugewiesene VIP abzurufen:

      gdcloud compute forwarding-rules describe FORWARDING_RULE_EXTERNAL_NAME
      
    2. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP am Port, der im Feld PROTOCOL_PORT in der Weiterleitungsregel angegeben ist:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Ersetzen Sie Folgendes:

      • FORWARDING_RULE_VIP: die VIP der Weiterleitungsregel.
      • PORT: die Portnummer aus dem Feld PROTOCOL_PORT in der Weiterleitungsregel.

API

Erstellen Sie einen ELB, der Pod-Arbeitslasten mithilfe der KRM API als Ziel hat. Dieser ELB ist auf alle Arbeitslasten im Projekt ausgerichtet, die dem im Backend-Objekt definierten Label entsprechen. So erstellen Sie einen zonalen ELB mit der KRM API:

  1. Damit ELB-Dienste funktionieren, müssen Sie eine eigene benutzerdefinierte Richtlinie für die eingehende Datenübertragung (ProjectNetworkPolicy) konfigurieren und anwenden, um Traffic zu den Arbeitslasten dieses ELB-Dienstes zuzulassen. Netzwerkrichtlinien steuern den Zugriff auf Ihre Arbeitslasten, nicht auf den Load Balancer selbst. ELBs stellen Arbeitslasten für Ihr Kundennetzwerk bereit. Daher sind explizite Netzwerkrichtlinien erforderlich, um externen Traffic zum Arbeitslastport, z. B. 8080, zuzulassen.

    Geben Sie die externe CIDR-Adresse an, um Traffic zu den Arbeitslasten dieses ELB zuzulassen:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ProjectNetworkPolicy
    metadata:
      namespace: PROJECT
      name: allow-inbound-traffic-from-external
    spec:
      policyType: Ingress
      subject:
        subjectType: UserWorkload
      ingress:
      - from:
        - ipBlock:
            cidr: CIDR
        ports:
        - protocol: TCP
          port: PORT
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: der kubeconfig-Pfad des globalen API-Servers. Wenn Sie noch keine kubeconfig-Datei für den globalen API-Server generiert haben, finden Sie weitere Informationen unter kubeconfig-Datei manuell generieren.
    • PROJECT: Name Ihres Projekts
    • CIDR: der externe CIDR-Bereich, über den auf den ELB zugegriffen werden muss. Diese Richtlinie ist erforderlich, da der externe Load Balancer Direct Server Return (DSR) verwendet. Dadurch wird die externe Quell-IP-Adresse beibehalten und der Load Balancer auf dem Rückgabepfad umgangen. Weitere Informationen finden Sie unter Globale Firewallregel für eingehenden Traffic für organisationsinternen Traffic erstellen.
    • PORT: der Backend-Port auf den Pods hinter dem Load Balancer. Dieser Wert befindet sich im Feld .spec.ports[].targetPortfield des Manifests für die Ressource Service. Dieses Feld ist optional.
  2. Erstellen Sie eine Backend-Ressource, um die Endpunkte für den ELB zu definieren. Erstellen Sie Backend-Ressourcen für jede Zone, in der die Arbeitslasten platziert werden:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: networking.gdc.goog/v1
    kind: Backend
    metadata:
      namespace: PROJECT
      name: BACKEND_NAME
    spec:
      clusterName: CLUSTER_NAME
      endpointsLabels:
        matchLabels:
          app: APP_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • MANAGEMENT_API_SERVER: der kubeconfig-Pfad des kubeconfig-Pfads des zonalen Management API-Servers. Wenn Sie noch keine kubeconfig-Datei für den API-Server in Ihrer Zielzone generiert haben, finden Sie weitere Informationen unter kubeconfig-Datei manuell generieren.
    • PROJECT: Name Ihres Projekts
    • BACKEND_NAME ist der Name der Backend-Ressource.
    • CLUSTER_NAME: der Kubernetes-Cluster, auf den der Bereich der definierten Selektoren beschränkt ist. Wenn dieses Feld nicht angegeben ist, werden alle Endpunkte mit dem angegebenen Label ausgewählt. Dieses Feld ist optional.
    • APP_NAME: der Name Ihrer Containeranwendung.

    Sie können für jede Zone dieselbe Backend-Ressource verwenden oder Backend-Ressourcen mit unterschiedlichen Label-Sätzen für jede Zone erstellen.

  3. Erstellen Sie ein BackendService-Objekt mit der zuvor erstellten Backend-Ressource:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: BackendService
    metadata:
      namespace: PROJECT
      name: BACKEND_SERVICE_NAME
    spec:
      backendRefs:
      - name: BACKEND_NAME
        zone: ZONE
      healthCheckName: HEALTH_CHECK_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • BACKEND_SERVICE_NAME: der ausgewählte Name für Ihre BackendService-Ressource.
    • HEALTH_CHECK_NAME: der Name der zuvor erstellten HealthCheck-Ressource. Geben Sie dieses Feld nicht an, wenn Sie einen ELB für Pod-Arbeitslasten konfigurieren.
    • ZONE: die Zone, in der sich die Backend-Ressource befindet. Sie können im Feld backendRefs mehrere Back-Ends angeben. Beispiel:
    - name: my-backend-1
      zone: us-east1-a
    - name: my-backend-2
      zone: us-east1-b
    

  4. Erstellen Sie eine externe ForwardingRule-Ressource, die die VIP definiert, unter der der Dienst verfügbar ist.

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: networking.global.gdc.goog/v1
    kind: ForwardingRuleExternal
    metadata:
      namespace: PROJECT
      name: FORWARDING_RULE_EXTERNAL_NAME
    spec:
      cidrRef:
        name: CIDR_NAME
      ports:
      - port: PORT
        protocol: PROTOCOL
      backendServiceRef:
        name: BACKEND_SERVICE_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • FORWARDING_RULE_EXTERNAL_NAME: der ausgewählte Name für Ihre ForwardingRuleExternal-Ressource.
    • CIDR_NAME: der Name des CIDR, der für die Weiterleitungsregel verwendet werden soll. Dieses Feld ist optional. Wenn Sie nichts angeben, wird automatisch ein IPv4/32-CIDR aus dem globalen IP-Adresspool reserviert. Geben Sie den Namen einer Subnet-Ressource im selben Namespace wie diese Weiterleitungsregel an. Eine Subnet-Ressource stellt die Anfrage- und Zuweisungsinformationen eines globalen Subnetzes dar. Weitere Informationen zu Subnet-Ressourcen finden Sie unter Subnetze verwalten.
    • PORT: der Port, der in der Weiterleitungsregel freigegeben werden soll. Verwenden Sie das Feld ports, um ein Array von L4-Ports anzugeben, für die Pakete an die Backends weitergeleitet werden, die mit dieser Weiterleitungsregel konfiguriert sind. Es muss mindestens ein Port angegeben werden. Verwenden Sie das Feld port, um eine Portnummer anzugeben. Der freigegebene Port muss mit dem Port übereinstimmen, den die eigentliche Anwendung im Container freigibt.
    • PROTOCOL: das Protokoll, das für die Weiterleitungsregel verwendet werden soll, z. B. TCP. Ein Eintrag im ports-Array muss so aussehen:
    ports:
    - port: 80
      protocol: TCP
    
  5. Prüfen Sie die Ready-Bedingung für jedes der erstellten Objekte, um den konfigurierten ELB zu validieren. Testen Sie den Traffic mit einer curl-Anfrage an die VIP.

    1. Rufen Sie die VIP für das Projekt ab:

      kubectl get forwardingruleexternal -n PROJECT
      

      Die Ausgabe sieht etwa so aus:

      NAME           BACKENDSERVICE                  CIDR              READY
      elb-name       BACKEND_SERVICE_NAME            192.0.2.0/32      True
      
    2. Prüfen Sie den Traffic mit einer curl-Anfrage an die VIP am Port, der im Feld PORT in der Weiterleitungsregel angegeben ist:

      curl http://FORWARDING_RULE_VIP:PORT
      

      Ersetzen Sie FORWARDING_RULE_VIP:PORT durch die VIP und den Port der Weiterleitungsregel, z. B. 192.0.2.0:80.

Containerarbeitslasten in jedem zonalen Cluster bereitstellen

Containerarbeitslasten sind keine globale Ressource. Das bedeutet, dass Sie jede Ihrer Containeranwendungen separat in den zonalen Kubernetes-Clustern bereitstellen müssen.

  1. Melden Sie sich in der Zone an, in der Ihr Kubernetes-Cluster gehostet wird:

    gdcloud config set core/zone ZONE
    
  2. Prüfen Sie, ob Ihr Container-Image in der verwalteten Harbor-Registry verfügbar ist. Weitere Informationen finden Sie in der Anleitung Containeranwendung bereitstellen.

  3. Erstellen Sie eine Manifestdatei für Ihre Containerarbeitslast und stellen Sie sie in Ihrem zonalen Kubernetes-Cluster bereit:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: DEPLOYMENT_NAME
    spec:
      replicas: NUMBER_OF_REPLICAS
      selector:
        matchLabels:
          run: APP_NAME
      template:
        metadata:
          labels:
            run: APP_NAME
        spec:
          containers:
          - name: CONTAINER_NAME
            image: HARBOR_INSTANCE_URL/HARBOR_PROJECT_NAME/IMAGE:TAG
    EOF
    

    Ersetzen Sie Folgendes:

    • KUBERNETES_CLUSTER: Die kubeconfig-Datei für den zonalen Kubernetes-Cluster, in dem Sie Containerarbeitslasten bereitstellen. Wenn Sie noch keine kubeconfig-Datei für Ihren zonalen Kubernetes-Cluster generiert haben, finden Sie weitere Informationen unter kubeconfig-Datei manuell generieren.
    • PROJECT: der Projekt-Namespace, in dem die Containerarbeitslasten bereitgestellt werden sollen.
    • DEPLOYMENT_NAME: der Name Ihres Container-Deployments.
    • NUMBER_OF_REPLICAS: Die Anzahl der replizierten Pod-Objekte, die vom Deployment verwaltet werden.
    • APP_NAME: Der Name der Anwendung, die im Deployment ausgeführt werden soll.
    • CONTAINER_NAME: Der Name des Containers.
    • HARBOR_INSTANCE_URL: die URL der Harbor-Instanz, z. B. harbor-1.org-1.zone1.google.gdc.test.. Informationen zum Abrufen der URL der Harbor-Instanz finden Sie unter Harbor-Registry-Instanzen ansehen.
    • HARBOR_PROJECT_NAME: der Name des Harbor-Projekts, z. B. my-project.
    • IMAGE: der Name des Images, z. B. nginx.
    • TAG: das Tag für die Image-Version, die Sie abrufen möchten, z. B. 1.0.
  4. Wiederholen Sie die vorherigen Schritte für jede Zone in Ihrem GDC-Universum. Achten Sie darauf, dass sich Ihre Containeranwendung in jeder Zone befindet, die Sie für Ihre HA-Strategie verwenden möchten.

Containeranwendung mit Kubernetes freigeben

Sie müssen Ihre Containeranwendung freigeben, um den Zugriff von anderen Ressourcen in Ihrem GDC-Universum zu ermöglichen.

  1. Erstellen Sie eine Service-Ressource von type: LoadBalancer. Diese Ressource stellt die Pods Ihrer Anwendung über ein Netzwerk bereit.

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: v1
    kind: Service
    metadata:
      name: SERVICE_NAME
    spec:
      selector:
        app: APP_NAME
      ports:
        - port: 80
          protocol: TCP
      type: LoadBalancer
    EOF
    

    Ersetzen Sie Folgendes:

    • KUBERNETES_CLUSTER: Die kubeconfig-Datei für den zonalen Kubernetes-Cluster, in dem Sie Containerarbeitslasten bereitstellen.
    • PROJECT: der Projekt-Namespace, in dem sich Ihre Containerarbeitslasten befinden.
    • SERVICE_NAME: der Name des Load-Balancer-Dienstes.
    • APP_NAME: das Label, das Sie für Ihre Containeranwendung angewendet haben.
  2. Erstellen Sie eine benutzerdefinierte NetworkPolicy-Ressource, um den gesamten Netzwerkverkehr zum Standard-Namespace zuzulassen:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: networking.k8s.io/v1
    kind: NetworkPolicy
    metadata:
      annotations:
      name: allow-all
    spec:
      ingress:
      - from:
        - ipBlock:
            cidr: 0.0.0.0/0
      podSelector: {}
      policyTypes:
      - Ingress
    EOF
    

Nichtflüchtigen Speicher für Ihre Pods bereitstellen

Sie müssen eine PersistentVolumeClaim-Ressource (PVC) erstellen, um Anwendungspods mit nichtflüchtigem Speicher zu versorgen.

In der folgenden Anleitung wird gezeigt, wie Sie ein Volume mit der GDC-standard-rwo StorageClass erstellen.

  1. PersistentVolumeClaim-Ressource erstellen Konfigurieren Sie sie beispielsweise mit dem Zugriffsmodus ReadWriteOnce und der Speicherklasse standard-rwo:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: PVC_NAME
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: standard-rwo
    EOF
    

    Ersetzen Sie Folgendes:

    • KUBERNETES_CLUSTER: die kubeconfig-Datei für den Kubernetes-Cluster.
    • PROJECT: der Projekt-Namespace, in dem der PVC erstellt werden soll.
    • PVC_NAME: der Name des PersistentVolumeClaim-Objekts.
  2. Die PersistentVolume-Objekte (PV) werden dynamisch bereitgestellt. Prüfen Sie den Status der neuen PVs in Ihrem Kubernetes-Cluster:

    kubectl get pv --kubeconfig KUBERNETES_CLUSTER
    

    Die Ausgabe sieht etwa so aus:

    NAME       CAPACITY   ACCESS MODES   STATUS      CLAIM     STORAGECLASS   AGE
    pvc-uuidd  10Gi       RWO            Bound       pvc-name  standard-rwo   60s
    
  3. Konfigurieren Sie Ihre Containerarbeitslasten für die Verwendung des PVC. Das folgende Beispiel zeigt ein Pod-Manifest, das einen standard-rwo-PVC verwendet:

    kubectl --kubeconfig KUBERNETES_CLUSTER -n PROJECT apply -f - <<EOF
    apiVersion: apps/v1
    kind: Pod
    metadata:
      name: web-server-deployment
      labels:
        app: APP_LABEL
    spec:
      containers:
      - name: CONTAINER_NAME
        image: HARBOR_INSTANCE_URL/HARBOR_PROJECT_NAME/IMAGE:TAG
        volumeMounts:
        - mountPath: MOUNT_PATH
          name: data
      volumes:
      - name: data
        persistentVolumeClaim:
          claimName: PVC_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • KUBERNETES_CLUSTER: Die kubeconfig-Datei für den Kubernetes-Cluster, in dem Sie Containerarbeitslasten bereitstellen.
    • PROJECT: der Projekt-Namespace, in dem sich der PVC befindet.
    • APP_LABEL: das Label, das Sie für Ihre Containeranwendung angewendet haben.
    • CONTAINER_NAME: Der Name des Containers.
    • HARBOR_INSTANCE_URL: die URL der Harbor-Instanz, z. B. harbor-1.org-1.zone1.google.gdc.test.. Informationen zum Abrufen der URL der Harbor-Instanz finden Sie unter Harbor-Registry-Instanzen ansehen.
    • HARBOR_PROJECT_NAME: der Name des Harbor-Projekts, z. B. my-project.
    • IMAGE: der Name des Images, z. B. nginx.
    • TAG: das Tag für die Image-Version, die Sie abrufen möchten, z. B. 1.0.
    • MOUNT_PATH: der Pfad im Pod, unter dem das Volume bereitgestellt werden soll.
    • PVC_NAME: der von Ihnen erstellte PVC.

Speicherreplikation konfigurieren

GDC-Universen mit mehreren Zonen unterstützen die Speicherreplikation für die Notfallwiederherstellung. Diese Strategie ermöglicht die Datenreplikation zwischen zwei beliebigen Zonen in derselben Region. So bleiben Ihre Anwendungsdaten auch dann zugänglich, wenn eine Zone nicht mehr verfügbar ist.

Wählen Sie einen der folgenden Speicherreplikationstypen für Ihre Containeranwendung aus:

Bizonale Buckets für die Objektspeicherung erstellen

Objektspeicherdaten werden in einen einzelnen Bucket geschrieben, dessen Daten in beiden Zonen gespeichert werden. Im Gegensatz zur Volume-Replikation sind replizierte Buckets während Zonenpartitionen beschreibbar. Jeder Schreibvorgang in ein Objekt erzeugt eine andere Version. Die neueste Version in einer der beiden Zonen ist der endgültige Zustand, nachdem die Verbindung wiederhergestellt wurde.

  1. Prüfen Sie, ob Ihr Infrastrukturoperator (IO) die benutzerdefinierte Ressource BucketLocationConfig erstellt hat, die für die zonenübergreifende Replikation für den Objektspeicher erforderlich ist. Diese Ressource muss auf dem globalen API-Stammserver bereitgestellt werden.

  2. Erstellen Sie die benutzerdefinierte Bucket-Ressource für zwei Zonen:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: object.global.gdc.goog/v1
    kind: Bucket
    metadata:
      name: BUCKET_NAME
      namespace: PROJECT
    spec:
      location: LOCATION_NAME
      description: Sample DZ Bucket
      storageClass: Standard
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: die kubeconfig-Datei für den globalen API-Server.
    • BUCKET_NAME: der Name des Storage-Buckets.
    • PROJECT: der Name des Projekts, in dem sich der Bucket befindet.
    • LOCATION_NAME: der physische Ort, an dem sich die Objektdaten im Bucket befinden. Dieser muss dem Namen einer vorhandenen BucketLocation-Ressource zugeordnet sein. Wenn Sie den globalen API-Server Ihrer Organisation nach einer Liste der verfügbaren BucketLocation-Ressourcen abfragen möchten, führen Sie kubectl --kubeconfig GLOBAL_API_SERVER bucketlocations aus. Wenn keine BucketLocation-Ressourcen vorhanden sind, wenden Sie sich an Ihren IO, um zu prüfen, ob die Replikation aktiviert ist.

Asynchrone Blockspeicherreplikation über Zonen hinweg konfigurieren

Replicated Blockspeicher bietet asynchron replizierte Volumes (PVs), die die Blockäquivalenz zwischen den primären und sekundären Volumes aufrechterhalten. Aufgrund der asynchronen Natur spiegelt das sekundäre Volume den Zustand der primären Zone zu einem bestimmten Zeitpunkt in der Vergangenheit wider (RPO ungleich null). Das sekundäre Volume kann nicht bereitgestellt werden, solange es das Ziel der Replikation ist. Es ist ein manueller Eingriff erforderlich, um die Beziehung zu beenden und Schreibvorgänge zu ermöglichen.

Sie müssen eine zonenübergreifende Speicherreplikationsbeziehung konfigurieren, um replizierte Daten zu erstellen, die für ein Failover verfügbar sind, wenn die Daten der Quellzone nicht mehr verfügbar sind. Das ist relevant, wenn Sie Blockspeicher für Ihre Containeranwendung verwenden.

Prüfen Sie vorab, ob Ihr Infrastrukturoperator (IO) die benutzerdefinierten Ressourcen StorageClusterPeering und StorageVirtualMachinePeering erstellt und konfiguriert hat, um die Replikation von Blockspeicher über Zonen hinweg zu ermöglichen. Diese Ressource muss auf dem globalen API-Stammserver bereitgestellt werden.

  1. Erstellen Sie eine YAML-Datei für die benutzerdefinierte Ressource VolumeReplicationRelationship und stellen Sie sie auf dem globalen API-Server bereit:

    kubectl --kubeconfig GLOBAL_API_SERVER apply -f - <<EOF
    apiVersion: storage.global.gdc.goog/v1
    kind: VolumeReplicationRelationship
    metadata:
      name: PVC_REPL_NAME
      namespace: PROJECT
    spec:
      source:
        pvc:
          clusterRef: SOURCE_PVC_CLUSTER
          pvcRef: SOURCE_PVC
        zoneRef: SOURCE_ZONE
    destination:
        pvc:
          clusterRef: DEST_PVC_CLUSTER
        zoneRef: DEST_ZONE
    EOF
    

    Ersetzen Sie Folgendes:

    • GLOBAL_API_SERVER: die kubeconfig-Datei für den globalen API-Server.
    • PVC_REPL_NAME: der Name der Volume-Replikationsbeziehung.
    • PROJECT: das Projekt, in dem sich die Speicherinfrastruktur befindet.
    • SOURCE_PVC_CLUSTER: der Kubernetes-Cluster, in dem der PVC gehostet wird.
    • SOURCE_PVC: der PVC in der Quellzone, der repliziert werden soll.
    • SOURCE_ZONE: die Quellzone, in der der PVC gehostet wird.
    • DEST_PVC_CLUSTER: der Kubernetes-Zielcluster, in den der PVC repliziert werden soll.
    • DEST_ZONE: die Zielzone, in die der PVC repliziert werden soll.
  2. Erstellen Sie in der Zielzone eine benutzerdefinierte VolumeFailover-Ressource, die die Replikation in die Zielzone beendet, wenn die Quellzone aus irgendeinem Grund nicht verfügbar ist:

    kubectl --kubeconfig MANAGEMENT_API_SERVER apply -f - <<EOF
    apiVersion: storage.gdc.goog/v1
    kind: VolumeFailover
    metadata:
      name: PVC_FAILOVER_NAME
      namespace: PROJECT
    spec:
      volumeReplicationRelationshipRef: PVC_REPL_NAME
    EOF
    

    Ersetzen Sie Folgendes:

    • MANAGEMENT_API_SERVER: die kubeconfig-Datei des zonalen Management API-Servers.
    • PVC_FAILOVER_NAME: der Name des PVC-Failovers.
    • PROJECT: das Projekt, in dem sich die Speicherinfrastruktur befindet.
    • PVC_REPL_NAME: der Name der Volume-Replikationsbeziehung.

Nächste Schritte