Administrator- und Nutzercluster von GKE on Bare Metal auf Compute Engine-VMs erstellen

Auf dieser Seite wird beschrieben, wie Sie einen GKE on Bare Metal-Nutzercluster und einen Administratorcluster auf virtuellen Maschinen (VMs) von Compute Engine erstellen. Das bereitgestellte Skript erstellt Compute Engine-VMs für die Administrator- und Nutzerclusterknoten sowie eine Administratorworkstation.

Die Admin-Workstation hostet Befehlszeilentools und Konfigurationsdateien zum Bereitstellen von Clustern während der Installation sowie Befehlszeilentools für die Interaktion mit bereitgestellten Clustern nach der Installation. Das Skript installiert die Befehlszeilentools auf der VM der Administratorworkstation.

Ein Nutzercluster ist ein Kubernetes-Cluster, auf dem Ihre containerisierten Arbeitslasten ausgeführt werden. Die Instanz besteht aus Knoten der Steuerungsebene und Worker-Knoten. Nutzercluster müssen einen oder mehrere Worker-Knoten enthalten, die Nutzerarbeitslasten ausführen. Ein Administratorcluster ist ein Kubernetes-Cluster, der einen oder mehrere Nutzercluster verwaltet und beim Erstellen, Aktualisieren und Löschen von Nutzerclustern hilft. Ein Administratorcluster besteht nur aus Knoten der Steuerungsebene. Weitere Informationen finden Sie unter Bereitstellung von Administrator- und Nutzerclustern.

Das Skript konfiguriert ein VXLAN-Overlay-Netzwerk (Virtual Extensible LAN) zwischen den VMs und bereitet die VMs für die Clustererstellung vor. Optional erstellt das Skript einen Administratorcluster oder Sie können den Administratorcluster selbst erstellen, um mehr über die Tools zu erfahren, die Google Distributed Cloud zum Erstellen von Administratorclustern bereitstellt.

Mit dem bereitgestellten Skript können Sie Google Distributed Cloud schnell und ohne Vorbereitung von Hardware testen. Wenn Sie die Schritte auf dieser Seite ausführen, erhalten Sie eine funktionierende Google Distributed Cloud-Testumgebung, die in Compute Engine ausgeführt wird.

Wichtig: Dieses Deployment dient nur zu Bewertungszwecken. Führen Sie Google Distributed Cloud nicht auf Compute Engine-VMs in der Produktion aus.

Was ist die GKE On-Prem API?

Die GKE On-Prem API ist eine von Google Cloud gehostete API, mit der Sie den Lebenszyklus Ihrer lokalen Cluster mithilfe von Terraform und Google Cloud-Standardanwendungen verwalten können. Die GKE On-Prem API wird in der Infrastruktur von Google Cloud ausgeführt. Terraform, die Console und die gcloud CLI sind Clients der API und verwenden die API, um Cluster in Ihrem Rechenzentrum zu erstellen.

Zum Verwalten des Lebenszyklus Ihrer Cluster muss die GKE On-Prem API Metadaten zum Status Ihres Clusters in Google Cloud speichern. Dazu wird die Google Cloud-Region verwendet, die Sie beim Erstellen des Clusters angeben. Mit diesen Metadaten kann die API den Clusterlebenszyklus verwalten. Sie enthalten keine arbeitslastspezifischen Daten.

Wenn Sie einen Cluster mit einem GKE On-Prem API-Client erstellen, geben Sie ein Google Cloud-Projekt an. Nachdem der Cluster erstellt wurde, wird er automatisch in der Flotte des angegebenen Projekts registriert. Dieses Projekt wird als Flotten-Hostprojekt bezeichnet. Das Flotten-Hostprojekt kann nach dem Erstellen des Clusters nicht mehr geändert werden.

Hinweise

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

5. Make sure that billing is enabled for your Google Cloud project.

6. Notieren Sie sich die Projekt-ID. Sie benötigen sie zum Festlegen einer Umgebungsvariable, die im Skript und in Befehlen auf dieser Seite verwendet wird. Wenn Sie ein vorhandenes Projekt ausgewählt haben, müssen Sie entweder ein Projektinhaber oder -bearbeiter sein.
7. Sie können das Skript in Cloud Shell oder auf Ihrem lokalen Computer ausführen, auf dem Linux oder macOS ausgeführt wird. Wenn Sie Cloud Shell nicht verwenden:
   1. Prüfen Sie, ob Sie die neueste Google Cloud CLI installiert haben, das Befehlszeilentool für die Interaktion mit Google Cloud. Aktualisieren Sie bei Bedarf die Komponenten der gcloud CLI:

      gcloud components update

      Je nachdem, wie die gcloud CLI installiert wurde, wird möglicherweise diese Meldung angezeigt: "Sie können diese Aktion nicht ausführen, da der gcloud CLI-Komponentenmanager für diese Installation deaktiviert ist. Mit dem folgenden Befehl können Sie bei dieser Installation dasselbe Ergebnis erzielen: Folgen Sie der Anleitung, um den Befehl zu kopieren und einzufügen, um die Komponenten zu aktualisieren.

   2. Achte darauf, dass kubectl installiert ist. Wenn Sie kubectl installieren müssen, führen Sie den folgenden Befehl aus:

      gcloud components install kubectl

VM-Infrastruktur und optional den Administratorcluster erstellen

Führen Sie die folgenden Schritte aus, um das Skript einzurichten und auszuführen. Das Skript, das Sie herunterladen und ausführen, stammt aus dem Repository anthos-samples. Wenn Sie vor der Ausführung mehr über das Skript erfahren möchten, lesen Sie den Abschnitt Das Skript im nächsten Abschnitt.

1. Richten Sie Umgebungsvariablen ein:

   export PROJECT_ID=PROJECT_ID
   export ADMIN_CLUSTER_NAME=ADMIN_CLUSTER_NAME
   export ON_PREM_API_REGION=ON_PREM_API_REGION
   export ZONE=ZONE
   

   • ON_PREM_API_REGION: Die Google Cloud-Region, in der die GKE On-Prem API ausgeführt wird und ihre Metadaten speichert. Geben Sie us-central1 oder eine andere unterstützte Region an.

   • ZONE: Die Google Cloud-Zone, in der die Compute Engine-VMs erstellt werden. Sie können us-central1-a oder eine der anderen Compute Engine-Zonen verwenden.

2. Legen Sie das Standardprojekt und die -zone fest:

   gcloud config set project $PROJECT_ID
   gcloud config set compute/zone $ZONE
   

   Wenn der Fehler PERMISSION_DENIED angezeigt wird, prüfen Sie noch einmal die eingegebene Projekt-ID. Wenn die Projekt-ID korrekt ist, führen Sie gcloud auth login aus, um sich in der gcloud CLI mit dem Konto anzumelden, das Zugriff auf das Projekt hat.

3. Rufen Sie eine Liste der Google Distributed Cloud-Versionen ab, die Sie installieren können:

   gcloud container bare-metal admin-clusters query-version-config \
       --location=ON_PREM_API_REGION
   

   Einige Anleitungen in diesem Dokument hängen von der GKE On-Prem API ab, die einen Teil der verfügbaren Google Distributed Cloud-Versionen unterstützt.

