Einfache Cluster erstellen

Diese Seite ist der zweite Teil eines Leitfadens, der Sie durch die Verwendung der Google Distributed Cloud-Software (ehemals Google Distributed Cloud Virtual) führt, um eine kleine Proof-of-Concept-Installation von GKE-Clustern auf Ihrer Bare-Metal-Hardware zu erstellen. 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. Sie können dann mit Dienst und Ingress erstellen fortfahren.

Diese Seite richtet sich an Administratoren, Architekturfachkräfte und Betreiber, die technische Infrastrukturen einrichten, überwachen und verwalten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud-Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

In diesem Leitfaden erfahren Sie, wie Sie eine Mindestinstallation von Google Distributed Cloud 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

  1. Sie müssen die Hardware eingerichtet und Ihre IP-Adressen geplant haben, wie im vorherigen Teil dieses Leitfadens, Minimale Infrastruktur einrichten, beschrieben. Alternativ können Sie den Netzwerkanforderungsplaner im Abschnitt Voraussetzungen des Ablaufs zum Erstellen eines GKE on Bare Metal-Administratorclusters in der Google Cloud Console verwenden.

  2. 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

  3. 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 des Flotten-Hostprojekts.

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

    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 die verfügbaren 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 einfacher Cluster umfasst die folgenden Hauptschritte:

  1. Sammeln Sie Informationen, um die Konfiguration Ihrer Cluster anzugeben.

  2. Erstellen Sie einen Administratorcluster zum Verwalten des Nutzerclusters.

  3. Erstellen Sie einen Nutzercluster, der Ihre Arbeitslasten ausführen kann.

1. Informationen einholen

Verwenden Sie die Informationen, die Sie unter Minimale Infrastruktur einrichten oder über den Netzwerkplaner vorbereitet haben, um die Platzhalter in der folgenden Tabelle auszufüllen. Die Platzhalter entsprechen Feldwerten in den Clusterkonfigurationsdateien für die Mindestinstallation eines Administrator- 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 Speicherort und die Benennung von Clusterartefakten auf der Administrator-Workstation basieren auf dem Clusternamen. Der Cluster-Namespace wird vom Clusternamen abgeleitet. ADMIN_CLUSTER_NAME
Der Name des Nutzerclusters, den Sie erstellen. Der Speicherort und die Benennung von Clusterartefakten auf der Administrator-Workstation 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 Administrator-Workstation. Der Pfad ist standardmäßig
/home/USERNAME/.ssh/id_rsa.		 SSH_PRIVATE_KEY_PATH
Die ID des Google Cloud-Projekts, das Sie zum Herstellen einer Verbindung Ihres Clusters zu 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
Maschinen-IP-Adressen des Knotens
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)
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 zur Verwendung als externe Adresse für den Ingress-Proxy 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 Ingress-VIP enthält, die für MetalLB erforderlich ist. Keine anderen IP-Adressen dürfen sich mit diesem Bereich überschneiden. START_IP-END_IP
Pod- und Dienst-CIDRs
Bereich von IP-Adressen in CIDR-Blocknotation zur Verwendung durch Pods im Administratorcluster. Der empfohlene Startwert, der in der generierten Clusterkonfigurationsdatei bereits ausgefüllt ist, lautet 192.168.0.0/16. 192.168.0.0/16
Bereich von IP-Adressen in CIDR-Block-Notation zur Verwendung durch Services im Administratorcluster. Der empfohlene Startwert, der in der generierten Clusterkonfigurationsdatei bereits ausgefüllt ist, lautet 10.96.0.0/20. 10.96.0.0/20
Bereich von IP-Adressen in CIDR-Block-Notation zur Verwendung durch Pods im Nutzercluster. Der empfohlene Startwert, der in der generierten Clusterkonfigurationsdatei bereits ausgefüllt und der Standardwert in der Console ist, lautet 192.168.0.0/16. 192.168.0.0/16
Bereich von IP-Adressen in CIDR-Blocknotation für die Verwendung durch Dienste im Nutzercluster. Der empfohlene Startwert, der in der generierten Clusterkonfigurationsdatei vorausgefüllt und in der Console der Standardwert ist, lautet 10.96.0.0/20. 10.96.0.0/20

2. Administratorcluster erstellen

Mit den folgenden Schritten erstellen Sie einen Administratorcluster für eine minimale Installation eines Administratorclusters und eines Nutzerclusters. Prüfen Sie, ob Sie im vorherigen Abschnitt Informationen erfassen für alle Platzhalter in der Tabelle Werte angegeben haben, 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 bei dieser von Google Cloud gehosteten API registrieren, können Sie den Lebenszyklus Ihres Clusters über die Google Cloud Console oder die gcloud CLI verwalten.

