Versão 1.15. Esta versão não é mais compatível. Para informações sobre como fazer upgrade para a versão 1.16, consulte Fazer upgrade dos clusters na documentação mais recente. Para mais informações sobre as versões compatíveis e não compatíveis, consulte a página Histórico de versões na documentação mais recente.

Criar clusters básicos

Esta página é a segunda parte de um guia que explica uma pequena instalação de prova de conceito do GDCV para Bare Metal. A primeira parte, Configurar infraestrutura mínima, mostra como configurar seu hardware, planejar endereços IP e configurar a infraestrutura necessária do Google Cloud. Este documento é baseado na configuração e no planejamento da seção anterior e mostra como criar um cluster de administrador e um cluster de usuário. Em seguida, será possível Criar um Serviço e um Ingress.

Este guia ajuda a criar uma instalação mínima do GKE em bare metal. Essa instalação mínima pode não ser adequada para suas necessidades de produção e casos de uso reais. Para informações sobre instalações de produção, consulte os guias de instalação.

Antes de começar

Verifique se você configurou o hardware e planejou seus endereços IP, conforme descrito na seção anterior deste guia, Configurar infraestrutura mínima. Como alternativa, use o planejador de requisitos de rede na seção Pré-requisitos do fluxo Criar um cluster de administrador do GKE em bare metal no console do Google Cloud.
Se você quiser usar o Terraform para criar o cluster de usuário, use o Terraform na estação de trabalho do administrador ou em outro computador.
1. Verifique se você tem os componentes mais recentes da Google Cloud CLI instalados:
```
gcloud components update
```
Siga as etapas a seguir para ativar e usar a API GKE On-Prem:
1. Ative a API no projeto:
```
gcloud services enable \
    --project PROJECT_ID \
    gkeonprem.googleapis.com
```
  Substitua PROJECT_ID pelo ID do projeto host da frota.
  
  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 Google Cloud CLI com a conta que tem acesso ao projeto.
2. Se esta é a primeira vez que você ativa a API GKE On-Prem no projeto, é necessário inicializar a API. Para fazer isso, chame um comando da gcloud CLI que exibe as versões disponíveis que podem ser usadas para criar um cluster:
```
gcloud container bare-metal clusters query-version-config \
    --project=PROJECT_ID \
    --location="us-central1"
```

Visão geral do procedimento

A criação de clusters básicos consiste nas seguintes etapas principais:

Coletar informações usadas para especificar a configuração dos clusters.
Criar um cluster de administrador para gerenciar seu cluster de usuário.
Criar um cluster de usuário que pode executar suas cargas de trabalho reais.

1. Coletar informações

Use as informações preparadas em Configurar infraestrutura mínima ou pelo planejador de rede para preencher cada marcador de posição na tabela a seguir. Os marcadores de posição correspondem aos valores de campo nos arquivos de configuração do cluster para a instalação mínima de um cluster de administrador e um cluster de usuário. Alguns marcadores de posição são definidos com os valores pré-preenchidos do arquivo de configuração do cluster gerado, mas todos os marcadores são editáveis.

