Crie clusters de administrador e de utilizador do Google Distributed Cloud de demonstração em VMs do Compute Engine

Saiba mais sobre o Google Distributed Cloud (apenas software) para bare metal (anteriormente conhecido como Google Distributed Cloud Virtual, anteriormente conhecido como clusters do Anthos em bare metal) criando clusters de demonstração em máquinas virtuais (MVs) do Compute Engine. A criação de um cluster de administrador e um cluster de utilizador com este guia pode demorar entre 40 minutos e 1 hora. Os clusters de demonstração que criar neste guia ajudam a avaliar o processo de aprovisionamento e funcionamento dos clusters do Google Distributed Cloud, mas não se destinam a utilização em produção.

O documento explica o processo de execução de um script que:

  • Aprovisiona cinco VMs do Compute Engine para instalar os seus clusters de demonstração
  • Configura uma rede de VPC para fornecer conetividade de cluster

Depois de o script aprovisionar os recursos necessários, use um dos seguintes clientes para criar um cluster de administrador e um cluster de utilizador associado que possa alojar cargas de trabalho: bmctl, Google Cloud console, Google Cloud CLI ou Terraform.

Vista geral do procedimento

Este guia contém estes passos principais:

  1. Prepare o seu ambiente local para que o script tenha as variáveis de ambiente necessárias e tenha reunido 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 suportados.

  4. Crie o cluster de utilizadores com um dos clientes suportados.

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

1. Prepare o seu ambiente local

Uma vez que este guia usa um script que configura a rede por si, não precisa de recolher muitas informações nem fazer planeamento. Os passos seguintes configuram o seu ambiente local e recolhem as informações básicas de que precisa nas secções subsequentes 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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

  6. Tome nota do ID do projeto, porque precisa dele para definir uma variável de ambiente que é usada no script e nos comandos nesta página. Se selecionou um projeto existente, certifique-se de que é proprietário do projeto ou editor.
  7. Pode executar o script no Cloud Shell ou na sua máquina local com Linux ou macOS. Se não estiver a usar o Cloud Shell:
    1. Certifique-se de que instalou a CLI do Google Cloud mais recente, a ferramenta de linha de comandos para interagir com o Google Cloud. Atualize os componentes da CLI gcloud, se necessário: 
      gcloud components update

      Consoante a forma como a CLI gcloud foi instalada, pode ver 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 para atualizar os componentes.

    2. Certifique-se de que tem o kubectl instalado. Se precisar de instalar o kubectl, execute o seguinte comando: 
      gcloud components install kubectl
  8. Certifique-se de que o seu projeto tem uma rede VPC denominada "default".

    Se não tiver uma rede VPC "predefinida", o script na secção seguinte não aprovisiona os recursos necessários. A menos que opte por eliminá-la ou restringi-la, cada novo projeto começa com uma rede VPC no modo automático denominada "predefinição" que deve funcionar com o script. Para mais informações, consulte o artigo Redes VPC.

  9. Certifique-se de que as seguintes restrições de políticas de organização não são aplicadas:
    • constraints/iam.disableServiceAccountKeyCreation
    • constraints/compute.vmCanIpForward
    • constraints/compute.requireShieldedVm
    • constraints/compute.vmExternalIpAccess

    Se estas restrições forem aplicadas, o script na secção seguinte não consegue aprovisionar os recursos necessários. Para um novo projeto, estas restrições estão definidas como Inativas (não aplicadas) por predefinição. Para mais informações, consulte as restrições de políticas da organização.

  10. Configure 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 que escolher para o cluster de administrador.
    • ON_PREM_API_REGION: a Google Cloud região na qual a API GKE On-Prem é executada e armazena os respetivos metadados. Especifique us-central1 ou outra região suportada.
    • ZONE: A Google Cloud zona em que as VMs do Compute Engine são criadas. Pode usar us-central1-a ou qualquer uma das outras zonas do Compute Engine.
  11. Execute os seguintes comandos para definir o projeto e a zona predefinidos. 
    gcloud config set project $PROJECT_ID
