Anthos-Cluster auf Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

Diese Seite wurde von der Cloud Translation API übersetzt.

Demo-Administratorcluster und -Nutzercluster für Google Distributed Cloud auf Compute Engine-VMs erstellen

Erstellen Sie Democluster auf Compute Engine-VMs, um mehr über Google Distributed Cloud (nur Software) für Bare-Metal (früher Google Distributed Cloud Virtual, zuvor Anthos-Cluster auf Bare-Metal) zu erfahren. Das Erstellen eines Administrator- und eines Nutzerclusters mithilfe dieses Leitfadens kann zwischen 40 Minuten und einer Stunde dauern. Die Democluster, die Sie in diesem Leitfaden erstellen, helfen Ihnen, die Bereitstellung und den Betrieb von Google Distributed Cloud-Clustern zu bewerten. Sie sind aber nicht für die Produktion vorgesehen.

In diesem Dokument wird beschrieben, wie Sie ein Script ausführen, das:

Fünf Compute Engine-VMs für die Installation von Democlustern bereitstellt
Ein VPC-Netzwerk für Clusterkonnektivität einrichtet

Sobald das Script die erforderlichen Ressourcen bereitgestellt hat, können Sie mit einem der folgenden Clients einen Administratorcluster und einen zugehörigen Nutzercluster erstellen,auf dem Arbeitslasten gehostet werden können: bmctl, Google Cloud Console, Google Cloud CLI oder Terraform.

Verfahrensübersicht

Dieser Leitfaden enthält die folgenden Hauptschritte:

Bereiten Sie Ihre lokale Umgebung vor, sodass das Script die erforderlichen Umgebungsvariablen enthält und Sie die grundlegenden Informationen zum Ausführen von Befehlen zusammengestellt haben.
Erstellen Sie die VMs und das Netzwerk mit dem heruntergeladenen Script.
Erstellen Sie den Administratorcluster mit einem der unterstützten Clients.
Erstellen Sie den Nutzercluster mit einem der unterstützten Clients.
Klicken Sie auf Bereinigen, um die Cluster und VMs zu entfernen, die Sie mit diesem Leitfaden erstellt haben.

1. Lokale Umgebung vorbereiten

Da in dieser Anleitung ein Script verwendet wird, das das Netzwerk für Sie einrichtet, müssen Sie nicht viele Informationen sammeln und nichts planen. In den folgenden Schritten richten Sie Ihre lokale Umgebung ein und sammeln die grundlegenden Informationen, die Sie in den nachfolgenden Abschnitten des Leitfadens benötigen:

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.

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

Go to project selector

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

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

Go to project selector

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

Notieren Sie sich die Projekt-ID, da Sie diese zum Festlegen einer Umgebungsvariablen benötigen, die in den Scripts und Befehlen auf dieser Seite verwendet wird. Wenn Sie ein bestehendes Projekt ausgewählt haben, vergewissern Sie sich, dass Sie entweder Projektinhaber oder Bearbeiter sind.
Sie können das Skript in Cloud Shell oder auf einem lokalen Computer ausführen, auf dem Linux oder macOS ausgeführt wird. Wenn Sie Cloud Shell nicht verwenden:
1. Sie sollten die neueste Version der Google Cloud CLI installiert haben, das Befehlszeilentool für die Interaktion mit Google Cloud. Aktualisieren Sie bei Bedarf die gcloud CLI-Komponenten:
```
gcloud components update
```
  Je nachdem, wie die gcloud CLI installiert wurde, wird möglicherweise die folgende Meldung angezeigt:
```
You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:
```
  Folgen Sie der Anleitung, um den Befehl zum Aktualisieren der Komponenten zu kopieren und einzufügen.
2. Prüfen Sie, ob kubectl installiert ist. Wenn Sie kubectl installieren möchten, führen Sie den folgenden Befehl aus:
```
gcloud components install kubectl
```
Achten Sie darauf, dass Ihr Projekt ein VPC-Netzwerk namens „default“ hat.
Wenn Sie kein Standard-VPC-Netzwerk haben, werden die erforderlichen Ressourcen mit dem Script im folgenden Abschnitt nicht bereitgestellt. Sofern Sie es nicht löschen oder einschränken, beginnt jedes neue Projekt mit einem VPC-Netzwerk im automatischen Modus namens „default“, das mit dem Script funktionieren sollte. Weitere Informationen finden Sie unter VPC-Netzwerke.
Die folgenden Einschränkungen für Organisationsrichtlinien dürfen nicht erzwungen werden:
- constraints/iam.disableServiceAccountKeyCreation
- constraints/compute.vmCanIpForward
- constraints/compute.requireShieldedVm
- constraints/compute.vmExternalIpAccess
Wenn diese Einschränkungen erzwungen werden, kann das Script im folgenden Abschnitt die erforderlichen Ressourcen nicht bereitstellen. Bei einem neuen Projekt sind diese Einschränkungen standardmäßig auf „Inaktiv (nicht erzwungen)“ festgelegt. Weitere Informationen finden Sie unter Einschränkungen für Organisationsrichtlinien.
Umgebungsvariablen einrichten:
```
export PROJECT_ID=PROJECT_ID
export ADMIN_CLUSTER_NAME=ADMIN_CLUSTER_NAME
export ON_PREM_API_REGION=ON_PREM_API_REGION
export ZONE=ZONE
```
- ADMIN_CLUSTER_NAME: der Name, den Sie für den Administratorcluster auswählen.
- ON_PREM_API_REGION: die Google Cloud Region, in der die GKE On-Prem API ausgeführt wird und 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.
Führen Sie die folgenden Befehle aus, um das Standardprojekt und die Standardzone festzulegen.
```
gcloud config set project $PROJECT_ID
gcloud config set compute/zone $ZONE
```
Wenn Sie den Fehler PERMISSION_DENIED erhalten, prüfen Sie die eingegebene Projekt-ID. Wenn die Projekt-ID korrekt ist, führen Sie gcloud auth login aus, um sich mit dem Konto, das Zugriff auf das Projekt hat, in der gcloud CLI anzumelden.

Rufen Sie eine Liste der unterstützten Versionen auf, die Sie installieren können:

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

Wählen Sie in 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 Funktionen und Fehlerbehebungen von Google Distributed Cloud zu erhalten.

2. VMs und Netzwerk erstellen