Informações básicas do cluster
O nome do cluster de administrador que você está criando. O local e os nomes dos artefatos do cluster na estação de trabalho do administrador são baseados no nome do cluster. O namespace do cluster é derivado do nome do cluster.	`ADMIN_CLUSTER_NAME`
O nome do cluster de usuário que você está criando. O local e os nomes dos artefatos do cluster na estação de trabalho do administrador são baseados no nome do cluster. O namespace do cluster é derivado do nome do cluster.	`USER_CLUSTER_NAME`
A versão de `bmctl` de que você fez o download na primeira parte deste guia.	`CLUSTER_VERSION`
Informações da conta
O caminho para o arquivo de chave privada SSH na estação de trabalho do administrador. Por padrão, o caminho é `/home/USERNAME/.ssh/id_rsa`.	`SSH_PRIVATE_KEY_PATH`
O ID do projeto do Google Cloud que você quer usar para conectar seu cluster ao Google Cloud e visualizar registros e métricas. Esse projeto é chamado de projeto host da frota.	`PROJECT_ID`
O endereço de e-mail associado à sua conta do Google Cloud. Por exemplo, `alex@example.com`.	`GOOGLE_ACCOUNT_EMAIL`
Endereços IP da máquina do nó
Um endereço IP para o nó do plano de controle do cluster de administrador.	`ADMIN_CP_NODE_IP`
Um endereço IP para o nó do plano de controle do cluster de usuário.	`USER_CP_NODE_IP`
Um endereço IP para o nó de trabalho do cluster de usuário.	`USER_WORKER_NODE_IP`
Endereços VIP
VIP para o servidor da API Kubernetes do cluster de administrador.	`ADMIN_CP_VIP`
VIP para o servidor da API Kubernetes do cluster de usuário.	`USER_CP_VIP`
Um VIP para usar como o endereço externo do proxy de entrada.	`USER_INGRESS_VIP`
Intervalo de 10 endereços IP para uso como endereços IP externos para Serviços do tipo LoadBalancer. Observe que esse intervalo inclui o VIP de entrada, que é necessário ao MetalLB. Nenhum outro endereço IP pode se sobrepor a esse intervalo.	`START_IP-END_IP`
CIDRs de pod e Serviço
Intervalo de endereços IP na notação de bloco CIDR para uso por pods no cluster de administrador. O valor inicial recomendado, que vem preenchido automaticamente no arquivo de configuração do cluster gerado, é `192.168.0.0/16`.	`192.168.0.0/16`
Intervalo de endereços IP na notação de bloco CIDR para uso por Serviços no cluster de administrador. O valor inicial recomendado, que vem preenchido automaticamente no arquivo de configuração do cluster gerado, é `10.96.0.0/20`.	`10.96.0.0/20`
Intervalo de endereços IP na notação de bloco CIDR para uso por pods no cluster de usuário. O valor inicial recomendado, que vem preenchido automaticamente no arquivo de configuração do cluster gerado, é `192.168.0.0/16`.	`192.168.0.0/16`
Intervalo de endereços IP na notação de bloco CIDR para uso por Serviços no cluster de usuário. O valor inicial recomendado, que vem preenchido automaticamente no arquivo de configuração do cluster gerado, é `10.96.0.0/20`.	`10.96.0.0/20`

2. Criar um cluster de administrador

As etapas a seguir criam um cluster de administrador para uma instalação mínima de cluster de administrador e cluster de usuário. Verifique se você informou os valores para cada marcador de posição na tabela na seção anterior Coletar informações antes de prosseguir.

Para criar um cluster de administrador para a instalação mínima:

Use o comando a seguir para definir as credenciais padrão que o GKE em Bare Metal pode usar para criar o cluster:
```
gcloud auth application-default login
```
Para gerar um arquivo de configuração do cluster, execute o seguinte comando no diretório /baremetal na estação de trabalho do administrador:
```
bmctl create config -c ADMIN_CLUSTER_NAME \
    --enable-apis --create-service-accounts --project-id=PROJECT_ID
```

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

O arquivo de configuração do cluster a seguir é preenchido com os valores inseridos na tabela de planejamento na seção anterior. 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 especificação NodePool foi removida. Os nós de trabalho não são permitidos em um cluster de administrador.

gcrKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-gcr.json
sshPrivateKeyPath: SSH_PRIVATE_KEY_PATH
gkeConnectAgentServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-connect.json
gkeConnectRegisterServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-register.json
cloudOperationsServiceAccountKeyPath: bmctl-workspace/.sa-keys/PROJECT_ID-anthos-baremetal-cloud-ops.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: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: ADMIN_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: ADMIN_CP_VIP
  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: 250

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.
Para criar o cluster de administrador, execute o seguinte comando no diretório /baremetal na estação de trabalho do 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/ADMIN_CLUSTER_NAME/log na estação de trabalho do administrador.

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

Verifique se o cluster foi criado e está em execução:

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

Se o cluster estiver em execução, a resposta será parecida com esta:

NAME     STATUS  ROLES          AGE  VERSION
node-01  Ready   control-plane  16h  v1.25.7-gke.1000

Para conceder à sua conta de usuário o papel clusterrole/cluster-admin do Kubernetes no cluster, execute o seguinte comando gcloud:

gcloud container fleet memberships generate-gateway-rbac \
    --membership=ADMIN_CLUSTER_NAME \
    --role=clusterrole/cluster-admin \
    --users=GOOGLE_ACCOUNT_EMAIL \
    --project=PROJECT_ID \
    --kubeconfig=bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig \
    --context=ADMIN_CLUSTER_NAME-admin@ADMIN_CLUSTER_NAME \
    --apply

A saída desse comando é semelhante à seguinte, truncada para facilitar a leitura:

Validating input arguments.
Specified Cluster Role is: clusterrole/cluster-admin
Generated RBAC policy is:
--------------------------------------------
...

