Instalar o Kf no Google Cloud (prévia)

Pré-lançamento

Este produto ou recurso está sujeito aos Termos das Ofertas 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 assistência limitada. Para mais informações, consulte as descrições das fases de lançamento.

Neste documento, descrevemos como configurar um cluster do GKE e instalar o Kf e as dependências dele usando novos recursos em prévia.

Observação: este guia de instalação inclui as seguintes diferenças importantes em relação ao guia de instalação do GA:

• O Kf vai usar a nova pilha encapsulada v2 para oferecer os benefícios do buildpack nativo da nuvem para aplicativos legados.
• Remove o Config Connector como uma dependência.
• Remove o papel serviceAccountUpdater personalizado do IAM.

Antes de começar

Observação: os clusters do GKE do Autopilot não podem executar o Kf no momento. Use um cluster do GKE Standard. Para mais informações sobre esses modos e saber mais sobre o Autopilot, consulte a visão geral do Autopilot.

Requisitos de clusters do GKE

• Opcional, mas é recomendado que o cluster seja dedicado ao Kf. Recomendamos que você instale apenas o Kf e as dependências dele para garantir que a matriz de compatibilidade seja mantida.

• No mínimo, quatro nós. Se for preciso adicionar nós, confira Como redimensionar um cluster.

• O tipo de máquina mínimo que tem pelo menos quatro vCPUs, como e2-standard-4. Se o tipo de máquina do cluster não tiver pelo menos quatro vCPUs, altere o tipo de máquina conforme descrito em Como migrar cargas de trabalho para diferentes tipos de máquina.

• Como opção recomendada, inscreva o cluster em um canal de lançamento. Siga as instruções em Como registrar um cluster atual em um canal de lançamento se você tiver uma versão estática do GKE.

• Identidade da carga de trabalho ativada.

Requisitos do Kf

Analise e entenda as permissões de acesso dos componentes no Kf na página de dependências e arquitetura do Kf.

A matriz de dependências lista as versões específicas.

• Artifact Registry

• Cloud Service Mesh

• Config Connector

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

• Uma conta de serviço dedicada do Google

Observação: a seção Limpar tem instruções para excluir o cluster.

Ativar o suporte ao Compute Engine

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Ative a API Compute Engine.

   Ativar a API

Ativar suporte ao Artifact Registry

1. Ative a API Artifact Registry.

   Ative a API Artifact Registry

Ativar e configurar o GKE

Antes de começar, verifique se você realizou as tarefas a seguir:

• Ativar a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da gcloud CLI não sejam compatíveis com a execução dos comandos neste documento.
  Observação: em instalações prévias da gcloud CLI, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na gcloud CLI como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Preparar um novo cluster do GKE 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

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

Configurar conta de serviço

Crie uma conta de serviço do Google Cloud que será associada a uma conta do Kubernetes usando a Identidade da Carga de Trabalho. Assim não é preciso criar e injetar uma chave de conta de serviço.

Observação: leia e entenda as implicações de segurança do uso da Identidade da Carga de Trabalho no documento Visão geral da segurança.

1. Crie a conta de serviço que o Kf vai usar.

   gcloud iam service-accounts create ${CLUSTER_NAME}-sa \
   --project=${CLUSTER_PROJECT_ID} \
   --description="GSA for Kf ${CLUSTER_NAME}" \
   --display-name="${CLUSTER_NAME}"

2. Conceda o papel de monitoramento das métricas à conta de serviço para que ela possa gravar dados no Cloud Monitoring.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}." \
     --role="roles/monitoring.metricWriter"

3. Conceda o papel de geração de registros à conta de serviço para que ela possa gravar dados no Cloud Logging.

   gcloud projects add-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}." \
     --role="roles/logging.logWriter"

Criar cluster do GKE

Observação: para fins de demonstração, usamos um cluster zonal nestas instruções. Para implantações de produção, um cluster regional é recomendado.

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --disk-size "122" \
  --network=${NETWORK} \
  --addons HorizontalPodAutoscaling,HttpLoadBalancing,GcePersistentDiskCsiDriver \
  --enable-dataplane-v2 \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes cloud-platform \
  --release-channel=regular \
  --workload-pool="${CLUSTER_PROJECT_ID}." \
  --service-account="${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}."

Definir regras de firewall