In diesem Abschnitt laden Sie das Script install_admin_cluster.sh herunter und führen es aus.

Klonen Sie das Repository anthos-samples und wechseln Sie in das Verzeichnis, in dem sich das Script befindet:
```
git clone https://github.com/GoogleCloudPlatform/anthos-samples
cd anthos-samples/anthos-bm-gcp-bash
```
Führen Sie das Skript aus:
```
bash install_admin_cluster.sh
```
Geben Sie 2 ein, um nur die Compute Engine-Infrastruktur einzurichten, und bestätigen Sie Ihre Auswahl, wenn Sie dazu aufgefordert werden.

Das Script erstellt Compute Engine-VMs, ein VXLAN-Netzwerk und richtet die Administratorworkstation und die Clusterknoten ein. Die Einrichtung der Infrastruktur dauert etwa 5 Minuten.

Weitere Informationen zum Script finden Sie unter folgendem Link:
Das Script

Sie finden das Script im Ordner anthos-bm-gcp-bash im GitHub-Repository anthos-samples. Das Script automatisiert die folgenden manuellen Schritte:
1. Aktiviert die folgenden Google Cloud APIs:
  anthos.googleapis.com anthosaudit.googleapis.com anthosgke.googleapis.com cloudresourcemanager.googleapis.com connectgateway.googleapis.com container.googleapis.com compute.googleapis.com gkeconnect.googleapis.com gkehub.googleapis.com gkeonprem.googleapis.com serviceusage.googleapis.com stackdriver.googleapis.com monitoring.googleapis.com logging.googleapis.com kubernetesmetadata.googleapis.com iam.googleapis.com opsconfigmonitoring.googleapis.com
2. Anstatt mehrere Dienstkonten für verschiedene APIs und Dienste zu erstellen, erstellt das Script ein einzelnes Dienstkonto namens baremetal-gcr und gewährt ihm die folgenden IAM-Rollen:
  - roles/gkehub.admin
  - roles/gkehub.connect
  - roles/logging.logWriter
  - roles/monitoring.dashboardEditor
  - roles/monitoring.metricWriter
  - roles/monitoring.viewer
  - roles/opsconfigmonitoring.resourceMetadata.writer
  - roles/serviceusage.serviceUsageViewer
  - roles/stackdriver.resourceMetadata.writer
3. Erstellen der folgenden VMs:
  - Eine VM für die Administratorworkstation.
  - 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.
4. Prüfen, ob SSH auf allen VMs aktiviert ist und ob die Administratorworkstation SSH-Zugriff auf alle anderen VMs hat, die für Clusterknoten erstellt wurden.
5. Erstellen eines VXLAN-Overlay-Netzwerk (Virtual Extensible LAN) für die Layer 2-Verbindung zwischen den VMs. Das VXLAN ist nicht persistent. Wenn Sie eine VM-Instanz neu starten, wird das Netzwerk gelöscht. Das Netzwerk ist für das Subnetz 10.200.0.0/24 eingerichtet. Die Layer 2-Verbindung ist eine Voraussetzung für den gebündelten Load Balancer.
6. Installieren der folgenden Tools auf der Administratorworkstation:
  - bmctl
  - kubectl
  - Docker
  Außerdem lädt das Script den Dienstkontoschlüssel für das Dienstkonto baremetal-gcr auf die Administratorworkstation herunter.
7. Prüfen, ob root@10.200.0.x auf der Administratorworkstation funktioniert. Dafür führt das Script die folgenden Aufgaben aus:
  1. Generieren Sie einen neuen SSH-Schlüssel auf der Administrator-Workstation.
  2. Hinzufügen des öffentlichen Schlüssels zu allen anderen VMs im Deployment.
Das Script gibt jeden ausgeführten Befehl und den Status aus. Wenn alle Schritte abgeschlossen sind, gibt das Script Folgendes aus:
```
✅ Successfully set up SSH access from admin workstation to cluster node VMs.

✅ GCE Infrastructure setup 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-cp  | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp   | 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         |
|---------------------------------------------------------------------------------------------------------|
```

3. Erstellen Sie den Administratorcluster.

`bmctl`

Wenn Sie einen Administratorcluster mit bmctl erstellen möchten, greifen Sie in einem Terminalfenster auf die VM der Administratorworkstation zu und führen dort Befehle aus:

Verwenden Sie SSH, um als Root auf die Administratorworkstation-VM abm-ws zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Legen Sie Ihre Nutzeranmeldedaten als Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) fest:
```
gcloud auth application-default login
```
Folgen Sie den Anweisungen, um Ihr Google-Konto für ADC auszuwählen.

Generieren Sie eine Clusterkonfigurationsdatei:

bmctl create config -c ADMIN_CLUSTER_NAME --project-id=PROJECT_ID

Prüfen Sie die Konfigurationsdatei für den Administratorcluster:

Die folgende Clusterkonfigurationsdatei enthält die Werte, die Sie zuvor angegeben haben. Neben den von Ihnen eingegebenen Werten gibt es noch folgende Unterschiede zur generierten Konfigurationsdatei:

Aus diesem Beispiel wurden Kommentare entfernt, um die Lesbarkeit zu verbessern.
Das Script erstellt ein einzelnes Dienstkonto mit allen erforderlichen Berechtigungen und lädt den in der Konfigurationsdatei referenzierten Schlüssel bm-gcr.json herunter.

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
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      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:
    projectID: PROJECT_ID
    location: ON_PREM_API_REGION
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 110

Ersetzen Sie den Inhalt der generierten Konfigurationsdatei auf Ihrer Administrator-Workstation durch die Inhalte aus dem vorherigen Beispiel.

Öffnen Sie die generierte Datei bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml und ersetzen Sie deren Inhalt durch den Inhalt des Beispiels, das Sie im vorhergehenden Schritt geprüft haben.
Erstellen Sie den Administratorcluster:
```
bmctl create cluster -c ADMIN_CLUSTER_NAME
```
Mit dem Befehl bmctl wird die Ausgabe während der Ausführung von Preflight-Prüfungen auf dem Bildschirm angezeigt und der Cluster erstellt. Ausführliche Informationen werden in Logs im Ordner baremetal/bmctl-workspace/abm-user-cluster-metallb/log auf der Administratorworkstation geschrieben.

Die Erstellung eines Clusters kann einige Minuten dauern.
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. Der Administratorcluster sollte aufgeführt sein.
Melden Sie sich im Administratorcluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).

