Como instalar usando DHCP

Nesta página, explicamos como instalar o GKE On-Prem em um ambiente do VMware vSphere 6.5 usando um servidor do Dynamic Host Configuration Protocol (DHCP) para atribuir endereços IP aos nós do cluster. Também é possível instalar usando IPs estáticos.

Visão geral

Nas instruções desta página, você verá como criar um cluster de administrador e um cluster de usuário com três nós. Cada nó é executado em uma máquina virtual (VM) em um cluster do vSphere e cada nó tem um endereço IP atribuído a ele por um servidor DHCP no ambiente.

Depois de criar os clusters, é possível criar outros clusters de usuário e adicionar ou remover nós de um cluster de usuário.

Antes de começar

  1. Configure seu ambiente no local conforme descrito em Requisitos do sistema.

  2. Complete os procedimentos em Como preparar para instalar.

  3. Crie uma estação de trabalho de administrador no vSphere.

  4. Conecte-se à sua estação de trabalho do administrador:

    ssh -i ~/.ssh/vsphere_workstation ubuntu@[IP_ADDRESS]

  5. Se você estiver usando um proxy, precisará configurar a Google Cloud CLI para o proxy se quiser executar os comandos gcloud e gsutil. Para mais instruções, consulte Como configurar a CLI gcloud para que seja usada com um proxy/firewall.

  6. Faça login no Google Cloud usando as credenciais da sua conta:

    gcloud auth login

  7. Registre gcloud como um auxiliar de credenciais do Docker (Leia mais sobre este comando):

    gcloud auth configure-docker

  8. Configure um projeto padrão. Isso faz com que todos os comandos da CLI gcloud sejam executados no projeto, de modo que você não precise especificar o projeto para cada comando:

    gcloud config set project [PROJECT_ID]

    Substitua [PROJECT_ID] pelo ID do projeto. É possível encontrar o ID do projeto no console do Google Cloud ou ao executar gcloud config get-value project.

Como usar reservas de DHCP em nós de cluster

No Kubernetes, é importante que os endereços IP do nó nunca mudem. Se um endereço IP de nó for alterado ou ficar indisponível, ele poderá interromper o cluster. Para evitar isso, considere o uso de reservas de DHCP para atribuir nós de endereços permanentes nos clusters de administrador e de usuário. O uso de reservas do DHCP garante que cada nó receba os mesmos endereços IP após a reinicialização ou a renovação do lease.

Como escolher um registro de imagem de contêiner para instalação

Para a instalação, o GKE On-Prem precisa saber onde receber os componentes do cluster em contêiner. Você tem duas opções:

Container Registry

Por padrão, o GKE On-Prem usa um registro de imagem de contêiner do Google hospedado pelo Container Registry. Não é necessário fazer outras configurações: basta configurar o proxy para permitir o tráfego do gcr.io.

Registro particular do Docker

É possível optar por um registro particular do Docker para instalação. O GKE On-Prem envia os componentes do cluster para esse registro do Docker.

Antes de instalar, você precisa configurar o registro. Durante a instalação, preencha o arquivo de configuração do GKE On-Prem com informações sobre o registro.

Como configurar um registro particular do Docker para instalação (opcional)

Nesta seção, explicamos como configurar um registro do Docker para instalar o GKE On-Prem. Para saber como criar um registro do Docker, consulte Executar um registro acessível externamente. Depois de configurar o registro, preencha o campo privateregistryconfig do arquivo de configuração do GKE On-Prem.

Se você quiser usar o registro particular do Docker para instalação, a VM da estação de trabalho do administrador precisará confiar na CA que assinou o certificado. O GKE On-Prem não é compatível com registros do Docker não seguros. Ao iniciar o registro do Docker, forneça um certificado e uma chave. O certificado pode ser assinado por uma autoridade de certificação (CA) pública ou autoassinado.

Para estabelecer essa confiança, execute as seguintes etapas na VM da estação de trabalho do administrador:

  1. Crie uma pasta para manter o certificado:

    sudo mkdir -p /etc/docker/certs.d/[REGISTRY_SERVER]

    [REGISTRY_SERVER] é o endereço IP ou o nome do host da VM que executa o registro do Docker.

  2. Copie o arquivo de certificado para /etc/docker/certs.d/[REGISTRY_SERVER]/ca.crt. Você precisa nomear o arquivo ca.crt, mesmo que ele tenha outro nome.

  3. Reinicie o serviço do Docker:

    sudo service docker restart

  4. Verifique se é possível fazer login no Docker:

    docker login -u [USERNAME] -p [PASSWORD] [REGISTRY_SERVER]

    [USERNAME] e [PASSWORD] são as credenciais para fazer login no registro do Docker.

Agora, quando você executa gkectl prepare durante a instalação, as imagens necessárias são enviadas para o registro do Docker.

Solução de problemas da configuração do registro

  • GET https://[REGISTRY_SERVER]/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers): verifique se você tem o endereço IP correto para a VM que executa o registro do Docker.

  • login attempt to https://[REGISTRY_SERVER]/v2/ failed with status: 401 Unauthorized: verifique se o nome de usuário e a senha estão corretos.

  • GET https://[REGISTRY_SERVER]/v1/users/: x509: certificate signed by unknown authority: a VM da estação de trabalho do administrador não confia no certificado.