Um die automatische Registrierung zu deaktivieren, entfernen Sie das Kommentarzeichen im Abschnitt spec.gkeOnPremAPI in der Clusterkonfigurationsdatei und setzen Sie spec.gkeOnPremAPI.enabled auf false, bevor Sie den Cluster erstellen. Das Feld spec.gkeOnPremAPI.enabled ist änderbar, sodass Sie die Registrierung des Clusters jederzeit nach der Erstellung aufheben können.

So erstellen Sie einen Administratorcluster für die Mindestinstallation:

  1. Legen Sie die Standardanmeldedaten fest, mit denen Google Distributed Cloud den Cluster erstellen kann. Verwenden Sie dazu den folgenden Befehl:

    gcloud auth application-default login

  2. Führen Sie den folgenden Befehl aus, um eine Clusterkonfigurationsdatei aus dem Verzeichnis /baremetal auf Ihrer Administratorworkstation zu generieren:

    bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID

  3. Prüfen Sie die Konfigurationsdatei des Administratorclusters:

    Die folgende Clusterkonfigurationsdatei ist mit den Werten gefüllt, 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

  4. 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 ihren Inhalt durch den Inhalt des Beispiels, das Sie im vorherigen Schritt geprüft haben.

  5. Führen Sie zum Erstellen des Administratorclusters den folgenden Befehl über das Verzeichnis /baremetal auf Ihrer Administratorworkstation aus:

    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/ADMIN_CLUSTER_NAME/log auf der Administratorworkstation geschrieben.

    Die Erstellung eines Clusters kann einige Minuten dauern.

  6. 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

  7. Führen Sie den folgenden gcloud-Befehl aus, um Ihrem Nutzerkonto die Kubernetes-Rolle clusterrole/cluster-admin im Cluster zuzuweisen:

    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 aufzurufen.

3. Nutzercluster erstellen

Mit den folgenden Schritten wird ein Nutzercluster für eine minimale Installation von Administratorcluster und Nutzercluster erstellt. Achten Sie darauf, dass Sie für alle Platzhalter in der Tabelle im vorherigen Abschnitt Informationen erfassen Werte angegeben haben, bevor Sie fortfahren.

So erstellen Sie einen Nutzercluster für die minimale Installation:

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 bei dieser von Google Cloud gehosteten API registriert ist, können Sie den Clusterlebenszyklus mit der Google Cloud Console oder der gcloud CLI verwalten.

Um die automatische Registrierung zu deaktivieren, entfernen Sie das Kommentarzeichen im Abschnitt spec.gkeOnPremAPI in der Clusterkonfigurationsdatei und setzen Sie spec.gkeOnPremAPI.enabled auf false, bevor Sie den Cluster erstellen. Das Feld spec.gkeOnPremAPI.enabled kann geändert werden, sodass Sie die Registrierung des Clusters jederzeit nach der Erstellung aufheben können.

  1. Generieren Sie eine Clusterkonfigurationsdatei:

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

  2. Prüfen Sie die Konfigurationsdatei des Nutzerclusters:

    Die folgende Clusterkonfigurationsdatei enthält die Werte, die Sie zuvor 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.
    • 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 zuzuweisen. In diesem Feld können Sie sich unter anderem bei Ihrem Cluster in der Google Cloud Console anmelden, um weitere Clusterdetails aufzurufen.
    ---
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

  3. 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/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml und ersetzen Sie deren Inhalt durch den Inhalt des Beispiels, das Sie im vorhergehenden Schritt geprüft haben.

  4. 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 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/USER_CLUSTER_NAME/log auf der Administratorworkstation geschrieben.

    Die Erstellung eines Clusters kann einige Minuten dauern.

  5. 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

So erstellen Sie einen Nutzercluster in der Console:

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

    Zur Seite „Bare-Metal-Cluster erstellen“

  2. Achten Sie darauf, dass für die Google Cloud-Projektliste PROJECT_ID ausgewählt ist.

  3. Klicken Sie auf Cluster erstellen.

  4. Klicken Sie im Dialogfeld auf Lokal.

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

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

  7. Klicken Sie auf Weiter.

Clustergrundlagen

  1. Geben Sie USER_CLUSTER_NAME als Namen des Nutzerclusters ein oder verwenden Sie den Standardwert.

  2. Achten Sie darauf, dass der neu erstellte Administratorcluster ausgewählt ist.

  3. Wählen Sie unter GCP API-Speicherort die Option us-central1 aus.

  4. Wählen Sie in der Google Distributed Cloud-Version CLUSTER_VERSION aus oder verwenden Sie die Standardeinstellung. Sie können die Standardeinstellungen für die übrigen Einstellungen auf dieser Seite verwenden.

  5. Klicken Sie in der linken Navigationsleiste auf Netzwerk.

