Einfache Cluster erstellen

Diese Seite ist der zweite Teil einer Anleitung, die Sie durch eine kleine Proof-of-Concept-Installation von GDCV für Bare Metal führt. Im ersten Teil, Minimale Infrastruktur einrichten, erfahren Sie, wie Sie Ihre Hardware einrichten, IP-Adressen planen und die erforderliche Google Cloud-Infrastruktur einrichten. Dieses Dokument baut auf der Einrichtung und Planung aus dem vorherigen Abschnitt auf und zeigt Ihnen, wie Sie einen Administrator- und einen Nutzercluster erstellen. Anschließend können Sie mit Dienst und Ingress erstellen fortfahren.

In dieser Anleitung erfahren Sie, wie Sie eine minimale GKE on Bare Metal-Installation erstellen. Diese Mindestinstallation ist möglicherweise nicht für Ihre tatsächlichen Produktionsanforderungen und Anwendungsfälle geeignet. Informationen zu Produktionsinstallationen finden Sie in den Installationsanleitungen.

Hinweise

Prüfen Sie, ob Sie die Hardware eingerichtet und Ihre IP-Adressen wie im vorherigen Teil dieser Anleitung Minimale Infrastruktur einrichten beschrieben geplant haben. Alternativ können Sie den Netzwerkanforderungsplaner im Abschnitt Voraussetzungen des Vorgangs GKE on Bare Metal-Administratorcluster erstellen in der Google Cloud Console verwenden.
Wenn Sie den Nutzercluster mit Terraform erstellen möchten, benötigen Sie Terraform entweder auf Ihrer Administratorworkstation oder auf einem anderen Computer.
1. Prüfen Sie, ob die neuesten Komponenten der Google Cloud CLI installiert sind:
```
gcloud components update
```
Führen Sie die folgenden Schritte aus, um die GKE On-Prem API zu aktivieren und zu verwenden:
1. Aktivieren Sie die API in Ihrem Projekt:
```
gcloud services enable \
    --project PROJECT_ID \
    gkeonprem.googleapis.com
```
  Ersetzen Sie PROJECT_ID durch die Projekt-ID Ihres Flotten-Hostprojekts.
  
  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 Google Cloud CLI anzumelden.
2. Wenn Sie die GKE On-Prem API zum ersten Mal in Ihrem Projekt aktiviert haben, müssen Sie die API initialisieren. Rufen Sie dazu einen gcloud CLI-Befehl auf, der verfügbare Versionen anzeigt, mit denen Sie einen Cluster erstellen können:
```
gcloud container bare-metal clusters query-version-config \
    --project=PROJECT_ID \
    --location="us-central1"
```

Verfahrensübersicht

Das Erstellen von Basisclustern umfasst die folgenden Hauptschritte:

Erfassen Sie Informationen, die zur Angabe der Konfiguration Ihrer Cluster verwendet werden.
Erstellen Sie einen Administratorcluster zum Verwalten des Nutzerclusters.
Erstellen Sie einen Nutzercluster, der Ihre Arbeitslasten ausführen kann.

1. Informationen einholen

Verwenden Sie die Informationen, die Sie unter Minimale Infrastruktur einrichten oder im Netzwerkplaner vorbereitet haben, um die einzelnen Platzhalter in der folgenden Tabelle auszufüllen. Die Platzhalter entsprechen Feldwerten in den Clusterkonfigurationsdateien für die Mindestinstallation eines Administratorclusters und eines Nutzerclusters. Einige Platzhalter werden auf die vorausgefüllten Werte aus der generierten Clusterkonfigurationsdatei gesetzt, aber alle Platzhalter können bearbeitet werden.

