Criar clusters de administrador e de usuário do GKE em Bare Metal em VMs do Compute Engine

Version 1.16 

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

Nesta página, mostramos como criar um cluster de usuário do GKE em Bare Metal e um cluster de administrador em máquinas virtuais (VMs) do Compute Engine. O script fornecido cria VMs do Compute Engine para os nós de cluster de administrador e usuário e uma estação de trabalho de administrador.

A 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. O script instala as ferramentas da CLI na VM da estação de trabalho do administrador.

Um cluster de usuário é um cluster do Kubernetes que executa suas cargas de trabalho conteinerizadas. Ele consiste em nós do plano de controle e nós de trabalho. Os clusters de usuário precisam conter um ou mais nós de trabalho que executam cargas de trabalho do usuário. Um cluster de administrador é um cluster do Kubernetes que gerencia um ou mais clusters de usuário, ajudando na criação, atualizações e exclusão de clusters de usuário. Um cluster de administrador consiste apenas em nós do plano de controle. Para saber mais, consulte Implantação de cluster de administrador e de usuário.

O script configura uma rede de sobreposição de Extensible LAN (VXLAN) virtual entre as VMs e prepara as VMs para a criação do cluster. Como opção, o script cria um cluster de administrador, ou você pode optar por criá-lo por conta própria para saber mais sobre as ferramentas que os clusters do GKE em bare metal oferecem para criar clusters de administrador.

Com o script fornecido, é possível testar clusters do GKE em bare metal rapidamente e sem precisar preparar hardware. Ao concluir as etapas desta página, você terá um ambiente de trabalho do GKE em ambiente bare metal executado no Compute Engine.

Importante: esta implantação é apenas para fins de avaliação. Não execute o GKE em bare metal nas VMs do Compute Engine em produção.

O que é a API GKE On-Prem?

A API GKE On-Prem é uma API hospedada no Google Cloud que permite gerenciar o ciclo de vida dos clusters no local usando o Terraform e aplicativos padrão do Google Cloud. A API GKE On-Prem é executada na infraestrutura do Google Cloud. Terraform, o console e a CLI gcloud são clientes da API e usam a API para criar clusters no data center.

Para gerenciar o ciclo de vida dos clusters, a API GKE On-Prem precisa armazenar metadados sobre o estado do cluster no Google Cloud, usando a região do Google Cloud especificada ao criá-lo. Esses metadados permitem que a API gerencie o ciclo de vida do cluster e não incluem dados específicos da carga de trabalho.

Ao criar um cluster usando um cliente da API GKE On-Prem, você especifica um projeto do Google Cloud. Depois de criado, o cluster é automaticamente registrado na frota do projeto especificado. Esse projeto é chamado de projeto host da frota. O projeto host da frota não pode ser alterado após a criação do 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. Make sure that billing is enabled for your Google Cloud project.

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. Make sure that billing is enabled for your Google Cloud project.

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. É possível executar o script no Cloud Shell ou na máquina local executando Linux ou macOS. Se você não estiver usando o Cloud Shell:
   1. Verifique se você instalou a CLI mais recente do Google Cloud, a ferramenta de linha de comando para interagir com o Google Cloud. Atualize os componentes da gcloud CLI, se necessário:

      gcloud components update

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

   2. Verifique se o kubectl está instalado. Se você precisar instalar kubectl, execute o seguinte comando:

      gcloud components install kubectl

Criar a infraestrutura da VM e, opcionalmente, o cluster de administrador

Siga estas etapas para configurar e executar o script. O script que você salva e executa é do repositório anthos-samples. Se você quiser saber mais sobre o script antes de executá-lo, consulte a próxima seção, Sobre o script.

1. Configure as variáveis de ambiente:

   export PROJECT_ID=PROJECT_ID
   export ADMIN_CLUSTER_NAME=ADMIN_CLUSTER_NAME
   export ON_PREM_API_REGION=ON_PREM_API_REGION
   export ZONE=ZONE
   

   • ON_PREM_API_REGION: a região do Google Cloud em que a API GKE On-Prem executa e armazena metadados. Especifique us-central1 ou outra região compatível.

   • ZONE: a zona do Google Cloud em que as VMs do Compute Engine serão criadas. É possível usar us-central1-a ou qualquer uma das outras zonas do Compute Engine.

2. Defina o projeto e a zona padrão:

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

   Se você receber um erro PERMISSION_DENIED, verifique novamente o ID do projeto inserido. Se o ID do projeto estiver correto, execute gcloud auth login para fazer login na CLI da gcloud com a conta que tem acesso ao projeto.

3. Acesse uma lista de versões do GKE em Bare Metal que podem ser instaladas:

   gcloud container bare-metal admin-clusters query-version-config \
       --location=ON_PREM_API_REGION | grep 1.16
   

   Algumas instruções neste documento dependem da API GKE On-Prem, que é compatível com um subconjunto de versões disponíveis do GKE em Bare Metal.

4. Selecione uma versão da saída do comando anterior e defina-a em uma variável de ambiente:

   export BMCTL_VERSION=BMCTL_VERSION
   

   Recomendamos que você selecione a versão compatível mais recente para acessar os recursos e correções mais recentes do GKE em Bare Metal.

5. Clone o repositório anthos-samples e mude para o diretório em que o script está localizado:

   git clone https://github.com/GoogleCloudPlatform/anthos-samples
   cd anthos-samples/anthos-bm-gcp-bash
   

6. Execute o script:

   bash install_admin_cluster.sh
   

7. Quando solicitado, digite um número para escolher o modo de instalação:

   • Digite 1 para que o script configure a infraestrutura da VM e instale o cluster de administrador.
   • Digite 2 para configurar o script apenas na infraestrutura da VM.

