Crea un cluster ibrido GKE on Bare Metal sulle VM di Compute Engine

Questa pagina mostra come configurare un cluster ibrido GKE on Bare Metal in modalità ad alta disponibilità utilizzando macchine virtuali (VM) in esecuzione su Compute Engine.

Puoi provare Google Distributed Cloud rapidamente e senza dover preparare alcun hardware. Il completamento dei passaggi in questa pagina ti fornisce un ambiente di test funzionante di Google Distributed Cloud in esecuzione su Compute Engine.

Per provare le VM di Google Distributed Cloud su Compute Engine, completa i seguenti passaggi:

  1. Crea sei VM in Compute Engine
  2. Crea una rete vxlan tra tutte le VM con connettività L2
  3. Prerequisiti di installazione per Google Distributed Cloud
  4. Esegui il deployment di un cluster ibrido GKE on Bare Metal

  5. Verifica il cluster

Prima di iniziare

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

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Prendi nota dell'ID progetto perché è necessario per impostare una variabile di ambiente che viene utilizzata negli script e nei comandi di questa pagina. Se hai selezionato un progetto esistente, assicurati di essere un proprietario o un editor del progetto.
  4. Sulla workstation Linux, assicurati di aver installato la versione più recente di Google Cloud CLI, lo strumento a riga di comando per interagire con Google Cloud. Se hai già installato gcloud CLI, aggiorna i relativi componenti eseguendo questo comando:
    gcloud components update

    A seconda di come è stata installata gcloud CLI, potrebbe essere visualizzato il seguente messaggio: "Non puoi eseguire questa azione perché il gestore dei componenti Google Cloud CLI è disabilitato per questa installazione. Per ottenere lo stesso risultato per questa installazione, puoi eseguire il comando seguente:" Segui le istruzioni per copiare e incollare il comando per aggiornare i componenti.

I passaggi in questa guida sono ricavati dallo script di installazione nel repository anthos-samples. La sezione delle domande frequenti contiene ulteriori informazioni su come personalizzare questo script in modo che funzioni con alcune varianti popolari.

Crea sei VM in Compute Engine

Completa questi passaggi per creare le seguenti VM:

  • Una VM per la workstation di amministrazione. Una workstation di amministrazione ospita strumenti di interfaccia a riga di comando e file di configurazione per eseguire il provisioning dei cluster durante l'installazione e strumenti di interfaccia a riga di comando per interagire con i cluster di cui è stato eseguito il provisioning dopo l'installazione. La workstation di amministrazione avrà accesso a tutti gli altri nodi del cluster tramite SSH.
  • Tre VM per i tre nodi del piano di controllo necessari per eseguire il piano di controllo Google Distributed Cloud.
  • Due VM per i due nodi worker necessari per eseguire i carichi di lavoro nel cluster Google Distributed Cloud.
  1. Configura le variabili di ambiente:

    export PROJECT_ID=PROJECT_ID
    export ZONE
    =ZONE
    export CLUSTER_NAME
    =CLUSTER_NAME
    export BMCTL_VERSION
    =1.29.100-gke.251

    Per ZONE, puoi utilizzare us-central1-a o una qualsiasi delle altre zone di Compute Engine .

  2. Esegui questi comandi per accedere con il tuo Account Google e impostare il tuo progetto come predefinito:

    gcloud auth login
    gcloud config
    set project $PROJECT_ID
    gcloud config
    set compute/zone $ZONE
  3. Crea l'account di servizio e la chiave baremetal-gcr:

    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. Abilita le API e i servizi Google Cloud:

    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. Concedi all'account di servizio baremetal-gcr autorizzazioni aggiuntive per evitare di aver bisogno di più account di servizio per API e servizi diversi:

    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. Crea le variabili e gli array necessari per tutti i comandi in questa pagina:

    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. Usa il seguente loop per creare sei VM:

    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

    Questo comando crea istanze VM con i seguenti nomi:

    • abm-ws: la VM per la workstation di amministrazione.
    • abm-cp1, abm-cp2, abm-cp3: le VM per i nodi del piano di controllo.
    • abm-w1, abm-w2: le VM per i nodi che eseguono i carichi di lavoro.
  8. Utilizza il seguente loop per verificare che SSH sia pronto su tutte le VM:

    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

Crea una rete vxlan con connettività L2 tra le VM

Utilizza la funzionalità vxlan standard di Linux per creare una rete che connetta tutte le VM con connettività L2.

Il seguente comando contiene due loop che eseguono le azioni seguenti:

  1. tramite SSH in ogni VM.
  2. Aggiorna e installa i pacchetti necessari.
  3. Esegui i comandi richiesti per configurare la rete con vxlan.

    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