4. Wählen Sie aus der Ausgabe des vorherigen Befehls eine Version aus und legen Sie sie in einer Umgebungsvariablen fest:

   export BMCTL_VERSION=BMCTL_VERSION
   

   Wir empfehlen, die höchste kompatible Version auszuwählen, um die neuesten Google Distributed Cloud-Features und Fehlerbehebungen zu erhalten.

5. Klonen Sie das Repository anthos-samples und wechseln Sie in das Verzeichnis, in dem sich das Skript befindet:

   git clone https://github.com/GoogleCloudPlatform/anthos-samples
   cd anthos-samples/anthos-bm-gcp-bash
   

6. Führen Sie das Skript aus:

   bash install_admin_cluster.sh
   

7. Wenn Sie dazu aufgefordert werden, geben Sie eine Nummer ein, um den Installationsmodus auszuwählen:

   • Geben Sie 1 ein, damit das Skript die VM-Infrastruktur einrichtet und den Administratorcluster installiert.
   • Geben Sie 2 ein, damit das Skript nur die VM-Infrastruktur einrichtet.

8. Bestätigen Sie Ihre Auswahl, wenn Sie dazu aufgefordert werden.

Das Skript gibt alle ausgeführten Befehle und den Status aus. Nach Abschluss des Vorgangs gibt das Skript Folgendes aus, je nachdem, ob Sie den Administratorcluster installieren möchten:

Administratorcluster erstellt

✅ Installation complete. Please check the logs for any errors!!!
✅ If you do not see any errors in the output log, then you now have the following setup:

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | Has control plane of admin cluster running inside       |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

Nur VMs einrichten

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

Über das Skript

Um weitere Informationen zu install_admin_cluster.sh zu erhalten, klicken Sie in der nächsten Zeile auf Informationen zum Skript.

Über das Skript

Das Skript automatisiert die folgenden manuellen Schritte:

1. Ein Dienstkonto mit dem Namen baremetal-gcr wird erstellt und dem Dienstkonto werden zusätzliche Berechtigungen gewährt, um zu vermeiden, dass mehrere Dienstkonten für unterschiedliche APIs und Dienste erforderlich sind.
2. Aktiviert die folgenden Google Cloud APIs:

     anthos.googleapis.com
     anthosaudit.googleapis.com
     anthosgke.googleapis.com
     cloudresourcemanager.googleapis.com
     connectgateway.googleapis.com
     container.googleapis.com
     gkeconnect.googleapis.com
     gkehub.googleapis.com
     gkeonprem.googleapis.com
     iam.googleapis.com
     logging.googleapis.com
     monitoring.googleapis.com
     opsconfigmonitoring.googleapis.com
     serviceusage.googleapis.com
     stackdriver.googleapis.com
     storage.googleapis.com

3. Erstellt die folgenden VMs:
   • Eine VM für die Administratorworkstation. Die Administratorworkstation hat über SSH Zugriff auf alle anderen Clusterknoten.
   • Eine VM für den Knoten der Steuerungsebene des Administratorclusters.
   • Zwei VMs für die Worker-Knoten des Nutzerclusters.
   • Eine VM für den Knoten der Steuerungsebene des Nutzerclusters.
   Das Skript prüft außerdem, ob SSH auf allen VMs aktiviert ist.
4. Erstellt ein VXLAN-Overlay-Netzwerk (Virtual Extensible LAN) für Ebene-2-Verbindungen zwischen den VMs. Das VXLAN ist nicht persistent. Wenn Sie also eine VM-Instanz neu starten, wird das Netzwerk zerstört. Das Netzwerk ist so eingerichtet, dass es sich im Subnetz 10.200.0.0/24 befindet. Ebene-2-Verbindungen sind eine Voraussetzung für den gebündelten Load-Balancer.
5. Installiert die folgenden Tools auf der Administratorworkstation:
   • bmctl
   • kubectl
   • Docker

   Das Skript lädt auch den Dienstkontoschlüssel für das Dienstkonto baremetal-gcr auf die Administratorworkstation herunter.

6. Prüfen Sie, ob root@10.200.0.x von der Administratorworkstation funktioniert. Dazu führen Sie die folgenden Aufgaben aus:
   1. Generieren Sie einen neuen SSH-Schlüssel auf der Administratorworkstation.
   2. Fügt den öffentlichen Schlüssel allen anderen VMs in der Bereitstellung hinzu.
7. Optional erstellt das Skript den Administratorcluster mit der folgenden Konfigurationsdatei:

     gcloud compute ssh root@"$VM_WS" --zone "${ZONE}" <<EOF
   set -x
   export PROJECT_ID=\$(gcloud config get-value project)
   ADMIN_CLUSTER_NAME=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/cluster_id -H "Metadata-Flavor: Google")
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export ADMIN_CLUSTER_NAME
   export BMCTL_VERSION
   bmctl create config -c \$ADMIN_CLUSTER_NAME
   cat > bmctl-workspace/\$ADMIN_CLUSTER_NAME/\$ADMIN_CLUSTER_NAME.yaml << EOB
   ---
   gcrKeyPath: /root/bm-gcr.json
   sshPrivateKeyPath: /root/.ssh/id_rsa
   gkeConnectAgentServiceAccountKeyPath: /root/bm-gcr.json
   gkeConnectRegisterServiceAccountKeyPath: /root/bm-gcr.json
   cloudOperationsServiceAccountKeyPath: /root/bm-gcr.json
   ---
   apiVersion: v1
   kind: Namespace
   metadata:
     name: cluster-\$ADMIN_CLUSTER_NAME
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: \$ADMIN_CLUSTER_NAME
     namespace: cluster-\$ADMIN_CLUSTER_NAME
   spec:
     type: admin
     anthosBareMetalVersion: \$BMCTL_VERSION
     gkeConnect:
       projectID: \$PROJECT_ID
     controlPlane:
       nodePoolSpec:
         clusterName: \$ADMIN_CLUSTER_NAME
         nodes:
         - address: 10.200.0.3
     clusterNetwork:
       pods:
         cidrBlocks:
         - 192.168.0.0/16
       services:
         cidrBlocks:
         - 10.96.0.0/20
     loadBalancer:
       mode: bundled
       ports:
         controlPlaneLBPort: 443
       vips:
         controlPlaneVIP: 10.200.0.48
     clusterOperations:
       # might need to be this location
       location: us-central1
       projectID: \$PROJECT_ID
     storage:
       lvpNodeMounts:
         path: /mnt/localpv-disk
         storageClassName: node-disk
       lvpShare:
         numPVUnderSharedPath: 5
         path: /mnt/localpv-share
         storageClassName: local-shared
     nodeConfig:
       podDensity:
         maxPodsPerNode: 250
   EOB
   
   bmctl create cluster -c \$ADMIN_CLUSTER_NAME
   EOF

   Wenn Sie festgelegt haben, dass das Skript den Administratorcluster erstellen soll, verwendet das Skript SSH, um sich als Root-Nutzer bei der Administratorworkstation anzumelden. Als Nächstes führt das Skript das bmctl-Befehlszeilentool aus, um den Administratorcluster zu erstellen. Dies ist eines der Tools, mit dem Sie Administratorcluster erstellen können.

   Wenn Google Distributed Cloud Cluster erstellt, wird ein Kubernetes in einem Docker-Cluster (Art) auf der Administratorworkstation bereitgestellt. Dieser Bootstrap-Cluster hostet die zum Erstellen von Clustern erforderlichen Kubernetes-Controller und wird zum Erstellen des Administratorclusters verwendet. Beim Erstellen werden relevante Controller vom Bootstrap-Cluster in den Administratorcluster verschoben. Sofern nicht anders angegeben, wird der Bootstrap-Cluster nach erfolgreicher Erstellung entfernt. Der Bootstrap-Cluster benötigt Docker, um Container-Images abzurufen.

