Hybrid-Cluster mit Anthos on Bare Metal auf Compute Engine-VMs erstellen

Auf dieser Seite wird beschrieben, wie Sie einen Anthos on Bare Metal-Hybridcluster im Hochverfügbarkeitsmodus mit virtuellen Maschinen (VMs) einrichten, die in Compute Engine ausgeführt werden.

Sie können Anthos-Cluster auf Bare Metal schnell und ohne vorherige Hardware testen. Durch das Ausführen der Schritte auf dieser Seite erhalten Sie eine funktionierende Anthos-Cluster-Umgebung auf einer Bare-Metal-Testumgebung, die in Compute Engine 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-Bare-Metal-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. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

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

  4. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

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

  6. Notieren Sie sich die Projekt-ID, da Sie sie brauchen, um eine Umgebungsvariable festzulegen, die in den Skripts und Befehlen auf dieser Seite verwendet wird. Wenn Sie ein vorhandenes Projekt auswählen, müssen Sie entweder Projektinhaber oder -bearbeiter sein.
  7. Achten Sie darauf, dass auf Ihrer Linux-Workstation die neueste Google Cloud CLI, das Befehlszeilentool für die Interaktion mit Google Cloud, installiert ist. Wenn Sie die gcloud CLI bereits installiert haben, aktualisieren Sie ihre Komponenten mit dem folgenden Befehl: 
    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 Komponentenmanager der Google Cloud CLI für diese Installation deaktiviert ist. Sie können den folgenden Befehl ausführen, um dasselbe Ergebnis für die Installation zu erzielen: Folgen Sie der Anleitung, um den Befehl zu kopieren und einzufügen, um die Komponenten zu aktualisieren.

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.

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 (CLI) und Konfigurationsdateien, um Cluster während der Installation bereitzustellen. Über die Befehlszeile können Sie mit bereitgestellten Clustern nach der Installation interagieren. Die Administratorworkstation hat über SSH Zugriff auf alle anderen Knoten im Cluster.
  • Drei VMs für die drei Knoten der Steuerungsebene, 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 in den Anthos-Clustern auf Bare-Metal-Clustern 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.13.10

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

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 
    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 
    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 
    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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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

    Dieser Befehl erstellt VM-Instanzen mit den folgenden Namen:

    • abm-ws: Die VM für die Administrator-Workstation.
    • 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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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. Stellen Sie eine SSH-Verbindung zu jeder VM her.
  2. Aktualisieren Sie die erforderlichen Pakete und installieren Sie sie.

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

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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:

  • VM der Administratorworkstation: 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

Sie müssen die folgenden Tools auf der Administratorworkstation installieren, bevor Sie Anthos-Cluster auf Bare Metal installieren:

  • bmctl
  • kubectl
  • Docker

So installieren Sie die Tools und bereiten die Anthos-Cluster auf Bare-Metal-Installation vor:

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

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 den Befehlen werden die folgenden Aufgaben ausgeführt:

    1. Generieren Sie einen neuen SSH-Schlüssel auf der Administratorworkstation.
    2. Fügen Sie den öffentlichen Schlüssel zu allen anderen VMs im Deployment hinzu.
    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 on Bare Metal-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.
anthos-bm-gcp-bash/install_hybrid_cluster.sh 
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 Ihres Clusters auf der Administrator-Workstation im Verzeichnis bmctl-workspace des Stammkontos. Führen Sie die folgenden Schritte aus, um Ihre Bereitstellung 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 diese Anleitung ausführen. Wenn Sie die VMs als Testumgebung behalten möchten, sollten Sie das Betriebssystem aktualisieren oder auf den nächsten Release upgraden, wie in der Ubuntu-Dokumentation beschrieben.

  2. Legen Sie die Umgebungsvariable KUBECONFIG mit dem Pfad zur Konfigurationsdatei des Clusters fest, um kubectl-Befehle für den 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 Rolle clusterrole/cluster-admin von Kubernetes im Cluster.
    • Konfiguriert den Cluster so, dass Sie kubectl-Befehle auf Ihrem lokalen Computer ausführen können, ohne eine SSH-Verbindung zur Administratorworkstation herstellen zu müssen.

    Ersetzen Sie GOOGLE_ACCOUNT_EMAIL durch die E-Mail-Adresse, die mit Ihrem Google Cloud-Konto verknüpft ist. Beispiel: --users=alex@example.com.

    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 so aus, weil er gekürzt wurde:

    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 Administratorworkstation abzumelden.

  6. Rufen Sie den Eintrag kubeconfig 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 in Anthos-Clustern auf Bare Metal in der Google Cloud Console beobachten möchten, müssen Sie sich im Cluster anmelden. Bevor Sie sich zum ersten Mal in der Console anmelden, müssen Sie eine Authentifizierungsmethode konfigurieren. Die einfachste Authentifizierungsmethode ist die Google-Identität. Mit dieser Authentifizierungsmethode können Sie sich mit der E-Mail-Adresse anmelden, die mit Ihrem Google Cloud-Konto verknüpft ist.

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

  1. In der Google Cloud Console haben Sie folgende Möglichkeiten:

    oder:

    • Wählen Sie auf der Seite Anthos-Cluster in der Liste der Cluster den Cluster aus, bei dem Sie sich anmelden möchten, und klicken Sie dann im angezeigten Informationsfenster auf Anmelden.

      Zur Seite "Anthos-Cluster"

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

  3. Klicken Sie auf Login.

Bereinigen

  1. Stellen Sie eine Verbindung zur Administratorworkstation her, um die Cluster-VMs vor der Installation auf ihren Zustand zurückzusetzen und die Registrierung des Clusters in Ihrem Google Cloud-Projekt aufzuheben:

    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