8. Quando solicitado, confirme sua seleção.

O script gera cada comando executado e o status. Quando terminar, o script mostrará o seguinte dependendo se você escolheu instalar o cluster de administrador:

Cluster de administrador criado

✅ Installation complete. Please check the logs for any errors!!!
✅ If you do not see any errors in the output log, then you now have the following setup:

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | Has control plane of admin cluster running inside       |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

Configurar apenas VMs

|---------------------------------------------------------------------------------------------------------|
| VM Name               | L2 Network IP (VxLAN) | INFO                                                    |
|---------------------------------------------------------------------------------------------------------|
| abm-admin-cluster-cp1 | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp1  | 10.200.0.4            | 🌟 Ready for use as control plane for the user cluster  |
| abm-user-cluster-w1   | 10.200.0.5            | 🌟 Ready for use as worker for the user cluster         |
| abm-user-cluster-w2   | 10.200.0.6            | 🌟 Ready for use as worker for the user cluster         |
|---------------------------------------------------------------------------------------------------------|

Sobre o script

Para saber mais sobre install_admin_cluster.sh, clique em Sobre o script na próxima linha.

Sobre o script

O script automatiza as seguintes etapas manuais:

1. Cria uma conta de serviço chamada baremetal-gcr e concede a ela outras permissões para evitar a necessidade de várias contas de serviço para diferentes APIs e serviços.
2. Ativa as seguintes APIs do Google Cloud:

     anthos.googleapis.com
     anthosaudit.googleapis.com
     anthosgke.googleapis.com
     cloudresourcemanager.googleapis.com
     connectgateway.googleapis.com
     container.googleapis.com
     gkeconnect.googleapis.com
     gkehub.googleapis.com
     gkeonprem.googleapis.com
     iam.googleapis.com
     logging.googleapis.com
     monitoring.googleapis.com
     opsconfigmonitoring.googleapis.com
     serviceusage.googleapis.com
     stackdriver.googleapis.com
     storage.googleapis.com

3. Cria as seguintes VMs:
   • Uma VM para a estação de trabalho do administrador. A estação de trabalho do administrador terá acesso a todos os outros nós do cluster usando SSH.
   • Uma VM para o nó do plano de controle do cluster de administrador.
   • Duas VMs para os nós de trabalho do cluster de usuário.
   • Uma VM para o nó do plano de controle do cluster de usuário.
   O script também verifica se o SSH está ativado em todas as VMs.
4. Cria uma rede de sobreposição de LAN virtual extensível (VXLAN) para conectividade de camada 2 entre as VMs. A VXLAN não é persistente. Portanto, se você reinicializar uma instância de VM, a rede será destruída. A rede está configurada para estar na sub-rede 10.200.0.0/24. A conectividade da camada 2 é um requisito do balanceador de carga em pacote.
5. Instala as seguintes ferramentas na estação de trabalho de administrador:
   • bmctl
   • kubectl
   • Docker

   O script também faz o download da chave da conta de serviço de baremetal-gcr para a estação de trabalho do administrador.

6. Isso garante que o root@10.200.0.x da estação de trabalho de administrador realize as seguintes 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.
7. Opcionalmente, o script cria o cluster de administrador com o seguinte arquivo de configuração:
     gcloud compute ssh root@"$VM_WS" --zone "${ZONE}" <<EOF
   set -x
   export PROJECT_ID=\$(gcloud config get-value project)
   ADMIN_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 ADMIN_CLUSTER_NAME
   export BMCTL_VERSION
   bmctl create config -c \$ADMIN_CLUSTER_NAME
   cat > bmctl-workspace/\$ADMIN_CLUSTER_NAME/\$ADMIN_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-\$ADMIN_CLUSTER_NAME
   ---
   apiVersion: baremetal.cluster.gke.io/v1
   kind: Cluster
   metadata:
     name: \$ADMIN_CLUSTER_NAME
     namespace: cluster-\$ADMIN_CLUSTER_NAME
   spec:
     type: admin
     anthosBareMetalVersion: \$BMCTL_VERSION
     gkeConnect:
       projectID: \$PROJECT_ID
     controlPlane:
       nodePoolSpec:
         clusterName: \$ADMIN_CLUSTER_NAME
         nodes:
         - address: 10.200.0.3
     clusterNetwork:
       pods:
         cidrBlocks:
         - 192.168.0.0/16
       services:
         cidrBlocks:
         - 10.96.0.0/20
     loadBalancer:
       mode: bundled
       ports:
         controlPlaneLBPort: 443
       vips:
         controlPlaneVIP: 10.200.0.48
     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
   EOB
   
   bmctl create cluster -c \$ADMIN_CLUSTER_NAME
   EOF

   Se você escolheu que o script crie o cluster de administrador, ele usará SSH para fazer login na estação de trabalho do administrador como o usuário raiz. Em seguida, o script executa a ferramenta de linha de comando bmctl para criar o cluster de administrador. Essa é uma das ferramentas que você pode usar para criar clusters de administrador.

   Quando os clusters do GKE em bare metal criam clusters, ele implanta um cluster do Kubernetes no Docker (tipo) na estação de trabalho de administrador. Este cluster de bootstrap hospeda os controladores do Kubernetes necessários para criar clusters e é usado para criar o cluster de administrador. Após a criação, os controladores relevantes são movidos do cluster de inicialização para o cluster de administrador. A menos que você especifique o contrário, o cluster de inicialização será removido quando a criação do cluster for concluída com êxito. O cluster de inicialização requer que o Docker extraia imagens de contêiner.

Como opção, crie o cluster de administrador

