Anthos-Cluster auf Bare Metal auf Compute Engine-VMs testen

Version 1.12 

• Neueste
• Version 1.16
• Frühere Versionen (nicht unterstützt)

Auf dieser Seite erfahren Sie, wie Sie Anthos-Cluster auf Bare Metal im Hochverfügbarkeitsmodus (High Availability, HA) mithilfe von virtuellen Maschinen (VMs) testen, die auf Compute Engine ausgeführt werden.

Wichtig: Dieses Deployment dient nur zu Bewertungszwecken. Führen Sie Anthos-Cluster auf Bare Metal nicht auf Compute Engine-VMs in der Produktion aus. Führen Sie die Schritte in unserer Kurzanleitung aus, um Anthos-Cluster auf Bare Metal in der Produktion bereitzustellen.

Sie können Anthos-Cluster auf Bare Metal schnell testen, ohne Hardware vorbereiten zu müssen. Wenn Sie die Schritte auf dieser Seite ausführen, erhalten Sie eine funktionierende Testumgebung, die in Compute Engine für Ihre Anthos-Cluster auf Bare Metal-Umgebung ausgeführt wird.

Führen Sie die folgenden Schritte aus, um Anthos-Cluster auf Bare Metal 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 Anthos-Cluster auf Bare Metal installieren
4. Anthos-Cluster auf Bare-Metal-Cluster bereitstellen
5. Cluster überprüfen

Hinweis

Für das Deployment sind die folgenden Ressourcen erforderlich:

• Sechs VMs für die Bereitstellung von Anthos-Cluster auf Bare Metal
• Eine Workstation, die mit gcloud mit Inhaberberechtigungen für Ihr Projekt angemeldet ist.

Die Schritte in dieser Anleitung stammen aus dem Installationsskript im Repository anthos-samples. Im Abschnitt „FAQs“ finden Sie weitere Informationen dazu, wie Sie dieses Skript anpassen, um mit einigen beliebten Varianten zu arbeiten.

Hinweis: Alle Befehle werden auf einem Computer ausgeführt, auf dem gcloud mit Anmeldedaten des Projektinhabers oder -bearbeiters im Projekt angemeldet ist.

Sechs VMs in Compute Engine erstellen

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

• Eine Administrator-VM, die zum Bereitstellen von Anthos-Cluster auf Bare Metal auf den anderen Maschinen verwendet wird.
• Drei VMs für die drei Steuerungsebenenknoten, die zum Ausführen der Anthos-Cluster auf Bare Metal-Steuerungsebene erforderlich sind
• Zwei VMs für die beiden Worker-Knoten, die zum Ausführen von Arbeitslasten auf dem Anthos-Cluster auf Bare Metal-Cluster benötigt werden

1. Richten Sie Umgebungsvariablen ein:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.12.9
   

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 Dienstkonto baremetal-gcr:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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

4. Aktivieren Sie Google Cloud APIs und Dienste:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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, aktivieren Sie die Hardwarevirtualisierung, um --enable-nested-virtualization die Leistung zu verbessern. Fügen Sie dazu dem vorherigen gcloud-Befehl --enable-nested-virtualization hinzu.
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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

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

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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.

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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-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 Anthos-Cluster auf Bare Metal installieren

Die folgenden Tools sind auf der Administratormaschine erforderlich, bevor Sie Anthos-Cluster auf Bare Metal installieren:

• bmctl
• kubectl
• Docker

1. Führen Sie den folgenden Befehl aus, um die erforderlichen Tools zu installieren:

   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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 Administratormaschine.
   2. Fügen Sie den öffentlichen Schlüssel zu allen anderen VMs im Deployment hinzu.
   anthos-bm-gcp-bash/install_hybrid_cluster.sh

   Auf GitHub ansehen
   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

Anthos-Cluster auf Bare Metal-Cluster 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.

anthos-bm-gcp-bash/install_hybrid_cluster.sh

Auf GitHub ansehen

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

Sie finden die Datei kubeconfig des Clusters auf der Administratormaschine im Verzeichnis bmctl-workspace. Führen Sie die folgenden Schritte aus, um Ihre Bereitstellung zu überprüfen.

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

   gcloud compute ssh root@$VM_WS --zone ${ZONE}
   

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
   

Über die Google Cloud Console beim Cluster anmelden

Um Ihre Arbeitslasten in Anthos-Cluster auf Bare Metal in der Google Cloud Console zu beobachten, müssen Sie sich bei Ihrer Administratormaschine anmelden, auf der die Datei kubeconfig des Clusters gespeichert ist.

Weitere Informationen finden Sie unter Über die Google Cloud Console bei einem Cluster anmelden.

Bereinigen

1. Stellen Sie eine Verbindung zur Administratormaschine 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@$VM_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