O Kf requer a abertura de algumas portas de firewall. O nó mestre precisa se comunicar com pods nas portas 80, 443, 8080, 8443 e 6443.

Ativar a identidade da carga de trabalho

Agora que você tem uma conta de serviço e um cluster do GKE, associe o namespace de identidade do cluster ao cluster.

gcloud iam service-accounts add-iam-policy-binding \
  --project=${CLUSTER_PROJECT_ID} \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${CLUSTER_PROJECT_ID}.[kf/controller]" \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}."

gcloud iam service-accounts add-iam-policy-binding \
  --project=${CLUSTER_PROJECT_ID} \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${CLUSTER_PROJECT_ID}.[cnrm-system/cnrm-controller-manager]" \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}."

Cluster do GKE de destino

Use o comando a seguir para configurar o acesso à linha de comando kubectl.

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --project=${CLUSTER_PROJECT_ID} \
    --zone=${CLUSTER_LOCATION}

Crie um repositório do Artifact Registry

1. Crie um Artifact Registry para armazenar as imagens de contêiner.

   gcloud artifacts repositories create ${CLUSTER_NAME} \
     --project=${CLUSTER_PROJECT_ID} \
     --repository-format=docker \
     --location=${COMPUTE_REGION}

2. Conceda permissão à conta de serviço no repositório do Artifact Registry.

   gcloud artifacts repositories add-iam-policy-binding ${CLUSTER_NAME} \
     --project=${CLUSTER_PROJECT_ID} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}." \
     --role='roles/artifactregistry.writer'

Instalar dependências de software em um cluster

Observação: a matriz de dependências na página Downloads do Kf mostra os números das versões de dependência com suporte de cada versão do Kf.

1. Instale o Cloud Service Mesh.

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

   2. Depois de instalar o Cloud Service Mesh, crie um gateway de entrada usando o guia de instalação de gateways.

2. Instale o Tekton:

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

Instalar o Kf

Observação: verifique se o cluster atende aos requisitos encontrados em Criar e preparar um cluster do GKE para 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.7.3/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.7.3/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.7.3/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.7.3/kf-windows.exe kf.exe

2. Instale o operador:

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

3. Instale AppDevExperience Build do Kf (ADX Build).

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   cat << EOF | kubectl apply --filename -
   apiVersion: builds.appdevexperience.dev/v1alpha1
   kind: BuildSystem
   metadata:
       name: buildsystem
   spec:
     secrets:
       workloadidentity:
         googleprojectid: ${CLUSTER_PROJECT_ID}
         googleserviceaccount: ${CLUSTER_NAME}-sa
     containerRegistry: ${CONTAINER_REGISTRY}
     enabled: true
   EOF

4. Configure o ADX Build para a Identidade da Carga de Trabalho.

   gcloud iam service-accounts add-iam-policy-binding \
     --project=${CLUSTER_PROJECT_ID} \
     --role roles/iam.workloadIdentityUser \
     --member "serviceAccount:${CLUSTER_PROJECT_ID}.[adx-builds-system/controller]" \
     "${GSA_NAME}@${CLUSTER_PROJECT_ID}."

5. Configure o operador para o Kf:

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

6. Configure Secrets e padrões:

   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}'}}}}}]"
   

Validar a instalação

Observação: esse comando vai 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. Uma série de resultados PASS será exibida. Se o status de algum componente gerar FAIL depois de novas tentativas, consulte a página Solução de problemas do Kf.

kf doctor --retries=20

Limpar

Estas etapas removem todos os componentes criados na seção Criar e preparar um cluster do GKE.

1. Exclua a conta de serviço do Google:

   gcloud iam service-accounts delete ${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.

2. Exclua as vinculações da política do IAM:

   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
       --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}." \
       --role="roles/iam.serviceAccountAdmin"
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
       --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}." \
       --role="roles/monitoring.metricWriter"

3. Exclua o repositório de imagens de contêineres:

   gcloud artifacts repositories delete ${CLUSTER_NAME} \
     --location=${COMPUTE_REGION}

4. Desinstale o Kf:

   kubectl patch kfsystem kfsystem \
     --type='json' \
     -p="[{'op': 'replace', 'path': '/spec/kf', 'value': {'enabled': false, }}]"

5. Exclua o cluster do GKE:

   gcloud container clusters delete ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}