Google Distributed Cloud-Hybridcluster auf Compute Engine-VMs erstellen

Auf dieser Seite erfahren Sie, wie Sie einen Google Distributed Cloud-Hybridcluster im Modus für hohe Verfügbarkeit (High Availability, HA) mithilfe von virtuellen Maschinen (VMs) einrichten, die auf Compute Engine ausgeführt werden.

Wichtig: Dieses Deployment dient nur zu Bewertungszwecken. Führen Sie Google Distributed Cloud nicht auf Compute Engine-VMs in der Produktion aus. Führen Sie für die Produktion die Schritte in unserer Kurzanleitung aus, um Google Distributed Cloud auf Ihrer Hardware zu installieren.

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

Führen Sie die folgenden Schritte aus, um Google Distributed Cloud auf Compute Engine-VMs zu testen:

1. Sechs VMs in Compute Engine erstellen
2. Erstellen Sie ein vxlan-Netzwerk zwischen allen VMs mit L2-Verbindung.
3. Voraussetzungen für Google Distributed Cloud installieren

4. Google Distributed Cloud-Hybridcluster bereitstellen

5. Cluster überprüfen

Hinweise

1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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

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

   Go to project selector

3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

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

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

   Go to project selector

5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

6. Notieren Sie sich die Projekt-ID, da Sie diese zum Setzen 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.
7. Auf Ihrer Linux-Workstation muss die neueste Version der Google Cloud CLI installiert sein, das Befehlszeilentool für die Interaktion mit Google Cloud. Wenn Sie gcloud CLI bereits installiert haben, aktualisieren Sie die Komponenten, indem Sie den folgenden Befehl ausführen:

   gcloud components update

   Je nachdem, wie die gcloud CLI installiert wurde, wird möglicherweise die folgende Meldung angezeigt: „Sie können diese Aktion nicht ausführen, da der Google Cloud CLI-Komponentenmanager für diese Installation deaktiviert ist. Sie können den folgenden Befehl ausführen, um das gleiche Ergebnis für diese Installation zu erzielen: „Folgen Sie den Anweisungen, um den Befehl zum Aktualisieren der Komponenten zu kopieren und einzufügen.

Die Schritte in dieser Anleitung stammen aus dem Installationsskript im anthos-samples-Repository. Im Abschnitt mit häufig gestellten Fragen finden Sie weitere Informationen darüber, wie Sie dieses Skript für einige beliebte Varianten anpassen können.

Sechs VMs in Compute Engine erstellen

Führen Sie diese Schritte aus, um die folgenden VMs zu erstellen:

• Eine VM für die Administratorworkstation. Eine Administratorworkstation hostet Befehlszeilentools und Konfigurationsdateien zum Bereitstellen von Clustern während der Installation sowie Befehlszeilentools zum Interagieren mit bereitgestellten Clustern nach der Installation. Die Administratorworkstation hat Zugriff auf alle anderen Knoten im Cluster über SSH.
• Drei VMs für die drei Knoten der Steuerungsebene, die zum Ausführen der Google Distributed Cloud-Steuerungsebene benötigt werden.
• Zwei VMs für die beiden Worker-Knoten, die zum Ausführen von Arbeitslasten auf dem Google Distributed Cloud-Cluster benötigt werden.

1. Umgebungsvariablen einrichten:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.29.200-gke.243
   

   Für die ZONE können Sie us-central1-a oder eine der anderen Compute Engine-Zonen verwenden.

2. Führen Sie die folgenden Befehle aus, um sich mit Ihrem Google-Konto anzumelden und Ihr Projekt als Standard festzulegen:

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

3. Erstellen Sie das baremetal-gcr-Dienstkonto und den Schlüssel:

   gcloud iam service-accounts create baremetal-gcr
   
   gcloud iam service-accounts keys create bm-gcr.json \
       --iam-account=baremetal-gcr@"${PROJECT_ID}".iam.gserviceaccount.com

   Hinweis: Dienstkontoschlüssel stellen ein Sicherheitsrisiko dar, wenn sie nicht ordnungsgemäß verwaltet werden. Sie sind für die Sicherheit des privaten Schlüssels und für andere Vorgänge verantwortlich, die unter Best Practices für die Verwaltung von Dienstkontoschlüsseln beschrieben werden. Wenn Sie keinen Dienstkontoschlüssel erstellen können, ist das Erstellen von Dienstkontoschlüsseln für Ihre Organisation möglicherweise deaktiviert. Weitere Informationen finden Sie unter Standardmäßig sichere Organisationsressourcen verwalten.