Optional den Administratorcluster erstellen

Wenn das Skript den Administratorcluster erstellt hat, fahren Sie mit dem nächsten Abschnitt Administratorcluster überprüfen fort. Folgen Sie andernfalls den Schritten in diesem Abschnitt, um einen Bootstrap-Cluster und einen Administratorcluster zu erstellen.

Bevor Sie den Administratorcluster erstellen, müssen Sie den Befehl bmctl register bootstrap auf Ihrer Administratorworkstation ausführen. Mit diesem Befehl wird ein temporäres Kubernetes in einem Docker-Cluster (Art) auf der Administratorworkstation bereitgestellt. Dieser Bootstrap-Cluster hostet die Kubernetes-Controller, die zum Erstellen des Administratorclusters erforderlich sind. Wenn Sie den Administratorcluster erstellen, stellen die Controller im Bootstrap-Cluster Knoten bereit, führen Preflight-Prüfungen aus und registrieren den Administratorcluster bei der Flotte. Der Bootstrap-Cluster wird automatisch gelöscht, nachdem der Cluster erfolgreich erstellt wurde.

Console

1. Rufen Sie in der Console die Seite GKE on Bare Metal-Cluster erstellen auf.

   Zur Seite „GKE on Bare Metal-Cluster erstellen“

2. Wählen Sie in der Projektliste PROJECT_ID aus.

3. Klicken Sie in der linken Navigationsleiste auf Bootstrap-Umgebung installieren.

4. Geben Sie ADMIN_CLUSTER_NAME als Namen des Administratorclusters ein. Der Name des Bootstrap-Clusters wird abgeleitet, indem dem Namen des Administratorclusters bootstrap- vorangestellt wird.

5. Wählen Sie VERSION als Version für Ihren Administratorcluster aus. Das Skript hat diese Version des bmctl-Befehlszeilentools auf die Administratorworkstation heruntergeladen. Die von Ihnen installierte Google Distributed Cloud-Version muss mit der bmctl-Version übereinstimmen.

6. Wählen Sie im Feld Google Cloud API-Standort ON_PREM_API_REGION aus der Liste aus. Diese Einstellung gibt die Region an, in der die GKE On-Prem API ausgeführt wird, sowie die Region, in der Folgendes gespeichert ist:

   • Die Clustermetadaten, die die GKE On-Prem API zum Verwalten des Clusterlebenszyklus benötigt
   • Cloud Logging- und Cloud Monitoring-Daten von Systemkomponenten
   • Das von Cloud-Audit-Logs erstellte Administrator-Audit-Log

   Durch den Clusternamen, das Projekt und den Standort wird der Cluster in Google Cloud eindeutig identifiziert.

Führen Sie zum Erstellen des Bootstrap-Clusters die Schritte im nächsten Abschnitt anstelle der in der Konsole angezeigten Schritte aus. Lassen Sie die Konsolenseite angezeigt, da Sie dort den Administratorcluster erstellen.

gcloud-CLI

Öffnen Sie ein neues Terminalfenster. Im zweiten Terminalfenster stellen Sie eine Verbindung zur Administratorworkstation her, um den Bootstrap-Cluster zu erstellen. Im ersten Terminalfenster führen Sie den gcloud CLI-Befehl aus, um den Administratorcluster zu erstellen.

Bootstrap-Cluster erstellen

Führen Sie die folgenden Schritte auf Ihrer Administratorworkstation aus.

1. Verwenden Sie SSH, um als Root auf die Administrator-Workstation zuzugreifen:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Sie können alle Meldungen zur Aktualisierung der VM ignorieren und diese Anleitung abschließen. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder ein Upgrade auf den nächsten Release durchführen, wie in der Ubuntu-Dokumentation beschrieben.

2. Legen Sie Ihre Nutzeranmeldedaten als Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) fest:

   gcloud auth application-default login
   

   Folgen Sie der Anleitung, um Ihr Google-Konto für ADC auszuwählen.

3. Erstellen Sie den Bootstrap-Cluster.

   bmctl register bootstrap \
     --ssh-key=/root/.ssh/id_rsa \
     --name=bootstrap-ADMIN_CLUSTER_NAME \
     --project-id=PROJECT_ID
   

Nachdem bmctl den Bootstrap-Cluster erfolgreich erstellt hat, sieht die Ausgabe in etwa so aus:

[2023-03-22 17:35:24+0000] Waiting for the temporary cluster to be registered... OK
[2023-03-22 17:35:37+0000] Please go to https://console.cloud.google.com/home/dashboard?project=example-project-12345 to create the cluster
[2023-03-22 17:35:37+0000] Waiting for preflight checks and cluster to run..

Achtung: Lassen Sie den Befehl ausgeführt, während Sie den Administratorcluster erstellen. Wenn Sie den Befehl bmctl register bootstrap beenden, bevor der Administratorcluster erstellt wurde, schlägt das Erstellen des Administratorclusters fehl. Nachdem der Cluster erfolgreich erstellt wurde, löscht der Befehl automatisch den Bootstrap-Cluster und wird beendet.

Erstellen Sie den Administratorcluster.

Console

1. Klicken Sie auf der Seite Bootstrap-Umgebung installieren im Abschnitt Bootstrap-Umgebung von Administratorworkstation auf Verbindung prüfen.

   Bei Erfolg zeigt die Console Verbindung hergestellt an.

   Die Verbindung zum Bootstrap-Cluster muss hergestellt werden, bevor Sie fortfahren. Wenn die Verbindung nicht hergestellt wurde, prüfen Sie die Argumente, die Sie im Befehl bmctl register bootstrap angegeben haben:

   • Achten Sie darauf, dass der Wert für --name mit dem abgeleiteten Bootstrap-Namen übereinstimmt, der im Abschnitt Grundlagen der Bootstrap-Umgebung angezeigt wird.

   • Der Wert für --project-id muss mit der ID des Projekts übereinstimmen, das Sie in der Console ausgewählt haben.

   Wenn Sie den Namen des Bootstrap-Clusters oder die Projekt-ID ändern müssen, geben Sie Ctrl-C ein, um bmctl register bootstrap zu beenden und den Befehl noch einmal auszuführen.

2. Klicken Sie in der linken Navigationsleiste auf Netzwerke.

3. Geben Sie im Abschnitt Steuerungsebene Folgendes in das Feld IP 1 des Knotens der Steuerungsebene ein:

   10.200.0.3
   

   Dies ist die IP-Adresse der VM "abm-admin-cluster-cp" in dem vom Skript erstellten VXLAN.

4. Achten Sie darauf, dass im Abschnitt Load-Balancer die Option Bundled (Gebündelt) ausgewählt ist.

5. Geben Sie im Bereich Virtuelle IP-Adressen (VIPs) Folgendes in das Feld VIP der Steuerungsebene ein:

   10.200.0.48
   

6. Klicken Sie auf Verify and Create (Bestätigen und erstellen).

   In der Console werden Statusmeldungen angezeigt, während die Einstellungen überprüft und der Cluster erstellt wird.