gcloud config set compute/zone $ZONE

    Se receber um erro PERMISSION_DENIED, verifique novamente o ID do projeto que introduziu. Se o ID do projeto estiver correto, execute gcloud auth login para iniciar sessão na CLI gcloud com a conta que tem acesso ao projeto.

  12. Aceda a uma lista das versões suportadas que pode instalar: 
    gcloud container bare-metal admin-clusters query-version-config \
    --location=ON_PREM_API_REGION
  13. Selecione uma versão a partir do resultado do comando anterior e defina-a numa variável de ambiente: 
    export BMCTL_VERSION=BMCTL_VERSION

    Recomendamos que selecione a versão compatível mais elevada para aceder às funcionalidades e correções mais recentes do Google Distributed Cloud.

    14. 2. Crie as VMs e a rede

    Nesta secção, transfere e executa o script install_admin_cluster.sh.

    1. Clone o repositório anthos-samples e mude para o diretório onde o script se encontra:

      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 comando, introduza 2 para configurar apenas a infraestrutura do Compute Engine e confirme a sua seleção quando lhe for pedido.

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

      Para saber mais sobre o script, clique no seguinte link:

      Acerca do script

      Pode ver o script na pasta anthos-bm-gcp-bash no repositório do GitHub anthos-samples. O script automatiza os seguintes passos manuais:

      1. Ativa as seguintes Google Cloud APIs: 
        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 denominada baremetal-gcr e concede-lhe as seguintes funções 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 controlo do cluster de administrador.
        • Duas VMs para os nós de trabalho do cluster de utilizadores.
        • Uma VM para o nó do plano de controlo do cluster de utilizadores.
      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 extensível virtual (VXLAN) para a conetividade de camada 2 entre as VMs. A VXLAN não é persistente, pelo que, se reiniciar uma instância de VM, a rede é destruída. A rede está configurada para estar na sub-rede 10.200.0.0/24. A conetividade de camada 2 é um requisito para o balanceador de carga integrado.
      6. Instala as seguintes ferramentas na estação de trabalho do administrador:
        • bmctl
        • kubectl
        • Docker

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

      7. Garante que root@10.200.0.x da estação de trabalho do administrador funciona ao realizar as seguintes tarefas:
        1. Gere uma nova chave SSH na estação de trabalho do administrador.
        2. Adiciona a chave pública a todas as outras VMs na implementação.

      O script produz cada comando que executa e o estado. Quando terminar, o script produz o seguinte resultado:

      ✅ 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, aceda à VM da estação de trabalho de administrador numa janela de terminal e execute comandos a partir daí:

    1. Use o SSH para aceder à VM da estação de trabalho de administração, abm-ws, como raiz:

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

    2. Defina as suas credenciais de utilizador como credenciais padrão da aplicação (ADC):

      gcloud auth application-default login

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

    3. Gere um ficheiro de configuração do cluster:

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

    4. Valide o ficheiro de configuração do cluster de administrador:

      O seguinte ficheiro de configuração do cluster é preenchido com os valores que indicou anteriormente. Além dos valores que introduziu, tenha em atenção as seguintes diferenças em relação ao ficheiro de configuração gerado:

      • Os comentários foram removidos desta amostra para melhorar a legibilidade.
      • O script cria uma única conta de serviço com todas as autorizações necessárias e transfere a chave bm-gcr.json referenciada no ficheiro 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: ON_PREM_API_REGION
  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 ficheiro de configuração gerado na estação de trabalho do administrador pelo conteúdo do exemplo anterior.

      Abra o ficheiro gerado bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME.yaml e substitua o respetivo conteúdo pelo conteúdo do exemplo que validou no passo anterior.

    6. Crie o cluster de administrador:

      bmctl create cluster -c ADMIN_CLUSTER_NAME

      O comando bmctl apresenta o resultado no ecrã à medida que executa verificações prévias e cria o cluster. As informações detalhadas são escritas nos registos na pasta baremetal/bmctl-workspace/abm-user-cluster-metallb/log na estação de trabalho do administrador.

      A criação de clusters pode demorar vários minutos a ser concluída.

    7. Na consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

      Certifique-se de que o projeto no qual criou o cluster de utilizadores está selecionado. Deve ver o cluster de administrador listado.

    8. Inicie sessão no cluster de administrador:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

    Valide o cluster de administrador

    Pode encontrar o ficheiro kubeconfig do cluster de administrador na estação de trabalho de administrador no diretório bmctl-workspace da conta raiz. Para validar a implementação, conclua os seguintes passos:

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

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

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

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

      O resultado é semelhante ao seguinte:

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

    3. Quando terminar de explorar, introduza exit para se desligar da estação de trabalho de administração.

    Consola

    Para criar um cluster de administrador na consola, tem de executar bmctl register bootstrap a partir da VM da estação de trabalho de administrador para criar um cluster de arranque. Enquanto o comando bmctl register bootstrap está em execução, execute os passos na consola para criar o cluster de administrador.

    Introduza as noções básicas do ambiente de arranque

    1. Na Google Cloud consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

    2. Clique em Criar.

    3. Na caixa de diálogo Criar um cluster, selecione No local e clique em Configurar para hardware físico:

    4. Certifique-se de que seleciona PROJECT_ID na lista de projetos.

    5. Na barra de navegação do lado esquerdo, clique em Instalar ambiente de arranque.

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

    7. Selecione BMCTL_VERSION como a versão do cluster de administrador. O script transferiu esta versão da ferramenta de linha de comandos bmctl para a estação de trabalho do administrador. A versão do Google Distributed Cloud que instalar tem de corresponder à versão do bmctl.

    8. No campo Localização da API Google Cloud, selecione ON_PREM_API_REGION na lista. Esta definição especifica a região onde a API GKE On-Prem é executada e a região onde os seguintes elementos são armazenados:

      • Os metadados do cluster de que a GKE On-Prem API precisa para gerir o ciclo de vida do cluster
      • Os dados do Cloud Logging e do Cloud Monitoring dos componentes do sistema
      • O registo de auditoria do administrador criado pelos registos de auditoria da nuvem

      O nome do cluster, o projeto e a localização identificam de forma exclusiva o cluster no Google Cloud.

    Em vez dos passos apresentados na consola, use os passos na secção seguinte para criar o cluster de arranque. Deixe a página da consola apresentada porque vai continuar aí para criar o cluster de administrador.

    Crie o cluster de arranque

    Quando usa um cliente da API GKE On-Prem, como a consola, para criar um cluster de administrador, tem de criar um cluster de arranque na estação de trabalho do administrador. O cluster de arranque aloja os controladores do Kubernetes necessários para criar o cluster de administrador.

    1. Na linha de comandos, use o SSH para aceder à VM da estação de trabalho de administração como raiz:

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

      Pode ignorar todas as mensagens sobre a atualização da VM e concluir este tutorial. Se planeia manter as VMs como um ambiente de teste, recomendamos que atualize o SO ou faça a atualização para a versão seguinte, conforme descrito na documentação do Ubuntu.

    2. Defina as suas credenciais de utilizador como credenciais padrão da aplicação (ADC):

      gcloud auth application-default login

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

    3. Altere para o diretório baremetal/ e execute o seguinte comando para criar o cluster de arranque.

      O nome do cluster de arranque é derivado ao adicionar 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 de bmctl criar com êxito o cluster de arranque, é apresentado um resultado semelhante ao seguinte:

      [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 arranque, na secção Ambiente de arranque da estação de trabalho do administrador, clique em Verificar ligação.

      Se for bem-sucedida, a consola apresenta a mensagem Ligação estabelecida.

      A ligação ao cluster de arranque tem de ser estabelecida antes de continuar. Se a ligação não for estabelecida, verifique os argumentos que especificou no comando bmctl register bootstrap:

      • Certifique-se de que o valor de --name corresponde ao nome de arranque derivado apresentado na secção Noções básicas do ambiente de arranque.

      • Certifique-se de que o valor de --project-id corresponde ao ID do projeto que selecionou na consola.

      Se precisar de alterar o nome do cluster de arranque ou o ID do projeto, introduza Ctrl-C para sair de bmctl register bootstrap e voltar a executar o comando.

    Trabalhar em rede

    1. Clique em Rede na barra de navegação do lado esquerdo.

    2. Na secção Plano de controlo, introduza o seguinte no campo IP do nó do plano de controlo 1:

      10.200.0.3

      Este é o endereço IP da VM abm-admin-cluster-cp no VXLAN criado pelo script.

    3. Na secção Equilibrador de carga, certifique-se de que a opção Agrupado está selecionada.

    4. Na secção IPs virtuais (VIPs), introduza o seguinte no campo VIP do plano de controlo:

      10.200.0.48

      O passo seguinte depende da disponibilidade do cluster de arranque. O comando bmctl register bootstrap na janela do terminal tem de ser executado durante alguns minutos antes de o cluster de arranque ser apresentado como um membro registado. Se, após alguns minutos, ainda não estiver disponível, verifique o nome do cluster de arranque e o ID do projeto que usou. Se precisar de alterar o nome do cluster de arranque ou o ID do projeto, introduza Ctrl-C na outra janela do terminal para sair do bmctl register bootstrap e executar novamente o comando.

    5. Clique em Validar e criar.

      A consola apresenta mensagens de estado à medida que valida as definições e cria o cluster.

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

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

    Valide o cluster de administrador

    Pode encontrar o ficheiro kubeconfig do cluster de administrador na estação de trabalho de administrador no diretório bmctl-workspace da conta raiz. Para validar a implementação, conclua os seguintes passos:

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

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

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

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

      O resultado é semelhante ao seguinte:

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

    3. Quando terminar de explorar, introduza exit para se desligar da estação de trabalho de administração.

    CLI gcloud

    As instruções seguintes requerem duas janelas de terminal. Numa janela de terminal, executa bmctl register bootstrap para criar um cluster de arranque. Enquanto o comando bmctl register bootstrap está em execução, execute gcloud container bare-metal admin-clusters create noutra janela do terminal para criar o cluster de administrador.

    Crie o cluster de arranque

    Quando usa um cliente da API GKE On-Prem, como a CLI gcloud, para criar um cluster de administrador, tem de criar um cluster de arranque na estação de trabalho do administrador. O cluster de arranque aloja os controladores do Kubernetes necessários para criar o cluster de administrador.

    1. Na linha de comandos, use o SSH para aceder à VM da estação de trabalho de administração como raiz:

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

      Pode ignorar todas as mensagens sobre a atualização da VM e concluir este tutorial. Se planeia manter as VMs como um ambiente de teste, recomendamos que atualize o SO ou faça a atualização para a versão seguinte, conforme descrito na documentação do Ubuntu.

    2. Defina as suas credenciais de utilizador como credenciais padrão da aplicação (ADC):

      gcloud auth application-default login

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

    3. Altere para o diretório baremetal/ e execute o seguinte comando para criar o cluster de arranque.

      O nome do cluster de arranque é derivado ao adicionar 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 de bmctl criar com êxito o cluster de arranque, é apresentado um resultado semelhante ao seguinte:

      [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. Numa nova janela do terminal, confirme que o cluster de arranque foi registado como membro da frota:

      gcloud container fleet memberships list \
    --project=PROJECT_ID

      O comando gcloud container bare-metal admin-clusters create no passo seguinte depende da disponibilidade do cluster de arranque. O comando bmctl register bootstrap na outra janela do terminal tem de ser executado durante alguns minutos antes de o cluster de arranque ser apresentado como um membro registado. Se, após alguns minutos, ainda não for apresentado, verifique o nome do cluster de arranque e o ID do projeto que usou. Se precisar de alterar o nome do cluster de arranque ou o ID do projeto, introduza Ctrl-C na outra janela do terminal para sair do bmctl register bootstrap e executar novamente o comando.

    2. Crie o cluster de administrador com o balanceador de carga incluído:

      Certifique-se de que os valores especificados correspondem às variáveis de ambiente que especificou 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

      Neste comando:

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

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

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

      O resultado do comando é semelhante ao seguinte:

      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. Pode saber o estado da operação executando o seguinte comando noutra janela do terminal:

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

      Quando o comando gcloud container bare-metal admin-clusters create é concluído com êxito, o resultado é semelhante ao seguinte:

      none{:.devsite-disable-click-to-copy} 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.31.300-gke.81 abm-cluster-1 RUNNING

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

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

    Valide o cluster de administrador

    Pode encontrar o ficheiro kubeconfig do cluster de administrador na estação de trabalho de administrador no diretório bmctl-workspace da conta raiz. Para validar a implementação, conclua os seguintes passos:

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

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

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

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

      O resultado é semelhante ao seguinte:

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

    3. Quando terminar de explorar, introduza exit para se desligar da estação de trabalho de administração.

    Terraform

    As instruções seguintes requerem duas janelas de terminal. Numa janela de terminal, executa bmctl register bootstrap para criar um cluster de arranque. Enquanto o comando bmctl register bootstrap está em execução, execute os comandos do Terraform noutra janela do terminal para criar o cluster de administrador.

    Modifique os ficheiros de exemplo do cluster de utilizadores para funcionarem num cluster de administrador

    O repositório anthos-samples não inclui um exemplo especificamente para criar um cluster de administrador do Google Distributed Cloud. Os passos seguintes mostram como criar um cluster de administrador modificando um exemplo do Terraform de um cluster de utilizadores existente.

    1. No diretório onde clonou anthos-samples, execute o seguinte comando para copiar os ficheiros de exemplo do exemplo de cluster de utilizador do MetalLB para uma nova pasta do seu 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 ficheiros do Terraform:

      • variables.tf:

        • Defina uma variável para os endereços IP dos nós do plano de controlo (embora usemos apenas um para esta demonstração). Esta variável deve ser semelhante à entrada variable "control_plane_ips" { ... }.

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

      • terraform.tfvars:

        • Atribua valores de variáveis para as seguintes definições do cluster de administração:

          • Endereços IP dos nós do plano de controlo: 10.200.0.3

          • Endereço VIP do plano de controlo: 10.200.0.48

      • main.tf:

        • Substitua o recurso google_gkeonprem_bare_metal_cluster pelo recurso google_gkeonprem_bare_metal_admin_cluster.

        • Eliminar o recurso google_gkeonprem_bare_metal_node_pool e a secção lifecycle relacionada.

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

      Segue-se um exemplo do aspeto do ficheiro main.tf 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 a 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              = "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 o artigo google_gkeonprem_bare_metal_admin_cluster no registo do Terraform.

    Crie o cluster de arranque

    Quando usa um cliente da API GKE On-Prem, como o Terraform, para criar um cluster de administrador, tem de criar um cluster de arranque na estação de trabalho de administrador. O cluster de arranque aloja os controladores do Kubernetes necessários para criar o cluster de administrador.

    1. Na linha de comandos, use o SSH para aceder à VM da estação de trabalho de administração como raiz:

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

      Pode ignorar todas as mensagens sobre a atualização da VM e concluir este tutorial. Se planeia manter as VMs como um ambiente de teste, recomendamos que atualize o SO ou faça a atualização para a versão seguinte, conforme descrito na documentação do Ubuntu.

    2. Defina as suas credenciais de utilizador como credenciais padrão da aplicação (ADC):

      gcloud auth application-default login

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

    3. Altere para o diretório baremetal/ e execute o seguinte comando para criar o cluster de arranque.

      O nome do cluster de arranque é derivado ao adicionar 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 de bmctl criar com êxito o cluster de arranque, é apresentado um resultado semelhante ao seguinte:

      [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 Google Cloud fornecedor.

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

      A criação do cluster de administrador demora 15 minutos ou mais. Quando a criação do cluster estiver concluída, é apresentada uma mensagem semelhante à seguinte:

      ...
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 arranque na estação de trabalho do administrador é eliminado. A saída do comando bmctl register bootstrap na outra janela do terminal é semelhante à seguinte:

      ...
[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. Na consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

      Certifique-se de que o projeto no qual criou o cluster de utilizadores está selecionado. Deve ver o cluster de administrador listado.

    5. Inicie sessão no cluster de administrador:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

    Valide o cluster de administrador

    Pode encontrar o ficheiro kubeconfig do cluster de administrador na estação de trabalho de administrador no diretório bmctl-workspace da conta raiz. Para validar a implementação, conclua os seguintes passos:

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

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

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

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

      O resultado é semelhante ao seguinte:

      none{:.devsite-disable-click-to-copy} NAME STATUS ROLES AGE VERSION abm-admin-cluster-cp Ready control-plane 94m 1.31.300-gke.81

    3. Quando terminar de explorar, introduza exit para se desligar da estação de trabalho de administração.

    4. Crie o cluster de utilizadores

    Pode usar a Google Cloud consola, a CLI Google Cloud ou o Terraform para criar o cluster de utilizadores. Para simplificar, use abm-user-cluster-metallb para o nome do cluster do utilizador, para corresponder ao nome codificado nos scripts do Terraform.

    bmctl

    1. Use o SSH para aceder à VM da estação de trabalho de administração, abm-ws, como raiz:

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

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

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

    3. No ficheiro de configuração do cluster de utilizadores seguinte, defina o seu endereço de email na secção clusterSecurity e valide as restantes definições:

      O seguinte ficheiro de configuração do cluster é preenchido com os valores que introduziu anteriormente na tabela de planeamento. Além dos valores que introduziu, tenha em atenção as seguintes diferenças em relação ao ficheiro de configuração gerado:

      • Os comentários foram removidos desta amostra para melhorar a legibilidade.
      • A secção de credenciais foi removida, como é normal para os clusters de utilizadores.
      • O tipo de cluster, spec.type, foi definido como user.
      • O campo spec.clusterSecurity.authorization.clusterAdmin.gcpAccounts foi adicionado para conceder o clusterrole/cluster-admin à sua conta. Entre outras coisas, este campo permite-lhe iniciar sessão no cluster na Google Cloud consola 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: ON_PREM_API_REGION
  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 ficheiro de configuração gerado na estação de trabalho do administrador pelo conteúdo do exemplo anterior.

      Abra o ficheiro gerado bmctl-workspace/abm-user-cluster-metallb/abm-user-cluster-metallb.yaml e substitua o respetivo conteúdo pelo conteúdo do exemplo que validou no passo anterior.

    5. Crie o cluster de utilizadores:

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

      O comando bmctl apresenta o resultado no ecrã à medida que executa verificações prévias e cria o cluster. As informações detalhadas são escritas nos registos na pasta baremetal/bmctl-workspace/abm-user-cluster-metallb/log na estação de trabalho do administrador.

      A criação de clusters pode demorar vários minutos a ser concluída.

    6. Na Google Cloud consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

      Certifique-se de que o projeto no qual criou o cluster de utilizadores está selecionado. Deve ver o cluster de administrador e de utilizador na lista.

    7. Inicie sessão no cluster de utilizadores:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

      Repita os mesmos passos para iniciar sessão no cluster de administrador.

    Consola

    Siga estes passos para criar um cluster de utilizadores na consola:

    1. Na consola, aceda à página Criar um cluster bare metal.

      Aceda a Crie um cluster bare metal

    2. Certifique-se de que o Google Cloud projeto no qual criou o cluster de administrador está selecionado.

    3. Clique em Criar cluster.

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

    5. Junto a Bare metal, clique em Configurar. A página Pré-requisitos é apresentada.

    6. Em Escolha o tipo de cluster, selecione Criar um cluster de utilizadores para um cluster de administrador existente

    7. Clicar em Seguinte.

    Noções básicas sobre clusters

    1. Introduza um nome para o cluster de utilizadores ou use o predefinido.

    2. Certifique-se de que o cluster de administrador recém-criado está selecionado. Pode usar as predefinições para as restantes definições nesta página.

    3. Clique em Rede na barra de navegação do lado esquerdo.

    Trabalhar em rede

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

    1. Na secção Plano de controlo, introduza o seguinte no campo IP do nó do plano de controlo 1:

      10.200.0.4

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

    2. Na secção Balanceador de carga, use o balanceador de carga predefinido, Incluído no MetalLB.

    3. Na secção Novo conjunto de endereços, introduza o seguinte intervalo de endereços IP no campo Intervalo de endereços IP 1:

      10.200.0.51-10.200.0.70

    4. Clique em Concluído.

    5. Na secção IPs virtuais, introduza o seguinte endereço IP no campo VIP do plano de controlo:

      10.200.0.50

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

      10.200.0.51

    7. Use os endereços IP predefinidos na secção CIDRs de serviços e pods.

    8. Clique em conjunto predefinido na barra de navegação do lado esquerdo.

    Crie um node pool

    O cluster de utilizadores tem de ter, pelo menos, um conjunto de nós para nós de trabalho.

    1. Introduza o seguinte endereço IP no campo Endereço do nó 1:

      10.200.0.5

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

    Crie o cluster

    1. Clique em Validar e criar para criar o cluster de utilizadores.

      A criação do cluster de utilizadores demora 15 minutos ou mais. A consola apresenta mensagens de estado à medida que valida as definições e cria o cluster.

      Se houver um problema com a configuração, a consola apresenta uma mensagem de erro que deve ser suficientemente clara para corrigir o problema de configuração e tentar novamente criar o cluster.

      Para ver informações adicionais sobre o processo de criação, clique em Mostrar detalhes para apresentar um painel lateral. Clique em para fechar o painel de detalhes.

      Quando o cluster é criado, é apresentado o Estado do cluster: em execução.

    2. Depois de criar o cluster, clique em Clusters para voltar à página Clusters.

    3. Inicie sessão no cluster de utilizadores:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

      Repita os mesmos passos para iniciar sessão no cluster de administrador.

    CLI gcloud

    Para criar o cluster de utilizadores:

    1. Execute o seguinte comando para criar o cluster de utilizadores:

      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, vê um resultado semelhante ao seguinte:

      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 saber o estado 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 do passo anterior.

      A criação do cluster demora cerca de 15 minutos ou mais. À medida que o cluster é criado, pode executar o comando anterior com alguma frequência para obter o estado atual.

      Quando o cluster é criado, vê um resultado semelhante ao seguinte:

      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 para o recurso de clusters na referência da CLI gcloud.

    Crie um node pool

    Depois de criar o cluster com êxito, pode criar um conjunto de nós para o cluster.

    Para criar um node pool:

    1. Execute o seguinte comando para criar um node pool:

      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 conjunto de nós.

      Depois de executar o comando, vê um resultado semelhante ao seguinte:

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

      A criação do node pool demora cerca de 5 minutos ou menos. Quando o node pool é criado, vê um resultado semelhante ao seguinte:

      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. Aceda à página Clusters do Kubernetes na consola:

      Aceda à página Crie um cluster bare metal

      Certifique-se de que o projeto no qual criou o cluster de utilizadores está selecionado. Deve ver o cluster de administrador e de utilizador na lista.

    3. Inicie sessão no cluster de utilizadores:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

      Repita os mesmos passos para iniciar sessão no cluster de administrador.

    Terraform

    Pode usar o seguinte exemplo de configuração básica para criar um cluster de utilizadores com o balanceador de carga MetalLB incluído. Para mais informações, consulte a google_gkeonprem_bare_metal_cluster documentação de referência.

    1. No diretório onde clonou anthos-samples, mude para o diretório onde se encontra o exemplo do Terraform:

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

      A amostra fornece um ficheiro de variáveis de exemplo para transmitir ao main.tf.

    2. Crie uma cópia do ficheiro terraform.tfvars.sample:

      cp terraform.tfvars.sample terraform.tfvars

    3. Valide os valores no seguinte exemplo:

      O seguinte ficheiro de variáveis do Terraform, terraform.tfvars.sample, é pré-preenchido com endereços IP e com valores que introduziu nas secçõ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 email associado à sua conta ou remova-o quando editar o ficheiro de variáveis. Google Cloud

      Para mais informações sobre os argumentos neste exemplo para os quais está a definir variáveis, consulte a Referência de argumentos na documentação do Terraform para clusters de utilizadores bare metal.

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

    5. Inicialize e crie o plano do Terraform:

      terraform init

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

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

      terraform plan

    7. Aplique o plano do Terraform para criar o cluster de utilizadores:

      terraform apply

      A criação do cluster de utilizadores demora 15 minutos ou mais. Pode ver o cluster na consola na página Clusters do GKE. Google Cloud

    8. Na Google Cloud consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

      Certifique-se de que o projeto no qual criou o cluster de utilizadores está selecionado. Deve ver o cluster de administrador e de utilizador na lista.

    9. Inicie sessão no cluster de utilizadores:

      1. Clique no link no nome do cluster e, no painel lateral, clique em Iniciar sessão.

      2. Selecione Utilizar a sua identidade Google para iniciar sessão.

      3. Clique em Iniciar sessão.

      Repita os mesmos passos para iniciar sessão no cluster de administrador.

    5. Limpar

    Use as instruções seguintes para remover os clusters e as VMs que criou com este guia.

    Elimine o cluster de utilizadores

    bmctl

    • Para eliminar o cluster de utilizadores com bmctl, execute o seguinte comando a partir da VM da estação de trabalho de administração, abm-ws:

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

    Consola

    1. Na consola, aceda à página Clusters do GKE.

      Aceda aos clusters do GKE

    2. Na lista de clusters, clique no cluster de utilizadores.

    3. No painel Detalhes, clique em Ver mais detalhes.

    4. Junto à parte superior da janela, clique em Eliminar.

    5. Quando lhe for pedido que confirme, introduza o nome do cluster e clique em Eliminar.

    6. Clique em no canto superior direito para ver o estado da eliminação. Pode ter de atualizar a página para atualizar a lista de clusters.

    CLI gcloud

    • Para eliminar 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 flag --force permite-lhe eliminar um cluster com node pools. Sem a flag --force, tem de eliminar os node pools primeiro e, em seguida, eliminar o cluster.

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

    Terraform

    O comando terraform destroy termina os recursos que foram criados quando executou terraform apply para criar o cluster de utilizadores.

    • Execute o seguinte comando a partir do diretório onde se encontram os ficheiros de exemplo do cluster do utilizador do Terraform, como main.tf:

      terraform destroy

    Aguarde até que o cluster de utilizadores seja eliminado antes de eliminar o cluster de administrador e as VMs.

    Elimine o cluster de administrador e as VMs

    1. Anule 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. Ligue-se à estação de trabalho de administração:

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

    3. Elimine o cluster de administrador:

      bmctl reset -c ADMIN_CLUSTER_NAME

      bmctl anula o registo do cluster na frota e, em seguida, elimina o cluster. Aguarde a eliminação do cluster antes de eliminar as VMs.

    4. Saia da estação de trabalho de administração:

      exit

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

      gcloud compute instances list | grep 'abm'

    6. Confirme que não tem problemas em eliminar todas as VMs que contenham abm no nome.

      Depois de fazer a validação, pode eliminar VMs abm executando o seguinte comando:

      gcloud compute instances list --format="value(name)" | \
    grep 'abm' | \
    xargs gcloud compute instances delete --quiet --zone ZONE

    7. Execute o seguinte comando para eliminar a conta de serviço e, quando lhe for pedido, introduza y:

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

      O que se segue?