Grundlegende Clusterinformationen
Der Name des Administratorclusters, den Sie erstellen. Der Standort und die Benennung von Clusterartefakten auf der Administratorworkstation basieren auf dem Clusternamen. Der Cluster-Namespace wird vom Clusternamen abgeleitet.	`ADMIN_CLUSTER_NAME`
Der Name des Nutzerclusters, den Sie erstellen. Der Standort und die Benennung von Clusterartefakten auf der Administratorworkstation basieren auf dem Clusternamen. Der Cluster-Namespace wird vom Clusternamen abgeleitet.	`USER_CLUSTER_NAME`
Die Version von `bmctl`, die Sie im ersten Teil dieses Leitfadens heruntergeladen haben.	`CLUSTER_VERSION`
Kontoinformationen
Der Pfad zur privaten SSH-Schlüsseldatei auf Ihrer Administratorworkstation. Standardmäßig lautet der Pfad `/home/USERNAME/.ssh/id_rsa`.	`SSH_PRIVATE_KEY_PATH`
Die ID des Google Cloud-Projekts, das Sie zum Verbinden Ihres Clusters mit Google Cloud und zum Aufrufen von Logs und Messwerten verwenden möchten. Dieses Projekt wird auch als Flotten-Hostprojekt bezeichnet.	`PROJECT_ID`
Die E-Mail-Adresse, die mit Ihrem Google Cloud-Konto verknüpft ist. Beispiel: `alex@example.com`.	`GOOGLE_ACCOUNT_EMAIL`
IP-Adressen der Knotenmaschine
Eine IP-Adresse für den Knoten der Steuerungsebene des Administratorclusters.	`ADMIN_CP_NODE_IP`
Eine IP-Adresse für den Knoten der Steuerungsebene des Nutzerclusters.	`USER_CP_NODE_IP`
Eine IP-Adresse für den Worker-Knoten des Nutzerclusters.	`USER_WORKER_NODE_IP`
Virtuelle IP-Adressen
VIP für den Kubernetes API-Server des Administratorclusters.	`ADMIN_CP_VIP`
VIP für den Kubernetes API-Server des Nutzerclusters.	`USER_CP_VIP`
Eine virtuelle IP-Adresse, die als externe Adresse für den Ingress-Proxy verwendet werden soll.	`USER_INGRESS_VIP`
Bereich von zehn IP-Adressen zur Verwendung als externe IP-Adressen für Dienste vom Typ LoadBalancer. Beachten Sie, dass dieser Bereich die virtuelle IP-Adresse für eingehenden Traffic enthält, die von MetalLB erforderlich ist. Mit diesem Bereich dürfen sich keine anderen IP-Adressen überschneiden.	`START_IP-END_IP`
Pod- und Dienst-CIDRs
Bereich von IP-Adressen in CIDR-Blöcken zur Verwendung durch Pods im Administratorcluster. Der empfohlene Startwert, der in die generierte Clusterkonfigurationsdatei vorausgefüllt ist, ist `192.168.0.0/16`.	`192.168.0.0/16`
Bereich von IP-Adressen in CIDR-Blöcken zur Verwendung durch Dienste im Administratorcluster. Der empfohlene Startwert, der in die generierte Clusterkonfigurationsdatei vorausgefüllt ist, ist `10.96.0.0/20`.	`10.96.0.0/20`
Bereich von IP-Adressen in CIDR-Blöcken zur Verwendung durch Pods im Nutzercluster. Der empfohlene Startwert, der in die generierte Clusterkonfigurationsdatei vorausgefüllt ist und in der Console als Standardwert verwendet wird, ist `192.168.0.0/16`.	`192.168.0.0/16`
Bereich von IP-Adressen in CIDR-Blöcken zur Verwendung durch Dienste im Nutzercluster. Der empfohlene Startwert, der in die generierte Clusterkonfigurationsdatei vorausgefüllt ist und in der Console als Standardwert verwendet wird, ist `10.96.0.0/20`.	`10.96.0.0/20`

2. Administratorcluster erstellen

Mit den folgenden Schritten wird ein Administratorcluster für eine minimale Installation von Administratorclustern und Nutzerclustern erstellt. Für jeden Platzhalter in der Tabelle im obigen Abschnitt Informationen sammeln müssen Sie Werte angeben, bevor Sie fortfahren.

Wenn die GKE On-Prem API (gkeonprem.googleapis.com) für Ihr Projekt aktiviert ist, werden neu erstellte Cluster automatisch bei der API registriert. Die Registrierung erfolgt auch dann, wenn spec.gkeOnPremAPI in der Clusterkonfigurationsdatei nicht angegeben ist. Wenn Sie sich für diese von Google Cloud gehostete API registrieren, können Sie den Lebenszyklus Ihres Clusters über die Google Cloud Console oder die gcloud CLI verwalten.

