Instalar o Kf fora do Google Cloud

Pré-lançamento

Este produto ou recurso está sujeito aos Termos das Soluções Pré-GA na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os produtos e recursos pré-GA estão disponíveis no estado em que se encontram e podem ter suporte limitado. Você encontra mais detalhes nas descrições das fases de lançamento.

Neste documento, descrevemos como instalar o Kf e as dependências dele em um cluster no local criado como parte do Google Distributed Cloud, seja no VMware ou em bare metal.

Para quem já sabe como instalar o Kf em um cluster do GKE no Google Cloud, as principais diferenças do procedimento local são:

• O Config Connector não é necessário para uma instalação local.
• Você vai usar as credenciais do Docker em vez da Identidade da Carga de Trabalho.

Antes de começar

Requisitos do Google Distributed Cloud

• Um cluster de usuário que atende aos requisitos do Cloud Service Mesh.

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

  • VMware.
  • Bare metal.

• Registrado em uma frota:

  Acessar os clusters do GKE

Requisitos do Kf

• Cloud Service Mesh.

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

• Uma conta de serviço dedicada do Google.

Preparar um novo cluster local e os serviços relacionados

Configurar variáveis de ambiente

Observação: exporte as variáveis de ambiente no terminal ou no Cloud Shell para os comandos subsequentes funcionarem. Se você se desconectar do ambiente shell e depois se reconectar, 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 usadas para que os builds leiam/gravem no Container Registry. Esta etapa varia dependendo do registro de contêineres utilizado, porque ele pode conseguir as credenciais para acessar o registro de outra forma.

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 pelo 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 Cloud Service Mesh.

   1. Siga o Guia de instalação do Cloud Service Mesh.

   2. Se estiver no Google Distributed Cloud, defina loadBalancerIP como um IP alocado ao cluster, conforme descrito em Configurar endereços IP externos para o Google Distributed Cloud.

2. Instale o Tekton:

   kubectl apply -f "https://storage.googleapis.com/tekton-releases/pipeline/previous/v0.32.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ê.

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

   Mac

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

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

   Cloud Shell

   O comando vai instalar o kf na instância do Cloud Shell se você usar bash. Talvez seja necessário mudar as instruções para outros shells.

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

   Windows

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

   gcloud storage cp gs://kf-releases/v2.9.0/kf-windows.exe kf.exe

2. Instale o operador:

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

3. Configure o operador para o Kf:

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

Criar um Secret do Kubernetes para credenciais do Docker

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

1. Ative e atualize o operador do Kf para usar o Container Registry como o registro de contêineres.

   Observação: o comando abaixo usa o seguinte Container Registry como registro de contêineres: gcr.io/${CLUSTER_PROJECT_ID}. Também é possível usar um registro próprio personalizado. Modifique o comando conforme necessário se você usa um registro de contêineres 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 do Kf. Isso pode levar alguns minutos.

   kubectl get namespace kf

3. Crie um Secret do Kubernetes para usar 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 do 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}'}}}}}]"
   

Validar a instalação

kf doctor --retries=20

Observação: esse comando inspeciona o cluster para confirmar se o Kf e as dependências dele estão instalados e funcionando. Ele será executado até 20 vezes para que o cluster do Kubernetes tenha tempo de reconciliação. Uma série de resultados PASS será exibida. Se o status de qualquer componente gerar FAIL depois de novas tentativas, consulte a página Solução de problemas do Kf.