Se o script tiver criado o cluster de administrador, pule para a próxima seção Verificar o cluster de administrador. Caso contrário, siga as etapas nesta seção para criar um cluster de inicialização e o cluster de administrador.

Antes de criar o cluster de administrador, você precisa executar o comando bmctl register bootstrap na estação de trabalho do administrador. Esse comando implanta um cluster temporário do Kubernetes no Docker (tipo) na estação de trabalho de administrador. Esse cluster bootstrap hospeda os controladores do Kubernetes necessários para criar o cluster de administrador. Quando você cria o cluster de administrador, os controladores nele provisionam nós, executam verificações de simulação e registram o cluster de administrador na frota. O cluster de inicialização é excluído automaticamente após a criação do cluster.

Console

1. No console, acesse a página Criar um GKE em um cluster Bare Metal.

   Acesse "Criar um cluster do GKE em bare metal

2. Selecione PROJECT_ID na lista de projetos.

3. Na barra de navegação à esquerda, clique em Instalar ambiente de inicialização.

4. Insira ADMIN_CLUSTER_NAME como o nome do cluster de administrador. Observe que o nome do cluster de inicialização é derivado de bootstrap- no início do nome do cluster de administrador.

5. Selecione VERSION como a versão do cluster de administrador. O script fez o download dessa versão da ferramenta de linha de comando bmctl para a estação de trabalho do administrador. A versão do GKE em Bare Metal que você instala precisa corresponder à versão bmctl.

6. No campo Local da API do Google Cloud, selecione ON_PREM_API_REGION na lista. Essa configuração especifica a região em que a API GKE On-Prem é executada e a região em que os itens a seguir são armazenados:

   • Os metadados do cluster que a API GKE On-Prem precisa para gerenciar o ciclo de vida do cluster
   • Os dados do Cloud Logging e do Cloud Monitoring dos componentes do sistema
   • O registro de auditoria do administrador criado pelos registros de auditoria do Cloud

   O nome, o projeto e o local do cluster identificam exclusivamente o cluster no Google Cloud.

Use as etapas da próxima seção em vez das etapas exibidas no console para criar o cluster de inicialização. Deixe a página do console exibida porque você voltará para criar o cluster de administrador.

CLI da gcloud

Abra uma nova janela do terminal. Você usará a segunda janela de terminal para se conectar à estação de trabalho de administrador para criar o cluster de inicialização. Use a primeira janela do terminal para executar o comando da CLI da gcloud e criar o cluster de administrador.

Criar o cluster de inicialização

Execute as etapas a seguir na estação de trabalho do administrador.

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

   gcloud compute ssh root@abm-ws --zone ZONE
   

   É possível ignorar todas as mensagens sobre a 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 suas credenciais de usuário como Application Default Credentials (ADC):

   gcloud auth application-default login
   

   Siga as instruções para selecionar sua Conta do Google para o ADC.

3. Crie o cluster de inicialização.

   bmctl register bootstrap \
     --ssh-key=/root/.ssh/id_rsa \
     --name=bootstrap-ADMIN_CLUSTER_NAME \
     --project-id=PROJECT_ID
   

Depois que bmctl criar o cluster de inicialização, você verá uma saída semelhante a esta:

[2023-03-22 17:35:24+0000] Waiting for the temporary cluster to be registered... OK
[2023-03-22 17:35:37+0000] Please go to https://console.cloud.google.com/home/dashboard?project=example-project-12345 to create the cluster
[2023-03-22 17:35:37+0000] Waiting for preflight checks and cluster to run..

Cuidado: deixe o comando em execução enquanto cria o cluster de administrador. Se você sair do comando bmctl register bootstrap antes da criação do cluster de administrador, a criação do cluster de administrador falhará. Depois que o cluster for criado, o comando excluirá automaticamente o cluster de inicialização e sairá.

Crie o cluster de administrador

Console

1. Na página Instalar ambiente de inicialização na seção Ambiente de inicialização da estação de trabalho de administrador, clique em Verificar conexão.

   Se o processo for bem-sucedido, o console exibirá Conexão estabelecida.

   A conexão com o cluster de inicialização precisa ser estabelecida antes de você continuar. Se a conexão não estiver estabelecida, verifique os argumentos especificados para o comando bmctl register bootstrap:

   • Verifique se o valor de --name corresponde ao Nome de inicialização derivado exibido na seção Noções básicas do ambiente de inicialização.

   • Verifique se o valor de --project-id corresponde ao ID do projeto selecionado no console.

   Se você precisar alterar o nome do cluster de inicialização ou o ID do projeto, insira Ctrl-C para sair de bmctl register bootstrap e execute o comando novamente.

2. Clique em Rede na barra de navegação à esquerda.

3. Na seção Plano de controle, insira o seguinte IP no campo IP do nó do plano de controle 1.

   10.200.0.3
   

   Esse é o endereço IP da VM abm-admin-cluster-cp na VXLAN criada pelo script.

4. Na seção Balanceador de carga, verifique se a opção Pacotes está selecionada.

5. Na seção IPs virtuais (VIPs), digite o seguinte no campo VIP do plano de controle:

   10.200.0.48
   

6. Clique em Verificar e criar.

   O console exibe mensagens de status enquanto verifica as configurações e cria o cluster.

CLI da gcloud

1. Verifique se as variáveis de ambiente que você definiu anteriormente têm os valores corretos. O comando de exemplo usa marcadores, mas eles precisam corresponder às variáveis de ambiente usadas pelo script.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Confirme se o cluster de inicialização foi registrado como membro da frota:

   gcloud container fleet memberships list \
     --project=PROJECT_ID
   

   Se o cluster de inicialização não estiver listado, verifique o nome dele e o ID do projeto especificado em bmctl register bootstrap. Se você precisar alterar o nome do cluster de inicialização ou o ID do projeto, insira Ctrl-C para sair de bmctl register bootstrap e execute o comando novamente.