gcloud-CLI

1. Prüfen Sie, ob die zuvor definierten Umgebungsvariablen die richtigen Werte haben. Im Beispielbefehl werden zwar Platzhalter verwendet, diese müssen aber mit den vom Skript verwendeten Umgebungsvariablen übereinstimmen.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Prüfen Sie, ob der Bootstrap-Cluster als Mitglied der Flotte registriert wurde:

   gcloud container fleet memberships list \
     --project=PROJECT_ID
   

   Wenn der Bootstrap-Cluster nicht aufgeführt ist, prüfen Sie den Namen und die Projekt-ID des Bootstrap-Clusters, die Sie für bmctl register bootstrap angegeben haben. Wenn Sie den Namen des Bootstrap-Clusters oder die Projekt-ID ändern müssen, geben Sie Ctrl-C ein, um bmctl register bootstrap zu beenden und den Befehl noch einmal auszuführen.

3. Erstellen Sie den Administratorcluster mit dem gebündelten Load-Balancer:

   gcloud container bare-metal admin-clusters create ADMIN_CLUSTER_NAME \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --max-pods-per-node=110 \
     --control-plane-vip=10.200.0.48 \
     --control-plane-load-balancer-port=443 \
     --control-plane-node-configs node-ip=10.200.0.3 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

   Im vorherigen Befehl gilt:

   • --control-plane-vip: Ist auf 10.200.0.48 gesetzt. Dies ist die virtuelle IP-Adresse (VIP) des Load-Balancers für den Kubernetes API-Server des Clusters.

   • --control-plane-node-configs: node-ip ist auf 10.200.0.3 festgelegt. Dies ist die IP-Adresse der VM "abm-admin-cluster-cp" in dem vom Skript erstellten VXLAN.

   Eine vollständige Liste der Flags und ihrer Beschreibungen finden Sie in der Referenz zur gcloud CLI.

   Die Ausgabe des Befehls sieht in etwa so aus:

   Waiting for operation [projects/example-project-12345/locations/us-west1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.
   

   In der Beispielausgabe ist der String operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 die OPERATION_ID des Vorgangs mit langer Ausführungszeit. Sie können den Status des Vorgangs ermitteln, indem Sie den folgenden Befehl in einem anderen Terminalfenster ausführen:

   gcloud container bare-metal operations describe OPERATION_ID \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION
   

Details zum Clustererstellungsprozess werden auf Ihrer Administratorworkstation ausgegeben. Vor dem Erstellen des Clusters führt bmctl eine Reihe von Preflight-Prüfungen zur Überprüfung der Konfiguration aus. Wenn die Preflight-Prüfungen bestanden sind, wird in etwa Folgendes angezeigt:

[2023-03-22 23:12:47+0000] Waiting for cluster kubeconfig to become ready OK
[2023-03-22 23:15:47+0000] Writing kubeconfig file
[2023-03-22 23:15:47+0000] kubeconfig of cluster being created is present at bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig
[2023-03-22 23:15:47+0000] Please restrict access to this file as it contains authentication credentials of your cluster.
[2023-03-22 23:15:47+0000] Waiting for cluster to become ready OK
[2023-03-22 23:20:17+0000] Please run
[2023-03-22 23:20:17+0000] kubectl --kubeconfig bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig get nodes
[2023-03-22 23:20:17+0000] to get cluster nodes status.
[2023-03-22 23:20:17+0000] Waiting for node pools to become ready OK
[2023-03-22 23:20:37+0000] Waiting for metrics to become ready in GCP OK
[2023-03-22 23:25:38+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2023-03-22 23:25:48+0000] Moving admin cluster resources to the created admin cluster
[2023-03-22 23:25:51+0000] Waiting for node update jobs to finish OK
[2023-03-22 23:27:41+0000] Flushing logs... OK
[2023-03-22 23:27:41+0000] Deleting membership... OK
[2023-03-22 23:27:42+0000] Deleting bootstrap cluster.

Administratorcluster prüfen

Sie finden die Datei kubeconfig Ihres Administratorclusters auf der Administratorworkstation im Verzeichnis bmctl-workspace des Root-Kontos. Führen Sie die folgenden Schritte aus, um Ihre Bereitstellung zu prüfen.

1. Wenn das Skript den Administratorcluster erstellt hat, verwenden Sie SSH, um als Root auf die Administratorworkstation zuzugreifen:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   Sie können alle Meldungen zur Aktualisierung der VM ignorieren und diese Anleitung abschließen. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder ein Upgrade auf den nächsten Release durchführen, wie in der Ubuntu-Dokumentation beschrieben.

2. Legen Sie die Umgebungsvariable KUBECONFIG mit dem Pfad zur Konfigurationsdatei des Clusters fest, um kubectl-Befehle im Cluster auszuführen.

   export clusterid=ADMIN_CLUSTER_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

   Die Ausgabe sieht in etwa so aus:

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   91m   v1.24.2-gke.1900
   

3. Legen Sie den aktuellen Kontext in einer Umgebungsvariablen fest:

   export CONTEXT="$(kubectl config current-context)"
   

4. Führen Sie dazu den folgenden gcloud-Befehl aus. Mit diesem Befehl wird Folgendes ausgeführt:

   • Gewährt Ihrem Nutzerkonto die Kubernetes-Rolle clusterrole/cluster-admin für den Cluster.
   • Konfiguriert den Cluster so, dass Sie kubectl-Befehle auf Ihrem lokalen Computer ausführen können, ohne eine SSH-Verbindung zur Administratorworkstation herstellen zu müssen.
   • Ermöglicht die Anmeldung beim Cluster in der Console mit Ihrer Google-Identität.

   Ersetzen Sie YOUR_EMAIL_ADDRESS durch die E-Mail-Adresse, die mit Ihrem Google Cloud-Konto verknüpft ist. Beispiel: --users=[e-mail].

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=ADMIN_CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=YOUR_EMAIL_ADDRESS \
       --project=PROJECT_ID \
       --kubeconfig=$KUBECONFIG \
       --context=$CONTEXT\
       --apply
   

   Die Ausgabe dieses Befehls sieht in etwa so aus, dass er zur besseren Lesbarkeit abgeschnitten wird:

   Validating input arguments.
   Specified Cluster Role is: clusterrole/cluster-admin
   Generated RBAC policy is:
   --------------------------------------------
   ...
   
   Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig, context: ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME
   Writing RBAC policy for user: YOUR_EMAIL_ADDRESS to cluster.
   Successfully applied the RBAC policy to cluster.
   

5. Wenn Sie mit der Untersuchung fertig sind, geben Sie exit ein, um sich von der Administrator-Workstation abzumelden.

6. Führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus, um den kubeconfig-Eintrag abzurufen, der über das Verbindungsgateway auf den Cluster zugreifen kann:

   gcloud container fleet memberships get-credentials ADMIN_CLUSTER_NAME
   

   Die Ausgabe sieht in etwa so aus:

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_ADMIN_CLUSTER_NAME" has been generated and set as the current context.
   

7. Sie können jetzt kubectl-Befehle über das Verbindungs-Gateway ausführen:

   kubectl get nodes
   

   Die Ausgabe sieht in etwa so aus:

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   94m   v1.24.2-gke.1900
   

In Google Distributed Cloud 1.16 und höher wird der Cluster automatisch bei der GKE On-Prem API registriert. Dadurch können Sie die gcloud CLI und die Console verwenden, um den Administratorcluster zu aktualisieren und zu aktualisieren.

Nutzercluster erstellen

Als das Skript das L2-VXLAN für die VMs erstellt hat, hat es die folgenden IP-Adressen im Netzwerk 10.200.0.0/24 zugewiesen. Sie verwenden diese IP-Adressen, wenn Sie die Netzwerk- und Knotenpooleinstellungen für den Nutzercluster konfigurieren.

VM-Name	Netzwerk-IP-Adresse	Knotenbeschreibung
abm-admin-cluster-cp1	10.200.0.3	Knoten der Steuerungsebene für den Administratorcluster
abm-user-cluster-cp1	10.200.0.4	Knoten der Steuerungsebene für den Nutzercluster
abm-user-cluster-w1	10.200.0.5	Worker-Knoten für den Nutzercluster
abm-user-cluster-w2	10.200.0.6	Einen weiteren Worker-Knoten für den Nutzercluster

Sie können den Nutzercluster mit der Google Cloud Console, der Google Cloud CLI oder Terraform erstellen.

Console

Führen Sie die folgenden Schritte aus, um einen Nutzercluster in der Console zu erstellen:

1. Rufen Sie in der Console die Seite GKE on Bare Metal-Cluster erstellen auf.

   Zur Seite „GKE on Bare Metal-Cluster erstellen“

2. Achten Sie darauf, dass das Google Cloud-Projekt ausgewählt ist, in dem Sie den Administratorcluster erstellt haben.

3. Klicken Sie auf Cluster erstellen.

4. Klicken Sie im Dialogfeld auf Lokal.

5. Klicken Sie neben Bare Metal auf Konfigurieren. Die Seite Voraussetzungen wird angezeigt.

6. Wählen Sie unter Clustertyp auswählen die Option Nutzercluster für vorhandenen Administratorcluster erstellen aus.

7. Klicken Sie auf Weiter.

Clustergrundlagen

1. Geben Sie einen Namen für den Nutzercluster ein oder verwenden Sie den Standardwert.

2. Achten Sie darauf, dass der neu erstellte Administratorcluster ausgewählt ist. Für die restlichen Einstellungen auf dieser Seite können Sie die Standardeinstellungen verwenden.

3. Klicken Sie in der linken Navigationsleiste auf Netzwerke.

Netzwerk

1. Geben Sie im Abschnitt Steuerungsebene Folgendes in das Feld IP 1 des Knotens der Steuerungsebene ein:

   10.200.0.4
   

   Dies ist die IP-Adresse der VM "abm-user-cluster-cp1" in dem vom Skript erstellten VXLAN.

2. Verwenden Sie im Abschnitt Load-Balancer den Standard-Load-Balancer Im Bundle mit MetalLB.

3. Geben Sie im Bereich Neuer Adresspool den folgenden IP-Adressbereich in das Feld IP-Adressbereich 1 ein:

   10.200.0.51-10.200.0.70
   

4. Klicken Sie auf Fertig.

5. Geben Sie im Bereich Virtuelle IP-Adressen die folgende IP-Adresse in das Feld VIP der Steuerungsebene ein:

   10.200.0.50
   

6. Geben Sie die folgende IP-Adresse für die virtuelle IP-Adresse für eingehenden Traffic ein:

   10.200.0.51
   

7. Verwenden Sie die Standard-IP-Adressen im Abschnitt Dienst- und Pod-CIDRs.

8. Klicken Sie in der linken Navigationsleiste auf Standardpool.

Knotenpool erstellen

Der Cluster muss mindestens einen Knotenpool für Worker-Knoten haben. Ein Knotenpool ist eine Vorlage für die Gruppen von Worker-Knoten, die in diesem Cluster erstellt werden.

Geben Sie die folgende IP-Adresse in das Feld Knotenadresse 1 ein:

10.200.0.5

Dies ist die IP-Adresse der VM "abm-user-cluster-w1" in dem vom Skript erstellten VXLAN.

Cluster erstellen

1. Klicken Sie auf Verify and Create (Überprüfen und erstellen), um den Nutzercluster zu erstellen.

   Das Erstellen des Nutzerclusters dauert mindestens 15 Minuten. Die Konsole zeigt Statusmeldungen an, während die Einstellungen überprüft und der Cluster erstellt wird.

   Wenn ein Problem mit der Konfiguration auftritt, wird in der Konsole eine Fehlermeldung angezeigt, die deutlich genug sein sollte, damit Sie das Konfigurationsproblem beheben und noch einmal versuchen können, den Cluster zu erstellen.

   Wenn Sie weitere Informationen zum Erstellungsvorgang sehen möchten, klicken Sie auf Details anzeigen, um eine Seitenleiste aufzurufen. Klicken Sie auf , um den Detailbereich zu schließen.

   Beim Erstellen des Clusters wird Clusterstatus: wird ausgeführt angezeigt.

   

2. Klicken Sie nach dem Erstellen des Clusters auf Cluster, um zur Seite Cluster zurückzukehren.

gcloud-CLI

Sie verwenden den folgenden Befehl, um einen Nutzercluster zu erstellen:

gcloud container bare-metal clusters create

Nachdem Sie den Cluster erstellt haben, müssen Sie mit dem folgenden Befehl mindestens einen Knotenpool erstellen:

gcloud container bare-metal node-pools create

So erstellen Sie den Nutzercluster:

1. Prüfen Sie, ob die zuvor definierten Umgebungsvariablen die richtigen Werte haben. Im Beispielbefehl werden zwar Platzhalter verwendet, diese müssen aber mit den vom Skript verwendeten Umgebungsvariablen übereinstimmen.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Führen Sie den folgenden Befehl aus, um den Nutzercluster zu erstellen. Ersetzen Sie dabei Folgendes:

   • USER_CLUSTER_NAME: Der Name des Clusters.

   • Achten Sie darauf, dass --admin-users auf die E-Mail-Adresse festgelegt ist, die mit Ihrem Google-Konto verknüpft ist, damit Sie den Cluster verwalten können.

   Die übrigen Flag-Werte wurden bereits ausgefüllt. Scrollen Sie bei Bedarf, um zu prüfen, ob das Flag --admin-cluster-membership den richtigen Wert für den Namen des Administratorclusters hat. Dies ist das letzte Segment im vollständig angegebenen Mitgliedschaftsnamen.

   gcloud container bare-metal clusters create USER_CLUSTER_NAME \
     --project=PROJECT_ID \
     --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --admin-users=YOUR_EMAIL_ADDRESS \
     --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=10.200.0.51-10.200.0.70' \
     --control-plane-node-configs='node-ip=10.200.0.4' \
     --control-plane-vip=10.200.0.50 \
     --control-plane-load-balancer-port=443 \
     --ingress-vip=10.200.0.51 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

In der folgenden Liste werden die Flags beschrieben:

• --project: Die ID des Projekts, in dem der Nutzercluster registriert wird. Dieses Projekt wird als Flotten-Hostprojekt bezeichnet.

• --admin-cluster-membership: Der vollständig angegebene Name des Administratorclusters, der den Administratorcluster in der Flotte identifiziert.

• --location: Die Google Cloud-Region, in der die GKE On-Prem API ausgeführt wird und ihre Metadaten speichert.

• --version: Die Version von Google Distributed Cloud.

• --admin-users: Geben Sie Ihre E-Mail-Adresse an, um die Richtlinien für die rollenbasierte Zugriffssteuerung (Role-based Access Control, RBAC) von Kubernetes zu erhalten, die Ihnen vollständigen administrativen Zugriff auf den Cluster gewährt.

• --metal-lb-address-pools: Die Adresspoolkonfiguration für den gebündelten MetalLB-Load-Balancer. Der IP-Adressbereich muss sich im Netzwerk 10.200.0.0/24 befinden, das vom Skript erstellt wurde. Der Adressbereich darf weder die IP-Adressen enthalten, die den VMs noch der VIP der Steuerungsebene zugewiesen sind. Die virtuelle IP-Adresse für eingehenden Traffic muss sich jedoch in diesem Adressbereich befinden.

• --control-plane-node-configs: Die Knotenkonfiguration der Steuerungsebene für den Nutzercluster. Der Wert für node-ip lautet 10.200.0.4. Das ist die IP-Adresse, die das Skript der VM abm-user-cluster-cp1 zugewiesen hat.

• --control-plane-vip: Die virtuelle IP-Adresse für die Steuerungsebene. Der Wert 10.200.0.50 befindet sich im Netzwerk 10.200.0.0/24, das vom Skript erstellt wurde, überschneidet sich jedoch nicht mit dem IP-Adressbereich, der für die Adresspools des MetalLB-Load-Balancers verwendet wird.

• --control-plane-load-balancer-port: Der Port, an dem der Load-Balancer die Steuerungsebene bedient. Obwohl Sie auch einen anderen Wert konfigurieren können, ist Port 443 der Standardport für HTTPS-Verbindungen.

• --ingress-vip: Die virtuelle IP-Adresse für den Dienst für eingehenden Traffic. Diese IP-Adresse muss sich im IP-Adressbereich befinden, der für die Adresspools des MetalLB-Load-Balancers verwendet wird.

• --island-mode-service-address-cidr-blocks: Ein Bereich von IP-Adressen im CIDR-Format, die für Dienste im Nutzercluster verwendet werden sollen. Im Beispielbefehl wurde 10.96.0.0/20 verwendet. Dies ist der Standardwert, der von der Konsole bereitgestellt wird. Der CIDR-Bereich muss zwischen /24 und /12 liegen, wobei /12 die meisten IP-Adressen bereitstellt. Wir empfehlen, im IP-Adressbereich für private Internets einen Bereich gemäß RFC 1918 zu verwenden.

• --island-mode-pod-address-cidr-blocks: Ein Bereich von IP-Adressen im CIDR-Format, die für Pods im Nutzercluster verwendet werden sollen. Im Beispielbefehl wurde 192.168.0.0/16 verwendet. Dies ist der Standardwert, der von der Konsole bereitgestellt wird. Der CIDR-Bereich muss zwischen /18 und /8 liegen, wobei /8 die meisten IP-Adressen bereitstellt. Wir empfehlen, im IP-Adressbereich für private Internets einen Bereich gemäß RFC 1918 zu verwenden.

• --lvp-share-path: Dies ist der Pfad zum Hostcomputer, in dem Unterverzeichnisse erstellt werden können. Für jedes Unterverzeichnis wird ein lokales nichtflüchtiges Volume (PV) erstellt.

• --lvp-share-storage-class: Dies ist die Speicherklasse, die zum Erstellen nichtflüchtiger Volumes verwendet werden soll. Die StorageClass wird während der Clustererstellung erstellt.

• --lvp-node-mounts-config-path: Dies ist der Pfad zum Hostcomputer, in dem bereitgestellte Laufwerke gefunden werden können. Für jede Bereitstellung wird ein lokales nichtflüchtiges Volume (PV) erstellt.

• --lvp-node-mounts-config-storage: Die Speicherklasse, mit der PVs bei der Clustererstellung erstellt werden.

Nachdem Sie den Befehl ausgeführt haben, sieht die Ausgabe in etwa so aus:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678304606537-5f668bde5c57e-341effde-b612ff8a] to complete...

