Crie um cluster híbrido em VMs do Compute Engine

Esta página mostra-lhe como configurar um cluster híbrido no modo de alta disponibilidade (HA) usando máquinas virtuais (VMs) executadas no Compute Engine.

Importante: esta implementação destina-se apenas a fins de avaliação. Não execute o software Google Distributed Cloud apenas em VMs do Compute Engine em produção. Para produção, siga os passos no nosso início rápido para instalar o Google Distributed Cloud apenas com software no seu hardware.

Pode experimentar o software Google Distributed Cloud rapidamente e sem ter de preparar hardware. A conclusão dos passos nesta página oferece-lhe um ambiente de teste funcional que é executado no Compute Engine.

Para experimentar o software apenas do Google Distributed Cloud em VMs do Compute Engine, conclua os seguintes passos:

1. Crie seis VMs no Compute Engine
2. Crie uma rede vxlan entre todas as VMs com conetividade L2
3. Instale os pré-requisitos para o Google Distributed Cloud
4. Implemente um cluster híbrido
5. Valide o seu cluster

Antes de começar

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.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify 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.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

1. Tome nota do ID do projeto, pois precisa dele para definir uma variável de ambiente que é usada nos scripts e comandos nesta página. Se selecionou um projeto existente, certifique-se de que é proprietário do projeto ou editor.
2. Na sua estação de trabalho Linux, certifique-se de que instalou a CLI do Google Cloud mais recente, a ferramenta de linha de comandos para interagir com o Google Cloud. Se já tiver a CLI gcloud instalada, atualize os respetivos componentes executando o seguinte comando:

   gcloud components update

   Consoante a forma como a CLI gcloud foi instalada, pode ver a seguinte mensagem:

   "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:"

   Siga as instruções para copiar e colar o comando para atualizar os componentes.

Os passos neste guia são retirados do script de instalação no repositório anthos-samples. A secção de Perguntas frequentes tem mais informações sobre como personalizar este script para funcionar com algumas variações populares.

Crie seis VMs no Compute Engine

Conclua estes passos para criar as seguintes VMs:

• Uma VM para a estação de trabalho do administrador. Uma estação de trabalho de administração aloja ferramentas de interface de linhas de comando (CLI) e ficheiros de configuração para aprovisionar clusters durante a instalação, e ferramentas de CLI para interagir com clusters aprovisionados após a instalação. A estação de trabalho do administrador tem acesso a todos os outros nós no cluster através de SSH.
• Três VMs para os três nós do plano de controlo necessários para executar o plano de controlo do Google Distributed Cloud.
• Duas VMs para os dois nós de trabalho necessários para executar cargas de trabalho no cluster do Google Distributed Cloud.

1. Configure variáveis de ambiente:

   export PROJECT_ID=PROJECT_ID
   export ZONE=ZONE
   export CLUSTER_NAME=CLUSTER_NAME
   export BMCTL_VERSION=1.33.100-gke.89
   

   Para o ZONE, pode usar us-central1-a ou qualquer uma das outras zonas do Compute Engine .

2. Execute os seguintes comandos para iniciar sessão com a sua Conta Google e definir o seu projeto como predefinição:

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

3. Crie a conta de serviço baremetal-gcr e a chave:

   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: As chaves de contas de serviço representam um risco de segurança se não forem geridas corretamente. É responsável pela segurança da chave privada e por outras operações descritas nas Práticas recomendadas de gestão de chaves de contas de serviço. Se não conseguir criar uma chave de conta de serviço, a criação de chaves de contas de serviço pode estar desativada para a sua organização. Para mais informações, consulte o artigo Gerir recursos da organização seguros por predefinição.

   Se adquiriu a chave da conta de serviço a partir de uma fonte externa, tem de a validar antes de a usar. Para mais informações, consulte o artigo Requisitos de segurança para credenciais de origem externa".

4. Ative Google Cloud APIs e serviços:

   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

5. Conceda autorizações adicionais à conta de serviço baremetal-gcr para evitar precisar de várias contas de serviço para diferentes APIs e serviços:

   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

6. Crie as variáveis e as matrizes necessárias para todos os comandos nesta página:

   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. Use o seguinte ciclo para criar seis VMs:

   for vm in "${VMs[@]}"
   do
       gcloud compute instances create "$vm" \
         --image-family=ubuntu-2204-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

   Este comando cria instâncias de VM com os seguintes nomes:

   • abm-ws: a VM para a estação de trabalho do administrador.
   • abm-cp1, abm-cp2, abm-cp3: as VMs para os nós do plano de controlo.
   • abm-w1, abm-w2: as VMs para os nós que executam cargas de trabalho.

8. Use o seguinte ciclo para verificar se o SSH está pronto em todas as VMs:

   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

Crie uma rede vxlan com conetividade L2 entre VMs