Administratorcluster prüfen

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

Verwenden Sie SSH, um als Root auf die Administratorworkstation zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Prüfen Sie, ob der Administratorcluster erstellt wurde und ausgeführt wird:
```
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
```
Die Ausgabe sieht in etwa so aus:

none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81
Wenn Sie fertig sind, geben Sie exit ein, um die Verbindung zur Administratorworkstation zu trennen.

Console

Wenn Sie einen Administratorcluster in der Console erstellen möchten, müssen Sie bmctl register bootstrap auf der Administratorworkstation-VM ausführen, um einen Bootstrap-Cluster zu erstellen. Während der Befehl bmctl register bootstrap ausgeführt wird, führen Sie in der Console Schritte aus, um den Administratorcluster zu erstellen.

Grundlagen der Bootstrap-Umgebung eingeben

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

Zu GKE-Clustern
Klicken Sie auf Erstellen.
Wählen Sie im Dialogfeld Cluster erstellen die Option Lokal aus und klicken Sie für Bare Metal auf Konfigurieren:
Achten Sie darauf, in der Projektliste PROJECT_ID auszuwählen.
Klicken Sie in der linken Navigationsleiste auf Bootstrap-Umgebung installieren.
Geben Sie ADMIN_CLUSTER_NAME als Namen des Administratorclusters ein.
Wählen Sie BMCTL_VERSION als Version für Ihren Administratorcluster aus. Das Script hat diese Version des bmctl-Befehlszeilentools auf die Administratorworkstation heruntergeladen. Die von Ihnen installierte Version von Google Distributed Cloud muss der bmctl-Version entsprechen.
Wählen Sie im Feld Standort der Google Cloud API die Option ON_PREM_API_REGION aus der Liste aus. Mit dieser Einstellung wird die Region angegeben, in der die GKE On-Prem API ausgeführt wird, und die Region, in der Folgendes gespeichert wird:
- Die Metadaten des Clusters, die die GKE On-Prem API zum Verwalten des Clusterlebenszyklus benötigt
- Cloud Logging- und Cloud Monitoring-Daten von Systemkomponenten
- Die von Cloud-Audit-Logs erstellten Administrator-Audit-Logs
Anhand des Clusternamens, des Projekts und des Standorts kann der Cluster in Google Cloudeindeutig identifiziert werden.

Folgen Sie zum Erstellen des Bootstrap-Clusters den Schritten im nächsten Abschnitt, anstatt den in der Console angezeigten Schritten. Lassen Sie die Console-Seite geöffnet, da Sie dort mit dem Erstellen des Administratorclusters fortfahren.

Bootstrap-Cluster erstellen

Wenn Sie einen GKE On-Prem API-Client wie die Console zum Erstellen eines Administratorclusters verwenden, müssen Sie auf der Administratorworkstation einen Bootstrap-Cluster erstellen. Der Bootstrap-Cluster hostet die Kubernetes-Controller, die zum Erstellen des Administratorclusters erforderlich sind.

Verwenden Sie SSH, um über die Befehlszeile als Root auf die Administratorworkstation-VM zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Sie können alle Nachrichten zum Aktualisieren der VM ignorieren und mit diesem Tutorial fortfahren. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder ein Upgrade auf die nächste Version ausführen, wie in der Ubuntu-Dokumentation beschrieben.
Legen Sie Ihre Nutzeranmeldedaten als Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) fest:
```
gcloud auth application-default login
```
Folgen Sie den Anweisungen, um Ihr Google-Konto für ADC auszuwählen.
Wechseln Sie zum Verzeichnis baremetal/ und führen Sie den folgenden Befehl aus, um den Bootstrap-Cluster zu erstellen.

Der Name des Bootstrap-Clusters wird durch Voranstellen von bootstrap- vor dem Namen des Administratorclusters abgeleitet.