Applying the generate RBAC policy to cluster with kubeconfig: /root/bmctl-workspace/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>/<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-kubeconfig, context: <var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>-admin@<var class="edit"scope="ADMIN_CLUSTER_NAME">ADMIN_CLUSTER_NAME</var>
Writing RBAC policy for user: GOOGLE_ACCOUNT_EMAIL to cluster.
Successfully applied the RBAC policy to cluster.

Entre outras coisas, a política do RBAC permite fazer login no cluster no console do Google Cloud para ver mais detalhes do cluster.

Opcionalmente, registre o cluster na API GKE On-Prem. Essa API hospedada no Google Cloud permite gerenciar o ciclo de vida do cluster de administrador usando o console do Google Cloud ou a gcloud CLI.

gcloud container bare-metal admin-clusters enroll ADMIN_CLUSTER_NAME  \
    --project=PROJECT_ID \
    --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
    --location=us-central1

3. Criar um cluster de usuário

As etapas a seguir criam um cluster de usuário para uma instalação mínima de cluster de administrador e cluster de usuário. Verifique se você informou os valores para cada marcador de posição na tabela na seção anterior Coletar informações antes de prosseguir.

Se você usar o Terraform para criar o cluster de usuário, o cluster será automaticamente registrado na API GKE On-Prem. Essa API hospedada no Google Cloud permite gerenciar o ciclo de vida do cluster usando o console do Google Cloud, a gcloud CLI e o Terraform. Se você usar bmctl, será possível registrar o cluster na API GKE On-Prem depois que ele for criado.

Para criar um cluster de usuário para a instalação mínima:

`bmctl`

Gere um arquivo de configuração do cluster:

bmctl create config -c USER_CLUSTER_NAME \
  --project-id=PROJECT_ID

Verifique o arquivo de configuração do cluster de usuário:

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.
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 no console do Google Cloud para ver mais detalhes do cluster.

---
apiVersion: v1
kind: Namespace
metadata:
  name: cluster-USER_CLUSTER_NAME
---
apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: USER_CLUSTER_NAME
  namespace: cluster-USER_CLUSTER_NAME
spec:
  type: user
  profile: default
  anthosBareMetalVersion: CLUSTER_VERSION
  gkeConnect:
    projectID: PROJECT_ID
  controlPlane:
    nodePoolSpec:
      nodes:
      - address: USER_CP_NODE_IP
  clusterNetwork:
    pods:
      cidrBlocks:
      - 192.168.0.0/16
    services:
      cidrBlocks:
      - 10.96.0.0/20
  loadBalancer:
    mode: bundled
    ports:
      controlPlaneLBPort: 443
    vips:
      controlPlaneVIP: USER_CP_VIP
      ingressVIP: USER_INGRESS_VIP
    addressPools:
    - name: pool1
      addresses:
      - START_IP-END_IP
  clusterOperations:
    projectID: PROJECT_ID
    location: us-central1
  clusterSecurity:
    authorization:
      clusterAdmin:
        gcpAccounts:
        - GOOGLE_ACCOUNT_EMAIL
  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-USER_CLUSTER_NAME
