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 no projeto.

As etapas deste guia foram 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 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. Configurar as variáveis de ambiente:

    export PROJECT_ID=PROJECT_ID
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
export BMCTL_VERSION=1.12.9

  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 baremetal-gcr:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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

  4. Ative as APIs e os serviços do Google Cloud:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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

  8. Use a seguinte repetição para verificar se o SSH está pronto em todas as VMs:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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.

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 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:

    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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 máquina de administração.
    2. Adicionam a chave pública a todas as outras VMs na implantação.
    anthos-bm-gcp-bash/install_hybrid_cluster.sh 
    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.
anthos-bm-gcp-bash/install_hybrid_cluster.sh 
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

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

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_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