Criar chaves privadas de contas de serviço na estação de trabalho de administrador

Em Como se preparar para a instalação, você criou quatro contas de serviço. Agora, você precisa criar um arquivo de chave privada JSON para cada uma dessas contas de serviço. Você fornecerá essas chaves durante a instalação.

Listar endereços de e-mail de contas de serviço

Primeiro, liste as contas de serviço no projeto do Google Cloud:

gcloud iam service-accounts list

Para um projeto do Google Cloud denominado my-gcp-project, a saída deste comando terá esta aparência:

gcloud iam service-accounts list
NAME                                    EMAIL
                                        access-service-account@my-gcp-project.iam.gserviceaccount.com
                                        register-service-account@my-gcp-project.iam.gserviceaccount.com
                                        connect-service-account@my-gcp-project.iam.gserviceaccount.com
                                        stackdriver-service-account@my-gcp-project.iam.gserviceaccount.com

Anote o endereço de e-mail de cada conta. Para cada uma das seções a seguir, você fornece a conta de e-mail da conta relevante.

Acessar conta de serviço

gcloud iam service-accounts keys create access-key.json \
--iam-account [ACCESS_SERVICE_ACCOUNT_EMAIL]

em que [ACCESS_SERVICE_ACCOUNT_EMAIL] é o endereço de e-mail da conta de serviço de acesso.

Registrar conta de serviço

gcloud iam service-accounts keys create register-key.json \
--iam-account [REGISTER_SERVICE_ACCOUNT_EMAIL]

[REGISTER_SERVICE_ACCOUNT_EMAIL] é o endereço de e-mail da conta de serviço de registro.

Conectar conta de serviço

gcloud iam service-accounts keys create connect-key.json \
--iam-account [CONNECT_SERVICE_ACCOUNT_EMAIL]

[CONNECT_SERVICE_ACCOUNT_EMAIL] é o endereço de e-mail da conta de serviço de conexão.

Conta de serviço do Cloud Monitoring

gcloud iam service-accounts keys create stackdriver-key.json \
--iam-account [STACKDRIVER_SERVICE_ACCOUNT_EMAIL]

[STACKDRIVER_SERVICE_ACCOUNT_EMAIL] é o endereço de e-mail da conta de serviço do Cloud Monitoring.

Como ativar a conta de serviço de acesso para a Google Cloud CLI

Ativar a conta de serviço de acesso para a gcloud CLI faz com que todos os comandos gcloud e gsutil sejam executados como essa conta de serviço. Como a conta de serviço de acesso tem permissão para acessar os binários do GKE On-Prem, ativar a conta para a gcloud CLI concede a você permissão para fazer o download dos binários do GKE On-Prem no Cloud Storage.

Para ativar a conta de serviço de acesso, execute o seguinte comando. Informe o caminho para o arquivo de chave da conta, se ele não estiver no diretório de trabalho atual:

gcloud auth activate-service-account --key-file=access-key.json

Como gerar um arquivo de configuração

Para iniciar uma instalação, execute gkectl create-config para gerar um arquivo de configuração. Modifique o arquivo com as especificações do ambiente e com as especificações do cluster que você quer.

Para gerar o arquivo, execute o seguinte comando, em que --config [PATH] é opcional e aceita um caminho e um nome para o arquivo de configuração. Omitir --config cria config.yaml no diretório de trabalho atual:

gkectl create-config [--config [PATH]]

Como modificar o arquivo de configuração

Agora que você gerou o arquivo de configuração, é necessário modificá-lo para que se adeque ao ambiente e atenda às expectativas dos clusters. As seções a seguir explicam cada campo, os valores esperados e onde é possível encontrar as informações. Alguns campos são comentados por padrão. Se alguns campos forem relevantes para a instalação, remova a marca de comentário e insira valores.

bundlepath

Um pacote do GKE On-Prem é um conjunto de arquivos YAML. Coletivamente, os arquivos YAML descrevem todos os componentes em uma versão específica do GKE On-Prem.

Quando você cria uma estação de trabalho de administrador, ela vem com um pacote em /var/lib/gke/bundles/gke-onprem-vsphere-[VERSION]-full.tgz. A versão deste pacote corresponde à versão do OVA que você usou para criar a estação de trabalho do administrador.

Defina o valor de bundlepath como o caminho do arquivo de pacote da estação de trabalho do administrador. Ou seja, defina bundlepath como:

/var/lib/gke/bundles/gke-onprem-vsphere-[VERSION]-full.tgz

em que [VERSION] é a versão do GKE On-Prem que você está instalando. A versão mais recente é 1.1.2-gke.0.

É possível manter seu arquivo de pacote em um local diferente ou atribuir outro nome. No arquivo de configuração, verifique se o valor de bundlepath é o caminho para o arquivo de pacote, seja ele qual for.

Especificação do vCenter

A especificação do servidor vCenter, vcenter, contém informações sobre a instância do servidor vCenter que o GKE On-Prem precisa instalar no ambiente.

vcenter.credentials.address

O campo vcenter.credentials.address contém o endereço IP ou o nome do host do servidor vCenter.