Netzwerk

  1. Geben Sie im Abschnitt Steuerungsebene Folgendes in das Feld IP 1 für den Knoten der Steuerungsebene ein:

    USER_CP_NODE_IP

  2. Verwenden Sie im Abschnitt Load-Balancer den Standard-Load-Balancer Gebündelt mit MetalLB.

  3. 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

  4. Klicken Sie auf Fertig.

  5. Geben Sie im Abschnitt Virtuelle IP-Adressen die IP-Adresse für die Virtuelle IP-Adresse der Steuerungsebene an:

    USER_CP_VIP

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

    USER_INGRESS_VIP

  7. Falls Sie im Abschnitt Dienst- und Pod-CIDRs die Dienst- und Pod-CIDRs im Planer nicht geändert haben, können Sie die Standardeinstellungen verwenden.

    Wenn Sie die CIDRs geändert haben, geben Sie die CIDRs ein, die Sie verwenden möchten:

    • Dienst-CIDR:
    10.96.0.0/20
    • Pod-CIDR:
    192.168.0.0/16

  8. Klicken Sie in der linken Navigationsleiste auf Standardpool.

Knotenpool erstellen

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

Geben Sie die IP-Adresse des Worker-Knotens des Nutzerclusters in das Feld Knotenadresse 1 ein:

USER_WORKER_NODE_IP

Cluster erstellen

  1. 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 Erstellungsvorgang sehen möchten, klicken Sie auf Details anzeigen, um eine Seitenleiste aufzurufen. Klicken Sie auf , um den Detailbereich zu schließen.

    Nach dem Erstellen des Clusters wird Clusterstatus: Wird ausgeführt angezeigt.

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

gcloud-CLI

In diesem Abschnitt erfahren Sie, wie Sie einen Nutzercluster und einen Knotenpool über die gcloud CLI erstellen können.

  1. 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 die OPERATION_ID des Vorgangs mit langer Ausführungszeit. Sie können den Status des Vorgangs 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 regelmäßig ausführen, um den aktuellen Status abzurufen.

    Nachdem der Cluster erstellt wurde, sieht die Ausgabe in etwa so aus:

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

  2. Nachdem der Cluster erstellt wurde, führen Sie den folgenden Befehl aus, um einen Knotenpool im 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.

  1. 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

  2. Prüfen Sie die Terraform-Ressource des Nutzerclusters:

    Das folgende Beispiel für eine Terraform-Ressource ist mit den Werten gefüllt, 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"
    }
  }
}

  3. Kopieren Sie die Terraform-Ressource in main.tf und speichern Sie die Datei.

  4. Initialisieren und erstellen Sie den Terraform-Plan:

    terraform init

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

  5. Prüfen Sie die Konfiguration und nehmen Sie bei Bedarf Änderungen vor:

    terraform plan

  6. 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 des Knotenpools dauert etwa 15 Minuten (oder länger, je nach Netzwerk).

  7. Führen Sie den folgenden Befehl auf der Administrator-Workstation 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

    Die Ausgabe des Befehls zeigt den Namen der kubeconfig-Datei für den Nutzercluster an, z. B.:

    bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig

    Der TIMESTAMP im Dateinamen gibt das Datum und die Uhrzeit der Dateierstellung an.

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

  8. 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, erhält Ihre E-Mail-Adresse die RBAC-Richtlinien (Role-Based Access Control, rollenbasierte Zugriffssteuerung), mit denen Sie eine Verbindung zum Cluster mit uneingeschränkten Administratorberechtigungen herstellen können. Wo Ihre E-Mail-Adresse angegeben wird, hängt vom Tool ab:

  • bmctl: Ihre E-Mail-Adresse wird im Abschnitt clusterSecurity der Beispiel-Nutzerkonfigurationsdatei aufgeführt.

  • Terraform: Ihre E-Mail-Adresse ist im Abschnitt security_config der Beispielressource google_gkeonprem_bare_metal_cluster enthalten.

  • Die Console: Als Clusterersteller ist Ihre E-Mail-Adresse automatisch auf der Seite Cluster-Grundlagen im Abschnitt Autorisierung enthalten.

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 zugewiesen werden, ermöglichen Folgendes:

  • Sie erhalten die Kubernetes-Rolle clusterrole/cluster-admin für den Cluster.

  • Sie können sich in der Google Cloud Console mit Ihrer Google-Identität anmelden. Sie können den Cluster auf der Seite GKE-Cluster in der Console aufrufen.

  • Sie können kubectl-Befehle auf Ihrem lokalen Computer mithilfe der kubeconfig-Datei des Connect-Gateways ausführen.

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

  1. Rufen Sie den kubeconfig-Eintrag ab, der den Cluster über das Connect-Gateway aufrufen 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.

  2. Sie können jetzt kubectl-Befehle über das Connect-Gateway 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-Datei für den Administratorcluster. Sie müssen diese Befehle auf der Administrator-Workstation ausführen.

Nächste Schritte