In der Beispielausgabe ist der String operation-1678304606537-5f668bde5c57e-341effde-b612ff8a die OPERATION_ID des Vorgangs mit langer Ausführungszeit.

Kopieren Sie die OPERATION_ID aus Ihrer Ausgabe in den folgenden Befehl, um den Status des Vorgangs abzurufen. Öffnen Sie ein anderes Terminalfenster und führen Sie den Befehl aus.

gcloud container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Das Erstellen des Clusters dauert etwa 15 Minuten. Während der Cluster erstellt wird, können Sie den vorherigen Befehl gelegentlich ausführen, um den aktuellen Status abzurufen.

Nachdem der Cluster erstellt wurde, sehen Sie in etwa folgende Ausgabe:

Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME].

Knotenpool erstellen

Nachdem der Cluster erfolgreich erstellt wurde, führen Sie den folgenden Befehl aus, um einen Knotenpool zu erstellen. Ersetzen Sie NODE_POOL_NAME durch einen Namen für den Knotenpool und achten Sie darauf, dass der Platzhalter für das Flag --cluster weiterhin auf den Namen des Nutzerclusters festgelegt ist.

gcloud container bare-metal node-pools create NODE_POOL_NAME \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.5'

• -node-configs: Der node-ip zugewiesene Wert ist die IP-Adresse der VM abm-user-cluster-w1 im VXLAN, die vom Skript erstellt wurde.