3. Crie o cluster de administrador com o balanceador de carga em pacote:

   gcloud container bare-metal admin-clusters create ADMIN_CLUSTER_NAME \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --max-pods-per-node=110 \
     --control-plane-vip=10.200.0.48 \
     --control-plane-load-balancer-port=443 \
     --control-plane-node-configs node-ip=10.200.0.3 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

   No comando anterior:

   • --control-plane-vip: definida como 10.200.0.48. Esse é o IP virtual (VIP) no balanceador de carga para o servidor da API Kubernetes do cluster.

   • --control-plane-node-configs: o node-ip está definido como 10.200.0.3. Esse é o endereço IP da VM abm-admin-cluster-cp na VXLAN criada pelo script.

   Para ver uma lista completa das sinalizações e as descrições delas, consulte a referência da CLI gcloud.

   A saída deste comando terá esta aparência:

   Waiting for operation [projects/example-project-12345/locations/us-west1/operations/operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179] to complete.
   

   No exemplo de saída, a string operation-1679543737105-5f7893fd5bae9-942b3f97-75e59179 é o OPERATION_ID da operação de longa duração. Descubra o status da operação executando o seguinte comando em outra janela de terminal:

   gcloud container bare-metal operations describe OPERATION_ID \
     --project=PROJECT_ID \
     --location=ON_PREM_API_REGION
   

Os detalhes sobre o processo de criação do cluster são gerados na estação de trabalho do administrador. Antes de criar o cluster, o bmctl executa uma série de verificações de simulação para conferir a configuração. Se as verificações de simulação forem aprovadas, você verá algo assim:

[2023-03-22 23:12:47+0000] Waiting for cluster kubeconfig to become ready OK
[2023-03-22 23:15:47+0000] Writing kubeconfig file
[2023-03-22 23:15:47+0000] kubeconfig of cluster being created is present at bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig
[2023-03-22 23:15:47+0000] Please restrict access to this file as it contains authentication credentials of your cluster.
[2023-03-22 23:15:47+0000] Waiting for cluster to become ready OK
[2023-03-22 23:20:17+0000] Please run
[2023-03-22 23:20:17+0000] kubectl --kubeconfig bmctl-workspace/abm-cluster-1/abm-cluster-1-kubeconfig get nodes
[2023-03-22 23:20:17+0000] to get cluster nodes status.
[2023-03-22 23:20:17+0000] Waiting for node pools to become ready OK
[2023-03-22 23:20:37+0000] Waiting for metrics to become ready in GCP OK
[2023-03-22 23:25:38+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2023-03-22 23:25:48+0000] Moving admin cluster resources to the created admin cluster
[2023-03-22 23:25:51+0000] Waiting for node update jobs to finish OK
[2023-03-22 23:27:41+0000] Flushing logs... OK
[2023-03-22 23:27:41+0000] Deleting membership... OK
[2023-03-22 23:27:42+0000] Deleting bootstrap cluster.

Verifique o cluster de administrador

É 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. Se o script criou o cluster de administrador, use SSH para acessar a estação de trabalho de administrador como raiz:

   gcloud compute ssh root@abm-ws --zone ZONE
   

   É possível ignorar todas as mensagens sobre a 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=ADMIN_CLUSTER_NAME
   export KUBECONFIG=$HOME/bmctl-workspace/$clusterid/$clusterid-kubeconfig
   kubectl get nodes
   

   O resultado será assim:

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   91m   v1.24.2-gke.1900
   

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

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

4. Execute o seguinte comando gcloud. Este comando faz o seguinte:

   • 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.
   • Permite fazer login no cluster no console usando sua identidade do Google.

   Substitua YOUR_EMAIL_ADDRESS 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=ADMIN_CLUSTER_NAME \
       --role=clusterrole/cluster-admin \
       --users=YOUR_EMAIL_ADDRESS \
       --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/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig, context: ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME
   Writing RBAC policy for user: YOUR_EMAIL_ADDRESS to cluster.
   Successfully applied the RBAC policy to cluster.
   

5. Quando terminar, insira exit para sair da estação de trabalho do administrador.

6. Execute o comando a seguir no computador local para conseguir a entrada kubeconfig que pode acessar o cluster pelo gateway de conexão:

   gcloud container fleet memberships get-credentials ADMIN_CLUSTER_NAME
   

   O resultado será assim:

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_ADMIN_CLUSTER_NAME" has been generated and set as the current context.
   

7. Agora é possível executar comandos kubectl pelo gateway de conexão:

   kubectl get nodes
   

   O resultado será assim:

   NAME                   STATUS   ROLES                  AGE   VERSION
   abm-admin-cluster-cp   Ready    control-plane,master   94m   v1.24.2-gke.1900
   

No GKE em Bare Metal 1.16 e versões mais recentes, o cluster é automaticamente registrado na API GKE On-Prem. Isso permite usar a gcloud CLI e o console para fazer upgrade e atualizar o cluster de administrador.

Criar o cluster de usuário

Quando o script criou a VXLAN L2 para as VMs, ele atribuiu os seguintes endereços IP na rede 10.200.0.0/24: Use esses endereços IP ao definir as configurações de rede e de pool de nós do cluster de usuário.

Nome da VM	IP da rede	Descrição do nó
abm-admin-cluster-cp1	10.200.0.3	Nó do plano de controle para o cluster de administrador
abm-user-cluster-cp1	10.200.0.4	Nó do plano de controle para o cluster de usuário.
abm-user-cluster-w1	10.200.0.5	Nó de trabalho para o cluster de usuário
abm-user-cluster-w2	10.200.0.6	Outro nó de trabalho para o cluster de usuário