Zum Deaktivieren der automatischen Registrierung entfernen Sie die Kommentarzeichen im Abschnitt spec.gkeOnPremAPI in der Clusterkonfigurationsdatei und setzen spec.gkeOnPremAPI.enabled auf false, bevor Sie den Cluster erstellen. Das Feld spec.gkeOnPremAPI.enabled ist änderbar, sodass Sie Ihren Cluster jederzeit abmelden können, nachdem er erstellt wurde.

So erstellen Sie einen Administratorcluster für die Mindestinstallation:

Legen Sie mit dem folgenden Befehl die Standardanmeldedaten fest, die GKE on Bare Metal zum Erstellen des Clusters verwenden kann:
```
gcloud auth application-default login
```
Führen Sie zum Generieren einer Clusterkonfigurationsdatei den folgenden Befehl im Verzeichnis /baremetal auf Ihrer Administratorworkstation aus:
```
bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID
```

Prüfen Sie die Konfigurationsdatei des Administratorclusters:

Die folgende Clusterkonfigurationsdatei enthält die Werte, die Sie im vorherigen Abschnitt in die Planungstabelle eingegeben haben. Beachten Sie zusätzlich zu den eingegebenen Werten die folgenden Unterschiede zur generierten Konfigurationsdatei:

Aus diesem Beispiel wurden Kommentare entfernt, um die Lesbarkeit zu verbessern.
Die NodePool-Spezifikation wurde entfernt. Worker-Knoten sind für einen Administratorcluster nicht zulässig.

gcrKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-gcr.json
sshPrivateKeyPath: SSH_PRIVATE_KEY_PATH
gkeConnectAgentServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-connect.json
gkeConnectRegisterServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-register.json
cloudOperationsServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-cloud-ops.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: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: ADMIN_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: ADMIN_CP_VIP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1

Ersetzen Sie den Inhalt der generierten Konfigurationsdatei auf Ihrer Administrator-Workstation durch den Inhalt 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 vorherigen Schritt überprüft haben.
Führen Sie zum Erstellen des Administratorclusters den folgenden Befehl im Verzeichnis /baremetal auf Ihrer Administratorworkstation aus:
```
bmctl create cluster -c ADMIN_CLUSTER_NAME
```
Mit dem Befehl bmctl wird die Ausgabe auf dem Bildschirm angezeigt, während Preflight-Prüfungen ausgeführt und der Cluster erstellt werden. Ausführliche Informationen werden in Logs im Ordner baremetal/bmctl-workspace/ADMIN_CLUSTER_NAME/log auf der Administratorworkstation geschrieben.

Die Erstellung eines Clusters kann einige Minuten dauern.

Prüfen Sie, ob der Cluster erstellt wurde und ausgeführt wird:

kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    get nodes

Wenn der Cluster ausgeführt wird, sieht die Antwort in etwa so aus:

NAME     STATUS  ROLES          AGE  VERSION
node-01  Ready   control-plane  16h  v1.25.7-gke.1000

Führen Sie den folgenden gcloud-Befehl aus, um Ihrem Nutzerkonto die Kubernetes-Rolle clusterrole/cluster-admin für den Cluster zu gewähren:

gcloud container fleet memberships generate-gateway-rbac \
    --membership=ADMIN_CLUSTER_NAME \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    --context=ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME \
    --apply

Die Ausgabe dieses Befehls sieht in etwa so aus und ist zur besseren Lesbarkeit gekürzt:

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/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-kubeconfig, context: <var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-admin@<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

Mit der RBAC-Richtlinie können Sie sich unter anderem in der Google Cloud Console bei Ihrem Cluster anmelden, um weitere Clusterdetails zu sehen.

3. Nutzercluster erstellen

Mit den folgenden Schritten wird ein Nutzercluster für eine minimale Installation von Administrator- und Nutzerclustern erstellt. Für jeden Platzhalter in der Tabelle im Abschnitt Informationen sammeln müssen Sie Werte angeben, bevor Sie fortfahren.

So erstellen Sie einen Nutzercluster für die Mindestinstallation:

`bmctl`