Ora hai la connettività L2 all'interno della rete 10.200.0.0/24. Le VM hanno i seguenti indirizzi IP:

  • VM della workstation di amministrazione: 10.200.0.2
  • VM che eseguono i nodi del piano di controllo:
    • 10,200,0,3
    • 10.200.0,4
    • 10,200,0,5
  • VM che eseguono i nodi worker:
    • 10.200.0,6
    • 10,200,0,7

Prerequisiti di installazione per Google Distributed Cloud

Prima di installare Google Distributed Cloud, devi installare gli strumenti seguenti sulla workstation di amministrazione:

  • bmctl
  • kubectl
  • Docker

Per installare gli strumenti e prepararti per l'installazione di Google Distributed Cloud:

  1. Esegui questi comandi per scaricare la chiave dell'account di servizio nella workstation di amministrazione e installare gli strumenti richiesti:

    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. Esegui questi comandi per assicurarti che root@10.200.0.x funzioni. I comandi eseguono queste attività:

    1. Genera una nuova chiave SSH sulla workstation di amministrazione.
    2. Aggiungi la chiave pubblica a tutte le altre VM nel deployment.
    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

Esegui il deployment di un cluster ibrido GKE on Bare Metal

Il seguente blocco di codice contiene tutti i comandi e le configurazioni necessari per completare le seguenti attività:

  1. Crea il file di configurazione per il cluster ibrido necessario.
  2. Esegui i controlli preflight.
  3. Eseguire il deployment del cluster.
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

Verifica il cluster

Puoi trovare il file kubeconfig del cluster sulla workstation di amministrazione nella directory bmctl-workspace dell'account root. Per verificare il deployment, completa questi passaggi.

  1. Accedi tramite SSH alla workstation di amministrazione come root:

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

    Puoi ignorare i messaggi sull'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, ti consigliamo di aggiornare il sistema operativo o di eseguire l'upgrade alla release successiva, come descritto nella documentazione di Ubuntu.

  2. Imposta la variabile di ambiente KUBECONFIG con il percorso del file di configurazione del cluster per eseguire i comandi kubectl sul cluster.

    export clusterid=CLUSTER_NAME
    export KUBECONFIG
    =$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
    kubectl get nodes
  3. Imposta il contesto attuale in una variabile di ambiente:

    export CONTEXT="$(kubectl config current-context)"
  4. Esegui questo comando gcloud. Questo comando:

    • Concede al tuo account utente il ruolo clusterrole/cluster-admin Kubernetes sul cluster.
    • Configura il cluster in modo da poter eseguire i comandi kubectl sul tuo computer locale senza doverti connettere alla workstation di amministrazione.

    Sostituisci GOOGLE_ACCOUNT_EMAIL con l'indirizzo email associato al tuo account Google Cloud. Ad esempio: --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

    L'output di questo comando è simile al seguente, che è troncato per garantire la leggibilità:

    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. Al termine dell'esplorazione, inserisci exit per uscire dalla workstation di amministrazione.

  6. Ottieni la voce kubeconfig che può accedere al cluster tramite il gateway di connessione.

    gcloud container fleet memberships get-credentials CLUSTER_NAME

    L'output è simile al seguente:

    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. Ora puoi eseguire i comandi kubectl tramite il gateway Connect:

    kubectl get nodes
    kubectl
    get namespaces

Accedi al cluster dalla console Google Cloud

Per osservare i carichi di lavoro su Google Distributed Cloud nella console Google Cloud, devi accedere al cluster. Prima di accedere per la prima volta alla console, devi configurare un metodo di autenticazione. Il metodo di autenticazione più semplice da configurare è Google. Questo metodo di autenticazione ti consente di accedere utilizzando l'indirizzo email associato al tuo account Google Cloud.

Il comando gcloud container fleet memberships generate-gateway-rbac che hai eseguito nella sezione precedente configura il cluster in modo che tu possa accedere con la tua identità Google.

  1. Nella console Google Cloud, vai alla pagina Cluster GKE.

    Vai ai cluster GKE

  2. Fai clic su Azioni accanto al cluster registrato, poi fai clic su Accedi.

  3. Seleziona Usa la tua identità Google per accedere.

  4. Fai clic su Accedi.

Esegui la pulizia

  1. Connettiti alla workstation di amministrazione per reimpostare le VM del cluster allo stato prima dell'installazione e annullare la registrazione del cluster dal tuo progetto Google Cloud:

    gcloud compute ssh root@abm-ws --zone ${ZONE} << EOF
    set -x
    export clusterid
    =CLUSTER_NAME
    bmctl reset
    -c \$clusterid
    EOF
  2. Elenca tutte le VM il cui nome contiene abm:

    gcloud compute instances list | grep 'abm'
  3. Verifica di poter eliminare tutte le VM il cui nome contiene abm.

    Dopo la verifica, puoi eliminare abm VM eseguendo questo comando:

    gcloud compute instances list --format="value(name)" | grep 'abm'  | xargs gcloud \
       
    --quiet compute instances delete