4. Aktivieren Sie Google Cloud APIs und -Dienste:

   gcloud services enable \
       anthos.googleapis.com \
       anthosaudit.googleapis.com \
       anthosgke.googleapis.com \
       cloudresourcemanager.googleapis.com \
       connectgateway.googleapis.com \
       container.googleapis.com \
       gkeconnect.googleapis.com \
       gkehub.googleapis.com \
       serviceusage.googleapis.com \
       stackdriver.googleapis.com \
       monitoring.googleapis.com \
       logging.googleapis.com \
       opsconfigmonitoring.googleapis.com

5. Weisen Sie dem Dienstkonto baremetal-gcr zusätzliche Berechtigungen zu, damit Sie nicht mehrere Dienstkonten für verschiedene APIs und Dienste benötigen:

   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.connect" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.admin" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.dashboardEditor" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/stackdriver.resourceMetadata.writer" \
     --no-user-output-enabled
   
   gcloud projects add-iam-policy-binding "$PROJECT_ID" \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/opsconfigmonitoring.resourceMetadata.writer" \
     --no-user-output-enabled

6. Erstellen Sie die Variablen und Arrays, die für alle Befehle auf dieser Seite benötigt werden:

   MACHINE_TYPE=n1-standard-8
   VM_PREFIX=abm
   VM_WS=$VM_PREFIX-ws
   VM_CP1=$VM_PREFIX-cp1
   VM_CP2=$VM_PREFIX-cp2
   VM_CP3=$VM_PREFIX-cp3
   VM_W1=$VM_PREFIX-w1
   VM_W2=$VM_PREFIX-w2
   declare -a VMs=("$VM_WS" "$VM_CP1" "$VM_CP2" "$VM_CP3" "$VM_W1" "$VM_W2")
   declare -a IPs=()

