Criar um cluster híbrido do GKE em Bare Metal em VMs do Compute Engine

Nesta página, mostramos como configurar um cluster híbrido do GKE em Bare Metal no modo de alta disponibilidade (HA, na sigla em inglês) usando máquinas virtuais (VMs) em execução no Compute Engine.

Importante: esta implantação é apenas para fins de avaliação. Não execute o Google Distributed Cloud em VMs do Compute Engine em produção. Para produção, siga as etapas no nosso Guia de início rápido para instalar o Google Distributed Cloud no seu hardware.

É possível testar o Google Distributed Cloud rapidamente e sem precisar preparar nenhum hardware. Ao concluir as etapas desta página, você terá um ambiente de teste funcional do Google Distributed Cloud que será executado no Compute Engine.

Para testar o Google Distributed Cloud em VMs do Compute Engine, conclua as etapas a seguir:

1. Crie seis VMs no Compute Engine
2. Crie uma rede vxlan entre todas as VMs com conectividade L2
3. Pré-requisitos de instalação para o Google Distributed Cloud

4. Implantar um cluster híbrido do GKE em Bare Metal

5. Verifique o cluster

Antes de começar

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

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

   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

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

   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

5. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

6. Anote o ID do projeto porque você precisa definir uma variável de ambiente usada nos scripts e comandos desta página. Se você selecionou um projeto atual, verifique se é proprietário ou editor de um projeto.
7. Na estação de trabalho do Linux, verifique se você instalou a versão mais recente da Google Cloud CLI, a ferramenta de linha de comando para interagir com o Google Cloud. Se você já tiver a CLI gcloud instalada, atualize os componentes executando o seguinte comando:

   gcloud components update

   Dependendo de como a CLI gcloud foi instalada, você poderá ver a seguinte mensagem: "Não é possível realizar esta ação porque o gerenciador de componentes da CLI do Google Cloud está desativado para esta instalação. Execute o comando a seguir para atingir o mesmo resultado para esta instalação:" Siga as instruções para copiar e colar o comando e atualizar os componentes.

As etapas deste guia são extraídas do script de instalação no repositório anthos-samples. A seção Perguntas frequentes tem mais informações sobre como personalizar esse script para funcionar com algumas variações conhecidas.

Crie seis VMs no Compute Engine

Conclua estas etapas para criar as VMs a seguir:

• Uma VM para a estação de trabalho do administrador. Uma estação de trabalho do administrador hospeda ferramentas de interface de linha de comando (CLI) e arquivos de configuração para provisionar clusters durante a instalação, além de ferramentas de CLI para interagir com clusters provisionados após a instalação. A estação de trabalho do administrador terá acesso a todos os outros nós no cluster via SSH.
• Três VMs para os três nós do plano de controle necessários para executar o plano de controle do Google Distributed Cloud.
• Duas VMs para os dois nós de trabalho necessárias para executar cargas de trabalho no cluster do Google Distributed Cloud.

1. Configurar as variáveis de ambiente:

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

   Para o ZONE, é possível usar us-central1-a ou qualquer uma das outras zonas do Compute Engine.

2. Execute os seguintes comandos para fazer login com sua Conta do Google e definir o projeto como padrão:

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

3. Crie a conta de serviço e a chave 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

   Observação: as chaves de conta de serviço poderão causar problemas de segurança se não forem gerenciadas corretamente. Você é responsável pela segurança da chave privada e por outras operações descritas em Práticas recomendadas para gerenciar chaves de contas de serviço. Se não for possível criar uma chave de conta de serviço, a criação pode ser desativada para sua organização. Para mais informações, consulte Gerenciar recursos da organização com segurança por padrão.

4. Ative as APIs e os serviços do 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. Conceda à conta de serviço baremetal-gcr permissões adicionais para evitar a necessidade 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

