Teste o Anthos em bare metal nas VMs do Compute Engine

Version 1.9 (unsupported)

• Mais recente
• Versão 1.16
• Versões anteriores (sem suporte)

Nesta página, mostramos como testar o Anthos no modo bare metal de alta disponibilidade (HA) 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 Anthos em bare metal nas VMs do Compute Engine em produção. Para implantar o Anthos em bare metal na produção, siga as etapas no nosso guia de início rápido.

Você pode testar o Anthos em bare metal rapidamente e sem precisar preparar hardwares. A conclusão das etapas nesta página fornece um ambiente de trabalho de teste em execução no Compute Engine para o ambiente do Anthos em bare metal.

Para testar o Anthos em bare metal nas 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 Anthos em bare metal
4. Implante um cluster do Anthos em bare metal
5. Verifique o cluster

Antes de começar

A implantação requer os recursos a seguir:

• Seis VMs para implantar o Anthos em bare metal
• Uma estação de trabalho conectada a gcloud com permissões de proprietário ou editor do seu projeto

Observação: Todos os comandos são executados em uma máquina conectada ao gcloud com as credenciais de proprietário ou editor do projeto.

Crie seis VMs no Compute Engine

Conclua estas etapas para criar as VMs a seguir:

• Uma VM de administração usada para implantar o Anthos em bare metal nas outras máquinas.
• Três VMs para os três nós do plano de controle necessários para executar o Anthos no plano de controle bare metal.
• Duas VMs para os dois nós de trabalho necessários para executar cargas de trabalho no cluster do Anthos em bare metal.

1. Crie a conta de serviço baremetal-gcr:

   export PROJECT_ID=$(gcloud config get-value project)
   export ZONE=us-central1-a
   
   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
   

2. 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 services enable \
       anthos.googleapis.com \
       anthosaudit.googleapis.com \
       anthosgke.googleapis.com \
       cloudresourcemanager.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
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.connect"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/gkehub.admin"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/logging.logWriter"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/monitoring.dashboardEditor"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/stackdriver.resourceMetadata.writer"
   
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:baremetal-gcr@$PROJECT_ID.iam.gserviceaccount.com" \
     --role="roles/opsconfigmonitoring.resourceMetadata.writer"
   

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

4. Use a seguinte repetição para criar seis VMs:

   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" \
                 --scopes cloud-platform \
                 --machine-type $MACHINE_TYPE
       IP=$(gcloud compute instances describe $vm --zone ${ZONE} \
            --format='get(networkInterfaces[0].networkIP)')
       IPs+=("$IP")
   done
   

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

5. 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 "echo SSH to $vm succeeded"
       do
           echo "Trying to SSH into $vm failed. Sleeping for 5 seconds. zzzZZzzZZ"
           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)
           echo "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
   

   Observação: a partir dos clusters do Anthos no bare metal 1.8.2, não é necessário desativar o AppArmor. Se você usar versões anteriores, adicione os seguintes comandos à lista acima:

       systemctl stop apparmor.service
       systemctl disable apparmor.service
   

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

• VM 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 para o Anthos em bare metal

As ferramentas a seguir são necessárias na máquina de administração antes de instalar o Anthos em bare metal:

• bmctl
• kubectl
• Docker

1. Execute o seguinte comando para instalar as ferramentas necessárias:

   gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
   set -x
   
   export PROJECT_ID=\$(gcloud config get-value project)
   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/1.9.8/linux-amd64/bmctl .
   chmod a+x bmctl
   mv bmctl /usr/local/sbin/
   
   cd ~
   echo "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 máquina 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
   

Implante um cluster do Anthos 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.

Observação: copie o bloco de código inteiro no console. Se você copiar apenas algumas partes, a criação do cluster não terá sucesso.

gcloud compute ssh root@$VM_WS --zone ${ZONE} << EOF
set -x
export PROJECT_ID=$(gcloud config get-value project)
export clusterid=cluster-1
bmctl create config -c \$clusterid
cat > bmctl-workspace/\$clusterid/\$clusterid.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-\$clusterid
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: \$clusterid
  namespace: cluster-\$clusterid
spec:
  type: hybrid
  anthosBareMetalVersion: 1.9.8
  gkeConnect:
    projectID: \$PROJECT_ID
  controlPlane:
    nodePoolSpec:
      clusterName: \$clusterid
      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
    containerRuntime: containerd
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-\$clusterid
spec:
  clusterName: \$clusterid
  nodes:
  - address: 10.200.0.6
  - address: 10.200.0.7
EOB

bmctl create cluster -c \$clusterid
EOF

Verifique o cluster

O arquivo kubeconfig do cluster pode ser encontrado na máquina de administração, no diretório bmctl-workspace. Para verificar a implantação, conclua as etapas a seguir.

1. Conecte-se por SSH à estação de trabalho de administração:

   gcloud compute ssh root@$VM_WS --zone ${ZONE}
   

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-1
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

Observação: substitua $clusterid pelo nome real do cluster. O comando usa cluster-1 porque esse é o valor definido no bloco de código anterior quando você criou o cluster.

Fazer login no cluster pelo Console do Google Cloud

Para observar suas cargas de trabalho no Anthos em bare metal no console do Google Cloud, faça login na sua máquina de administração em que o arquivo kubeconfig do cluster está armazenado.

Acesse Como fazer login em um cluster pelo console do Google Cloud para saber mais.

Limpar

1. Conecte-se à máquina 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@$VM_WS --zone ${ZONE} << EOF
   set -x
   export clusterid=cluster-1
   bmctl reset -c \$clusterid
   EOF
   

   Observação: substitua cluster-1 pelo nome real do cluster. O comando usa cluster-1 porque esse é o valor definido no bloco de código anterior quando você criou o cluster.

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