Antes de preencher o vsphere.credentials.address field, faça o download do certificado de exibição do servidor vCenter e inspecione-o. Digite o comando a seguir para fazer o download do certificado e salvá-lo em um arquivo chamado vcenter.pem.

true | openssl s_client -connect [VCENTER_IP]:443 -showcerts 2>/dev/null | sed -ne '/-BEGIN/,/-END/p' > vcenter.pem

Abra o arquivo de certificado para ver o nome comum e o alternativo do assunto:

openssl x509 -in vcenter.pem -text -noout

A saída mostra o nome comum (CN, na sigla em inglês) Subject. Pode ser um endereço IP ou um nome do host. Exemplo:

Subject: ... CN = 203.0.113.100
 
Subject: ... CN = my-host.my-domain.example

A saída também pode incluir um ou mais nomes de DNS em Subject Alternative Name:

X509v3 Subject Alternative Name:
    DNS:vcenter.my-domain.example

Escolha o nome comum Subject ou um dos nomes de DNS em Subject Alternative Name para usar como o valor de vcenter.credentials.address no arquivo de configuração. Por exemplo:

vcenter:
  credentials:
    address: "203.0.113.1"
    ...

vcenter:
  credentials:
    address: "my-host.my-domain.example"
    ...

Você precisa escolher um valor que apareça no certificado. Por exemplo, se o endereço IP não aparecer no certificado, não será possível usá-lo para vcenter.credentials.address.

vcenter.credentials

O GKE On-Prem precisa saber o nome de usuário e a senha do servidor vCenter. Para fornecer essas informações, defina os valores username e password em vcenter.credentials. Por exemplo:

vcenter:
  credentials:
    ...
    username: "my-name"
    password: "my-password"

vcenter.datacenter, .datastore, .cluster, .network

O GKE On-Prem precisa de algumas informações sobre a estrutura do ambiente do vSphere. Defina os valores em vcenter para especificar essas informações. Por exemplo:

vcenter:
  ...
  datacenter: "MY-DATACENTER"
  datastore: "MY-DATASTORE"
  cluster: "MY-VSPHERE-CLUSTER"
  network: "MY-VIRTUAL-NETWORK"

vcenter.resourcepool

Um pool de recursos do vSphere é um agrupamento lógico de VMs no cluster do vSphere. Se você estiver usando um pool de recursos diferente do padrão, forneça um nome para vcenter.resourcepool. Por exemplo:

vcenter:
  ...
  resourcepool: "my-pool"

Se você quiser que o GKE On-Prem local implante os nós no pool de recursos padrão do cluster do vSphere, forneça uma string vazia para vcenter.resourcepool. Por exemplo:

vcenter:
  ...
  resourcepool: ""

vcenter.datadisk

O GKE On-Prem cria um disco de máquina virtual (VMDK) a fim de armazenar os dados do objeto do Kubernetes para o cluster de administrador. O instalador cria o VMDK para você, mas é necessário fornecer um nome para o VMDK no campo vcenter.datadisk. Exemplo:

vcenter:
  ...
  datadisk: "my-disk.vmdk"
Armazenamento de dados vSAN: como criar uma pasta para o VMDK

Se você estiver usando um armazenamento de dados vSAN, será necessário colocar o VMDK em uma pasta. Você precisa criar a pasta manualmente com antecedência. Para fazer isso, use govc para criar uma pasta:

govc datastore.mkdir my-gke-on-prem-folder

Atualmente, um problema conhecido exige que você forneça o caminho do identificador universal exclusivo (UUID) da pasta, em vez do caminho do arquivo, para vcenter.datadisk. Para encontrar o UUID da pasta, abra o cliente do vCenter, selecione o armazenamento de dados e a pasta de seleção. Copie o UUID da pasta. Também é possível executar o seguinte comando, em que [ADMIN_CONTROL_PLANE_VM] é a VM do vSphere que executa o plano de controle do administrador:

govc vm.info -json ./vm/[ADMIN_CONTROL_PLANE_VM] | jq '.VirtualMachines[0].Config.Hardware.Device[] | select(.Backing | has("FileName")) | .Backing.FileName'

Em seguida, forneça o UUID da pasta no campo vcenter.datadisk. Por exemplo:

vcenter:
...
datadisk: "14159b5d-4265-a2ba-386b-246e9690c588/my-disk.vmdk"

vcenter.cacertpath

Quando um cliente, como o GKE On-Prem, envia uma solicitação ao vCenter Server, o servidor precisa comprovar a identidade ao cliente por meio de um certificado. O certificado é assinado por uma autoridade de certificação (CA). O cliente verifica o certificado do servidor usando o certificado da CA.

Defina vcenter.cacertpath como o caminho do certificado da CA. Por exemplo:

vcenter:
  ...
  cacertpath: "/my-cert-folder/altostrat.crt"

Independentemente de o servidor vCenter usar um certificado autoassinado ou um certificado assinado por uma CA pública, execute o comando a seguir na estação de trabalho do administrador para receber o certificado da CA:

true | openssl s_client -connect [VCENTER_IP]:443 -showcerts 2>/dev/null | sed -ne '/-BEGIN/,/-END/p' > vcenter.pem

[VCENTER_IP] é o endereço IP do servidor vCenter.

Especificação de proxy

