Como instalar usando IPs estáticos

Nesta página, você aprende a instalar o GKE On-Prem em um ambiente do VMware vSphere 6.5 usando IPs estáticos. Também é possível instalar usando um servidor DHCP.

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.

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. Saiba como ativar o balanceamento de carga manual, se quiser usá-lo.

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

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

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

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

    gcloud auth login

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

    gcloud auth configure-docker

  9. 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 Cloud ou ao executar gcloud config get-value project.

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.

Como configurar IPs estáticos

Durante a instalação, você gera um arquivo de configuração do GKE On-Prem. O arquivo de configuração gerado inclui dois campos ipblockfilepath:

  • admincluster.ipblockfilepath
  • usercluster.ipblockfilepath

O ipblockfilepath aceita o caminho para um arquivo YAML contendo um arquivo de configuração de host (ou hostconfig), conforme descrito abaixo.

Se você quiser usar IPs estáticos, precisará criar dois arquivos YAML na sua estação de trabalho de administrador: um contendo um hostconfig a ser usado pelo cluster de administrador e outro para ser usado pelo cluster de usuário.

É necessário um mínimo de N + 4 pares de IP/nome do host na configuração de IP do cluster de administrador, em que N é o número de clusters de usuário que você planeja criar.

Opte por criar um cluster de usuário de alta disponibilidade. Um cluster de usuário de alta disponibilidade usa três planos de controle de usuário. Cada VM que executa um plano de controle do usuário requer seu próprio IP estático. Como os planos de controle do usuário são gerenciados pelo cluster de administrador, esses valores precisam ser fornecidos no arquivo hostconfig do cluster de administrador.

Exemplo

Veja a seguir um exemplo de arquivo hostconfig com três hosts. Seu arquivo pode ter uma aparência diferente dependendo do ambiente. Por exemplo, é possível expandir a matriz ips com mais pares ip/hostname:

hostconfig:
  dns: 172.16.255.1
  tod: 192.138.210.214
  otherdns:
  - 8.8.8.8
  - 8.8.4.4
  othertod:
  - ntp.ubuntu.com
blocks:
  - netmask: 255.255.252.0
    gateway: 110.116.232.1
    ips:
    - ip: 10.116.232.23
      hostname: host1.enterprise.net  # will be trimmed to host1
    - ip: 10.116.232.65
      hostname: host2.enterprise.net  # will be trimmed to host2
    - ip: 10.116.232.66
      hostname: host3.enterprise.net  # will be trimmed to host3

O arquivo YAML contém duas seções: hostconfig e blocks.

hostconfig

O hostconfig contém parâmetros de rede que se aplicam estaticamente a todos os nós de um cluster. hostconfig configura os seguintes valores:

  • dns: endereço IP do servidor DNS a ser usado para nós.
  • tod: endereço IP do servidor de horário a ser usado para nós.
  • otherdns: servidores DNS alternativos a serem usados para nós.
  • othertod: servidores de horário alternativos a serem usados para nós.

blocks

blocks contém uma matriz de blocos de endereços IP estáticos. Atualmente, o GKE On-Prem considera apenas o primeiro bloco para alocação de IP. Cada bloco representa uma rede e os respectivos endereços IP dentro dela.

netmask e gateway

netmask e gateway representam a máscara de rede e o gateway padrão a serem usados nos nós.

blocks:
  - netmask: 255.255.252.0
    gateway: 110.116.232.1

ips

Uma matriz ips lista os IPs alocados. Cada objeto na matriz contém um endereço IPv4 e seu nome do host:

blocks:
...
  ips:
  - ip: [IPV4_ADDRESS]
    hostname: [HOSTNAME]
  - ip: [IPV4_ADDRESS]
    hostname: [HOSTNAME]
  - ip: [IPV4_ADDRESS]
    hostname: [HOSTNAME]
...

O GKE On-Prem monitora endereços IP gratuitos e atribuídos dentro desse bloco e aloca um endereço IP disponível para cada nó em um cluster. Verifique se o número de endereços IP na matriz é estritamente maior que o número de nós no cluster e se cada endereço IP é exclusivo à rede do ambiente.

hostname, interpretado como o nome do host local sem o domínio. Se você especificar um nome de domínio totalmente qualificado (FQDN), o nome de domínio será cortado. Por exemplo, host1.enterprise.net torna-se host1. Os valores hostname precisam estar em letras minúsculas.

Como criar arquivo hostconfig

Veja a seguir um exemplo de arquivo hostconfig referente a um cluster de usuário que tem três nós:

  1. Copie o seguinte modelo para um arquivo YAML:

    hostconfig:
  dns:
  tod:
blocks:
  - netmask:
    gateway:
    ips:
    - ip:
      hostname:
    - ip:
      hostname:
    - ip:
      hostname:

  2. Salve os arquivos por nomes diferentes, como admin-cluster-hostconfig.yaml e user-cluster-hostconfig.yaml.

  3. Durante a instalação, modifique os campos admincluster.ipblockfilepath e usercluster.ipblockfilepath do arquivo de configuração com os arquivos apropriados.

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

O arquivo de pacote do GKE On-Prem contém todos os componentes em uma determinada versão do GKE On-Prem. Quando você cria uma estação de trabalho de administrador, ela vem com um pacote completo em /var/lib/gke/bundles/gke-onprem-vsphere-[VERSION]-full.tgz. A versão deste pacote corresponde à versão do OVA que você importou 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 vcenter contém informações sobre a instância do servidor vCenter. O GKE On-Prem precisa dessas informações para se comunicar com o servidor vCenter.

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

Se a rede estiver protegida por um servidor proxy, preencha o campo proxy com o proxy HTTPS 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 admincluster contém as informações de 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

Como você está usando endereços IP estáticos, é necessário ter um arquivo de configuração de host, conforme descrito em Como configurar IPs estáticos. Forneça o caminho para seu arquivo de configuração de host no campo admincluster.ipblockfilepath. Por exemplo:

admincluster:
  ipblockfilepath: "/my-config-folder/my-admin-hostconfig.yaml"

admincluster.manuallbspec (modo de balanceamento de carga manual)

O controlador de entrada no cluster de administrador é implementado como um serviço do tipo NodePort. O serviço tem um ServicePort para HTTP e outro para HTTPS. Se você estiver usando o modo de balanceamento de carga manual, será necessário escolher valores nodePort para esses ServicePorts. Especifique os valores nodePort em ingresshttpnodeport e ingresshttpsnodeport. Por exemplo:

admincluster:
  ...
  manuallbspec:
    ingresshttpnodeport: 32527
    ingresshttpsnodeport: 30139

O servidor da API Kubernetes no cluster de administrador é implementado como um serviço do tipo NodePort. Se você estiver usando o balanceamento de carga manual, será necessário escolher um valor nodePort para o serviço. Especifique o valor nodePort em controlplanenodeport. Exemplo:

admincluster:
  ...
  manuallbspec:
    ...
    controlplanenodeport: 30968

O servidor de complementos no cluster de administrador é implementado como um serviço do tipo NodePort. Se você estiver usando o balanceamento de carga manual, será necessário escolher um valor nodePort para o serviço. Especifique o valor nodePort em controlplanenodeport. Exemplo:

admincluster:
  manuallbspec:
    ...
    addonsnodeport: 30562

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

Se você não estiver usando o modo de balanceamento de carga integrado, deixe admincluster.bigip com marca de comentário.

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

Se você usa o balanceamento de carga integrado ou manual para o cluster de administrador, é necessário preencher o campo 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. Para saber como ativar o DRS, consulte Como ativar o VMware DRS em um cluster.
  • 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

Como você está usando endereços IP estáticos, é necessário ter um arquivo de configuração de host, conforme descrito em Como configurar IPs estáticos. Forneça o caminho para seu arquivo de configuração de host no campo usercluster.ipblockfilepath. Por exemplo:

usercluster:
  ipblockfilepath: "/my-config-folder/my-user-hostconfig.yaml"

usercluster.manuallbspec (modo de balanceamento de carga manual)

O controlador de entrada no cluster do usuário é implementado como um serviço do tipo NodePort. O serviço tem um ServicePort para HTTP e outro para HTTPS. Se você estiver usando o modo de balanceamento de carga manual, será necessário escolher valores nodePort para esses ServicePorts. Especifique os valores nodePort em ingresshttpnodeport e ingresshttpsnodeport. Por exemplo:

usercluster:
  manuallbspec:
    ingresshttpnodeport: 30243
    ingresshttpsnodeport: 30879

O servidor da API Kubernetes no cluster de usuário é implementado como um serviço do tipo NodePort. Se você estiver usando o balanceamento de carga manual, será necessário escolher um valor nodePort para o serviço. Especifique o valor nodePort em controlplanenodeport. Por exemplo:

usercluster:
  ...
  manuallbspec:
    ...
    controlplanenodeport: 30562

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)

Se estiver usando o modo de balanceamento de carga integrado, você precisará criar uma partição BIG-IP para seu 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

Se você usa o balanceamento de carga integrado ou manual para o cluster de usuário, é necessário preencher o campo 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ê quiser 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 ou o balanceamento de carga manual. A escolha do modo de balanceamento de carga 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.

Para especificar sua opção de balanceamento de carga, defina o valor de lbmode como Integrated ou Manual. 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.

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

Conclua esta etapa na sua estação de trabalho de administrador.

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.

  • Se você usa um registro particular do Docker, envie imagens do GKE On-Prem para seu registro.

  • 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 do GKE On-Prem

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