Instalar o Kf fora do Google Cloud

Visualização

Este produto ou recurso está sujeito aos "Termos das ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos do serviço. Os produtos e recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Neste documento, descrevemos como instalar o Kf e as dependências dele em um cluster local GKE no VMware ou GKE em Bare Metal.

Se você já estiver familiarizado com o processo de instalação do Kf em um cluster do GKE no Google Cloud, as principais diferenças no procedimento local são:

• Não é necessário instalar o Config Connector para uma instalação local.
• O procedimento local usa as credenciais do Docker em vez da identidade da carga de trabalho.

Antes de começar

Requisitos do GKE no VMware

• Um cluster de usuário para GKE no VMware que atende aos requisitos do Anthos Service Mesh.

• Configurado para geração de registros e monitoramento.

  • GKE no VMware.
  • GKE em Bare Metal.

• Registrado na sua frota do GKE Enterprise:

  Acesse os clusters do GKE Enterprise

  Saiba como registrar um cluster.

Requisitos do Kf

• Anthos Service Mesh

• Tekton para uso pelo Kf. Este não é um serviço direcionado ao usuário.

• Uma conta de serviço dedicada do Google.

Preparar um novo cluster do GKE no VMware e serviços relacionados

Configure as variáveis de ambiente

Observação: exporte essas variáveis de ambiente no seu terminal ou no Cloud Shell para que os comandos subsequentes funcionem. Se você se desconectar do ambiente shell e se reconectar posteriormente, será necessário configurar as variáveis novamente.

Linux e Mac

export PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_NAME=kf-cluster
export COMPUTE_ZONE=us-central1-a
export COMPUTE_REGION=us-central1
export CLUSTER_LOCATION=${COMPUTE_ZONE} # Replace ZONE with REGION to switch
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default
export CLUSTER_PROJECT_ID=YOUR_PROJECT_ID
export CLUSTER_NAME=kf-cluster
export DOCKER_SERVER=YOUR_DOCKER_SERVER_URL
export SA_NAME=${CLUSTER_NAME}-sa
export SA_EMAIL=${SA_NAME}@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

Windows PowerShell

Set-Variable -Name PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_NAME -Value kf-cluster
Set-Variable -Name COMPUTE_ZONE -Value us-central1-a
Set-Variable -Name COMPUTE_REGION -Value us-central1
Set-Variable -Name CLUSTER_LOCATION -Value $COMPUTE_ZONE # Replace ZONE with REGION to switch
Set-Variable -Name NODE_COUNT -Value 4
Set-Variable -Name MACHINE_TYPE -Value e2-standard-4
Set-Variable -Name NETWORK -Value default
Set-Variable -Name CLUSTER_PROJECT_ID -Value YOUR_PROJECT_ID
Set-Variable -Name CLUSTER_NAME -Value kf-cluster
Set-Variable -Name DOCKER_SERVER -Value YOUR_DOCKER_SERVER_URL
Set-Variable -Name SA_NAME -Value ${CLUSTER_NAME}-sa
Set-Variable -Name SA_EMAIL -Value ${SA_NAME}@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com

Configurar conta de serviço

Crie a conta de serviço do Google Cloud (GSA) e a chave da conta de serviço usada para que os builds leiam/gravem no Container Registry. Essa etapa é diferente se você estiver usando um registro de contêiner diferente, porque ele pode ter uma maneira diferente de conseguir as credenciais para acessar o registro.

1. Crie a conta de serviço usada pelo Kf:

   gcloud beta iam service-accounts create ${SA_NAME} \
       --project=${CLUSTER_PROJECT_ID} \
       --description="gcr.io admin for ${CLUSTER_NAME}" \
       --display-name="${CLUSTER_NAME}"

2. Atribua à conta de serviço o papel storage.admin necessário para ler/gravar no Container Registry:

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
       --member="serviceAccount:${SA_NAME}@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
       --role="roles/storage.admin"

3. Crie a chave da conta de serviço:

   temp_dir=$(mktemp -d)
   key_path=${temp_dir}/key.json
   gcloud iam service-accounts keys create --iam-account ${SA_EMAIL} ${key_path}
   key_json=$(cat ${key_path})
   rm -rf ${temp_dir}

