Criar clusters de administrador e de usuário de demonstração do Google Distributed Cloud em VMs do Compute Engine

Saiba mais sobre o Google Distributed Cloud criando clusters de demonstração em máquinas virtuais (VMs) do Compute Engine. A criação de um cluster de administrador e de usuário com este guia pode levar de 40 minutos a uma hora. Os clusters de demonstração criados neste guia ajudam você a avaliar o processo de provisionamento e operação de clusters do Google Distributed Cloud, mas não são destinados ao uso na produção.

O documento orienta você no processo de execução de um script que:

  • provisiona cinco VMs do Compute Engine para instalar clusters de demonstração;
  • configura uma rede VPC para fornecer conectividade ao cluster.

Depois que o script provisionar os recursos necessários, use um dos seguintes clientes para criar um cluster de administrador e um cluster de usuário que possa hospedar workloads: bmctl, console do Google Cloud, CLI do Google Cloud ou Terraform.

Visão geral do procedimento

Este guia contém as seguintes etapas principais:

  1. Prepare seu ambiente local para que o script tenha as variáveis de ambiente necessárias e você tenha coletado as informações básicas necessárias para executar comandos.

  2. Crie as VMs e a rede com o script transferido.

  3. Crie o cluster de administrador com um dos clientes compatíveis.

  4. Crie o cluster de usuário com um dos clientes compatíveis.

  5. Limpar para remover os clusters e as VMs criados com este guia.

1. Preparar o ambiente local

Como este guia usa um script que configura a rede para você, não é necessário coletar muitas informações ou fazer nenhum planejamento. As etapas a seguir configuram seu ambiente local e coletam as informações básicas necessárias nas seções posteriores do guia:

  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.

    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.

    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:

      You cannot perform this action because the Google Cloud CLI component manager is disabled for this installation. You can run the following command to achieve the same result for this installation:

      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
  8. Configurar 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
    • ADMIN_CLUSTER_NAME: o nome escolhido para o cluster de administrador.
    • ON_PREM_API_REGION: a região do Google Cloud em que a API GKE On-Prem é executada e armazena os metadados. Especifique us-central1 ou outra região compatível.
    • ZONE: a zona do Google Cloud em que as VMs do Compute Engine são criadas. É possível usar us-central1-a ou qualquer uma das outras zonas do Compute Engine.
  9. Execute os comandos a seguir para definir 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 gcloud CLI com a conta que tem acesso ao projeto.

  10. Veja uma lista de versões compatíveis que podem ser instaladas:
    gcloud container bare-metal admin-clusters query-version-config \
    --location=ON_PREM_API_REGION
  11. 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 receber as correções e os recursos mais recentes da Google Distributed Cloud.

2. Criar as VMs e a rede

Nesta seção, você faz o download e executa o script install_admin_cluster.sh.

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

  2. Execute o script:

    bash install_admin_cluster.sh

  3. No prompt, digite 2 para configurar apenas a infraestrutura do Compute Engine e confirme sua seleção quando solicitado.

    O script cria VMs do Compute Engine, cria uma rede VXLAN e configura a estação de trabalho de administrador e os nós do cluster. Essa infraestrutura leva cerca de cinco minutos.

    Para saber mais sobre o script, clique neste link:

    Sobre o script

    É possível conferir o script na pasta anthos-bm-gcp-bash do repositório anthos-samples do GitHub. O script automatiza as seguintes etapas manuais:

    1. 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