Use o Console do Google Cloud, a CLI do Google Cloud ou o Terraform para criar o cluster de usuário.

Console

Siga estas etapas para criar um cluster de usuário no console:

1. No console, acesse a página Criar um GKE em um cluster Bare Metal.

   Acesse "Criar um cluster do GKE em bare metal

2. Verifique se o projeto do Cloud em que você criou o cluster de administrador está selecionado.

3. Em Escolher o tipo de cluster, selecione Criar um cluster de usuário para um cluster de administrador já existente

4. Clique em Próxima.

Noções básicas sobre clusters

1. Digite um nome para o cluster de usuário ou use o padrão.

2. Verifique se o cluster de administrador recém-criado está selecionado. Você pode usar os padrões para o restante das configurações nesta página.

3. Clique em Rede na barra de navegação à esquerda.

Rede

1. Na seção Plano de controle, insira o seguinte IP no campo IP do nó do plano de controle 1.

   10.200.0.4
   

   Este é o endereço IP da VM abm-user-cluster-cp1 na VXLAN criada pelo script.

2. Na seção Balanceador de carga, use o balanceador de carga padrão, Incorporado com MetalLB.

3. Na seção Novo pool de endereços, insira o intervalo de endereços IP a seguir no campo Intervalo de endereços IP 1:

   10.200.0.51-10.200.0.70
   

4. Clique em Concluído.

5. Na seção IPs virtuais, insira o endereço IP a seguir no campo VIP do plano de controle:

   10.200.0.50
   

6. Digite o seguinte endereço IP para o VIP de entrada:

   10.200.0.51
   

7. Use os endereços IP padrão na seção CIDRs de serviço e pod.

8. Clique em Pool padrão na barra de navegação à esquerda.

Criar um pool de nós

O cluster precisa ter pelo menos um pool de nós para nós de trabalho. Um pool de nós é um modelo para os grupos de nós de trabalho criados nesse cluster.

Digite o seguinte endereço IP no campo endereço de nós 1:

10.200.0.5

Este é o endereço IP da VM abm-user-cluster-w1 na VXLAN criada pelo script.

Crie o cluster

1. Clique em Verificar e concluir para criar o cluster de usuário.

   Leva 15 minutos ou mais para criar o cluster de usuário. O console exibe mensagens de status enquanto verifica as configurações e cria o cluster.

   Se houver um problema com a configuração, o console exibirá uma mensagem de erro que deve estar clara o suficiente para que você possa corrigi-lo e tente criar o cluster novamente.

   Para saber mais informações sobre o processo de criação, clique em Mostrar detalhes para exibir um painel lateral. Clique em para fechar o painel de detalhes.

   Quando o cluster é criado, o Status do cluster: em execução é exibido.

   

2. Depois que o cluster for criado, clique em Clusters para voltar à página Clusters.

CLI da gcloud

Use o seguinte comando para criar um cluster de usuário:

gcloud container bare-metal clusters create

Após criar o cluster, você precisa criar pelo menos um pool de nós usando o seguinte comando:

gcloud container bare-metal node-pools create

Para criar o cluster de usuário:

1. Verifique se as variáveis de ambiente que você definiu anteriormente têm os valores corretos. O comando de exemplo usa marcadores, mas eles precisam corresponder às variáveis de ambiente usadas pelo script.

   echo $PROJECT_ID
   echo $ADMIN_CLUSTER_NAME
   echo $ON_PREM_API_REGION
   echo $BMCTL_VERSION
   

2. Execute o comando a seguir para criar o cluster de usuário. Substitua o seguinte:

   • USER_CLUSTER_NAME: o nome do cluster.

   • Verifique se --admin-users está definido como o endereço de e-mail associado à sua Conta do Google para que você possa administrar o cluster.

   Os outros valores da sinalização foram preenchidos para você. Role se necessário para verificar se a sinalização --admin-cluster-membership tem o valor correto para o nome do cluster de administrador, que é o último segmento no nome de associação totalmente especificado.

   gcloud container bare-metal clusters create USER_CLUSTER_NAME \
     --project=PROJECT_ID \
     --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
     --location=ON_PREM_API_REGION \
     --version=BMCTL_VERSION \
     --admin-users=YOUR_EMAIL_ADDRESS \
     --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=10.200.0.51-10.200.0.70' \
     --control-plane-node-configs='node-ip=10.200.0.4' \
     --control-plane-vip=10.200.0.50 \
     --control-plane-load-balancer-port=443 \
     --ingress-vip=10.200.0.51 \
     --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
     --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
     --lvp-share-path=/mnt/localpv-share \
     --lvp-share-storage-class=local-shared \
     --lvp-node-mounts-config-path=/mnt/localpv-disk \
     --lvp-node-mounts-config-storage-class=local-disks
   

A lista a seguir descreve as sinalizações:

• --project: o ID do projeto em que o cluster de usuário será registrado. Esse projeto é chamado de projeto host da frota.

• --admin-cluster-membership: o nome do cluster de administrador totalmente especificado que identifica o cluster na frota.

• --location: a região do Google Cloud em que a API GKE On-Prem é executada e armazena metadados.

• --version: a versão do GKE em bare metal.

• --admin-users: inclua seu endereço de e-mail para receber as políticas de controle de acesso baseado em papéis (RBAC, na sigla em inglês) do Kubernetes que fornecem acesso administrativo completo ao cluster.

• --metal-lb-address-pools: a configuração do pool de endereços do balanceador de carga MetalLB agrupado. O intervalo de endereços IP precisa estar na rede 10.200.0.0/24 criada pelo script. O intervalo de endereços não pode conter os endereços IP atribuídos às VMs ou ao VIP do plano de controle. No entanto, o VIP de entrada precisa estar nesse intervalo de endereços.