Wenn die GKE On-Prem API (gkeonprem.googleapis.com) für Ihr Projekt aktiviert ist, werden neu erstellte Cluster automatisch bei der API registriert. Die Registrierung erfolgt auch dann, wenn spec.gkeOnPremAPI in der Clusterkonfigurationsdatei nicht angegeben ist. Wenn Ihr Cluster für diese von Google Cloud gehostete API registriert ist, können Sie den Clusterlebenszyklus über die Google Cloud Console oder die gcloud CLI verwalten.

Generieren Sie eine Clusterkonfigurationsdatei:

bmctl create config -c USER_CLUSTER_NAME \
  --project-id=PROJECT_ID

Prüfen Sie die Konfigurationsdatei des Nutzerclusters:

Die folgende Clusterkonfigurationsdatei enthält die Werte, die Sie zuvor in der Planungstabelle eingegeben haben. Beachten Sie neben den eingegebenen Werten die folgenden Unterschiede zur generierten Konfigurationsdatei:

Aus diesem Beispiel wurden Kommentare entfernt, um die Lesbarkeit zu verbessern.
Der Clustertyp spec.type wurde auf user festgelegt.
Das Feld spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts wurde hinzugefügt, um Ihrem Konto die clusterrole/cluster-admin zu gewähren. Mit diesem Feld können Sie sich unter anderem in der Google Cloud Console bei Ihrem Cluster anmelden, um weitere Clusterdetails zu sehen.

---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-USER_CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: USER_CLUSTER_NAME
  namespace: cluster-USER_CLUSTER_NAME
spec:
  type: user
  profile: default
  anthosBareMetalVersion: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: USER_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: USER_CP_VIP
      ingressVIP: USER_INGRESS_VIP
    addressPools:
    - name: pool1
      addresses:
      - START_IP-END_IP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - GOOGLE_ACCOUNT_EMAIL
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
  # GKEOnPremAPI (Optional) Specify if you wish to explicitly enable/disable the cloud hosted gkeonprem
  # API to enable/disable cluster lifecycle management from gcloud UI and Terraform.
  # gkeOnPremAPI:
    # enabled: false
    # location is the Cloud location for the cluster resource metadata where the cluster will be enrolled.
    # location: us-central1
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-USER_CLUSTER_NAME
spec:
  clusterName: USER_CLUSTER_NAME
  nodes:
  - address: USER_WORKER_NODE_IP

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

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

Die Erstellung eines Clusters kann einige Minuten dauern.

Prüfen Sie, ob der Cluster erstellt wurde und ausgeführt wird:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-kubeconfig \
  get nodes

Wenn der Cluster ausgeführt wird, sieht die Antwort in etwa so aus:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Console

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

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

Zur Seite „GKE on Bare Metal-Cluster erstellen“
In der Google Cloud-Projektliste muss PROJECT_ID ausgewählt sein.
Wählen Sie unter Clustertyp auswählen die Option Nutzercluster für einen vorhandenen Administratorcluster erstellen aus.
Klicken Sie auf Next (Weiter).

Clustergrundlagen

Geben Sie USER_CLUSTER_NAME als Namen des Nutzerclusters ein oder verwenden Sie den Standardwert.
Prüfen Sie, ob der neu erstellte Administratorcluster ausgewählt ist.
Wählen Sie unter GCP API-Standort die Option us-central1 aus.
Wählen Sie in GDCV für Bare-Metal-Version die Option CLUSTER_VERSION aus oder verwenden Sie die Standardeinstellung. Für die restlichen Einstellungen auf dieser Seite können Sie die Standardeinstellungen verwenden.
Klicken Sie in der linken Navigationsleiste auf Netzwerk.

Netzwerk

Geben Sie im Abschnitt Steuerungsebene Folgendes in das Feld IP 1 des Knotens der Steuerungsebene ein:
```
USER_CP_NODE_IP
```
Verwenden Sie im Abschnitt Load-Balancer den Standard-Load-Balancer Bundled with MetalLB.
Wechseln Sie zum Bereich Neuer Adresspool. Geben Sie den IP-Adressbereich in das Feld IP-Adressbereich 1 ein:
```
10.200.0.51-10.200.0.70
```
Klicken Sie auf Fertig.
Geben Sie im Abschnitt Virtuelle IP-Adressen die IP-Adresse für die VIP der Steuerungsebene ein:
```
USER_CP_VIP
```
Geben Sie die IP-Adresse für die VIP für eingehenden Traffic ein:
```
USER_INGRESS_VIP
```
Wenn Sie im Abschnitt Dienst- und Pod-CIDRs die Dienst- und Pod-CIDRs nicht geändert haben, können Sie die Standardwerte verwenden.