compute.googleapis.com
gkeconnect.googleapis.com
gkehub.googleapis.com
gkeonprem.googleapis.com
serviceusage.googleapis.com
stackdriver.googleapis.com
monitoring.googleapis.com
logging.googleapis.com
kubernetesmetadata.googleapis.com
iam.googleapis.com
opsconfigmonitoring.googleapis.com
    2. Em vez de criar várias contas de serviço para diferentes APIs e serviços, o script cria uma única conta de serviço chamada baremetal-gcr e concede a ela os seguintes papéis do IAM:
      • roles/gkehub.admin
      • roles/gkehub.connect
      • roles/logging.logWriter
      • roles/monitoring.dashboardEditor
      • roles/monitoring.metricWriter
      • roles/monitoring.viewer
      • roles/opsconfigmonitoring.resourceMetadata.writer
      • roles/serviceusage.serviceUsageViewer
      • roles/stackdriver.resourceMetadata.writer
    3. Cria as seguintes VMs:
      • Uma VM para a estação de trabalho do administrador.
      • 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.
    4. Verifica se o SSH está ativado em todas as VMs e se a estação de trabalho do administrador tem acesso SSH a todas as outras VMs criadas para nós do cluster.
    5. 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.
    6. 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.

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

    O script gera cada comando executado e o status. Quando ela terminar, o script mostrará a seguinte:

    ✅ Successfully set up SSH access from admin workstation to cluster node VMs.

✅ GCE Infrastructure setup 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-cp  | 10.200.0.3            | 🌟 Ready for use as control plane for the admin cluster |
| abm-user-cluster-cp   | 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         |
|---------------------------------------------------------------------------------------------------------|

3. Crie o cluster de administrador

bmctl

Para criar um cluster de administrador com bmctl, acesse a VM da estação de trabalho do administrador em uma janela do terminal e execute os comandos:

  1. Use o SSH para acessar a VM da estação de trabalho de administrador, abm-ws, como raiz:

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

  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. Gere um arquivo de configuração do cluster:

    bmctl create config -c ADMIN_CLUSTER_NAME --project-id=PROJECT_ID

  4. Verifique o arquivo de configuração do cluster de administrador:

    O arquivo de configuração do cluster a seguir é preenchido com os valores que você forneceu anteriormente. Além dos valores inseridos, observe as seguintes diferenças em relação ao arquivo de configuração gerado:

    • Os comentários foram removidos deste exemplo para melhorar a legibilidade.
    • O script cria uma única conta de serviço com todas as permissões necessárias e faz o download da chave bm-gcr.json referenciada no arquivo de configuração.
    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
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      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:
    projectID: PROJECT_ID
    location: us-central1
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 110

  5. Substitua o conteúdo do arquivo de configuração gerado na estação de trabalho de administrador pelo conteúdo do exemplo anterior.

    Abra o arquivo gerado, bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml, e substitua o conteúdo dele pelo conteúdo do exemplo que você verificou na etapa anterior.

  6. Crie o cluster de administrador:

    bmctl create cluster -c ADMIN_CLUSTER_NAME

    O comando bmctl exibe a saída na tela enquanto executa verificações de simulação e cria o cluster. As informações detalhadas são gravadas em registros da pasta baremetal/bmctl-workspace/abm-user-cluster-metallb/log na estação de trabalho do administrador.

    A criação do cluster pode levar vários minutos para ser concluída.

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

    Acesse os clusters do GKE

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

  8. Faça login no cluster de administrador:

    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.

Verifique o cluster de administrador

É possível encontrar o arquivo kubeconfig do cluster de administrador 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. Use o SSH para acessar a estação de trabalho de administrador como raiz:

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

  2. Verifique se o cluster de administrador foi criado e está em execução:

    kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

    O resultado será assim:

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  3. Quando terminar, digite exit para se desconectar da estação de trabalho do administrador.

Console

Para criar um cluster de administrador no console, execute bmctl register bootstrap na VM da estação de trabalho de administrador para criar um cluster de inicialização. Enquanto o comando bmctl register bootstrap estiver em execução, você vai realizar etapas no console para criar o cluster de administrador.

Acessar as noções básicas do ambiente de inicialização

  1. No Console do Google Cloud, acesse a página de clusters do GKE.

    Acesse os clusters do GKE

  2. Clique em Criar.

  3. Na caixa de diálogo Create a cluster, selecione On-premises e clique em Configure para bare metal:

  4. Selecione PROJECT_ID na lista de projetos.

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

  6. Insira ADMIN_CLUSTER_NAME como o nome do cluster de administrador.

  7. Selecione BMCTL_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 Google Distributed Cloud que você instala precisa corresponder à versão bmctl.

  8. 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 de 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ê vai continuar nela para criar o cluster de administrador.