Nachdem Sie den Befehl ausgeführt haben, sieht die Ausgabe in etwa so aus:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678308682052-5f669b0d132cb-6ebd1c2c-816287a7] to complete...

Das Erstellen des Knotenpools dauert maximal 5 Minuten. Nachdem der Knotenpool erstellt wurde, sieht die Ausgabe in etwa so aus:

Created node pool in Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME/bareMetalNodePools/NODE_POOL_NAME].

Andere Nutzerclusterbefehle

Zusätzlich zum Erstellen von Clustern können Sie weitere gcloud-Kommandozeilenbefehle ausführen, z. B.:

• So listen Sie Ihre Nutzercluster auf:

gcloud container bare-metal clusters list \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• So beschreiben Sie einen Nutzercluster:

gcloud container bare-metal clusters describe USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Weitere Informationen finden Sie unter gcloud container Bare-Metal-Cluster.

Weitere Knotenpoolbefehle

Zusätzlich zum Erstellen von Knotenpools können Sie weitere gcloud-Befehlszeilenbefehle ausführen, zum Beispiel:

• So listen Sie Knotenpools auf:

gcloud container bare-metal node-pools list \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• So beschreiben Sie einen Knotenpool:

gcloud container bare-metal node-pools describe NODE_POOL_NAME \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Weitere Informationen finden Sie unter gcloud container bare-metal node-pools.

Terraform

Sie können das folgende grundlegende Konfigurationsbeispiel verwenden, um einen Nutzercluster mit gebündeltem MetalLB-Load-Balancer zu erstellen. Weitere Informationen finden Sie in der Referenzdokumentation zu google_gkeonprem_bare_metal_cluster.

1. Wechseln Sie im Verzeichnis, in das Sie anthos-samples geklont haben, in das Verzeichnis, in dem sich das Terraform-Beispiel befindet:

   cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
   

   Das Beispiel enthält eine Beispielvariablendatei zur Übergabe an main.tf.