O campo proxy contém informações do proxy HTTPS fornecido pelo usuário e os endereços que precisam ser excluídos do proxy. Por exemplo:

proxy:
  url: "https://password:username@domain"
  noproxy: "100.151.222.0/24,corp.domain,100.151.2.1"
  • proxy.url é o URL do proxy HTTPS.
  • proxy.noproxy inclui o CIDR, os domínios e os endereços IP que não precisam usar o proxy. Normalmente, isso inclui a sub-rede vSphere e o endereço de registro particular se você estiver usando um registro particular do Docker.

Especificação do cluster de administrador

A especificação do cluster de administrador, admincluster, contém informações que o GKE On-Prem precisa para criar o cluster de administrador.

admincluster.vcenter.network

Em admincluster.vcenter.network, é possível especificar uma rede vCenter para os nós do cluster de administrador. Isso modifica a configuração global que você forneceu em vcenter. Por exemplo:

admincluster:
  vcenter:
    network: MY-ADMIN-CLUSTER-NETWORK

admincluster.ipblockfilepath

Esse campo será usado se você estiver usando IPs estáticos. Como você está usando um servidor DHCP para alocar endereços IP, deixe o campo admincluster.ipblockfilepath com marca de comentário.

admincluster.bigip.credentials (modo de balanceamento de carga integrado)

Se você estiver usando o modo de balanceamento de carga integrado, o GKE On-Prem precisará saber o endereço IP ou o nome do host, o nome de usuário e a senha do balanceador de carga F5 BIG-IP. Defina os valores em admincluster.bigip para fornecer essas informações. Por exemplo:

admincluster:
  ...
  bigip:
    credentials:
      address: "203.0.113.2"
      username: "my-admin-f5-name"
      password: "rJDlm^%7aOzw"

admincluster.bigip.credentials (modo de balanceamento de carga integrado)

Se estiver usando o modo de balanceamento de carga integrado, você precisará criar uma partição BIG-IP para o cluster de administrador. Defina admincluster.bigip.partition como o nome da partição. Por exemplo:

admincluster:
  ...
  bigip:
    partition: "my-admin-f5-partition"

admincluster.vips

Defina o valor de admincluster.vips.controlplanevip como o endereço IP que você escolheu configurar no balanceador de carga para o servidor da API Kubernetes do cluster de administrador. Defina o valor de ingressvip como o endereço IP que você escolheu configurar no balanceador de carga para o controlador de entrada do cluster de administrador. Por exemplo:

admincluster:
  ...
  vips:
    controlplanevip: 203.0.113.3
    ingressvip: 203.0.113.4

admincluster.serviceiprange e admincluster.podiprange

O cluster de administrador precisa ter um intervalo de endereços IP para usar em serviços e um para usar em pods. Esses intervalos são especificados pelos campos admincluster.serviceiprange e admincluster.podiprange. Esses campos são preenchidos quando você executa gkectl create-config. Se quiser, é possível alterar os valores preenchidos para valores de sua escolha.

Os intervalos de serviços e pods não podem se sobrepor. Além disso, os intervalos de serviços e pods não podem se sobrepor a endereços IP usados para nós em nenhum cluster.

Exemplo:

admincluster:
  ...
  serviceiprange: 10.96.232.0/24
  podiprange: 192.168.0.0/16

Especificação do cluster de usuário

A especificação do cluster de usuário, usercluster, contém informações que o GKE On-Prem precisa para criar o cluster de usuário inicial.

Como desativar regras antiafinidade do VMware DRS (opcional)

A partir da versão 1.1.0-gke.6, o GKE On-Prem cria automaticamente regras de antiafinidade do VMware Distributed Resource Scheduler (DRS) para os nós do cluster de usuário, fazendo com que eles sejam distribuídos por pelo menos três hosts físicos no seu data center. A partir da versão 1.1.0-gke.6, esse recurso é ativado automaticamente para novos clusters e clusters atuais.

Esse recurso exige que o ambiente vSphere atenda às seguintes condições

  • O VMware DRS está ativado. O VMware DRS requer a edição de licença do vSphere Enterprise Plus. Consulte Como criar um cluster do DRS para saber como ativá-lo.
  • A conta de usuário do vSphere fornecida no campo vcenter tem a permissão Host.Inventory.EditCluster.
  • Há pelo menos três hosts físicos disponíveis.

Se você não tiver o DRS ativado ou se não tiver pelo menos três hosts para os quais as VMs do vSphere podem ser programadas, adicione usercluster.antiaffinitygroups.enabled: false ao arquivo de configuração. Por exemplo:

usercluster:
  ...
  antiaffinitygroups:
    enabled: false
Para clusters que executam mais de três nós
Se o vSphere vMotion mover um nó para outro host, as cargas de trabalho do nó precisarão ser reiniciadas antes de serem distribuídas novamente entre os hosts.

usercluster.vcenter.network

Em usercluster.vcenter.network, é possível especificar uma rede vCenter para os nós do cluster de usuário. Isso modifica a configuração global que você forneceu em vcenter. Por exemplo:

usercluster:
  vcenter:
    network: MY-USER-CLUSTER-NETWORK

usercluster.ipblockfilepath

Esse campo será usado se você estiver usando IPs estáticos. Como você está usando um servidor DHCP para alocar endereços IP, deixe o campo usercluster.ipblockfilepath com marca de comentário.