spec:
  clusterName: USER_CLUSTER_NAME
  nodes:
  - address: USER_WORKER_NODE_IP

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/USER_CLUSTER_NAME/USER_CLUSTER_NAME.yaml, e substitua o conteúdo dele pelo conteúdo do exemplo que você verificou na etapa anterior.
Crie o cluster de usuário:
```
bmctl create cluster -c USER_CLUSTER_NAME \
--kubeconfig ADMIN_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/USER_CLUSTER_NAME/log na estação de trabalho do administrador.

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

Verifique se o cluster foi criado e está em execução:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-kubeconfig \
  get nodes

Se o cluster estiver em execução, a resposta será parecida com esta:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Opcionalmente, registre o cluster na API GKE On-Prem:

gcloud container bare-metal clusters enroll USER_CLUSTER_NAME  \
  --project=PROJECT_ID \
  --admin-cluster-membership=projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME \
  --location=us-central1

Console

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

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

Acesse "Criar um cluster do GKE em bare metal
Verifique se a lista de projetos do Google Cloud tem PROJECT_ID selecionado.
Em Escolher o tipo de cluster, selecione Criar um cluster de usuário para um cluster de administrador já existente
Clique em Próxima.

Noções básicas sobre clusters

Digite USER_CLUSTER_NAME como o nome do cluster de usuário ou use o padrão.
Verifique se o cluster de administrador recém-criado está selecionado.
Em Local da API GCP, selecione us-central1.
Em GDCV para versão Bare Metal, selecione CLUSTER_VERSION ou use o padrão. Você pode usar os padrões para o restante das configurações nesta página.
Clique em Rede na barra de navegação à esquerda.

Rede

Na seção Plano de controle, insira o seguinte IP no campo IP do nó do plano de controle 1.
```
USER_CP_NODE_IP
```
Na seção Balanceador de carga, use o balanceador de carga padrão, Incorporado com MetalLB.
Acesse a seção Novo pool de endereços. Insira o intervalo de endereços IP no campo Intervalo de endereços IP 1:
```
10.200.0.51-10.200.0.70
```
Clique em Concluído.
Na seção IPs virtuais, insira o endereço IP do VIP do plano de controle:
```
USER_CP_VIP
```
Insira o endereço IP para o VIP de entrada:
```
USER_INGRESS_VIP
```
Na seção CIDRs do serviço e do pod, se você não alterou os CIDRs do serviço e do pod no planejador, é possível usar os padrões.

Se você tiver alterado os CIDRs, insira aqueles que quer usar:
- CIDR de serviço:
```
10.96.0.0/20
```
- CIDR do pod:
```
192.168.0.0/16
```
Clique em Pool padrão na barra de navegação à esquerda.

Criar um pool de nós

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

Digite o endereço IP do nó de trabalho do cluster de usuário no campo Endereço de nós 1:

USER_WORKER_NODE_IP

Crie o cluster

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.
Depois que o cluster for criado, clique em Clusters para voltar à página Clusters.

CLI da gcloud

Nesta seção, mostramos como criar um cluster de usuário e um pool de nós usando a gcloud CLI.

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

gcloud container bare-metal clusters create USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --admin-cluster-membership=ADMIN_CLUSTER_NAME \
  --admin-cluster-membership-project=PROJECT_ID \
  --admin-cluster-membership-location=global \
  --version=CLUSTER_VERSION \
  --admin-users=GOOGLE_ACCOUNT_EMAIL \
  --island-mode-service-address-cidr-blocks=10.96.0.0/20 \
  --island-mode-pod-address-cidr-blocks=192.168.0.0/16 \
  --metal-lb-address-pools='pool=lb-pool-1,manual-assign=True,addresses=START_IP-END_IP' \
  --control-plane-node-configs='node-ip=USER_CP_NODE_IP' \
  --control-plane-vip=USER_CP_VIP \
  --control-plane-load-balancer-port=443 \
  --ingress-vip=USER_INGRESS_VIP \
  --lvp-share-path=/mnt/localpv-share \
  --lvp-share-storage-class=local-shared \
  --lvp-node-mounts-config-path=/mnt/localpv-disk \
  --lvp-node-mounts-config-storage-class=local-disks

A 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 com o seguinte comando:

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

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/us-central1/bareMetalClusters/USER_CLUSTER_NAME].

Depois que o cluster for criado, execute o comando a seguir para criar um pool de nós no cluster recém-criado.

gcloud container bare-metal node-pools create node-pool-1 \
  --cluster=USER_CLUSTER_NAME \
  --project=PROJECT_ID \
  --location=us-central1 \
  --node-configs node-ip=USER_WORKER_NODE_IP

Para mais informações e outros exemplos, consulte os seguintes artigos:

Terraform

Nesta seção, mostramos como criar um cluster de usuário e um pool de nós usando o Terraform.

Crie um diretório e um novo arquivo nele. O nome do arquivo precisa ter a extensão .tf. Neste guia, o arquivo é chamado de main.tf.
```
mkdir DIRECTORY && cd DIRECTORY && touch main.tf
```

Verifique o recurso do Terraform do cluster de usuário:

O exemplo de recurso do Terraform a seguir é preenchido com os valores inseridos na tabela de planejamento na seção anterior.

resource "google_gkeonprem_bare_metal_cluster"  "cluster-basic" {
  provider = google-beta
  name = "USER_CLUSTER_NAME"
  project = "PROJECT_ID"
  location = "us-central1"
  admin_cluster_membership = "projects/PROJECT_ID/locations/global/memberships/ADMIN_CLUSTER_NAME"
  bare_metal_version = "CLUSTER_VERSION"
  network_config {
    island_mode_cidr {
      service_address_cidr_blocks = ["10.96.0.0/20"]
      pod_address_cidr_blocks = ["192.168.0.0/16"]
    }
  }
  control_plane {
    control_plane_node_pool_config {
      node_pool_config {
        labels = {}
        operating_system = "LINUX"
        node_configs {
          labels = {}
          node_ip = "USER_CP_NODE_IP"
        }
      }
    }
  }
  load_balancer {
    port_config {
      control_plane_load_balancer_port = 443
    }
    vip_config {
      control_plane_vip = "USER_CP_VIP"
      ingress_vip = "USER_INGRESS_VIP"
    }
    metal_lb_config {
      address_pools {
        pool = "pool1"
        addresses = [
          "START_IP-END_IP"
        ]
        avoid_buggy_ips = true
        manual_assign = true
      }
    }
  }
  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"
    }
  }
  security_config {
    authorization {
      admin_users {
        username = "GOOGLE_ACCOUNT_EMAIL"
      }
    }
  }
}

resource "google_gkeonprem_bare_metal_node_pool" "node-pool-default" {
  provider = google-beta
  name =  "node-pool-1"
  bare_metal_cluster = google_gkeonprem_bare_metal_cluster.cluster-basic.name
  project = "PROJECT_ID"
  location = "us-central1"
  node_pool_config {
    operating_system = "LINUX"
    node_configs {
      node_ip = "USER_WORKER_NODE_IP"
    }
  }
}

Copie o recurso do Terraform para main.tf e salve o arquivo.
Inicialize e crie o plano do Terraform:
```
terraform init
```
O Terraform instala todas as bibliotecas necessárias, como o provedor do Google Cloud.
Revise a configuração e faça alterações, se necessário:
```
terraform plan
```
Aplique o plano do Terraform para criar o cluster de usuário:
```
terraform apply
```
Quando solicitado, digite yes.

Leva cerca de 15 minutos (ou mais, dependendo da rede) para criar o cluster de usuário básico e o pool de nós.
Para criar um arquivo kubeconfig para o cluster de usuário, execute o seguinte comando na estação de trabalho do administrador:
```
bmctl get credentials --cluster USER_CLUSTER_NAME \
--admin-kubeconfig bmctl-workspace/ADMIN_CLUSTER_NAME/ADMIN_CLUSTER_NAME-kubeconfig
```
A saída do comando exibe o nome do arquivo kubeconfig do cluster de usuário. Por exemplo:
```
bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig
```
O TIMESTAMP no nome do arquivo indica a data e a hora em que o arquivo foi criado.

Como esse arquivo contém credenciais de autenticação para o cluster, armazene-o em um local seguro com acesso restrito.

Verifique se o cluster foi criado e está em execução:

kubectl --kubeconfig bmctl-workspace/USER_CLUSTER_NAME/USER_CLUSTER_NAME-TIMESTAMP-kubeconfig \
    get nodes

Se o cluster estiver em execução, a resposta será parecida com esta:

NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001

Para mais informações e outros exemplos, consulte os seguintes artigos:

conecte-se ao cluster de usuário

Se você criou o cluster de usuário usando bmctl, seu endereço de e-mail será incluído na seção clusterSecurity do exemplo do arquivo de configuração de usuário. Se você criou o cluster usando o Terraform, seu endereço de e-mail será incluído na seção security_config do exemplo de recurso google_gkeonprem_bare_metal_cluster. Esses exemplos configuram políticas de controle de acesso baseado em função (RBAC) para você, com as seguintes ações:

Conceder a você o papel clusterrole/cluster-admin do Kubernetes no cluster.
permitir que você faça login no cluster no console do Google Cloud usando sua identidade do Google. É possível visualizar o cluster na página Clusters do GKE no console.
Permitir executar comandos kubectl no computador local usando o kubeconfig do gateway do Connect.

Para encontrar o kubeconfig do gateway do Connect, execute os seguintes comandos no computador local:

Encontre a entrada kubeconfig que pode acessar o cluster pelo gateway do Connect.

gcloud container fleet memberships get-credentials USER_CLUSTER_NAME  \
--project=PROJECT_ID

O resultado será assim:

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

Agora é possível executar comandos kubectl pelo gateway de conexão:
```
kubectl get nodes
```
O resultado será assim:
```
NAME    STATUS   ROLES           AGE     VERSION
nuc-3   Ready    control-plane   4m32s   v1.26.2-gke.1001
nuc-4   Ready    worker          2m2s    v1.26.2-gke.1001
```
Muitos comandos kubectl exigem o kubeconfig do cluster de administrador. Será necessário executar esses comandos na estação de trabalho do administrador.

A seguir

Crie um serviço e uma entrada
Saiba mais:
- O recurso do Terraform google_gkeonprem_bare_metal_cluster
- O gateway do Connect