2. Erstellen Sie eine Kopie der Datei terraform.tfvars.sample:

   cp terraform.tfvars.sample terraform.tfvars
   

   
   project_id          = "PROJECT_ID"
   region              = "ON_PREM_API_REGION"
   admin_cluster_name  = "ADMIN_CLUSTER_NAME"
   bare_metal_version  = "VERSION"
   admin_user_emails   = ["YOUR_EMAIL_ADDRESS", "ADMIN_2_EMAIL_ADDRESS"]
   cluster_name        = "abm-user-cluster-metallb"
   control_plane_ips   = ["10.200.0.4"]
   worker_node_ips     = ["10.200.0.5", "10.200.0.6"]
   control_plane_vip   = "10.200.0.50"
   ingress_vip         = "10.200.0.51"
   lb_address_pools    = [
       { name = "lbpool_1", addresses = ["10.200.0.51-10.200.0.70"] }
   ]
   

3. Ändern Sie die Parameterwerte in terraform.tfvars und speichern Sie die Datei.

   In der folgenden Liste werden die Variablen beschrieben:

   • project_id: Die ID des Projekts, in dem der Nutzercluster registriert wird. Dieses Projekt wird als Flotten-Hostprojekt bezeichnet.

   • region: Die Google Cloud-Region, die Sie zu Beginn der Anleitung festgelegt haben. Führen Sie echo $ON_PREM_API_REGION aus, um den Wert abzurufen.

   • admin_cluster_name: Der Name des Administratorclusters, den Sie zu Beginn dieser Anleitung festgelegt haben. Führen Sie echo $ADMIN_CLUSTER_NAME aus, um den Wert abzurufen.

   • bare_metal_version: Die Google Distributed Cloud-Version für Ihren Nutzercluster. Wenn Sie dieselbe Version verwenden möchten, die Sie für den Administratorcluster verwendet haben, führen Sie echo $BMCTL_VERSION aus, um den Wert abzurufen. Sie können aber auch eine Version angeben, die nicht mehr als eine Nebenversion niedriger als die Version des Administratorclusters ist. Die Version des Nutzerclusters darf nicht höher als die Version des Administratorclusters sein.

   • cluster_name: Sie können entweder den Namen in der TVARS-Datei für den Nutzercluster verwenden oder einen Namen Ihrer Wahl angeben. Der Name kann nach dem Erstellen des Clusters nicht mehr geändert werden.

   • admin_user_emails: Eine Liste der E-Mail-Adressen der Nutzer, denen Administratorberechtigungen für den Cluster gewährt werden. Vergessen Sie nicht, Ihre E-Mail-Adresse hinzuzufügen, damit Sie den Cluster verwalten können.

     Beim Erstellen des Clusters wendet die GKE On-Prem API die Richtlinien für die rollenbasierte Zugriffssteuerung (Role-based Access Control, RBAC) von Kubernetes auf den Cluster an, um den Administratornutzern die Kubernetes-Rolle clusterrole/cluster-admin zu gewähren, die vollständigen Zugriff auf jede Ressource im Cluster in allen Namespaces bietet. Auf diese Weise können sich Nutzer auch mit ihrer Google-Identität in der Konsole anmelden.

   Verwenden Sie für die verbleibenden Variablen die in terraform.tvars definierten Standardwerte. Das Skript hat diese Werte beim Erstellen der VMs und des Administratorclusters verwendet.

   • control_plane_ips: Eine Liste mit einer oder mehreren IPv4-Adressen für die Knoten der Steuerungsebene. Verwenden Sie den Standardwert. Das ist die IP-Adresse, die das Skript der VM abm-user-cluster-cp1 zugewiesen hat.

   • worker_node_ips: Eine Liste mit einer oder mehreren IPv4-Adressen für die Maschinen mit Worker-Knoten. Verwenden Sie die Standardwerte, also die IP-Adressen, die das Skript den VMs abm-user-cluster-w1 und abm-user-cluster-w2 zugewiesen hat.

   • control_plane_vip: Die virtuelle IP (VIP) für die Steuerungsebene. Verwenden Sie den Standardwert 10.200.0.50. Dieser befindet sich im Netzwerk 10.200.0.0/24, das vom Skript erstellt wurde. Beachten Sie, dass sich diese IP-Adresse nicht mit dem IP-Adressbereich überschneidet, der für die Adresspools des MetalLB-Load-Balancers verwendet wird.

   • ingress_vip: Die virtuelle IP-Adresse, die auf dem Load-Balancer für den Ingress-Proxy konfiguriert werden soll. Verwenden Sie den Standardwert 10.200.0.51. Dieser befindet sich im Netzwerk 10.200.0.0/24, das vom Skript erstellt wurde. Diese IP-Adresse befindet sich im IP-Adressbereich, der für die Adresspools des MetalLB-Load-Balancers verwendet wird.

   • lb_address_pools: Eine Liste der Zuordnungen, die die Adresspools für den MetalLB-Load-Balancer definieren. Verwenden Sie den Standardwert.

4. Speichern Sie die Änderungen in terraform.tfvars.

5. Initialisieren und erstellen Sie den Terraform-Plan:

   terraform init
   

   Terraform installiert alle erforderlichen Bibliotheken, z. B. den Google Cloud-Anbieter.

6. Überprüfen Sie die Konfiguration und nehmen Sie bei Bedarf Änderungen vor:

   terraform plan
   

7. Wenden Sie den Terraform-Plan an, um den Nutzercluster zu erstellen:

   terraform apply
   

   Das Erstellen des Nutzerclusters dauert mindestens 15 Minuten. Sie können den Cluster in der Google Cloud Console auf der Seite GKE-Cluster ansehen.

Verbindung zum Nutzercluster herstellen

Wenn Sie einen Nutzercluster über die Console oder die gcloud CLI erstellen, wird der Cluster mit denselben Kubernetes-Richtlinien für die rollenbasierte Zugriffssteuerung (Role-based Access Control, RBAC) konfiguriert, die Sie bei Ausführung von gcloud container fleet memberships generate-gateway-rbac für den Administratorcluster konfiguriert haben. Mit diesen RBAC-Richtlinien können Sie mithilfe Ihrer Google Cloud-Identität eine Verbindung zum Cluster herstellen. Dies ist die mit Ihrem Google Cloud-Konto verknüpfte E-Mail-Adresse. Mit diesen RBAC-Richtlinien können Sie sich ohne zusätzliche Konfiguration in der Console anmelden.

Verbindung zum Cluster in der Console herstellen

Wenn Sie die gcloud CLI oder Terraform zum Erstellen des Nutzerclusters verwendet haben, rufen Sie in der Console die Seite GKE-Cluster auf:

Zu GKE-Clustern

Achten Sie darauf, dass das Projekt ausgewählt ist, in dem Sie den Nutzercluster erstellt haben. In der Liste sollten sowohl der Administrator- als auch der Nutzercluster angezeigt werden.

Beachten Sie, dass im Nutzercluster in der Spalte Typ der Eintrag Bare Metal: Nutzer aufgeführt ist. Dies weist darauf hin, dass der Cluster von der GKE On-Prem API verwaltet wird.

Wenn Sie das Skript zum Erstellen des Administratorclusters verwendet haben, enthält die Spalte Typ den Eintrag Extern. Dies weist darauf hin, dass der Cluster nicht von der GKE On-Prem API verwaltet wird. Sie können den Administratorcluster so konfigurieren, dass er von der GKE On-Prem API verwaltet wird, nachdem der Cluster erstellt wurde.