usercluster.bigip.credentials (modo de balanceamento de carga integrado)

Se você estiver usando o modo de balanceamento de carga integrado, o GKE On-Prem precisará saber o endereço IP ou o nome do host, o nome de usuário e a senha do balanceador de carga F5 BIG-IP que você pretende usar para o cluster de usuário. Defina os valores em usercluster.bigip para fornecer essas informações. Por exemplo:

usercluster:
  ...
  bigip:
    credentials:
      address: "203.0.113.5"
      username: "my-user-f5-name"
      password: "8%jfQATKO$#z"
  ...

usercluster.bigip.partition (modo de balanceamento de carga integrado)

É preciso criar uma partição BIG-IP para o cluster de usuário. Defina usercluster.bigip.partition como o nome da partição. Por exemplo:

usercluster:
  ...
  bigip:
    partition: "my-user-f5-partition"
  ...

usercluster.vips

Defina o valor de usercluster.vips.controlplanevip como o endereço IP que você escolheu configurar no balanceador de carga para o servidor da API Kubernetes do cluster de usuário. Defina o valor de ingressvip como o endereço IP que você escolheu configurar no balanceador de carga para o controlador de entrada do cluster de usuário. Por exemplo:

usercluster:
  ...
  vips:
    controlplanevip: 203.0.113.6
    ingressvip: 203.0.113.7

usercluster.serviceiprange e usercluster.podiprange

O cluster de usuário precisa ter um intervalo de endereços IP para usar em serviços e um para usar em pods. Esses intervalos são especificados pelos campos usercluster.serviceiprange e usercluster.podiprange. Esses campos são preenchidos quando você executa gkectl create-config. Se quiser, é possível alterar os valores preenchidos para valores de sua escolha.

Os intervalos de serviços e pods não podem se sobrepor. Além disso, os intervalos de serviços e pods não podem se sobrepor a endereços IP usados para nós em nenhum cluster.

Exemplo:

usercluster:
  ...
  serviceiprange: 10.96.233.0/24
  podiprange: 172.16.0.0/12

usercluster.clustername

Defina o valor de usercluster.clustername como um nome de sua escolha. Escolha um nome com até 40 caracteres. Por exemplo:

usercluster:
  ...
  clustername: "my-user-cluster-1"

usercluster.masternode.replicas

O campo usercluster.masternode.replicas especifica quantos nós do plano de controle você quer que o cluster do usuário tenha. O nó do plano de controle do cluster de usuário executa o plano de controle do usuário, os componentes do plano de controle do Kubernetes. Esse valor precisa ser 1 ou 3:

usercluster.masternode.cpus e usercluster.masternode.memorymb

Os campos usercluster.masternode.cpus e usercluster.masternode.memorymb especificam o número de CPUs e a quantidade de memória, em megabytes, que são alocadas para cada nó do plano de controle do cluster de usuário. Por exemplo:

usercluster:
  ...
  masternode:
    cpus: 4
    memorymb: 8192

usercluster.workernode.replicas

O campo usercluster.workernode.replicas especifica quantos nós de trabalho você quer que o cluster de usuário tenha. Os nós de trabalho executam as cargas de trabalho do cluster.

usercluster.workernode.cpus e usercluster.workernode.memorymb

Os campos usercluster.masternode.cpus e usercluster.masternode.memorymb especificam quantas CPUs e quanta memória, em megabytes, são alocadas para cada nó de trabalho do cluster de usuário. Por exemplo:

usercluster:
  ...
  workernode:
    cpus: 4
    memorymb: 8192
    replicas: 3

usercluster.oidc

Se você pretende que os clientes do cluster de usuário usem a autenticação OIDC, defina valores para os campos em usercluster.oidc. A configuração do protocolo OIDC é opcional.

Para saber como configurar o OIDC, consulte Como autenticar com o OIDC.

Sobre a instalação da versão 1.0.2-gke.3

A versão 1.0.2-gke.3 introduz os campos OIDC (usercluster.oidc) a seguir. Esses campos permitem fazer login em um cluster do console do Google Cloud:

  • usercluster.oidc.kubectlredirecturl
  • usercluster.oidc.clientsecret
  • usercluster.oidc.usehttpproxy

Na versão 1.0.2-gke.3, se você quiser usar o OIDC, o campo clientsecret será obrigatório, mesmo que você não queira fazer login em um cluster no console do Google Cloud. Nesse caso, forneça um valor de marcador para clientsecret:

oidc:
clientsecret: "secret"

usercluster.sni

A Server Name Indication (SNI), uma extensão do Transport Layer Security (TLS), permite que os servidores apresentem vários certificados em apenas um endereço IP e uma porta TCP, dependendo do nome do host indicado pelo cliente.

Se a CA já estiver distribuída como uma CA confiável para clientes fora do cluster de usuário e você quiser confiar nessa cadeia para identificar clusters confiáveis, configure o servidor da API Kubernetes com um certificado extra que é apresentado a clientes externos do endereço IP do balanceador de carga.

Para usar a SNI com seus clusters de usuário, você precisa ter sua própria CA e infraestrutura de chave pública (ICP). Provisione um certificado de exibição separado para cada cluster de usuário. O GKE On-Prem adicionará cada certificado de exibição adicional ao respectivo cluster de usuário.