Wenn Sie die CIDRs geändert haben, geben Sie die gewünschten CIDRs ein:
- Dienst-CIDR:
```
10.96.0.0/20
```
- Pod-CIDR:
```
192.168.0.0/16
```
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 IP-Adresse des Worker-Knotens des Nutzerclusters in das Feld Knotenadresse 1 ein:

USER_WORKER_NODE_IP

Cluster erstellen

Klicken Sie auf Bestätigen 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 Console eine Fehlermeldung angezeigt, die klar genug verständlich ist, damit Sie das Konfigurationsproblem beheben und noch einmal versuchen können, den Cluster zu erstellen.

Wenn Sie zusätzliche Informationen zum Erstellungsprozess sehen möchten, klicken Sie auf Details anzeigen, um eine Seitenleiste einzublenden. Klicken Sie auf , um den Detailbereich zu schließen.

Nachdem der Cluster erstellt wurde, wird er als Clusterstatus: wird ausgeführt angezeigt.
Klicken Sie nach dem Erstellen des Clusters auf Cluster, um zur Seite Cluster zurückzukehren.

gcloud-CLI

In diesem Abschnitt erfahren Sie, wie Sie mit der gcloud CLI einen Nutzercluster und einen Knotenpool erstellen.

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

gcloud container bare-metal clusters create USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --admin-cluster-membership=ADMIN_CLUSTER_NAME \
  --admin-cluster-membership-project=PROJECT_ID \
  --admin-cluster-membership-location=global \
  --version=CLUSTER_VERSION \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
  --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=START_IP-END_IP' \
  --control-plane-node-configs='node-ip=USER_CP_NODE_IP' \
  --control-plane-vip=USER_CP_VIP \
  --control-plane-load-balancer-port=443 \
  --ingress-vip=USER_INGRESS_VIP \
  --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

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. Den Status des Vorgangs können Sie mit dem folgenden Befehl ermitteln:

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

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

Wenn 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/us-central1/bareMetalClusters/USER_CLUSTER_NAME].

Nachdem der Cluster erstellt wurde, führen Sie den folgenden Befehl aus, um einen Knotenpool für den neu erstellten Cluster zu erstellen.

gcloud container bare-metal node-pools create node-pool-1 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --node-configs node-ip=USER_WORKER_NODE_IP

Weitere Informationen und Beispiele finden Sie hier:

Terraform

In diesem Abschnitt erfahren Sie, wie Sie mit Terraform einen Nutzercluster und einen Knotenpool erstellen.

Erstellen Sie ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben. In dieser Anleitung heißt die Datei main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```

Prüfen Sie die Terraform-Ressource des Nutzerclusters:

Das folgende Beispiel für eine Terraform-Ressource enthält die Werte, die Sie im vorherigen Abschnitt in die Planungstabelle eingegeben haben.

resource "google_gkeonprem_bare_metal_cluster"  "cluster-basic" {
  provider = google-beta
  name = "USER_CLUSTER_NAME"
  project = "PROJECT_ID"
  location = "us-central1"
  admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME"
  bare_metal_version = "CLUSTER_VERSION"
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["10.96.0.0/20"]
      pod_address_cidr_blocks = ["192.168.0.0/16"]
    }
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        labels = {}
        operating_system = "LINUX"
        node_configs {
          labels = {}
          node_ip = "USER_CP_NODE_IP"
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = "USER_CP_VIP"
      ingress_vip = "USER_INGRESS_VIP"
    }
    metal_lb_config {
      address_pools {
        pool = "pool1"
        addresses = [
          "START_IP-END_IP"
        ]
        avoid_buggy_ips = true
        manual_assign = true
      }
    }
  }
  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"
    }
  }
  security_config {
    authorization {
      admin_users {
        username = "GOOGLE_ACCOUNT_EMAIL"
      }
    }
  }
}

resource "google_gkeonprem_bare_metal_node_pool" "node-pool-default" {
  provider = google-beta
  name =  "node-pool-1"
  bare_metal_cluster = google_gkeonprem_bare_metal_cluster.cluster-basic.name
  project = "PROJECT_ID"
  location = "us-central1"
  node_pool_config {
    operating_system = "LINUX"
    node_configs {
      node_ip = "USER_WORKER_NODE_IP"
    }
  }
}

Kopieren Sie die Terraform-Ressource in main.tf und speichern Sie die Datei.
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
```
Geben Sie bei Aufforderung yes ein.