• --control-plane-node-configs: a configuração do nó do plano de controle para o cluster de usuário. O valor de node-ip é 10.200.0.4, que é o endereço IP atribuído ao script à VM abm-user-cluster-cp1.

• --control-plane-vip: o IP virtual do plano de controle. O valor 10.200.0.50 está na rede 10.200.0.0/24 que o script criou, mas não se sobrepõe ao intervalo de endereços IP usado para os pools de endereços do balanceador de carga do MetalLB.

• --control-plane-load-balancer-port: a porta em que o balanceador de carga exibe o plano de controle. Embora seja possível configurar outro valor, a porta 443 é a porta padrão usada para conexões HTTPS.

• --ingress-vip: o IP virtual do serviço de entrada. Esse endereço IP precisa estar no intervalo de endereços IP usado para os pools de endereços do balanceador de carga do MetalLB.

• --island-mode-service-address-cidr-blocks: um intervalo de endereços IP, no formato CIDR, a serem usados para Serviços no cluster de usuário. O comando de exemplo usou 10.96.0.0/20, que é o valor padrão fornecido pelo console. O intervalo CIDR precisa estar entre /24 e /12, em que /12 fornece mais endereços IP. Recomendamos que você use um intervalo no espaço de endereços IP para Internet privada, conforme definido na RFC 1918.

• --island-mode-pod-address-cidr-blocks: um intervalo de endereços IP, no formato CIDR, a serem usados para pods no cluster de usuário. O comando de exemplo usou 192.168.0.0/16, que é o valor padrão fornecido pelo console. O intervalo CIDR precisa estar entre /18 e /8, em que /8 fornece mais endereços IP. Recomendamos que você use um intervalo no espaço de endereços IP para Internet privada, conforme definido na RFC 1918.

• --lvp-share-path: é o caminho da máquina host em que os subdiretórios podem ser criados. Um PersistentVolume (PV) local é criado para cada subdiretório.

• --lvp-share-storage-class: esse é o StorageClass a ser usado para criar volumes permanentes. O StorageClass é criado durante a criação do cluster.

• --lvp-node-mounts-config-path: é o caminho da máquina host em que os discos montados podem ser descobertos. Um PersistentVolume (PV) local é criado para cada montagem.

• --lvp-node-mounts-config-storage: a classe de armazenamento com a qual os PVs são criados durante a criação do cluster.

Depois de executar o comando, será exibida uma saída como esta:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678304606537-5f668bde5c57e-341effde-b612ff8a] to complete...

No exemplo de saída, a string operation-1678304606537-5f668bde5c57e-341effde-b612ff8a é o OPERATION_ID da operação de longa duração.

Para descobrir o status da operação, copie OPERATION_ID da saída para o comando a seguir. Abra outra janela de terminal e execute o comando.

gcloud container bare-metal operations describe OPERATION_ID \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Leva 15 minutos ou mais para criar o cluster. À medida que o cluster é criado, é possível executar o comando anterior de vez em quando para ver o status atual.

Quando o cluster é criado, é exibida uma saída como esta:

Created Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME].

Criar um pool de nós

Depois que o cluster for criado, execute o comando a seguir para criar um pool de nós. Substitua NODE_POOL_NAME por um nome para o pool de nós e verifique se o marcador da sinalização --cluster ainda está definido como o nome do cluster de usuário.

gcloud container bare-metal node-pools create NODE_POOL_NAME \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.5'

• -node-configs: o valor atribuído a node-ip é o endereço IP da VM abm-user-cluster-w1 na VXLAN criada pelo script.

Depois de executar o comando, será exibida uma saída como esta:

Waiting for operation [projects/PROJECT_ID/locations/ON_PREM_API_REGION/operations/operation-1678308682052-5f669b0d132cb-6ebd1c2c-816287a7] to complete...

A criação do pool de nós leva cerca de cinco minutos. Quando o pool de nós é criado, é exibida uma saída como esta:

