Questa pagina è stata tradotta dall'API Cloud Translation.

Creare un cluster ibrido sulle VM di Compute Engine

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

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

Per provare il software Google Distributed Cloud solo sulle VM di Compute Engine, completa i seguenti passaggi:

Crea sei VM in Compute Engine
Crea una rete vxlan tra tutte le VM con connettività L2
Installa i prerequisiti per Google Distributed Cloud
Esegui il deployment di un cluster ibrido
Verificare il cluster

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

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

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

Go to project selector

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

Prendi nota dell'ID progetto perché ti servirà per impostare una variabile di ambiente utilizzata negli script e nei comandi di questa pagina. Se hai selezionato un progetto esistente, assicurati di essere il proprietario o l'editor del progetto.
Sulla workstation Linux, assicurati di aver installato l'ultima versione 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, potresti visualizzare il seguente messaggio:
```
"You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:"
```
Segui le istruzioni per copiare e incollare il comando per aggiornare i componenti.

I passaggi di questa guida sono tratti dallo script di installazione nel repository anthos-samples. La sezione Domande frequenti contiene ulteriori informazioni su come personalizzare questo script per utilizzarlo con alcune varianti comuni.

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 (CLI) e file di configurazione per eseguire il provisioning dei cluster durante l'installazione, nonché 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 control plane necessari per eseguire il control plane di Google Distributed Cloud.
Due VM per i due nodi worker necessari per eseguire i carichi di lavoro sul cluster Google Distributed Cloud.

Configura le variabili di ambiente:

export PROJECT_ID=PROJECT_ID
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
export BMCTL_VERSION=1.32.100-gke.106

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

Esegui i seguenti 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
```
Crea la chiave e il account di servizio 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
```
Nota :le chiavi dei service account comportano un rischio per la sicurezza se non vengono gestite correttamente. Sei responsabile della sicurezza della chiave privata e di altre operazioni descritte in Best practice per la gestione delle chiavi degli account di servizio. Se non riesci a creare una chiave del account di servizio, la creazione di chiavi del account di servizio potrebbe essere disabilitata per la tua organizzazione. Per saperne di più, vedi Gestione delle risorse dell'organizzazione sicure per impostazione predefinita.
Se hai acquisito la chiave dell'account di servizio da una fonte esterna, devi convalidarla prima dell'uso. Per saperne di più, vedi Requisiti di sicurezza per le credenziali di origine esterna".

Abilita Google Cloud API e servizi:

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 \
    compute.googleapis.com \
    gkeonprem.googleapis.com \
    iam.googleapis.com \
    kubernetesmetadata.googleapis.com

Concedi all'account di servizio baremetal-gcr autorizzazioni aggiuntive per evitare di dover utilizzare più service account 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

gcloud projects add-iam-policy-binding "$PROJECT_ID" \
    --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/kubernetesmetadata.publisher" \
    --no-user-output-enabled

gcloud projects add-iam-policy-binding "$PROJECT_ID" \
  --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/monitoring.viewer" \
  --no-user-output-enabled

gcloud projects add-iam-policy-binding "$PROJECT_ID" \
  --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/serviceusage.serviceUsageViewer" \
  --no-user-output-enabled

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=()

Utilizza il seguente ciclo 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 control plane.
abm-w1, abm-w2: le VM per i nodi che eseguono i carichi di lavoro.

Utilizza il seguente ciclo 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à standard vxlan di Linux per creare una rete che colleghi tutte le VM con connettività L2.

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

Utilizza SSH per accedere a ogni VM.
Aggiorna e installa i pacchetti necessari.

Esegui i comandi necessari 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 workstation di amministrazione: 10.200.0.2
VM che eseguono i nodi del control plane:
- 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

Installa i prerequisiti per Google Distributed Cloud

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

bmctl
kubectl
Docker

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

Esegui questi comandi per scaricare la chiave del account di servizio sulla workstation amministrativa e installare gli strumenti necessari:

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

Esegui questi comandi per assicurarti che root@10.200.0.x funzioni. I comandi eseguono queste attività:

Genera una nuova chiave SSH sulla workstation di amministrazione.
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

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

Crea il file di configurazione per il cluster ibrido necessario.
Esegui i controlli preflight.
Esegui 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 amministrativa nella directory bmctl-workspace dell'account principale. Per verificare il deployment, completa i seguenti passaggi.

Utilizza SSH per accedere alla workstation di amministrazione come root:
```
gcloud compute ssh root@abm-ws --zone ${ZONE}
```
Puoi ignorare tutti i messaggi relativi all'aggiornamento della VM e completare questo tutorial. Se prevedi di mantenere le VM come ambiente di test, potresti voler aggiornare il sistema operativo o eseguire l'upgrade alla versione successiva come descritto nella documentazione di Ubuntu.
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
```
Imposta il contesto corrente in una variabile di ambiente:
```
export CONTEXT="$(kubectl config current-context)"
```

Esegui questo comando gcloud CLI. Questo comando:

Concede al tuo account utente il ruolo Kubernetes clusterrole/cluster-admin sul cluster.
Configura il cluster in modo da poter eseguire i comandi kubectl sul computer locale senza dover utilizzare SSH per connettersi 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 facilitare la lettura:

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.

Al termine dell'esplorazione, inserisci exit per uscire dalla workstation amministrativa.

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.

Ora puoi eseguire i comandi kubectl tramite il gateway di connessione:
```
kubectl get nodes
kubectl get namespaces
```

Accedi al cluster dalla console Google Cloud

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

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

Nella console Google Cloud , vai alla pagina Cluster GKE.

Vai ai cluster GKE
Fai clic su Azioni accanto al cluster registrato, quindi fai clic su Accedi.
Seleziona Accedi con la tua identità Google.
Fai clic su Login (Accedi).

Esegui la pulizia

Connettiti alla workstation di amministrazione per ripristinare lo stato delle VM del cluster precedente all'installazione e annulla 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
```

Elenca tutte le VM che hanno abm nel nome:

gcloud compute instances list | grep 'abm'

Verifica di voler eliminare tutte le VM che contengono abm nel nome.

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

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