Se quiser configurar a SNI para o servidor da API Kubernetes do cluster de usuário, forneça valores para usercluster.sni.certpath (caminho para o certificado externo) e usercluster.sni.keypath (caminho para o arquivo de chave privada do certificado externo). Por exemplo:

usercluster:
  ...
  sni:
    certpath: "/my-cert-folder/example.com.crt"
    keypath: "/my-cert-folder/example.com.key"

lbmode

É possível usar o balanceamento de carga integrado com o DHCP. O modo de balanceamento de carga integrado se aplica ao cluster de administrador e ao cluster de usuário inicial. Isso também se aplicará a todos os outros clusters de usuário que você criar no futuro. O modo de balanceamento de carga integrado é compatível com o uso do F5 BIG-IP como balanceador de carga.

Defina o valor de lbmode como Integrated. Exemplo:

lbmode: Integrated

gkeconnect

A especificação gkeconnect contém informações de que o GKE On-Prem precisa para configurar o gerenciamento dos clusters no local no console do Google Cloud.

Defina gkeconnect.projectid como o ID do projeto do Google Cloud em que você quer gerenciar os clusters locais.

Defina o valor de gkeconnect.registerserviceaccountkeypath como o caminho do arquivo de chave JSON para a conta de serviço de registro. Defina o valor de gkeconnect.agentserviceaccountkeypath como o caminho do arquivo de chave JSON para a conta de serviço de conexão.

Se você quiser que o agente do Connect use um proxy para se comunicar com o Google Cloud, defina o valor de gkeconnect.proxy como o URL do proxy. Use o formato http(s)://[PROXY_ADDRESS].

Exemplo:

gkeconnect:
  projectid: "my-project"
  registerserviceaccountkeypath: "/my-key-folder/register-key.json"
  agentserviceaccountkeypath: "/my-key-folder/connect-key.json"
  proxy: https://203.0.113.20

stackdriver

A especificação stackdriver contém informações que o GKE On-Prem precisa para armazenar entradas de registro geradas pelos clusters no local.

Defina stackdriver.projectid como o ID do projeto do Google Cloud em que você quer visualizar os registros do Stackdriver pertencentes aos clusters no local.

Defina stackdriver.clusterlocation como uma região do Google Cloud em que você quer armazenar registros do Stackdriver. É recomendável escolher uma região próxima ao data center local.

Defina stackdriver.enablevpc como true se você tiver a rede do cluster controlada por uma VPC. Isso garante que toda a telemetria flua pelos endereços IP restritos do Google.

Defina stackdriver.serviceaccountkeypath como o caminho do arquivo de chave JSON para a conta de serviço do Stackdriver Logging. Por exemplo:

stackdriver:
  projectid: "my-project"
  clusterlocation: "us-west1"
  enablevpc: false
  serviceaccountkeypath: "/my-key-folder/stackdriver-key.json"

privateregistryconfig

Se você tiver um registro particular do Docker, o campo privateregistryconfig conterá informações que o GKE On-Prem usa para enviar imagens ao seu registro particular. Se você não especificar um registro particular, o gkectl extrairá as imagens de contêiner do GKE On-Prem do repositório do Container Registry, gcr.io/gke-on-prem-release, durante a instalação.

Em privatedockerregistry.credentials, defina address como o endereço IP da máquina que executa o registro particular do Docker. Defina username e password como o nome de usuário e a senha do registro particular do Docker.

Quando o Docker recebe uma imagem do seu registro particular, o registro precisa comprovar a própria identidade apresentando um certificado. O certificado do registro é assinado por uma autoridade de certificação (CA). O Docker usa o certificado da CA para validar o certificado do registro.

Defina privateregistryconfig.cacertpath como o caminho do certificado da CA. Por exemplo:

privateregistryconfig
  ...
  cacertpath: /my-cert-folder/registry-ca.crt

gcrkeypath

Defina o valor de gcrkeypath como o caminho do arquivo de chave JSON para sua conta de serviço de acesso. Por exemplo:

gcrkeypath: "/my-key-folder/access-key.json"

cloudauditlogging

Se você quiser enviar os registros de auditoria do Kubernetes para o projeto do Google Cloud, preencha a especificação cloudauditlogging. Por exemplo:

cloudauditlogging:
  projectid: "my-project"
  # A GCP region where you would like to store audit logs for this cluster.
  clusterlocation: "us-west1"
  # The absolute or relative path to the key file for a GCP service account used to
  # send audit logs from the cluster
  serviceaccountkeypath: "/my-key-folder/audit-logging-key.json"

Saiba mais sobre como usar a geração de registros de auditoria.

Como validar o arquivo de configuração

Depois de modificar o arquivo de configuração, execute gkectl check-config para verificar se o arquivo é válido e pode ser usado para instalação:

gkectl check-config --config [PATH_TO_CONFIG]

Se o comando retornar mensagens FAILURE, corrija os problemas e valide o arquivo novamente.

Como pular validações

Os comandos gkectl a seguir executam automaticamente validações no seu arquivo de configuração:

  • gkectl prepare
  • gkectl create cluster
  • gkectl upgrade