Criar o cluster de inicialização

Ao usar um cliente da API GKE On-Prem, como o console, para criar um cluster de administrador, é necessário criar um cluster de inicialização na estação de trabalho de administrador. O cluster de inicialização hospeda os controladores do Kubernetes necessários para criar o cluster de administrador.

  1. Na linha de comando, use o SSH para acessar a VM da 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. Mude para o diretório baremetal/ e execute o comando a seguir para criar o cluster de inicialização.

    O nome do cluster de inicialização é derivado adicionando o prefixo bootstrap- ao nome do cluster de administrador.

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

Crie o cluster de administrador

  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 outra vez.

Rede

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

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

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

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

    10.200.0.48

    A etapa a seguir depende da disponibilidade do cluster de inicialização. O comando bmctl register bootstrap na janela do terminal precisa ser executado por alguns minutos antes que o cluster de inicialização seja mostrado como um membro registrado. Se, após alguns minutos, ele ainda não estiver disponível, verifique o nome do cluster de inicialização e o ID do projeto que você usou. Se você precisar mudar o nome do cluster de inicialização ou o ID do projeto, insira Ctrl-C na outra janela do terminal para sair de bmctl register bootstrap e execute o comando novamente.

  5. Clique em Verificar e criar.

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

    Quando o cluster de administrador é criado, o cluster de inicialização na estação de trabalho de administrador é excluído. A saída do comando bmctl register bootstrap na outra janela do terminal é semelhante a esta:

    ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

Verifique o cluster de administrador

É possível encontrar o arquivo kubeconfig do cluster de administrador 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. Use o SSH para acessar a estação de trabalho de administrador como raiz:

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

  2. Verifique se o cluster de administrador foi criado e está em execução:

    kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

    O resultado será assim:

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  3. Quando terminar, digite exit para se desconectar da estação de trabalho do administrador.

CLI da gcloud

As instruções a seguir exigem duas janelas de terminal. Em uma janela de terminal, execute bmctl register bootstrap para criar um cluster de inicialização. Enquanto o comando bmctl register bootstrap estiver em execução, execute gcloud container bare-metal admin-clusters create em outra janela de terminal para criar o cluster de administrador.

Criar o cluster de inicialização

Ao usar um cliente da API GKE On-Prem, como a gcloud CLI, para criar um cluster de administrador, é necessário criar um cluster de inicialização na estação de trabalho de administrador. O cluster de inicialização hospeda os controladores do Kubernetes necessários para criar o cluster de administrador.

  1. Na linha de comando, use o SSH para acessar a VM da 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. Mude para o diretório baremetal/ e execute o comando a seguir para criar o cluster de inicialização.

    O nome do cluster de inicialização é derivado adicionando o prefixo bootstrap- ao nome do cluster de administrador.

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

Crie o cluster de administrador

  1. Em uma nova janela do terminal, confirme se o cluster de inicialização foi registrado como membro da frota:

    gcloud container fleet memberships list \
    --project=PROJECT_ID

    O comando gcloud container bare-metal admin-clusters create na etapa a seguir depende da disponibilidade do cluster de inicialização. O comando bmctl register bootstrap na outra janela do terminal precisa ser executado por alguns minutos antes que o cluster de inicialização seja mostrado como um membro registrado. Se, após alguns minutos, ele ainda não estiver listado, verifique o nome do cluster de inicialização e o ID do projeto que você usou. Se você precisar mudar o nome do cluster de inicialização ou o ID do projeto, insira Ctrl-C na outra janela do terminal para sair de bmctl register bootstrap e execute o comando novamente.

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

    Verifique se os valores correspondem às variáveis de ambiente especificadas anteriormente para o script.

    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

    Nesse comando:

    • --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. Este é 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 comando a seguir em outra janela de terminal:

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

    Quando o gcloud container bare-metal admin-clusters create é concluído com sucesso, a saída é semelhante a esta:

    Created Anthos on bare metal Admin Cluster