Use a funcionalidade padrão do Linux para criar uma rede que ligue todas as VMs com conetividade L2.vxlan

O seguinte comando contém dois ciclos que realizam as seguintes ações:

1. Use SSH para aceder a cada VM.
2. Atualize e instale os pacotes necessários.

3. Execute os comandos necessários para configurar a rede com 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

Agora, tem conetividade L2 na rede 10.200.0.0/24. As VMs têm os seguintes endereços IP:

• VM da estação de trabalho do administrador: 10.200.0.2
• VMs que executam os nós do plano de controlo:
  • 10.200.0.3
  • 10.200.0.4
  • 10.200.0.5
• VMs que executam os nós trabalhadores:
  • 10.200.0.6
  • 10.200.0.7

Instale os pré-requisitos para o Google Distributed Cloud

Tem de instalar as seguintes ferramentas na estação de trabalho do administrador antes de instalar o Google Distributed Cloud:

• bmctl
• kubectl
• Docker

Para instalar as ferramentas e preparar a instalação do Google Distributed Cloud:

1. Execute os seguintes comandos para transferir a chave da conta de serviço para a estação de trabalho do administrador e instalar as ferramentas necessárias:

   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. Execute os seguintes comandos para garantir que o root@10.200.0.x funciona. Os comandos realizam as seguintes tarefas:

   1. Gere uma nova chave SSH na estação de trabalho do administrador.
   2. Adicione a chave pública a todas as outras VMs na implementação.
   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

Implemente um cluster híbrido

O bloco de código seguinte contém todos os comandos e configurações necessários para concluir as seguintes tarefas:

1. Crie o ficheiro de configuração para o cluster híbrido necessário.
2. Execute as verificações prévias.
3. Implemente o 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

Valide o seu cluster

Pode encontrar o ficheiro kubeconfig do cluster na estação de trabalho do administrador no diretório bmctl-workspace da conta raiz. Para validar a implementação, conclua os seguintes passos.

1. Use o SSH para aceder à estação de trabalho do administrador como raiz:

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

   Pode ignorar todas as mensagens sobre a atualização da VM e concluir este tutorial. Se planeia manter as VMs como um ambiente de teste, recomendamos que atualize o SO ou faça a atualização para a versão seguinte, conforme descrito na documentação do Ubuntu.

2. Defina a variável de ambiente KUBECONFIG com o caminho para o ficheiro de configuração do cluster para executar comandos kubectl no cluster.

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

3. Defina o contexto atual numa variável de ambiente:

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

4. Execute o seguinte comando da CLI gcloud. Este comando:

   • Concede à sua conta de utilizador a função do Kubernetes no cluster.clusterrole/cluster-admin
   • Configura o cluster para que possa executar comandos kubectl no seu computador local sem ter de usar SSH na estação de trabalho de administração.

   Substitua GOOGLE_ACCOUNT_EMAIL pelo endereço de email associado à sua conta Google Cloud . Por exemplo: --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
   

   O resultado deste comando é semelhante ao seguinte, que é truncado para facilitar a leitura:

   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. Quando terminar de explorar, introduza exit para terminar sessão na estação de trabalho de administração.

6. Obtenha a entrada kubeconfig que pode aceder ao cluster através do gateway de ligação.

   gcloud container fleet memberships get-credentials CLUSTER_NAME
   

   O resultado é semelhante ao seguinte:

   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. Agora, pode executar comandos kubectl através do gateway de ligação:

   kubectl get nodes
   kubectl get namespaces
   

Inicie sessão no cluster a partir da Google Cloud consola

Para observar as cargas de trabalho no cluster na Google Cloud consola, tem de iniciar sessão no cluster. Antes de iniciar sessão na consola pela primeira vez, tem de configurar um método de autenticação. O método de autenticação mais fácil de configurar é a identidade Google. Este método de autenticação permite-lhe iniciar sessão através do endereço de email associado à sua contaGoogle Cloud .

O comando gcloud container fleet memberships generate-gateway-rbac que executou na secção anterior configura o cluster para que possa iniciar sessão com a sua identidade Google.

1. Na Google Cloud consola, aceda à página Clusters do GKE.

   Aceda aos clusters do GKE

2. Clique em Ações junto ao cluster registado e, de seguida, clique em Iniciar sessão.

3. Selecione Utilizar a sua identidade Google para iniciar sessão.

4. Clique em Iniciar sessão.

Limpar

1. Ligue-se à estação de trabalho de administração para repor as VMs do cluster para o estado anterior à instalação e anule o registo do cluster no seu projeto Google Cloud:

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

2. Liste todas as VMs que têm abm no nome:

   gcloud compute instances list | grep 'abm'
   

3. Confirme que não tem problemas em eliminar todas as VMs que contêm abm no nome.

   Depois de fazer a validação, pode eliminar VMs abm executando o seguinte comando:

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