Das Erstellen des einfachen Nutzerclusters und Knotenpools dauert etwa 15 Minuten (oder je nach Netzwerk auch mehr).
Führen Sie den folgenden Befehl auf der Administratorworkstation aus, um eine kubeconfig-Datei für den Nutzercluster zu erstellen:
```
bmctl get credentials --cluster USER_CLUSTER_NAME \
--admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
```
In der Ausgabe des Befehls wird der Name der kubeconfig-Datei für den Nutzercluster angezeigt. Beispiel:
```
bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig
```
Der TIMESTAMP im Dateinamen gibt an, wann die Datei erstellt wurde (Datum und Uhrzeit).

Da diese Datei Authentifizierungsdaten für den Cluster enthält, sollten Sie sie an einem sicheren Ort mit eingeschränktem Zugriff speichern.

Prüfen Sie, ob der Cluster erstellt wurde und ausgeführt wird:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig \
    get nodes

Wenn der Cluster ausgeführt wird, sieht die Antwort in etwa so aus:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Weitere Informationen und Beispiele finden Sie hier:

Verbindung zum Nutzercluster herstellen

Unabhängig davon, mit welchem Tool Sie den Nutzercluster erstellt haben, werden Ihrer E-Mail-Adresse die Richtlinien für die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) zugewiesen, mit der Sie eine Verbindung zum Cluster mit vollständigen Administratorberechtigungen herstellen können. Wo Ihre E-Mail-Adresse angegeben ist, hängt vom Tool ab:

bmctl: Ihre E-Mail-Adresse ist im Abschnitt clusterSecurity der Beispiel-Nutzerkonfigurationsdatei enthalten.
Terraform: Ihre E-Mail-Adresse ist im Abschnitt security_config der Beispielressource google_gkeonprem_bare_metal_cluster enthalten.
Konsole: Als Ersteller des Clusters wird Ihre E-Mail-Adresse automatisch auf der Seite Clustergrundlagen im Bereich Autorisierung angezeigt.

Obwohl nur Ihre E-Mail-Adresse angegeben ist, können Sie andere E-Mail-Adressen angeben, um anderen Nutzern Administratorzugriff auf den Cluster zu gewähren.

Die RBAC-Richtlinien, die Ihrer E-Mail-Adresse gewährt werden, führen folgende Schritte aus:

Gewähren Sie die Kubernetes-Rolle clusterrole/cluster-admin für den Cluster.
Sie können sich in der Google Cloud Console mit Ihrer Google-Identität beim Cluster anmelden. Sie können den Cluster in der Console auf der Seite GKE-Cluster ansehen.
Sie können kubectl-Befehle auf Ihrem lokalen Computer mithilfe der kubeconfig-Datei des Verbindungsgateways ausführen.

Führen Sie die folgenden Befehle auf Ihrem lokalen Computer aus, um die kubeconfig-Datei des Verbindungsgateways abzurufen:

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

gcloud container fleet memberships get-credentials USER_CLUSTER_NAME  \
--project=PROJECT_ID

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.

Sie können jetzt kubectl-Befehle über das Verbindungsgateway ausführen:
```
kubectl get nodes
```
Die Ausgabe sieht in etwa so aus:
```
NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001
```
Viele kubectl-Befehle erfordern die kubeconfig für den Administratorcluster. Sie müssen diese Befehle auf der Administratorworkstation ausführen.

Nächste Schritte

Service und Ingress erstellen
Weitere Informationen zu folgenden Themen:
- google_gkeonprem_bare_metal_clusterTerraform-Ressource
- Das Verbindungsgateway