Para pular as validações de um comando, transmita --skip-validation-all. Por exemplo, para pular todas as validações de gkectl prepare:

gkectl prepare --config [PATH_TO_CONFIG] --skip-validation-all

Para ver todas as sinalizações disponíveis e pular validações específicas:

gkectl check-config --help

Como executar gkectl prepare

Antes da instalação, execute gkectl prepare na estação de trabalho do administrador para inicializar o ambiente do vSphere. O gkectl prepare executa as seguintes tarefas:

  • Importe a imagem do SO do nó para o vSphere e marque-a como um modelo.

  • Como alternativa, valide os atestados de build das imagens do contêiner, verificando se as imagens foram criadas e assinadas pelo Google e estão prontas para implantação.

Execute gkectl prepare com o arquivo de configuração do GKE On-Prem, em que --validate-attestations é opcional:

gkectl prepare --config [CONFIG_FILE] --validate-attestations

A saída positiva de --validate-attestations é Image [IMAGE_NAME] validated.

Como instalar o GKE On-Prem

Você criou um arquivo de configuração que especifica a aparência do ambiente e as características do cluster e também validou o arquivo. Você executou gkectl prepare para inicializar o ambiente com o software GKE On-Prem. Agora, você está pronto para iniciar uma nova instalação do GKE On-Prem.

Para instalar o GKE On-Prem, execute o seguinte comando:

gkectl create cluster --config [CONFIG_FILE]

em que [CONFIG_FILE] é o arquivo de configuração que você gerou e modificou.

É possível reutilizar o arquivo de configuração para criar outros clusters de usuário.

Como retomar uma instalação

Se a instalação for interrompida após a criação do cluster de administrador, será possível retomar a instalação:

  • Remoção da especificação admincluster do arquivo de configuração.
  • Execução de gkectl create cluster novamente, passando o arquivo kubeconfig do cluster de administrador.
gkectl create cluster --config [CONFIG_FILE] \
--kubeconfig [ADMIN_CLUSTER_KUBECONFIG]

[ADMIN_CLUSTER_NAME] é o kubeconfig do cluster de administrador, que foi criado no diretório de trabalho quando você iniciou a instalação.

Problemas conhecidos

Atualmente, não é possível retomar uma instalação se você estiver criando um cluster de usuário de alta disponibilidade. Ele será resolvido em uma versão futura.

Como conectar clusters ao Google

Como ativar a entrada

Depois que o cluster de usuário estiver em execução, você precisará ativar a entrada criando um objeto de gateway. A primeira parte do manifesto de gateway é sempre esta:

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-autogenerated-k8s-ingress
  namespace: gke-system
spec:
  selector:
    istio: ingress-gke-system

É possível personalizar o restante do manifesto de acordo com suas necessidades. Por exemplo, este manifesto diz que os clientes podem enviar solicitações na porta 80 usando o protocolo HTTP/2 e qualquer nome do host:

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-autogenerated-k8s-ingress
  namespace: gke-system
spec:
  selector:
    istio: ingress-gke-system
  servers:
  - port:
      number: 80
      protocol: HTTP2
      name: http
    hosts:
    - "*"

Se você quiser aceitar solicitações HTTPS, forneça um ou mais certificados que o controlador de entrada possa apresentar aos clientes.

Para fornecer um certificado:

  1. Crie um Secret que contenha seu certificado e sua chave.
  2. Crie um objeto de gateway, ou modifique um que já exista, que faça referência ao Secret. O nome do objeto de gateway precisa ser istio-autogenerated-k8s-ingress.

Por exemplo, suponha que você já tenha criado um arquivo de certificado ingress-wildcard.crt e um arquivo de chave ingress-wildcard.key.

Crie um Secret chamado ingressgateway-wildcard-certs:

kubectl create secret tls \
    --namespace gke-system \
    ingressgateway-wildcard-certs \
    --cert ./ingress-wildcard.crt \
    --key ./ingress-wildcard.key

Este é um manifesto de um gateway que se refere ao Secret. Os clientes podem chamar na porta 443 usando o protocolo HTTPS e qualquer nome do host que corresponda a *.example.com. Observe que o nome do host no certificado precisa corresponder ao nome do host no manifesto, *.example.com, neste exemplo:

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: istio-autogenerated-k8s-ingress
  namespace: gke-system
spec:
  selector:
    istio: ingress-gke-system
  servers:
  - port:
      number: 80
      protocol: HTTP2
      name: http
    hosts:
    - "*"
  - hosts:
    - "*.example.com"
    port:
      name: https-demo-wildcard
      number: 443
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: ingressgateway-wildcard-certs

Para criar vários certificados TLS para hosts diferentes, modifique o manifesto de gateway.

Salve o manifesto em um arquivo chamado my-gateway.yaml e crie o gateway:

kubectl apply -f my-gateway.yaml

Agora, é possível usar objetos de Entrada do Kubernetes de maneira padrão.

Limitações

Limitação Descrição
Limites máximo e mínimo para clusters e nós

Consulte Cotas e limites. O desempenho do ambiente pode afetar esses limites.
Exclusividade para nomes de cluster de usuário

Todos os clusters de usuário registrados no mesmo projeto do Google Cloud precisam ter nomes exclusivos.
Não é possível implantar em mais de um data center do vCenter e/ou do vSphere