7. Verwenden Sie die folgende Schleife, um sechs VMs zu erstellen:

   Hinweis: Wenn Sie VMs mit der Anthos-VM-Laufzeit bereitstellen möchten, sollte Sie für eine bessere Leistung die Hardwarevirtualisierung aktivieren. Dazu fügen Sie --enable-nested-virtualization zum vorherigen gcloud-Befehl hinzu.

   for vm in "${VMs[@]}"
   do
       gcloud compute instances create "$vm" \
         --image-family=ubuntu-2004-lts --image-project=ubuntu-os-cloud \
         --zone="${ZONE}" \
         --boot-disk-size 200G \
         --boot-disk-type pd-ssd \
         --can-ip-forward \
         --network default \
         --tags http-server,https-server \
         --min-cpu-platform "Intel Haswell" \
         --enable-nested-virtualization \
         --scopes cloud-platform \
         --machine-type "$MACHINE_TYPE" \
         --metadata "cluster_id=${CLUSTER_NAME},bmctl_version=${BMCTL_VERSION}"
       IP=$(gcloud compute instances describe "$vm" --zone "${ZONE}" \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done

   Mit diesem Befehl werden VM-Instanzen mit den folgenden Namen erstellt:

   • abm-ws: Die VM für die Administratorworkstation.
   • abm-cp1, abm-cp2, abm-cp3: Die VMs für die Knoten der Steuerungsebene.
   • abm-w1, abm-w2: Die VMs für die Knoten, auf denen Arbeitslasten ausgeführt werden.

8. Prüfen Sie mit der folgenden Schleife, ob SSH auf allen VMs bereit ist:

   for vm in "${VMs[@]}"
   do
       while ! gcloud compute ssh root@"$vm" --zone "${ZONE}" --command "printf 'SSH to $vm succeeded\n'"
       do
           printf "Trying to SSH into %s failed. Sleeping for 5 seconds. zzzZZzzZZ" "$vm"
           sleep  5
       done
   done

Erstellen Sie ein vxlan-Netzwerk mit einer L2-Verbindung zwischen VMs

Verwenden Sie die standardmäßige vxlan-Funktion von Linux, um ein Netzwerk zu erstellen, das alle VMs mit L2-Verbindungen verbindet.

Der folgende Befehl enthält zwei Schleifen, die die folgenden Aktionen ausführen:

1. SSH-Verbindung zu jeder VM herstellen.
2. Erforderliche Pakete aktualisieren und installieren.

3. Führen Sie die erforderlichen Befehle aus, um das Netzwerk mit vxlan zu konfigurieren.

   i=2 # We start from 10.200.0.2/24
   for vm in "${VMs[@]}"
   do
       gcloud compute ssh root@"$vm" --zone "${ZONE}" << EOF
           apt-get -qq update > /dev/null
           apt-get -qq install -y jq > /dev/null
           set -x
           ip link add vxlan0 type vxlan id 42 dev ens4 dstport 0
           current_ip=\$(ip --json a show dev ens4 | jq '.[0].addr_info[0].local' -r)
           printf "VM IP address is: \$current_ip"
           for ip in ${IPs[@]}; do
               if [ "\$ip" != "\$current_ip" ]; then
                   bridge fdb append to 00:00:00:00:00:00 dst \$ip dev vxlan0
               fi
           done
           ip addr add 10.200.0.$i/24 dev vxlan0
           ip link set up dev vxlan0
   
   EOF
       i=$((i+1))
   done

Sie haben jetzt L2-Verbindungen im Netzwerk 10.200.0.0/24. Die VMs haben die folgenden IP-Adressen:

• Administrator-Workstation-VM: 10.200.0.2
• VMs, auf denen die Knoten der Steuerungsebene ausgeführt werden:
  • 10.200.0.3
  • 10.200.0.4
  • 10.200.0.5
• VMs, auf denen die Worker-Knoten ausgeführt werden:
  • 10.200.0.6
  • 10.200.0.7

Voraussetzungen für Google Distributed Cloud installieren

Sie müssen die folgenden Tools auf der Administrator-Workstation installieren, bevor Sie Google Distributed Cloud installieren können:

• bmctl
• kubectl
• Docker

So installieren Sie die Tools und bereiten die Installation von Google Distributed Cloud vor:

1. Führen Sie die folgenden Befehle aus, um den Schlüssel für das Dienstkonto auf die Administrator-Workstation herunterzuladen und die erforderlichen Tools zu installieren:

   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   
   export PROJECT_ID=\$(gcloud config get-value project)
   BMCTL_VERSION=\$(curl http://metadata.google.internal/computeMetadata/v1/instance/attributes/bmctl_version -H "Metadata-Flavor: Google")
   export BMCTL_VERSION
   
   gcloud iam service-accounts keys create bm-gcr.json \
     --iam-account=baremetal-gcr@\${PROJECT_ID}.iam.gserviceaccount.com
   
   curl -LO "https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl"
   
   chmod +x kubectl
   mv kubectl /usr/local/sbin/
   mkdir baremetal && cd baremetal
   gsutil cp gs://anthos-baremetal-release/bmctl/$BMCTL_VERSION/linux-amd64/bmctl .
   chmod a+x bmctl
   mv bmctl /usr/local/sbin/
   
   cd ~
   printf "Installing docker"
   curl -fsSL https://get.docker.com -o get-docker.sh
   sh get-docker.sh
   EOF

2. Führen Sie die folgenden Befehle aus, damit root@10.200.0.x funktioniert. Mit diesen Befehlen werden folgende Aufgaben ausgeführt:

   1. Generieren Sie einen neuen SSH-Schlüssel auf der Administrator-Workstation.
   2. Fügen Sie den öffentlichen Schlüssel zu allen anderen VMs im Deployment hinzu.

   gcloud compute ssh root@$VM_WS --zone "${ZONE}" << EOF
   set -x
   ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
   sed 's/ssh-rsa/root:ssh-rsa/' ~/.ssh/id_rsa.pub > ssh-metadata
   for vm in ${VMs[@]}
   do
       gcloud compute instances add-metadata \$vm --zone ${ZONE} --metadata-from-file ssh-keys=ssh-metadata
   done
   EOF

Google Distributed Cloud-Hybridcluster bereitstellen

Der folgende Codeblock enthält alle Befehle und Konfigurationen, die zum Ausführen der folgenden Aufgaben erforderlich sind:

1. Erstellen Sie die Konfigurationsdatei für den erforderlichen Hybridcluster.
2. Führen Sie die Preflight-Prüfungen durch.
3. Stellen Sie den Cluster bereit.

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

bmctl create cluster -c \$CLUSTER_NAME
EOF

Cluster prüfen

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

1. Stellen Sie eine SSH-Verbindung zur Administrator-Workstation als Root her:

   gcloud compute ssh root@abm-ws --zone ${ZONE}
   

   Sie können alle Meldungen zum Aktualisieren der VM ignorieren und diesen Vorgang abschließen . Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder auf die nächste Version upgraden, wie in der Ubuntu-Dokumentation beschrieben.

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

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

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

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

4. Führen Sie dazu den folgenden gcloud-Befehl aus. Dieser Befehl:

   • Gewährt Ihrem Nutzerkonto die Kubernetes-clusterrole/cluster-admin Rolle im Cluster.
   • Konfiguriert den Cluster so, dass Sie kubectl-Befehle auf Ihrem lokalen Computer ausführen können, ohne sich per SSH mit der Administrator-Workstation verbinden zu müssen.

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

   gcloud container fleet memberships generate-gateway-rbac  \
       --membership=CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=GOOGLE_ACCOUNT_EMAIL \
       --project=PROJECT_ID \
       --kubeconfig=$KUBECONFIG \
       --context=$CONTEXT\
       --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/CLUSTER_NAME/CLUSTER_NAME-kubeconfig, context: CLUSTER_NAME-admin@CLUSTER_NAME
   Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
   Successfully applied the RBAC policy to cluster.
   

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

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

   gcloud container fleet memberships get-credentials CLUSTER_NAME
   

   Die Ausgabe sieht in etwa so aus:

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

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

   kubectl get nodes
   kubectl get namespaces
   

Über die Google Cloud Console beim Cluster anmelden

Wenn Sie Ihre Arbeitslasten auf Google Distributed Cloud in der Google Cloud Console beobachten möchten, müssen Sie sich beim Cluster anmelden. Bevor Sie sich zum ersten Mal bei der Console anmelden, müssen Sie eine Authentifizierungsmethode konfigurieren. Die am einfachsten zu konfigurierende Authentifizierungsmethode ist die Google-Identität. Bei dieser Authentifizierungsmethode können Sie sich mit der E-Mail-Adresse anmelden, die mit Ihrem Google Cloud-Konto verknüpft ist.

Der Befehl gcloud container fleet memberships generate-gateway-rbac, den Sie im vorherigen Abschnitt ausgeführt haben, konfiguriert den Cluster so, dass Sie sich mit Ihrer Google-Identität anmelden können.

1. Öffnen Sie in der Google Cloud Console die Seite zu den GKE-Clustern.

   Zu GKE-Clustern

2. Klicken Sie neben dem registrierten Cluster auf Aktionen und dann auf Anmelden.

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

4. Klicken Sie auf Login (Anmelden).

Bereinigen

1. Stellen Sie eine Verbindung zur Administrator-Workstation her, um die Cluster-VMs auf den Zustand vor der Installation zurückzusetzen. Heben Sie dann die Registrierung des Clusters für das Google Cloud-Projekt auf:

   gcloud compute ssh root@abm-ws --zone ${ZONE} << EOF
   set -x
   export clusterid=CLUSTER_NAME
   bmctl reset -c \$clusterid
   EOF
   

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

   gcloud compute instances list | grep 'abm'
   

3. Bestätigen Sie, 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 \
       --quiet compute instances delete