So melden Sie sich bei einem Cluster an:

1. Klicken Sie auf den Link im Clusternamen und in der Seitenleiste auf Login (Anmelden).

2. Mit Google-Identität anmelden auswählen

3. Klicken Sie auf Anmelden.

Wiederholen Sie dieselben Schritte, um sich auch beim Administratorcluster anzumelden.

Verbindung zum Cluster über die Befehlszeile herstellen

Die GKE On-Prem API konfiguriert die RBAC-Richtlinien für Sie als Ersteller des Nutzerclusters. Mit diesen Richtlinien können Sie kubectl-Befehle auf Ihrem lokalen Desktop über das Verbindungs-Gateway kubeconfig ausführen.

Auf Ihrem lokalen Computer:

1. Rufen Sie den Eintrag kubeconfig ab, der über das Verbindungsgateway auf den Cluster zugreifen kann.

   gcloud container fleet memberships get-credentials USER_CLUSTER_NAME
   

   Die Ausgabe sieht in etwa so aus:

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.
   

2. Sie können jetzt kubectl-Befehle über das Verbindungs-Gateway ausführen:

   kubectl get nodes
   

   Die Ausgabe sieht in etwa so aus:

   NAME                  STATUS   ROLES                  AGE     VERSION
   abm-user-cluster-cp   Ready    control-plane,master   14m     v1.24.2-gke.1900
   abm-user-cluster-w1   Ready    worker                 8m28s   v1.24.2-gke.1900
   

Weiteren Knotenpool zum Nutzercluster hinzufügen

Console

1. Rufen Sie in der Console die Seite GKE-Cluster auf.

   Zu GKE-Clustern

2. Klicken Sie in der Clusterliste auf den Namen des Clusters und dann im Feld Details auf Weitere Details.

3. Klicken Sie auf den Tab Knoten.

4. Klicken Sie auf Knotenpool hinzufügen .

5. Geben Sie einen Namen für den Knotenpool ein.

6. Geben Sie im Feld Knotenadresse 1 die folgende IP-Adresse ein:

   10.200.0.6
   

   Dies ist die IP-Adresse der VM abm-user-cluster-w2, die vom Skript erstellt wurde.

7. Klicke auf Erstellen.

8. Klicken Sie bei Bedarf noch einmal auf den Tab Knoten.

9. Der neue Knotenpool hat den Status Abgleich.

10. Klicken Sie rechts oben auf , um den Status der Knotenpoolerstellung anzusehen. Möglicherweise müssen Sie die Seite aktualisieren, damit der aktualisierte Status in der Liste der Knotenpools angezeigt wird.

gcloud-CLI

Führen Sie den folgenden Befehl aus, um einen weiteren Knotenpool zu erstellen. Ersetzen Sie NODE_POOL_NAME_2 durch einen Namen für den Knotenpool und achten Sie darauf, dass der Platzhalter für das Flag --cluster weiterhin auf den Namen des Nutzerclusters festgelegt ist.

gcloud container bare-metal node-pools create NODE_POOL_NAME_2 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.6'

• -node-configs: Der node-ip zugewiesene Wert ist die IP-Adresse der VM „abm-user-cluster-w2“ im VXLAN, die vom Skript erstellt wurde.

Terraform

Wenn Sie den Cluster mit Terraform erstellt haben, wurde der Cluster mit zwei Knoten erstellt, sodass im VXLAN keine zusätzlichen VMs zum Hinzufügen eines weiteren Knotens verfügbar sind. Informationen zum Hinzufügen von Knotenpools finden Sie in der Referenzdokumentation zu google_gkeonprem_bare_metal_cluster.

Sie können den neuen Knoten auch mit kubectl prüfen. Sie müssen zuerst den Befehl gcloud container fleet memberships get-credentials wie zuvor gezeigt ausführen, um die Clusterkonfiguration abzurufen:

kubectl get nodes

Die Ausgabe sieht in etwa so aus:

NAME                  STATUS   ROLES                  AGE     VERSION
abm-user-cluster-cp   Ready    control-plane,master   24m   v1.24.2-gke.1900
abm-user-cluster-w1   Ready    worker                 18m   v1.24.2-gke.1900
abm-user-cluster-w2   Ready    worker                 52s   v1.24.2-gke.1900

Bereinigen

Die folgenden Abschnitte enthalten Anweisungen zum Entfernen der Cluster und VMs, die Sie mit dieser Anleitung erstellt haben.

Nutzercluster löschen

Console

1. Rufen Sie in der Console die Seite GKE-Cluster auf.

   Zu GKE-Clustern

2. Klicken Sie in der Liste der Cluster auf den Nutzercluster.

3. Klicken Sie im Bereich Details auf Mehr Details.

4. Klicken Sie oben im Fenster auf Löschen.

5. Wenn Sie zur Bestätigung aufgefordert werden, geben Sie den Clusternamen ein und klicken Sie auf Bestätigen.

6. Klicken Sie rechts oben auf , um den Status des Löschvorgangs anzuzeigen. Möglicherweise müssen Sie die Seite aktualisieren, um die Clusterliste zu aktualisieren.

gcloud-CLI

Führen Sie den folgenden Befehl aus, um den Cluster zu löschen:

gcloud container bare-metal clusters delete USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --force

Mit dem Flag --force können Sie einen Cluster löschen, der Knotenpools hat. Ohne das Flag --force müssen Sie zuerst die Knotenpools löschen und dann den Cluster löschen.

Informationen zu anderen Flags finden Sie unter gcloud container Bare-Metal-Cluster löschen.

Terraform

Führen Sie dazu diesen Befehl aus:

terraform destroy

Warten Sie, bis der Nutzercluster gelöscht ist, bevor Sie den Administratorcluster und die VMs löschen.

Administratorcluster und VMs löschen

1. Melden Sie den Administratorcluster von der GKE On-Prem API ab:

   gcloud container bare-metal admin-clusters unenroll ADMIN_CLUSTER_NAME \
       --project=PROJECT_ID \
       --location=ON_PREM_API_REGION
   

2. Stellen Sie eine Verbindung zur Administrator-Workstation her:

   gcloud compute ssh root@abm-ws --zone ZONE
   

3. Löschen Sie den Administratorcluster:

   bmctl reset -c ADMIN_CLUSTER_NAME
   

   bmctl hebt die Registrierung des Clusters von der Flotte auf und löscht dann den Cluster. Warten Sie mit dem Löschen der VMs, bis der Cluster gelöscht ist.

4. Beenden Sie die Administratorworkstation.

5. Listen Sie alle VMs auf, deren Name abm enthält:

   gcloud compute instances list | grep 'abm'
   

6. Prüfen Sie, ob Sie alle VMs löschen können, deren Name abm enthält.

   Nach der Bestätigung können Sie abm-VMs mit dem folgenden Befehl löschen:

   gcloud compute instances list --format="value(name)" | \
     grep 'abm'  | \
     xargs gcloud --quiet compute instances delete --zone ZONE
   

7. Löschen Sie das Dienstkonto:

   gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
   

   Geben Sie in der Bestätigungsaufforderung y ein.

   Nächste Schritte

• Service und Ingress erstellen
• Installation planen
• Einfache Cluster erstellen