[https://gkeonprem.googleapis.com/v1/projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-gcloud-001].
NAME           LOCATION     VERSION           MEMBERSHIP     STATE
abm-cluster-1  us-central1  1.28.300-gke.131  abm-cluster-1  RUNNING

    Quando o cluster de administrador é criado, o cluster de inicialização na estação de trabalho de administrador é excluído. A saída do comando bmctl register bootstrap na outra janela do terminal é semelhante a esta:

    ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

Verifique o cluster de administrador

É possível encontrar o arquivo kubeconfig do cluster de administrador 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. Use o SSH para acessar a estação de trabalho de administrador como raiz:

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

  2. Verifique se o cluster de administrador foi criado e está em execução:

    kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

    O resultado será assim:

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  3. Quando terminar, digite exit para se desconectar da estação de trabalho do administrador.

Terraform

As instruções a seguir exigem duas janelas de terminal. Em uma janela de terminal, execute bmctl register bootstrap para criar um cluster de inicialização. Enquanto o comando bmctl register bootstrap está em execução, execute os comandos do Terraform em outra janela do terminal para criar o cluster de administrador.

Modificar arquivos de exemplo de cluster de usuário para funcionar em um cluster de administrador

O repositório anthos-samples não inclui um exemplo específico para criar um cluster de administrador do Google Distributed Cloud. As etapas a seguir mostram como criar um cluster de administrador modificando um exemplo de cluster de usuário do Terraform.

  1. No diretório em que você clonou anthos-samples, execute o seguinte comando para copiar os arquivos de exemplo do cluster de usuário do MetalLB para uma nova pasta do cluster de administrador:

    cp -r anthos-samples/anthos-onprem-terraform/abm_user_cluster_metallb \
    anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

  2. Altere para o diretório abm_admin_cluster_basic:

    cd anthos-samples/anthos-onprem-terraform/abm_admin_cluster_basic

  3. Edite os arquivos do Terraform:

    • variables.tf:

      • Defina uma variável para os endereços IP do nó do plano de controle. No entanto, usaremos apenas um para esta demonstração. Essa variável precisa ser semelhante à entrada variable "control_plane_ips" { ... }.

      • Defina uma variável para o endereço VIP do plano de controle. Essa variável precisa ser semelhante à entrada variable "control_plane_vip" { ... }.

    • terraform.tfvars:

      • Atribua valores de variáveis para as seguintes configurações do cluster de administrador:

        • Endereços IP do nó do plano de controle: 10.200.0.3

        • Endereço VIP do plano de controle: 10.200.0.48

    • main.tf:

      • Substitua o recurso google_gkeonprem_bare_metal_cluster pelo google_gkeonprem_bare_metal_admin_cluster.

      • Exclua o recurso google_gkeonprem_bare_metal_node_pool e a seção lifecycle relacionada.

      • Atualize o recurso para usar as variáveis recém-definidas.

    Confira um exemplo de como o arquivo main.tf pode ficar quando editado para criar um cluster de administrador:

    /**
* Copyright 2023 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#[START anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

module "enable_google_apis_primary" {
  source     = "terraform-google-modules/project-factory/google//modules/project_services"
  version    = "~> 14.0"
  project_id = var.project_id
  activate_apis = [
    "anthos.googleapis.com",
    "anthosaudit.googleapis.com",
    "anthosgke.googleapis.com",
    "cloudresourcemanager.googleapis.com",
    "compute.googleapis.com",
    "connectgateway.googleapis.com",
    "container.googleapis.com",
    "file.googleapis.com",
    "gkehub.googleapis.com",
    "iam.googleapis.com",
    "kubernetesmetadata.googleapis.com",
    "logging.googleapis.com",
    "monitoring.googleapis.com",
    "opsconfigmonitoring.googleapis.com",
    "serviceusage.googleapis.com",
    "stackdriver.googleapis.com"
  ]
  disable_services_on_destroy = false
}

# Enable GKE OnPrem API
resource "google_project_service" "default" {
  project            = var.project_id
  service            = "gkeonprem.googleapis.com"
  disable_on_destroy = false
}

# Create an anthos baremetal admin cluster and enroll it with the gkeonprem API
resource "google_gkeonprem_bare_metal_admin_cluster" "admin-cluster-basic" {
  name                     = var.admin_cluster_name
  description              = "Anthos bare metal admin cluster"
  provider                 = google
  depends_on               = [google_project_service.default]
  location                 = var.region
  bare_metal_version       = var.bare_metal_version
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["0.96.0.0/20"]
      pod_address_cidr_blocks     = ["192.168.0.0/16"]
    }
  }
  node_config {
    max_pods_per_node = 250
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        operating_system = "LINUX"
        dynamic "node_configs" {
          for_each = var.admin_cp_ips
          content {
            node_ip = node_configs.value
          }
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = var.admin_cp_vip
    }
  }
  storage {
    lvp_share_config {
      lvp_config {
        path = "/mnt/localpv-share"
        storage_class = "local-shared"
      }
      shared_path_pv_count = 5
    }
    lvp_node_mounts_config {
      path = "/mnt/localpv-disk"
      storage_class = "local-disks"
    }
  }

  dynamic "security_config" {
    for_each = length(var.admin_user_emails) == 0 ? [] : [1]
    content {
      authorization {
        dynamic "admin_users" {
          for_each = var.admin_user_emails
          content {
            username = admin_users.value
          }
        }
      }
    }
  }

  lifecycle {
    ignore_changes = [
      annotations["onprem.cluster.gke.io/user-cluster-resource-link"],
      annotations["alpha.baremetal.cluster.gke.io/cluster-metrics-webhook"],
      annotations["baremetal.cluster.gke.io/operation"],
      annotations["baremetal.cluster.gke.io/operation-id"],
      annotations["baremetal.cluster.gke.io/start-time"],
      annotations["baremetal.cluster.gke.io/upgrade-from-version"]
    ]
  }
}

#[END anthos_onprem_terraform_bare_metal_admin_cluster_basic_main]

    Para mais informações sobre o recurso do Terraform para clusters de administrador, consulte google_gkeonprem_bare_metal_admin_cluster no registro do Terraform.

Criar o cluster de inicialização

Ao usar um cliente da API GKE On-Prem, como o Terraform, para criar um cluster de administrador, é necessário criar um cluster de inicialização na estação de trabalho de administrador. O cluster de inicialização hospeda os controladores do Kubernetes necessários para criar o cluster de administrador.

  1. Na linha de comando, use o SSH para acessar a VM da 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. Mude para o diretório baremetal/ e execute o comando a seguir para criar o cluster de inicialização.

    O nome do cluster de inicialização é derivado adicionando o prefixo bootstrap- ao nome do cluster de administrador.

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

Crie o cluster de administrador

  1. Inicialize e crie o plano do Terraform:

    terraform init

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

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

    terraform plan

  3. Aplique o plano do Terraform para criar o cluster de administrador:

    terraform apply

    Leva 15 minutos ou mais para criar o cluster de administrador. Quando a criação do cluster for concluída, você vai receber uma mensagem como esta:

    ...
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Still creating... [20m10s elapsed]
google_gkeonprem_bare_metal_admin_cluster.admin-cluster-basic: Creation complete after 20m11s
[id=projects/anonuser-anonproject/locations/us-central1/bareMetalAdminClusters/gce-admin-terra002]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

    Quando o cluster de administrador é criado, o cluster de inicialização na estação de trabalho de administrador é excluído. A saída do comando bmctl register bootstrap na outra janela do terminal é semelhante a esta:

    ...
[2024-04-15 23:10:48+0000] Waiting for cluster to become ready OK
[2024-04-15 23:16:38+0000] Please run
[2024-04-15 23:16:38+0000] kubectl --kubeconfig bmctl-workspace/gce-admin-gcloud-001/gce-admin-gcloud-001-kubeconfig get nodes
[2024-04-15 23:16:38+0000] to get cluster nodes status.
[2024-04-15 23:16:38+0000] Waiting for node pools to become ready OK
[2024-04-15 23:16:58+0000] Waiting for metrics to become ready in GCP OK
[2024-04-15 23:21:58+0000] Waiting for cluster API provider to install in the created admin cluster OK
[2024-04-15 23:22:08+0000] Moving admin cluster resources to the created admin cluster
[2024-04-15 23:22:10+0000] Waiting for node update jobs to finish OK
[2024-04-15 23:24:30+0000] Flushing logs... OK
[2024-04-15 23:24:30+0000] Unregistering bootstrap cluster.
[2024-04-15 23:24:30+0000] Deleting membership... OK
[2024-04-15 23:24:32+0000] Deleting bootstrap cluster.

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

    Acesse os clusters do GKE

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

  5. Faça login no cluster de administrador:

    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.

Verifique o cluster de administrador

É possível encontrar o arquivo kubeconfig do cluster de administrador 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. Use o SSH para acessar a estação de trabalho de administrador como raiz:

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

  2. Verifique se o cluster de administrador foi criado e está em execução:

    kubectl --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig get nodes

    O resultado será assim:

    NAME                   STATUS   ROLES                  AGE   VERSION
abm-admin-cluster-cp   Ready    control-plane   94m   v1.27.4-gke.1600

  3. Quando terminar, digite exit para se desconectar da estação de trabalho do administrador.

4. Criar 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. Para simplificar, use abm-user-cluster-metallb para o nome do cluster do usuário para corresponder ao nome codificado nos scripts do Terraform.

bmctl

  1. Use o SSH para acessar a VM da estação de trabalho de administrador, abm-ws, como raiz:

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

  2. Gere um arquivo de configuração do cluster:

    bmctl create config -c abm-user-cluster-metallb \
    --project-id=PROJECT_ID

  3. No arquivo de configuração do cluster de usuário abaixo, defina seu endereço de e-mail na seção clusterSecurity e verifique o restante das configurações:

    O arquivo de configuração do cluster a seguir é preenchido com os valores inseridos anteriormente na tabela de planejamento. Além dos valores inseridos, observe as seguintes diferenças em relação ao arquivo de configuração gerado:

    • Os comentários foram removidos deste exemplo para melhorar a legibilidade.
    • A seção de credenciais foi removida, como é normal para clusters de usuários.
    • O tipo de cluster, spec.type, foi definido como user.
    • O campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts foi adicionado para conceder clusterrole/cluster-admin à sua conta. Entre outras coisas, esse campo permite fazer login no cluster pelo console do Google Cloud para ver mais detalhes do cluster.
    ---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-abm-user-cluster-metallb
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: abm-user-cluster-metallb
  namespace: cluster-abm-user-cluster-metallb
spec:
  type: user
  profile: default
  anthosBareMetalVersion: BMCTL_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: 10.200.0.4
  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.50
      ingressVIP: 10.200.0.51
    addressPools:
    - name: pool1
      addresses:
      - 10.200.0.51-10.200.0.70
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - YOUR_EMAIL_ADDRESS
  storage:
    lvpNodeMounts:
      path: /mnt/localpv-disk
      storageClassName: local-disks
    lvpShare:
      path: /mnt/localpv-share
      storageClassName: local-shared
      numPVUnderSharedPath: 5
  nodeConfig:
    podDensity:
      maxPodsPerNode: 250
---
apiVersion: baremetal.cluster.gke.io/v1
kind: NodePool
metadata:
  name: node-pool-1
  namespace: cluster-abm-user-cluster-metallb
spec:
  clusterName: abm-user-cluster-metallb
  nodes:
  - address: 10.200.0.5

  4. Substitua o conteúdo do arquivo de configuração gerado na estação de trabalho de administrador pelo conteúdo do exemplo anterior.

    Abra o arquivo gerado, bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml, e substitua o conteúdo dele pelo conteúdo do exemplo que você verificou na etapa anterior.

  5. Crie o cluster de usuário:

    bmctl create cluster -c abm-user-cluster-metallb \
  --kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

    O comando bmctl exibe a saída na tela enquanto executa verificações de simulação e cria o cluster. As informações detalhadas são gravadas em registros da pasta baremetal/bmctl-workspace/abm-user-cluster-metallb/log na estação de trabalho do administrador.

    A criação do cluster pode levar vários minutos para ser concluída.

  6. No Console do Google Cloud, acesse a página de clusters do GKE.

    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.

  7. Faça login no cluster de usuários:

    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.

Console

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

  1. No console, acesse a página Criar um cluster bare metal.

    Acesse "Criar um cluster bare metal"

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

  3. Clique em Criar cluster.

  4. Na caixa de diálogo, clique em No local.

  5. Ao lado de Bare Metal, clique em Configurar. A página Pré-requisitos é exibida.

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

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

O script executado para criar VMs e o cluster de administrador também criou uma VXLAN de camada 2 com endereços IP na sub-rede 10.200.0.0/24.

  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.

Crie um pool de nós.

O cluster de usuário precisa ter pelo menos um pool de nós para nós de trabalho.

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

  3. Faça login no cluster de usuários:

    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.

CLI da gcloud

Para criar o cluster de usuário:

  1. Execute o comando a seguir para criar o cluster de usuário:

    gcloud container bare-metal clusters create abm-user-cluster-metallb \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/ON_PREM_API_REGION/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

    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.

  2. Para descobrir o status da operação, 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

    Substitua OPERATION_ID pela string correspondente da saída da etapa anterior.

    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/abm-user-cluster-metallb].

    Para mais informações sobre o comando gcloud container bare-metal clusters create, incluindo descrições de cada flag, consulte a página container bare-metal clusters create do recurso de clusters na referência da gcloud CLI.

Crie um pool de nós.

Depois que o cluster for criado, você poderá criar um pool de nós para ele.

Para criar um pool de nós:

  1. Execute o comando a seguir para criar um pool de nós:

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

    Substitua NODE_POOL_NAME por um nome para o pool de nós.

    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/abm-user-cluster-metallb/bareMetalNodePools/NODE_POOL_NAME].

  2. Acesse a página Criar um cluster bare metal no console:

    Acessar a página "Criar um cluster bare metal"

    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.

  3. Faça login no cluster de usuários:

    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.

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

  3. Verifique os valores no exemplo a seguir:

    O arquivo de variáveis do Terraform terraform.tfvars.sample a seguir é preenchido com endereços IP e valores que você inseriu nas seções anteriores deste guia.

    
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"] }
]

    Substitua ADMIN_2_EMAIL_ADDRESS por um endereço de e-mail associado à sua conta do Google Cloud ou remova-o ao editar o arquivo de variáveis.

    Para mais informações sobre os argumentos no exemplo em que você está definindo variáveis, consulte a Referência de argumentos na documentação do Terraform para clusters de usuários do Google Distributed Cloud.

  4. Substitua o conteúdo da sua cópia do arquivo de variáveis pelo conteúdo da amostra anterior.

  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.

  8. No Console do Google Cloud, acesse a página de clusters do GKE.

    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.

  9. Faça login no cluster de usuários:

    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.

5. Limpar

Use as instruções a seguir para remover os clusters e as VMs criados com este guia.

Excluir o cluster de usuário

bmctl

  • Para excluir o cluster de usuários com bmctl, execute o seguinte comando na VM da estação de trabalho do administrador, abm-ws:

    bmctl reset \
    --cluster abm-user-cluster-metallb \
    --admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig

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 Ver 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 Excluir.

  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

  • Para excluir o cluster, execute o seguinte comando:

    gcloud container bare-metal clusters delete abm-user-cluster-metallb \
    --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

O comando terraform destroy encerra os recursos que foram criados quando você executou terraform apply para criar o cluster de usuário.

  • Execute o comando a seguir no diretório em que os arquivos de exemplo do cluster de usuários do Terraform, como main.tf, estão localizados:

    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:

    exit

  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 compute instances delete --quiet --zone ZONE

  7. Execute o comando abaixo para excluir a conta de serviço e, quando solicitado, digite y:

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

    A seguir