Created node pool in Anthos cluster on bare metal [https://gkeonprem.googleapis.com/v1/projects/PROJECT_ID/locations/ON_PREM_API_REGION/bareMetalClusters/USER_CLUSTER_NAME/bareMetalNodePools/NODE_POOL_NAME].

Outros comandos do cluster de usuário

Além de criar clusters, você pode executar outros comandos da CLI gcloud, por exemplo:

• Para listar os clusters de usuário:

gcloud container bare-metal clusters list \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Para descrever um cluster de usuário:

gcloud container bare-metal clusters describe USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Para mais informações sobre o comando gcloud container bare-metal clusters, consulte este link.

Outros comandos do pool de nós

Além de criar pools de nós, há outros comandos da CLI gcloud que podem ser executados. Por exemplo:

• Para listar pools de nós:

gcloud container bare-metal node-pools list \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

• Para descrever um pool de nós:

gcloud container bare-metal node-pools describe NODE_POOL_NAME \
    --cluster=USER_CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=ON_PREM_API_REGION

Para mais informações sobre o comando gcloud container bare-metal node-pools, consulte este link.

Terraform

Use a amostra de configuração básica a seguir para criar um cluster de usuário com o balanceador de carga MetalLB empacotado. Para mais informações, consulte a documentação de referência do google_gkeonprem_bare_metal_cluster.

1. No diretório em que você clonou anthos-samples, mude para o diretório em que a amostra do Terraform está localizada:

   cd anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb
   

   A amostra fornece um arquivo de variáveis de exemplo a ser transmitido para main.tf.

2. terraform.tfvars.samplefaça uma cópia do arquivo;

   cp terraform.tfvars.sample terraform.tfvars
   

   
   project_id          = "PROJECT_ID"
   region              = "ON_PREM_API_REGION"
   admin_cluster_name  = "ADMIN_CLUSTER_NAME"
   bare_metal_version  = "VERSION"
   admin_user_emails   = ["YOUR_EMAIL_ADDRESS", "ADMIN_2_EMAIL_ADDRESS"]
   cluster_name        = "abm-user-cluster-metallb"
   control_plane_ips   = ["10.200.0.4"]
   worker_node_ips     = ["10.200.0.5", "10.200.0.6"]
   control_plane_vip   = "10.200.0.50"
   ingress_vip         = "10.200.0.51"
   lb_address_pools    = [
       { name = "lbpool_1", addresses = ["10.200.0.51-10.200.0.70"] }
   ]
   

3. Modifique os valores dos parâmetros em terraform.tfvars e salve o arquivo.

   A lista a seguir descreve as variáveis:

   • project_id: o ID do projeto em que o cluster de usuário será registrado. Esse projeto é chamado de projeto host da frota.

   • region: a região do Google Cloud definida no início do tutorial. Execute echo $ON_PREM_API_REGION para receber o valor.

   • admin_cluster_name: o nome do cluster de administrador que você definiu no início deste tutorial. Execute o eco $ADMIN_CLUSTER_NAME para receber o valor.

   • bare_metal_version: a versão do GKE em bare metal para o cluster de usuário. Para usar a mesma versão usada no cluster de administrador, execute echo $BMCTL_VERSION para receber o valor. Se preferir, especifique uma versão que não seja maior que a versão secundária da versão do cluster de administrador. A versão do cluster de usuário não pode ser superior à versão do cluster de administrador.

   • cluster_name: é possível usar o nome no arquivo TVARS do cluster de usuário ou especificar um nome de sua escolha. O nome não pode ser alterado após a criação do cluster.

   • admin_user_emails: uma lista de endereços de e-mail dos usuários que receberão privilégios administrativos no cluster. Adicione seu endereço de e-mail para administrar o cluster.

     Quando o cluster é criado, a API GKE On-Prem aplica as políticas de controle de acesso baseadas em papéis (RBAC, na sigla em inglês) do Kubernetes ao cluster para conceder aos usuários administradores o papel clusterrole/cluster-admin do Kubernetes, que fornece acesso total a todos os recursos do cluster em todos os namespaces. Isso também permite que os usuários façam login no console usando a identidade do Google.

   Use os valores padrão definidos em terraform.tvars para as variáveis restantes. O script usou esses valores quando criou as VMs e o cluster de administrador.

   • control_plane_ips: uma lista de um ou mais endereços IPv4 para os nós do plano de controle. Use o valor padrão, que é o endereço IP que o script atribuiu à VM abm-user-cluster-cp1.

   • worker_node_ips: uma lista de um ou mais endereços IPv4 para as máquinas de nó de trabalho. Use os valores padrão, que são os endereços IP atribuídos pelo script às VMs abm-user-cluster-w1 e abm-user-cluster-w2.

   • control_plane_vip: o IP virtual (VIP) do plano de controle. Use o valor padrão, 10.200.0.50, que está na rede 10.200.0.0/24 criada pelo script. Observe que esse endereço IP não se sobrepõe ao intervalo de endereços IP usado nos pools de endereços do balanceador de carga do MetalLB.

   • ingress_vip: o endereço IP virtual a ser configurado no balanceador de carga para o proxy de entrada. Use o valor padrão, 10.200.0.51, que está na rede 10.200.0.0/24 que o script criou. Observe que esse endereço IP está no intervalo de endereços IP usado para os pools de endereços do balanceador de carga do MetalLB.

   • lb_address_pools: uma lista de mapas que definem os pools de endereços do balanceador de carga MetalLB. Use o valor padrão.

4. Salve as alterações em terraform.tfvars.

5. Inicialize e crie o plano do Terraform:

   terraform init
   

   O Terraform instala todas as bibliotecas necessárias, como o provedor do Google Cloud.

6. Revise a configuração e faça alterações, se necessário:

   terraform plan
   

7. Aplique o plano do Terraform para criar o cluster de usuário:

   terraform apply
   

   Leva 15 minutos ou mais para criar o cluster de usuário. É possível visualizar o cluster no console do Google Cloud na página Clusters do GKE.

conecte-se ao cluster de usuário

Quando você cria um cluster de usuário usando o console ou a CLI gcloud, o cluster é configurado com as mesmas políticas de controle de acesso baseado em papéis (RBAC) do Kubernetes que você configurou para o cluster de administrador ao executar gcloud container fleet memberships generate-gateway-rbac. Essas políticas do RBAC permitem que você se conecte ao cluster usando sua identidade do Google Cloud, que é o endereço de e-mail associado à sua conta do Google Cloud. Essas políticas de RBAC permitem fazer login no console sem nenhuma configuração adicional.

Conectar-se ao cluster no console

Se você usou a CLI gcloud ou o Terraform para criar o cluster de usuário, acesse a página Clusters do GKE no console:

Acesse os clusters do GKE

Verifique se o projeto em que você criou o cluster de usuário está selecionado. O cluster de administrador e de usuário estarão na lista.

O cluster de usuário tem Bare metal: usuário na coluna Tipo. Isso indica que o cluster é gerenciado pela API GKE On-Prem.

Se você usou o script para criar o cluster de administrador, ele terá Externo na coluna Tipo. Isso indica que o cluster não é gerenciado pela API GKE On-Prem. É possível configurar o cluster de administrador para ser gerenciado pela API GKE On-Prem depois da criação do cluster.

Para fazer login em um cluster:

1. Clique no link no nome do cluster de usuário e, no painel lateral, clique em Login.

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

3. Clique em Login.

Repita as mesmas etapas para fazer login no cluster de administrador também.

Conectar-se ao cluster na linha de comando

A API GKE On-Prem configura as políticas de RBAC para o criador do cluster de usuário. Essas políticas permitem executar comandos kubectl na área de trabalho local usando o gateway de conexão kubeconfig.

No computador local:

1. Consiga a entrada kubeconfig que pode acessar o cluster por meio do gateway de conexão.

   gcloud container fleet memberships get-credentials USER_CLUSTER_NAME
   

   O resultado será assim:

   Starting to build Gateway kubeconfig...
   Current project_id: PROJECT_ID
   A new kubeconfig entry "connectgateway_PROJECT_ID_global_USER_CLUSTER_NAME" has been generated and set as the current context.
   

2. Agora é possível executar comandos kubectl pelo gateway de conexão:

   kubectl get nodes
   

   O resultado será assim:

   NAME                  STATUS   ROLES                  AGE     VERSION
   abm-user-cluster-cp   Ready    control-plane,master   14m     v1.24.2-gke.1900
   abm-user-cluster-w1   Ready    worker                 8m28s   v1.24.2-gke.1900
   

Adicionar outro pool de nós ao cluster de usuário

Console

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

   Acesse os clusters do GKE

2. Na lista de clusters, clique no nome dele e em Mais detalhes no painel Detalhes.

3. Clique na guia Nós.

4. Clique em Adicionar pool de nós.

5. Insira um nome para o pool de nós.

6. No campo endereço de nós 1, digite o seguinte endereço IP:

   10.200.0.6
   

   Este é o endereço IP da VM abm-user-cluster-w2 criada pelo script.

7. Clique em Criar.

8. Clique na guia Nós novamente, se necessário.

9. O novo pool de nós mostra o status Reconciliação.

10. Clique em no canto superior direito para ver o status de criação do pool de nós. Talvez seja necessário atualizar a página para ver o status atualizado na lista de pools de nós.

CLI da gcloud

Execute o comando a seguir para criar outro pool de nós. Substitua NODE_POOL_NAME_2 por um nome para o pool de nós e verifique se o marcador da sinalização --cluster ainda está definido como o nome do cluster de usuário.

gcloud container bare-metal node-pools create NODE_POOL_NAME_2 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --node-configs='node-ip=10.200.0.6'

• -node-configs: o valor atribuído a node-ip é o endereço IP da VM abm-user-cluster-w2 na VXLAN criada pelo script.

Terraform

Se você criou o cluster usando o Terraform, ele foi criado com dois nós. Portanto, não há VMs adicionais na VXLAN disponíveis para adicionar outro nó. Para informações sobre como adicionar pools de nós, consulte a documentação de referência de google_gkeonprem_bare_metal_cluster.

Também é possível verificar o novo nó usando kubectl. Primeiro, é preciso executar o comando gcloud container fleet memberships get-credentials, conforme mostrado anteriormente para buscar a configuração do cluster:

kubectl get nodes

O resultado será assim:

NAME                  STATUS   ROLES                  AGE     VERSION
abm-user-cluster-cp   Ready    control-plane,master   24m   v1.24.2-gke.1900
abm-user-cluster-w1   Ready    worker                 18m   v1.24.2-gke.1900
abm-user-cluster-w2   Ready    worker                 52s   v1.24.2-gke.1900

Limpar

As seções a seguir incluem instruções para remover os clusters e VMs criados com este guia.

Excluir o cluster de usuário

Console

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

   Acesse os clusters do GKE

2. Na lista de clusters, clique no cluster de usuário.

3. No painel Detalhes, clique em Mais detalhes.

4. Próximo à parte superior da janela, clique em Excluir.

5. Quando uma confirmação for solicitada, insira o nome do cluster e clique em Confirmar.

6. Clique em no canto superior direito para ver o status da exclusão. Talvez seja necessário atualizar a página para atualizar a lista de clusters.

CLI da gcloud

Execute o comando a seguir para excluir o cluster:

gcloud container bare-metal clusters delete USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=ON_PREM_API_REGION \
  --force

A sinalização --force permite excluir um cluster que tenha pools de nós. Sem a sinalização --force, é necessário excluir os pools de nós primeiro e, em seguida, excluir o cluster.

Para informações sobre outras flags, consulte gcloud container bare-metal clusters delete.

Terraform

Execute este comando:

terraform destroy

Aguarde até que o cluster de usuário seja excluído antes de excluir o cluster de administrador e as VMs.

Excluir o cluster de administrador e as VMs

1. Cancele a inscrição do cluster de administrador na API GKE On-Prem:

   gcloud container bare-metal admin-clusters unenroll ADMIN_CLUSTER_NAME \
       --project=PROJECT_ID \
       --location=ON_PREM_API_REGION
   

2. Conecte-se à estação de trabalho de administrador:

   gcloud compute ssh root@abm-ws --zone ZONE
   

3. Exclua o cluster de administrador:

   bmctl reset -c ADMIN_CLUSTER_NAME
   

   bmctl cancela o registro do cluster na frota e depois o exclui. Aguarde a exclusão do cluster antes de excluir as VMs.

4. Saia da estação de trabalho do administrador.

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

   gcloud compute instances list | grep 'abm'
   

6. 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 --zone ZONE
   

7. Exclua a conta de serviço:

   gcloud iam service-accounts delete baremetal-gcr@PROJECT_ID.iam.gserviceaccount.com
   

   No prompt de confirmação, digite y.

   A seguir

• Crie um serviço e uma entrada
• Planejar a instalação
• Criar clusters básicos