Hinweis: Sie müssen bmctl nicht herunterladen, da das zuvor ausgeführte Script dies beim Einrichten der Administratorworkstation bereits getan hat.
```
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, wird eine Ausgabe angezeigt, die in etwa so aussieht:
```
[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..
```
Wichtig: Lassen Sie den Befehl laufen, während Sie die Schritte in einem neuen Terminalfenster ausführen. Wenn Sie den Befehl bmctl register bootstrap beenden, bevor der Administratorcluster erstellt wurde, schlägt die Erstellung fehl. Nachdem der Administratorcluster erstellt wurde, löscht der Befehl den Bootstrap-Cluster automatisch und beendet die Ausführung.

Erstellen Sie den Administratorcluster.

Klicken Sie auf der Seite Bootstrap-Umgebung installieren im Bereich Bootstrapping der Umgebung über Administratorworkstation ausführen auf Verbindung prüfen.

Bei Erfolg wird in der Console Verbindung hergestellt angezeigt.

Die Verbindung zum Bootstrap-Cluster muss hergestellt werden, bevor Sie fortfahren können. Wenn die Verbindung nicht hergestellt wird, prüfen Sie die Argumente, die Sie für den Befehl bmctl register bootstrap angegeben haben:
- Der Wert für --name muss mit dem abgeleiteten Bootstrap-Namen im Abschnitt Grundlagen der Bootstrap-Umgebung übereinstimmen.
- 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öchten, geben Sie Ctrl-C ein, um bmctl register bootstrap zu beenden, und führen Sie den Befehl noch einmal aus.

Netzwerk

Klicken Sie in der linken Navigationsleiste auf Netzwerk.
Geben Sie im Abschnitt Steuerungsebene im Feld Knoten-IP-Adresse 1 der Steuerungsebene Folgendes ein:
```
10.200.0.3
```
Dies ist die IP-Adresse der VM „abm-admin-cluster-cp“ im vom Script erstellten VXLAN.
Achten Sie darauf, dass im Abschnitt Load Balancer die Option Gebündelt ausgewählt ist.
Geben Sie im Abschnitt Virtuelle IP-Adressen (VIPs) im Feld VIP der Steuerungsebene Folgendes ein:
```
10.200.0.48
```
Der nächste Schritt hängt von der Verfügbarkeit des Bootstrap-Clusters ab. Der Befehl bmctl register bootstrap muss im Terminalfenster einige Minuten lang ausgeführt werden, bevor der Bootstrap-Cluster als registriertes Mitglied angezeigt wird. Wenn er nach einigen Minuten immer noch nicht verfügbar ist, prüfen Sie den Namen und die Projekt-ID des Bootstrap-Clusters. Wenn Sie den Namen des Bootstrap-Clusters oder die Projekt-ID ändern möchten, geben Sie im anderen Terminalfenster Ctrl-C ein, um bmctl register bootstrap zu beenden, und führen Sie den Befehl noch einmal aus.

Klicken Sie auf Überprüfen und erstellen.

Die Console zeigt Statusmeldungen an, während die Einstellungen geprüft werden und der Cluster erstellt wird.

Wenn der Administratorcluster erstellt wird, wird der Bootstrap-Cluster auf der Administratorworkstation gelöscht. Die Ausgabe des Befehls bmctl register bootstrap im anderen Terminalfenster sieht in etwa so aus:

...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

Administratorcluster prüfen

Verwenden Sie SSH, um als Root auf die Administratorworkstation zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Prüfen Sie, ob der Administratorcluster erstellt wurde und ausgeführt wird:
```
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
```
Die Ausgabe sieht in etwa so aus:

none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81
Wenn Sie fertig sind, geben Sie exit ein, um die Verbindung zur Administratorworkstation zu trennen.

gcloud-CLI

Für die folgende Anleitung sind zwei Terminalfenster erforderlich. Führen Sie in einem Terminalfenster bmctl register bootstrap aus, um einen Bootstrap-Cluster zu erstellen. Während der Befehl bmctl register bootstrap ausgeführt wird, führen Sie in einem anderen Terminalfenster gcloud container bare-metal admin-clusters create aus, um den Administratorcluster zu erstellen.

Bootstrap-Cluster erstellen

Wenn Sie einen GKE On-Prem API-Client wie die gcloud CLI verwenden, um einen Administratorcluster zu erstellen, müssen Sie auf der Administratorworkstation einen Bootstrap-Cluster erstellen. Der Bootstrap-Cluster hostet die Kubernetes-Controller, die zum Erstellen des Administratorclusters erforderlich sind.

Verwenden Sie SSH, um über die Befehlszeile als Root auf die Administratorworkstation-VM zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Sie können alle Nachrichten zum Aktualisieren der VM ignorieren und mit diesem Tutorial fortfahren. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder ein Upgrade auf die nächste Version ausführen, wie in der Ubuntu-Dokumentation beschrieben.
Legen Sie Ihre Nutzeranmeldedaten als Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) fest:
```
gcloud auth application-default login
```
Folgen Sie den Anweisungen, um Ihr Google-Konto für ADC auszuwählen.
Wechseln Sie zum Verzeichnis baremetal/ und führen Sie den folgenden Befehl aus, um den Bootstrap-Cluster zu erstellen.

Der Name des Bootstrap-Clusters wird durch Voranstellen von bootstrap- vor dem Namen des Administratorclusters abgeleitet.

Hinweis: Sie müssen bmctl nicht herunterladen, da das zuvor ausgeführte Script dies beim Einrichten der Administratorworkstation bereits getan hat.
```
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, wird eine Ausgabe angezeigt, die in etwa so aussieht:
```
[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..
```
Wichtig: Lassen Sie den Befehl laufen, während Sie die Schritte in einem neuen Terminalfenster ausführen. Wenn Sie den Befehl bmctl register bootstrap beenden, bevor der Administratorcluster erstellt wurde, schlägt die Erstellung fehl. Nachdem der Administratorcluster erstellt wurde, löscht der Befehl den Bootstrap-Cluster automatisch und beendet die Ausführung.

Erstellen Sie den Administratorcluster.

Prüfen Sie in einem neuen Terminalfenster, ob der Bootstrap-Cluster als Mitglied der Flotte registriert wurde:
```
gcloud container fleet memberships list \
    --project=PROJECT_ID
```
Der Befehl gcloud container bare-metal admin-clusters create im folgenden Schritt hängt von der Verfügbarkeit des Bootstrap-Clusters ab. Der Befehl bmctl register bootstrap im anderen Terminalfenster muss einige Minuten lang ausgeführt werden, bevor der Bootstrap-Cluster als registriertes Mitglied angezeigt wird. Wenn er nach einigen Minuten immer noch nicht aufgeführt ist, prüfen Sie den Namen und die Projekt-ID des Bootstrap-Clusters. Wenn Sie den Namen des Bootstrap-Clusters oder die Projekt-ID ändern möchten, geben Sie im anderen Terminalfenster Ctrl-C ein, um bmctl register bootstrap zu beenden, und führen Sie den Befehl dann noch einmal aus.

So erstellen Sie einen Administratorcluster mit dem gebündelten Load Balancer:

Die angegebenen Werte müssen den Umgebungsvariablen entsprechen, die Sie zuvor für das Script angegeben haben.

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

Dabei gilt:

--control-plane-vip ist auf 10.200.0.48 festgelegt. Dies ist die virtuelle IP-Adresse (VIP) auf dem Load Balancer für den Kubernetes API-Server des Clusters.
--control-plane-node-configs: Die node-ip ist auf 10.200.0.3 festgelegt. Dies ist die IP-Adresse der VM abm-admin-cluster-cp im vom Script erstellten VXLAN.

Eine vollständige Liste der Flags mit ihren 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 der OPERATION_ID des Vorgangs mit langer Ausführungszeit. Sie können den Status des Vorgangs ermitteln, indem Sie in einem anderen Terminalfenster den folgenden Befehl ausführen:

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

Wenn gcloud container bare-metal admin-clusters create erfolgreich abgeschlossen wurde, sieht die Ausgabe in etwa so aus:

none{:.devsite-disable-click-to-copy} Created Anthos on bare metal Admin Cluster [https://gkeonprem.googleapis.com/v1/projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-gcloud-001]. NAME LOCATION VERSION MEMBERSHIP STATE abm-cluster-1 us-central1 1.31.300-gke.81 abm-cluster-1 RUNNING

...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

Administratorcluster prüfen

Verwenden Sie SSH, um als Root auf die Administratorworkstation zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Prüfen Sie, ob der Administratorcluster erstellt wurde und ausgeführt wird:
```
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
```
Die Ausgabe sieht in etwa so aus:

none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81
Wenn Sie fertig sind, geben Sie exit ein, um die Verbindung zur Administratorworkstation zu trennen.

Terraform

Für die folgende Anleitung sind zwei Terminalfenster erforderlich. Führen Sie in einem Terminalfenster bmctl register bootstrap aus, um einen Bootstrap-Cluster zu erstellen. Während der Befehl bmctl register bootstrap ausgeführt wird, führen Sie die Terraform-Befehle in einem anderen Terminalfenster aus, um den Administratorcluster zu erstellen.

Nutzercluster-Beispieldateien so ändern, dass sie für einen Administratorcluster genutzt werden können

Das anthos-samples-Repository enthält kein Beispiel, das speziell zum Erstellen eines Google Distributed Cloud-Administratorclusters gedacht ist. In den folgenden Schritten erfahren Sie, wie Sie einen Administratorcluster erstellen, indem Sie ein vorhandenes Terraform-Beispiel für einen Nutzercluster ändern.

Führen Sie im Verzeichnis, in dem Sie anthos-samples geklont haben, den folgenden Befehl aus, um die Beispieldateien für das MetalLB-Nutzerclusterbeispiel in einen neuen Ordner für Ihren Administratorcluster zu kopieren:
```
cp -r anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb \
    anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic
```

Wechseln Sie in das Verzeichnis abm_admin_cluster_basic:

cd anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

Bearbeiten Sie die Terraform-Dateien:

variables.tf:
- Definieren Sie eine Variable für die IP-Adressen der Knoten der Steuerungsebene (für diese Demo verwenden wir aber nur eine IP-Adresse). Diese Variable sollte dem Eintrag variable "control_plane_ips" { ... } ähneln.
- Definieren Sie eine Variable für die virtuelle IP-Adresse der Steuerungsebene. Diese Variable sollte dem Eintrag variable "control_plane_vip" { ... } ähneln.
terraform.tfvars:
- Weisen Sie Variablenwerte für die folgenden Administratorcluster-Einstellungen zu:
  - IP-Adressen für Knoten der Steuerungsebene: 10.200.0.3
  - Virtuelle IP-Adresse der Steuerungsebene: 10.200.0.48
main.tf:
- Ersetzen Sie die Ressource google_gkeonprem_bare_metal_cluster durch die Ressource google_gkeonprem_bare_metal_admin_cluster.
- Löschen Sie die Ressource google_gkeonprem_bare_metal_node_pool und den zugehörigen lifecycle-Abschnitt.
- Aktualisieren Sie die Ressource, damit die neu definierten Variablen verwendet werden.

So könnte die Datei main.tf aussehen, wenn sie zum Erstellen eines Administratorclusters bearbeitet wird:

/**
* Copyright 2023 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#[START anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

module "enable_google_apis_primary" {
  source     = "terraform-google-modules/project-factory/google//modules/project_services"
  version    = "~> 14.0"
  project_id = var.project_id
  activate_apis = [
    "anthos.googleapis.com",
    "anthosaudit.googleapis.com",
    "anthosgke.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "compute.googleapis.com",
    "connectgateway.googleapis.com",
    "container.googleapis.com",
    "file.googleapis.com",
    "gkehub.googleapis.com",
    "iam.googleapis.com",
    "kubernetesmetadata.googleapis.com",
    "logging.googleapis.com",
    "monitoring.googleapis.com",
    "opsconfigmonitoring.googleapis.com",
    "serviceusage.googleapis.com",
    "stackdriver.googleapis.com"
  ]
  disable_services_on_destroy = false
}

# Enable GKE OnPrem API
resource "google_project_service" "default" {
  project            = var.project_id
  service            = "gkeonprem.googleapis.com"
  disable_on_destroy = false
}

# Create a baremetal admin cluster and enroll it with the gkeonprem API
resource "google_gkeonprem_bare_metal_admin_cluster" "admin-cluster-basic" {
  name                     = var.admin_cluster_name
  description              = "Bare metal admin cluster"
  provider                 = google
  depends_on               = [google_project_service.default]
  location                 = var.region
  bare_metal_version       = var.bare_metal_version
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["0.96.0.0/20"]
      pod_address_cidr_blocks     = ["192.168.0.0/16"]
    }
  }
  node_config {
    max_pods_per_node = 250
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        operating_system = "LINUX"
        dynamic "node_configs" {
          for_each = var.admin_cp_ips
          content {
            node_ip = node_configs.value
          }
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = var.admin_cp_vip
    }
  }
  storage {
    lvp_share_config {
      lvp_config {
        path = "/mnt/localpv-share"
        storage_class = "local-shared"
      }
      shared_path_pv_count = 5
    }
    lvp_node_mounts_config {
      path = "/mnt/localpv-disk"
      storage_class = "local-disks"
    }
  }

  dynamic "security_config" {
    for_each = length(var.admin_user_emails) == 0 ? [] : [1]
    content {
      authorization {
        dynamic "admin_users" {
          for_each = var.admin_user_emails
          content {
            username = admin_users.value
          }
        }
      }
    }
  }

  lifecycle {
    ignore_changes = [
      annotations["onprem.cluster.gke.io/user-cluster-resource-link"],
      annotations["alpha.baremetal.cluster.gke.io/cluster-metrics-webhook"],
      annotations["baremetal.cluster.gke.io/operation"],
      annotations["baremetal.cluster.gke.io/operation-id"],
      annotations["baremetal.cluster.gke.io/start-time"],
      annotations["baremetal.cluster.gke.io/upgrade-from-version"]
    ]
  }
}

#[END anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

Weitere Informationen zur Terraform-Ressource für Administratorcluster finden Sie in der Terraform-Registry unter google_gkeonprem_bare_metal_admin_cluster.

Bootstrap-Cluster erstellen

Wenn Sie einen GKE On-Prem API-Client wie Terraform zum Erstellen eines Administratorclusters verwenden, müssen Sie auf der Administratorworkstation einen Bootstrap-Cluster erstellen. Der Bootstrap-Cluster hostet die Kubernetes-Controller, die zum Erstellen des Administratorclusters erforderlich sind.

Verwenden Sie SSH, um über die Befehlszeile als Root auf die Administratorworkstation-VM zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Sie können alle Nachrichten zum Aktualisieren der VM ignorieren und mit diesem Tutorial fortfahren. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder ein Upgrade auf die nächste Version ausführen, wie in der Ubuntu-Dokumentation beschrieben.
Legen Sie Ihre Nutzeranmeldedaten als Standardanmeldedaten für Anwendungen (Application Default Credentials, ADC) fest:
```
gcloud auth application-default login
```
Folgen Sie den Anweisungen, um Ihr Google-Konto für ADC auszuwählen.
Wechseln Sie zum Verzeichnis baremetal/ und führen Sie den folgenden Befehl aus, um den Bootstrap-Cluster zu erstellen.

Der Name des Bootstrap-Clusters wird durch Voranstellen von bootstrap- vor dem Namen des Administratorclusters abgeleitet.

Hinweis: Sie müssen bmctl nicht herunterladen, da das zuvor ausgeführte Script dies beim Einrichten der Administratorworkstation bereits getan hat.
```
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, wird eine Ausgabe angezeigt, die in etwa so aussieht:
```
[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..
```
Wichtig: Lassen Sie den Befehl laufen, während Sie die Schritte in einem neuen Terminalfenster ausführen. Wenn Sie den Befehl bmctl register bootstrap beenden, bevor der Administratorcluster erstellt wurde, schlägt die Erstellung fehl. Nachdem der Administratorcluster erstellt wurde, löscht der Befehl den Bootstrap-Cluster automatisch und beendet die Ausführung.

Erstellen Sie den Administratorcluster.

Initialisieren und erstellen Sie den Terraform-Plan:
```
terraform init
```
Terraform installiert alle erforderlichen Bibliotheken, z. B. den Google Cloud -Anbieter.
Überprüfen Sie die Konfiguration und nehmen Sie bei Bedarf Änderungen vor:
```
terraform plan
```

Wenden Sie den Terraform-Plan an, um den Administratorcluster zu erstellen:

terraform apply

Das Erstellen des Nutzerclusters dauert mindestens 15 Minuten. Wenn die Clustererstellung abgeschlossen ist, wird eine Meldung angezeigt, die in etwa so aussieht:

...
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Still creating... [20m10s elapsed]
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Creation complete after 20m11s
[id=projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-terra002]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

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. Der Administratorcluster sollte aufgeführt sein.
Melden Sie sich im Administratorcluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).

Administratorcluster prüfen

Verwenden Sie SSH, um als Root auf die Administratorworkstation zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Prüfen Sie, ob der Administratorcluster erstellt wurde und ausgeführt wird:
```
kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes
```
Die Ausgabe sieht in etwa so aus:

none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81
Wenn Sie fertig sind, geben Sie exit ein, um die Verbindung zur Administratorworkstation zu trennen.

4. Nutzercluster erstellen

Sie können den Nutzercluster mit der Google Cloud -Konsole, der Google Cloud CLI oder Terraform erstellen. Verwenden Sie der Einfachheit halber abm-user-cluster-metallb für den Namen des Nutzerclusters, damit er mit dem hartcodierten Namen in den Terraform-Scripts übereinstimmt.

`bmctl`

Verwenden Sie SSH, um als Root auf die Administratorworkstation-VM abm-ws zuzugreifen:
```
gcloud compute ssh root@abm-ws --zone ZONE
```

Generieren Sie eine Clusterkonfigurationsdatei:

bmctl create config -c abm-user-cluster-metallb \
    --project-id=PROJECT_ID

Legen Sie in der folgenden Nutzercluster-Konfigurationsdatei im Abschnitt clusterSecurity Ihre E-Mail-Adresse fest und prüfen Sie die restlichen Einstellungen:

Die folgende Clusterkonfigurationsdatei enthält die Werte, die Sie zuvor in die Planungstabelle eingegeben haben. Neben den von Ihnen eingegebenen Werten gibt es noch folgende Unterschiede zur generierten Konfigurationsdatei:

Aus diesem Beispiel wurden Kommentare entfernt, um die Lesbarkeit zu verbessern.
Der Abschnitt für Anmeldedaten wurde entfernt, wie es bei Nutzerclustern üblich ist.
Der Clustertyp spec.type wurde auf user festgelegt.
Das Feld spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts wurde hinzugefügt, um Ihrem Konto die Rolle clusterrole/cluster-admin zu gewähren. Über dieses Feld können Sie sich unter anderem in derGoogle Cloud -Konsole in Ihrem Cluster anmelden, um weitere Clusterdetails aufzurufen.

---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-abm-user-cluster-metallb
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: abm-user-cluster-metallb
  namespace: cluster-abm-user-cluster-metallb
spec:
  type: user
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: 10.200.0.4
  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.50
      ingressVIP: 10.200.0.51
    addressPools:
    - name: pool1
      addresses:
      - 10.200.0.51-10.200.0.70
  clusterOperations:
    projectID: PROJECT_ID
    location: ON_PREM_API_REGION
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - YOUR_EMAIL_ADDRESS
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-abm-user-cluster-metallb
spec:
  clusterName: abm-user-cluster-metallb
  nodes:
  - address: 10.200.0.5

Ersetzen Sie den Inhalt der generierten Konfigurationsdatei auf Ihrer Administrator-Workstation durch die Inhalte aus dem vorherigen Beispiel.

Öffnen Sie die generierte Datei bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml und ersetzen Sie deren Inhalt durch den Inhalt des Beispiels, das Sie im vorhergehenden Schritt geprüft haben.
Nutzercluster erstellen:
```
bmctl create cluster -c abm-user-cluster-metallb \
  --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
```
Mit dem Befehl bmctl wird die Ausgabe während der Ausführung von Preflight-Prüfungen auf dem Bildschirm angezeigt und der Cluster erstellt. Ausführliche Informationen werden in Logs im Ordner baremetal/bmctl-workspace/abm-user-cluster-metallb/log auf der Administratorworkstation geschrieben.

Die Erstellung eines Clusters kann einige Minuten dauern.
Rufen Sie in der Google Cloud 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. Sie sollen den Administrator- und den Nutzercluster in der Liste sehen.
Melden Sie sich im Nutzercluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).
Wiederholen Sie die Schritte, um sich im Administratorcluster anzumelden.

Console

So erstellen Sie einen Nutzercluster in der Console:

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

Zur Seite „Bare-Metal-Cluster erstellen“
Achten Sie darauf, dass das Google Cloud Projekt ausgewählt ist, in dem Sie den Administratorcluster erstellt haben.
Klicken Sie auf Cluster erstellen.
Klicken Sie im Dialogfeld auf Lokal.
Klicken Sie neben Bare Metal auf Konfigurieren. Die Seite Voraussetzungen wird angezeigt.
Wählen Sie unter Clustertyp auswählen die Option Nutzercluster für einen vorhandenen Administratorcluster erstellen aus.
Klicken Sie auf Weiter.

Clustergrundlagen

Geben Sie einen Namen für den Nutzercluster ein oder verwenden Sie den Standardnamen.
Achten Sie darauf, dass der neu erstellte Administratorcluster ausgewählt ist. Für die übrigen Einstellungen auf dieser Seite können Sie die Standardwerte verwenden.
Klicken Sie in der linken Navigationsleiste auf Netzwerk.

Netzwerk

Mit dem Script, das Sie zum Erstellen der VMs und des Administratorclusters ausgeführt haben, wurde auch ein Layer 2-VXLAN mit IP-Adressen im Subnetz 10.200.0.0/24 erstellt.

Geben Sie im Abschnitt Steuerungsebene im Feld Knoten-IP-Adresse 1 der Steuerungsebene Folgendes ein:
```
10.200.0.4
```
Dies ist die IP-Adresse der VM abm-user-cluster-cp1 im vom Script erstellten VXLAN.
Verwenden Sie im Abschnitt Load-Balancer den Standard-Load-Balancer Gebündelt mit MetalLB.
Geben Sie im Abschnitt Neuer Adresspool im Feld IP-Adressbereich 1 den folgenden IP-Adressbereich ein:
```
10.200.0.51-10.200.0.70
```
Klicken Sie auf Fertig.
Geben Sie im Abschnitt Virtuelle IP-Adressen im Feld VIP der Steuerungsebene die folgende IP-Adresse ein:
```
10.200.0.50
```
Geben Sie unter Virtuelle IP-Adresse für eingehenden Traffic die folgende IP-Adresse ein:
```
10.200.0.51
```
Verwenden Sie die Standard-IP-Adressen im Abschnitt Dienst- und Pod-CIDRs.
Klicken Sie in der linken Navigationsleiste auf Standardpool.

Knotenpool erstellen

Ihr Nutzercluster muss mindestens einen Knotenpool für Worker-Knoten haben.

Geben Sie im Feld Knotenadresse 1 die folgende IP-Adresse ein:
```
10.200.0.5
```
Dies ist die IP-Adresse der VM „abm-user-cluster-w1“ im vom Script erstellten VXLAN.

Cluster erstellen

Klicken Sie auf Prüfen und erstellen, um den Nutzercluster zu erstellen.

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

Wenn bei der Konfiguration ein Fehler auftritt, wird in der Console eine Fehlermeldung angezeigt, die klar genug sein sollte, um das Konfigurationsproblem zu beheben. Versuchen Sie danach noch einmal, den Cluster zu erstellen.

Wenn Sie weitere Informationen zum Erstellungsprozess sehen möchten, klicken Sie auf Details anzeigen, um einen Detailbereich zu öffnen. Klicken Sie auf , um den Bereich wieder zu schließen.

Nach dem Erstellen des Clusters wird Clusterstatus: Wird ausgeführt angezeigt.
Klicken Sie nach dem Erstellen des Clusters auf Cluster um zur Seite Cluster zurückzukehren.
Melden Sie sich im Nutzercluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).
Wiederholen Sie die Schritte, um sich im Administratorcluster anzumelden.

gcloud-CLI

So erstellen Sie den Nutzercluster:

Führen Sie den folgenden Befehl aus, um den Nutzercluster zu erstellen:

gcloud container bare-metal clusters create abm-user-cluster-metallb \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/ON_PREM_API_REGION/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

Nach der Ausführung des Befehls wird eine Ausgabe angezeigt, die in etwa so aussieht:

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 der OPERATION_ID des Vorgangs mit langer Ausführungszeit.

Öffnen Sie ein neues Terminalfenster und führen Sie den Befehl aus, um den Status des Vorgangs zu ermitteln.
```
gcloud container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION
```
Ersetzen Sie OPERATION_ID durch den entsprechenden String aus der Ausgabe des vorherigen Schritts.

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

Wenn der Cluster erstellt wurde, sehen Sie eine Ausgabe wie diese:
```
Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/abm-user-cluster-metallb].
```
Weitere Informationen zum Befehl gcloud container bare-metal clusters create, einschließlich Beschreibungen der einzelnen Flags, finden Sie auf der Seite container bare-metal clusters create für die Clusterressource in der gcloud CLI-Referenz.

Knotenpool erstellen

Nachdem der Cluster erstellt wurde, können Sie einen Knotenpool für den Cluster erstellen.

So erstellen Sie einen Knotenpool:

Führen Sie den folgenden Befehl aus, um einen Knotenpool zu erstellen:

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

Ersetzen Sie NODE_POOL_NAME durch den gewünschten Namen für den Knotenpool.

Nach der Ausführung des Befehls wird eine Ausgabe angezeigt, die in etwa so aussieht:

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

Das Erstellen des Knotenpools dauert etwa 5 Minuten. Wenn der Knotenpool erstellt wird, sehen Sie eine Ausgabe wie diese:

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

Rufen Sie in der Console die Seite Kubernetes-Cluster auf:

Zur Seite „Bare-Metal-Cluster erstellen“

Achten Sie darauf, dass das Projekt ausgewählt ist, in dem Sie den Nutzercluster erstellt haben. Sie sollen den Administrator- und den Nutzercluster in der Liste sehen.
Melden Sie sich im Nutzercluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).
Wiederholen Sie die Schritte, um sich im Administratorcluster anzumelden.

Terraform

Mit dem folgenden grundlegenden Konfigurationsbeispiel können Sie einen Nutzercluster mit gebündeltem MetalLB-Load-Balancer erstellen. Weitere Informationen finden Sie in der google_gkeonprem_bare_metal_cluster-Referenzdokumentation.

Wechseln Sie im Verzeichnis, in das Sie anthos-samples geklont haben, in den Pfad, in dem sich das Terraform-Beispiel befindet:
```
cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
```
Das Beispiel enthält eine Variablendatei, die an main.tf übergeben wird.
Erstellen Sie eine Kopie der Datei terraform.tfvars.sample.
```
cp terraform.tfvars.sample terraform.tfvars
```

Prüfen Sie die Werte im folgenden Beispiel:

Die folgende Terraform-Variablendatei (terraform.tfvars.sample) ist mit IP-Adressen und Werten vorausgefüllt, die Sie in den vorherigen Abschnitten dieses Leitfadens eingegeben haben.


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"] }
]

Ersetzen Sie ADMIN_2_EMAIL_ADDRESS durch eine mit Ihrem Google Cloud -Konto verknüpfte E-Mail-Adresse oder entfernen Sie den Eintrag, wenn Sie die Variablendatei bearbeiten.

Weitere Informationen zu den Argumenten in diesem Beispiel, für die Sie Variablen festlegen, finden Sie in der Terraform-Dokumentation für Bare-Metal-Nutzercluster unter Referenz zu Argumenten.

Ersetzen Sie den Inhalt Ihrer Kopie der Variablendatei durch den Inhalt aus dem vorherigen Beispiel.
Initialisieren und erstellen Sie den Terraform-Plan:
```
terraform init
```
Terraform installiert alle erforderlichen Bibliotheken, z. B. den Google Cloud -Anbieter.
Überprüfen Sie die Konfiguration und nehmen Sie bei Bedarf Änderungen vor:
```
terraform plan
```
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 aufrufen.
Rufen Sie in der Google Cloud 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. Sie sollen den Administrator- und den Nutzercluster in der Liste sehen.
Melden Sie sich im Nutzercluster an:
1. Klicken Sie auf den Link zum Clusternamen und dann in der Seitenleiste auf Anmelden.
2. Mit Google-Identität anmelden auswählen
3. Klicken Sie auf Login (Anmelden).
Wiederholen Sie die Schritte, um sich im Administratorcluster anzumelden.

5. Bereinigen

Folgen Sie der Anleitung unten, um die Cluster und VMs zu entfernen, die Sie mit diesem Leitfaden erstellt haben.

Nutzercluster löschen

`bmctl`

Wenn Sie den Nutzercluster mit bmctl löschen möchten, führen Sie den folgenden Befehl auf der Administratorworkstation-VM abm-ws aus:

bmctl reset \
    --cluster abm-user-cluster-metallb \
    --admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

Console

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

Zu GKE-Clustern
Klicken Sie in der Liste der Cluster auf den Nutzercluster.
Klicken Sie im Bereich Details auf Weitere Details ansehen.
Klicken Sie oben im Fenster auf Löschen.
Wenn Sie zur Bestätigung aufgefordert werden, geben Sie den Clusternamen ein und klicken Sie auf Löschen.
Klicken Sie rechts oben auf , um den Status des Löschvorgangs aufzurufen. 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 abm-user-cluster-metallb \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION \
    --force
```
Mit dem --force-Flag können Sie einen Cluster mit Knotenpools löschen. Ohne das --force-Flag müssen Sie zuerst die Knotenpools löschen und dann den Cluster.

Informationen zu anderen Flags finden Sie unter gcloud container bare-metal clusters delete.

Terraform

Mit dem Befehl terraform destroy werden Ressourcen beendet, die beim Ausführen von terraform apply zum Erstellen des Nutzerclusters erstellt wurden.

Führen Sie den folgenden Befehl in dem Verzeichnis aus, in dem sich die Terraform-Beispieldateien (z. B. main.tf) für den Nutzercluster befinden:
```
terraform destroy
```

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

Administratorcluster und VMs löschen

Heben Sie die Registrierung des Administratorclusters in der GKE On-Prem API auf:

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

Stellen Sie eine Verbindung zur Administratorworkstation her:
```
gcloud compute ssh root@abm-ws --zone ZONE
```
Administratorcluster löschen:
```
bmctl reset -c ADMIN_CLUSTER_NAME
```
bmctl hebt die Registrierung des Clusters in der Flotte auf und löscht ihn dann. Warten Sie, bis der Cluster gelöscht wurde, bevor Sie die VMs löschen.
Beenden Sie die Administratorworkstation:
```
exit
```

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

gcloud compute instances list | grep 'abm'

Vergewissern Sie sich, dass Sie mit dem Löschen aller VMs fortfahren möchten, die abm im Namen enthalten.

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 compute instances delete --quiet --zone ZONE
```
Führen Sie den folgenden Befehl aus, um das Dienstkonto zu löschen, und geben Sie y ein, wenn Sie dazu aufgefordert werden:
```
gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
```
Nächste Schritte

Informationen zum Erstellen von Clustern auf Ihrer eigenen Hardware finden Sie unter Einfache Installation auf Ihrer Hardware planen und Einfache Cluster auf Ihrer Hardware erstellen.
Ausführliche Informationen zu den Installationsanforderungen finden Sie unter Voraussetzungen für die Installation – Übersicht.
Weitere Informationen zur Installation finden Sie unter Cluster erstellen – Übersicht.
Eine Anleitung zur Bereitstellung in Ihrem Cluster finden Sie unter Anwendung bereitstellen.

Demo-Administratorcluster und -Nutzercluster für Google Distributed Cloud auf Compute Engine-VMs erstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Verfahrensübersicht

1. Lokale Umgebung vorbereiten

2. VMs und Netzwerk erstellen

Das Script

3. Erstellen Sie den Administratorcluster.

bmctl

Administratorcluster prüfen

Console

Grundlagen der Bootstrap-Umgebung eingeben

Bootstrap-Cluster erstellen

Erstellen Sie den Administratorcluster.

Netzwerk

Administratorcluster prüfen

gcloud-CLI

Bootstrap-Cluster erstellen

Erstellen Sie den Administratorcluster.

Administratorcluster prüfen

Terraform

Nutzercluster-Beispieldateien so ändern, dass sie für einen Administratorcluster genutzt werden können

Bootstrap-Cluster erstellen

Erstellen Sie den Administratorcluster.

Administratorcluster prüfen

4. Nutzercluster erstellen

bmctl

Console

Clustergrundlagen

Netzwerk

Knotenpool erstellen

Cluster erstellen

gcloud-CLI

Knotenpool erstellen

Terraform

5. Bereinigen

Nutzercluster löschen

bmctl

Console

gcloud-CLI

Terraform

Administratorcluster und VMs löschen

Nächste Schritte

Demo-Administratorcluster und -Nutzercluster für Google Distributed Cloud auf Compute Engine-VMs erstellen

`bmctl`

`bmctl`

`bmctl`