Versão 1.6. Essa versão é compatível, conforme mencionado na política de compatibilidade de versão do Anthos, e oferece patches e atualizações mais recentes para vulnerabilidades de segurança, exposições e problemas que afetam os clusters do Anthos em bare metal. Consulte as notas da versão para saber mais detalhes. Esta não é a versão mais recente.

Teste o Anthos em bare metal nas VMs do Compute Engine

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.

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

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 para fazer o download de bmctl:

    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 \
        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
    
    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"
    
  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
    
  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
            systemctl stop apparmor.service #Anthos clusters on bare metal does not support apparmor
            systemctl disable apparmor.service
    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 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.6.2/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.

Antes de executar o seguinte bloco de código, verifique se você criou um espaço de trabalho do Cloud Monitoring para seu projeto.

Criar espaço de trabalho

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.6.2
  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: standard
---
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
    

Faça login no seu cluster pelo Console do Cloud

Para observar suas cargas de trabalho no Anthos em bare metal no Console do 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 Cloud para saber mais.

Limpeza

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

gcloud compute instances list | grep 'abm'

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 seguinte comando:

gcloud compute instances list | grep 'abm' | awk '{ print $1 }' | \```
  xargs gcloud --quiet compute instances delete