Atualmente, é possível implantar apenas um cluster de administrador e um conjunto de clusters de usuário associados a somente um data center do vCenter e/ou do vSphere. Não é possível implantar os mesmos clusters de administrador e de usuário em mais de um data center do vCenter e/ou do vSphere.
Não é possível alterar as configurações do cluster de maneira declarativa após a criação Embora você consiga criar outros clusters e redimensionar clusters atuais, não é possível alterar um cluster atual por meio do arquivo de configuração.

Solução de problemas

Para mais informações, consulte Solução de problemas.

Como diagnosticar problemas de cluster usando gkectl

Use os comandos gkectl diagnose para identificar problemas de cluster e compartilhar informações do cluster com o Google. Consulte Como diagnosticar problemas de cluster.

Comportamento de geração de registros padrão

Para gkectl e gkeadm, basta usar as configurações de geração de registros padrão:

  • Por padrão, as entradas de registro são salvas da seguinte maneira:

    • Para gkectl, o arquivo de registros padrão é /home/ubuntu/.config/gke-on-prem/logs/gkectl-$(date).log e está vinculado ao arquivo logs/gkectl-$(date).log no diretório local em que você executa gkectl.
    • Para gkeadm, o arquivo de registros padrão é logs/gkeadm-$(date).log no diretório local em que você executa gkeadm.
  • Todas as entradas de registro são salvas no arquivo de registros, mesmo que não sejam impressas no terminal (quando --alsologtostderr é false).
  • O nível de detalhamento -v5 (padrão) abrange todas as entradas de registro exigidas pela equipe de suporte.
  • O arquivo de registros também contém o comando executado e a mensagem de erro.

Recomendamos que você envie o arquivo de registros para a equipe de suporte quando precisar de ajuda.

Como especificar um local não padrão para o arquivo de registros

Se quiser especificar um local não padrão para o arquivo de registros gkectl, use a sinalização --log_file. O arquivo de registro que você especificar não será vinculado ao diretório local.

Se quiser especificar um local não padrão para o arquivo de registros gkeadm, use a sinalização --log_file.

Como localizar registros da API Cluster no cluster de administrador

Se uma VM não for iniciada após o início do plano de controle do administrador, tente depurar isso inspecionando os registros dos controladores da API Cluster no cluster de administrador:

  1. Encontre o nome do pod de controladores da API Cluster no namespace kube-system, em que [ADMIN_CLUSTER_KUBECONFIG] é o caminho para o arquivo kubeconfig do cluster de administrador:

    kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system get pods | grep clusterapi-controllers

  2. Abra os registros do pod, em que [POD_NAME] é o nome do pod. Opcionalmente, use grep ou uma ferramenta semelhante para pesquisar erros:

    kubectl --kubeconfig [ADMIN_CLUSTER_KUBECONFIG] -n kube-system logs [POD_NAME] vsphere-controller-manager

Como depurar problemas de F5 BIG-IP com o kubeconfig do nó do plano de controle do cluster de administrador

Após uma instalação, o GKE On-Prem gera um arquivo kubeconfig no diretório inicial da estação de trabalho do administrador denominado internal-cluster-kubeconfig-debug. Esse arquivo kubeconfig é idêntico ao kubeconfig do cluster de administrador, com a diferença de que ele aponta diretamente para o nó do plano de controle do cluster de administrador, em que o plano de controle de administrador é executado. É possível usar o arquivo internal-cluster-kubeconfig-debug para depurar problemas de F5 BIG-IP.

Falha na validação de gkectl check-config: não é possível encontrar partições de F5 BIG-IP

Sintomas

A validação falha porque não são encontradas partições de F5 BIG-IP, embora elas existam.

Causas possíveis

Um problema com a API F5 BIG-IP pode causar falha na validação.

Resolução

Tente executar gkectl check-config novamente.

Falha em gkectl prepare --validate-attestations: não foi possível validar o atestado de versão

Sintomas

Executar gkectl prepare com a sinalização --validate-attestations opcional retorna o seguinte erro:

could not validate build attestation for gcr.io/gke-on-prem-release/.../...: VIOLATES_POLICY
Causas possíveis

Um atestado pode não existir para as imagens afetadas.

Resolução

Tente fazer o download e implantar o OVA da estação de trabalho de administrador novamente, conforme instruído em Como criar uma estação de trabalho de administrador. Se o problema persistir, entre em contato com o Google para receber ajuda.

Como depurar usando os registros do cluster de inicialização

Durante a instalação, o GKE On-Prem cria um cluster temporário de inicialização. Após uma instalação bem-sucedida, o GKE On-Prem exclui o cluster de inicialização, deixando você com o cluster de administrador e de usuário. Geralmente, não há motivo para interagir com esse cluster.

Se algo der errado durante uma instalação e você tiver transmitido --cleanup-external-cluster=false para gkectl create cluster, talvez seja útil realizar a depuração usando os registros do cluster de inicialização. Encontre o pod e acesse os registros dele:

kubectl --kubeconfig /home/ubuntu/.kube/kind-config-gkectl get pods -n kube-system
 
kubectl --kubeconfig /home/ubuntu/.kube/kind-config-gkectl -n kube-system get logs [POD_NAME]

A seguir