6. Crie as variáveis e 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 a seguinte repetição para criar seis VMs:

   Observação: se você pretende implantar VMs usando o ambiente de execução de VMs do Anthos, ative a virtualização de hardware para melhor desempenho adicionando --enable-nested-virtualization ao comando gcloud a seguir.

   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

   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 dos nós do plano de controle.
   • abm-w1, abm-w2: as VMs dos nós que executam cargas de trabalho.

8. Use a seguinte repetição 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 conectividade L2 entre VMs

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

O comando a seguir contém duas repetições que realizam as seguintes ações:

1. SSH em cada VM.
2. Atualiza e instala 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 você tem conectividade L2 na rede 10.200.0.0/24. As VMs têm os seguintes endereços IP:

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

Pré-requisitos de instalação do Google Distributed Cloud

É necessário 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 se preparar para a instalação do Google Distributed Cloud:

1. Execute os comandos a seguir para fazer o download da 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 root@10.200.0.x funcione. Os comandos executam estas tarefas:

   1. Geram uma nova chave SSH na estação de trabalho de administração.
   2. Adicionam a chave pública a todas as outras VMs na implantaçã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

Implantar um cluster híbrido do GKE em Bare Metal

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

1. Criar o arquivo de configuração para o cluster híbrido necessário.
2. Executar as verificações de simulação.
3. Implantar 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

Verifique o cluster

É possível encontrar o arquivo kubeconfig do cluster na estação de trabalho de administrador no diretório bmctl-workspace da conta raiz. Para verificar a implantação, conclua as etapas a seguir.

1. Execute SSH na estação de trabalho do administrador como raiz:

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

   Você pode Ignorar todas as mensagens sobre atualização da VM e concluir este tutorial. Se você planeja manter as VMs como um ambiente de teste, talvez queira atualizar o SO ou fazer upgrade para a próxima versão, conforme descrito na documentação do Ubuntu.

2. Defina a variável de ambiente KUBECONFIG com o caminho para o arquivo 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 em uma variável de ambiente:

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

4. Execute o seguinte comando gcloud. Esse comando:

   • Concede à conta de usuário o papel clusterrole/cluster-admin do Kubernetes no cluster.
   • Configura o cluster para que você possa executar os comandos kubectl no computador local sem precisar executar o SSH na estação de trabalho do administrador.

   Substitua GOOGLE_ACCOUNT_EMAIL pelo endereço de e-mail associado à sua conta do 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
   

   A saída desse comando é semelhante à seguinte, truncada 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, insira exit para sair da estação de trabalho do administrador.

6. Receba a entrada kubeconfig que pode acessar o cluster pelo gateway de conexão.

   gcloud container fleet memberships get-credentials CLUSTER_NAME
   

   O resultado será assim:

   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 é possível executar comandos kubectl pelo gateway do Connect:

   kubectl get nodes
   kubectl get namespaces
   

Fazer login no cluster pelo Console do Google Cloud

Para observar suas cargas de trabalho no Google Distributed Cloud no console do Google Cloud, é necessário fazer login no cluster. Antes de fazer login no console pela primeira vez, você precisa configurar um método de autenticação. O método de autenticação mais fácil de configurar é a identidade do Google. Esse método de autenticação permite fazer login usando o endereço de e-mail associado à sua conta do Google Cloud.

O comando gcloud container fleet memberships generate-gateway-rbac que você executou na seção anterior configura o cluster para que você possa fazer login com sua identidade do Google.

1. No console do Google Cloud, acesse a página Clusters do GKE.

   Acessar clusters do GKE

2. Clique em Ações ao lado do cluster registrado e clique em Fazer login.

3. Selecione Usar a identidade do Google para fazer login.

4. Clique em Login.

Limpar

1. Conecte-se à estação de trabalho de administração para redefinir as VMs do cluster para o estado antes da instalação e cancelar o registro do cluster do projeto do 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. Verifique se não há problemas em excluir todas as VMs que contêm abm no nome.

   Depois de verificar, você pode excluir as VMS abm executando o comando a seguir:

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