Instalar dependências de software no cluster

1. Instale o Anthos Service Mesh.

   1. Siga as instruções do guia de instalação do Anthos Service Mesh.

   2. Se estiver no GKE no VMware, defina loadBalancerIP como um IP alocado para o cluster, conforme descrito em Configurar endereços IP externos para o GKE no VMware.

2. Instale o Tekton:

   kubectl apply -f "https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.47.1/release.yaml"

Instalar o Kf

1. Instale a CLI do Kf:

   Linux

   Este comando instala a CLI do Kf para todos os usuários no sistema. Siga as instruções na guia do Cloud Shell para instalá-lo só para você.

   gsutil cp gs://kf-releases/v2.11.21/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Mac

   Este comando instala kf para todos os usuários no sistema.

   gsutil cp gs://kf-releases/v2.11.21/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Cloud Shell

   Este comando instala kf na instância do Cloud Shell se você usar bash. Talvez as instruções precisem ser modificadas para outros shells.

   mkdir -p ~/bin
   gsutil cp gs://kf-releases/v2.11.21/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc

   Windows

   Este comando faz o download de kf para o diretório atual. Adicione-o ao caminho se você quiser chamar de outro local que não seja diretório atual.

   gsutil cp gs://kf-releases/v2.11.21/kf-windows.exe kf.exe

2. Instale o operador:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.11.21/operator.yaml"

3. Configure o operador para Kf:

   kubectl apply -f "https://storage.googleapis.com/kf-releases/v2.11.21/kfsystem.yaml"

Criar um secret do Kubernetes para credenciais do Docker

Crie um secret do Kubernetes no namespace Kf para credenciais do Docker que você criou acima em Configuração da conta de serviço. Em seguida, corrija o secret do Kubernetes na implantação subresource-apiserver para uploads de origem.

1. Ative e atualize o operador Kf para usar o Container Registry como o Container Registry.

   Observação: o comando abaixo usa o seguinte Container Registry como registro de contêiner: gcr.io/${CLUSTER_PROJECT_ID}. Como alternativa, é possível usar seu próprio registro de contêiner personalizado. Modifique o comando conforme necessário se você usa um registro de contêiner personalizado.

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   
   kubectl patch \
   kfsystem kfsystem \
   --type='json' \
   -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': true, 'config': {'featureFlags': {'enable_appdevexperience_builds': true}, 'spaceContainerRegistry': '${CONTAINER_REGISTRY}', 'secrets':{'workloadidentity':{'googleserviceaccount':'${CLUSTER_NAME}-sa', 'googleprojectid':'${CLUSTER_PROJECT_ID}'}}}}}]"
   

   export CONTAINER_REGISTRY=gcr.io/${CLUSTER_PROJECT_ID}
   kubectl patch kfsystem kfsystem \
     --type='json' \
     -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': true, 'config': {'spaceContainerRegistry':'${CONTAINER_REGISTRY}'}}}]"
   

2. Verifique se o namespace kf foi criado pelo operador Kf. Isso pode levar alguns minutos para ser concluído.

   kubectl get namespace kf

3. Crie um secret do Kubernetes para uso com registros do Docker.

   export secret_name=kf-gcr-key-${RANDOM}
   kubectl -n kf create secret docker-registry ${secret_name} \
      --docker-username=_json_key --docker-server ${DOCKER_SERVER} \
      --docker-password="${key_json}"
   

4. Atualize o operador Kf para especificar o secret que contém as credenciais do Docker.

   kubectl patch kfsystem kfsystem \
     --type='json' \
     -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'config': {'secrets':{'build':{'imagePushSecrets':'${secret_name}'}}}}}]"
   

Como validar a instalação

kf doctor --retries=20

Observação: esse comando inspecionará o cluster para garantir que o Kf e as dependências dele estejam instalados e funcionando. Ele será executado até 20 vezes para que o cluster do Kubernetes tenha tempo de reconciliação e isso deve resultar em uma série de resultados PASS. Se o status de qualquer componente gerar FAIL depois de novas tentativas, consulte a página Solução de problemas do Kf.