Instale o Kf

Este documento descreve como configurar um cluster do GKE e, em seguida, instalar o Kf e as respetivas dependências.

Antes de começar

Vista geral

Nota: atualmente, não é possível executar o Kf em clusters do GKE no modo Autopilot. Use um cluster do GKE padrão. Para mais informações acerca destes modos e para saber mais sobre o Autopilot, consulte a vista geral do Autopilot.

• O seu cluster do GKE tem de cumprir os seguintes requisitos:

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

  • Pelo menos, quatro nós. Se precisar de adicionar nós, consulte o artigo 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 seu cluster não tiver, pelo menos, quatro vCPUs, altere o tipo de máquina conforme descrito no artigo Migrar cargas de trabalho para diferentes tipos de máquinas.

  • Opcional, mas recomendado, inscreva o cluster num canal de lançamento. Siga as instruções em Inscrever um cluster existente num canal de lançamento se tiver uma versão estática do GKE.

  • Workload Identity ativado.

  • Artifact Registry ativado.

  • Cloud Service Mesh (ASM).

  • O Tekton está instalado. Consulte a matriz de dependências da versão.

  • Uma conta de serviço Google com a seguinte política de IAM (instruções de criação indicadas abaixo):

    • roles/iam.serviceAccountAdmin
    • serviceAccount:${CLUSTER_PROJECT}.[kf/controller] (para o membro serviceAccount:${CLUSTER_PROJECT}.[kf/controller])

Ative o suporte para o 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.

   Ative a API

Ative e configure o GKE

Antes de começar, certifique-se de que realizou as seguintes tarefas:

• Ative a API Google Kubernetes Engine.
Ative a API Google Kubernetes Engine
• Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.
  Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Crie e prepare um novo cluster do GKE

Configure variáveis de ambiente

Nota: exporte estas variáveis de ambiente no terminal ou no Cloud Shell para que os comandos subsequentes funcionem. Se se desligar do ambiente de shell e voltar a ligar-se mais tarde, tem de configurar as variáveis novamente.
Nota: antes de configurar as variáveis de ambiente, certifique-se de que consulta a matriz de dependências na página Transferências do Kf para a versão do Kf em questão.

Linux

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}
export NODE_COUNT=4
export MACHINE_TYPE=e2-standard-4
export NETWORK=default
export KF_VERSION=v2.2.0
export TEKTON_VERSION=v0.19.0

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
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 KF_VERSION -Value v2.2.0
Set-Variable -Name TEKTON_VERSION -Value v0.19.0

Configuração da conta de serviço

Crie uma conta de serviço do GCP (GSA) que vai ser associada a uma conta de serviço do Kubernetes através do Workload Identity. Isto evita a necessidade de criar e inserir uma chave de conta de serviço.

Nota: leia e compreenda as implicações de segurança da utilização da identidade da carga de trabalho no documento Vista 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. Permitir que a conta de serviço modifique a respetiva política. O controlador Kf usa esta opção para adicionar novos espaços de nomes à política, o que permite a reutilização para a identidade de carga de trabalho.

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

3. Atribua a função de métricas de monitorização para acesso de escrita ao Cloud Monitoring.

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

4. Conceda a função de registo para acesso de escrita ao Cloud Logging.

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

Crie um cluster do GKE

Nota: para fins de demonstração, estas instruções usam um cluster zonal. Para implementações de produção, recomenda-se um cluster regional.

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${CLUSTER_PROJECT_ID} \
  --zone=${CLUSTER_LOCATION} \
  --num-nodes=${NODE_COUNT} \
  --machine-type=${MACHINE_TYPE} \
  --network=${NETWORK} \
  --addons=HttpLoadBalancing,HorizontalPodAutoscaling,NetworkPolicy \
  --enable-stackdriver-kubernetes \
  --enable-ip-alias \
  --enable-network-policy \
  --enable-autorepair \
  --enable-autoupgrade \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --release-channel=regular \
  --workload-pool="${CLUSTER_PROJECT_ID}." \
  --service-account="${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}."

Defina regras de firewall

O Kf requer que algumas portas da firewall estejam abertas. O nó principal tem de conseguir comunicar com pods nas portas 80, 443, 8080, 8443 e 6443.

Ative o Workload Identity

Agora que tem uma conta de serviço e um cluster do GKE, associe o espaço de nomes de identidade do cluster ao cluster.

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

Cluster do GKE de destino

Configure o acesso à linha de comandos kubectl executando o seguinte comando.

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 imagens de contentores.

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

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

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

3. Configure a autenticação local.

   gcloud auth configure-docker ${COMPUTE_REGION}-docker.pkg.dev

Instale dependências de software no cluster

Nota: antes de instalar qualquer item, certifique-se de que verifica a matriz de dependências na página Transferências do Kf para a versão do Kf em questão.

1. Instale a malha de serviços.

   Nota: consulte a matriz de dependências para ver a versão correta.

2. Instale o Tekton:

   Nota: consulte a matriz de dependências para ver a versão correta.

   kubectl apply -f "https://github.com/tektoncd/pipeline/releases/download/${TEKTON_VERSION}/release.yaml"

Instale o Kf

1. Consulte o artigo Crie e prepare um cluster do GKE para o Kf para criar um cluster preparado para executar o Kf.

2. Selecione e anote a versão do Kf pretendida. Consulte a página Kf Downloads para ver as versões disponíveis

   Nota: muitos dos comandos neste guia dependem destas variáveis de ambiente. Se desligar o ambiente de shell e voltar a ligar mais tarde, tem de configurar as variáveis novamente.

3. Instalar CLI:

   Linux

   Esta ação instala o kf para todos os utilizadores no sistema. Siga as instruções no separador do Cloud Shell para o instalar apenas para si.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Mac

   Esta ação instala o kf para todos os utilizadores no sistema.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-darwin /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Cloud Shell

   Isto instala o kf na sua instância do Cloud Shell se usar o bash. As instruções podem ter de ser modificadas para outras shells.

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

   Windows

   Esta ação transfere kf para o diretório atual. Adicione-o ao caminho se quiser chamar a partir de qualquer outro local que não o diretório atual.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf-windows.exe kf.exe

4. Instale os componentes do servidor:

   Linux e Mac

   Esta ação transfere o ficheiro kf.yaml para o diretório atual.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf.yaml /tmp/kf.yaml
   kubectl apply -f /tmp/kf.yaml

   Windows

   Esta ação transfere o ficheiro kf.yaml para o diretório atual.

   gcloud storage cp gs://kf-releases/${KF_VERSION}/kf.yaml kf.yaml
   kubectl apply -f kf.yaml

5. Segredos de configuração:

   export WI_ANNOTATION=iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.
   
   kubectl annotate serviceaccount controller ${WI_ANNOTATION} \
   --namespace kf \
   --overwrite
   
   echo "{\"apiVersion\":\"v1\",\"kind\":\"ConfigMap\",\"metadata\":{\"name\":\"config-secrets\", \"namespace\":\"kf\"},\"data\":{\"wi.googleServiceAccount\":\"${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.\"}}" | kubectl apply -f -

6. Configure as predefinições do Kf. Pode alterar estes valores mais tarde. O exemplo abaixo usa modelos de domínio com um fornecedor de DNS de caráter universal para fornecer a cada espaço o seu próprio nome de domínio:

   export CONTAINER_REGISTRY=${COMPUTE_REGION}-docker.pkg.dev/${CLUSTER_PROJECT_ID}/${CLUSTER_NAME}
   export DOMAIN='$(SPACE_NAME).$(CLUSTER_INGRESS_IP).nip.io'
   
   kubectl patch configmaps config-defaults \
   -n=kf \
   -p="{\"data\":{\"spaceContainerRegistry\":\"${CONTAINER_REGISTRY}\",\"spaceClusterDomains\":\"- domain: ${DOMAIN}\"}}"

7. Valide a instalação:

   kf doctor --retries 10

   Nota: este comando inspeciona o cluster para garantir que o Kf e as respetivas dependências estão instalados e a funcionar. É executado até 10 vezes para dar tempo ao cluster do Kubernetes para reconciliar e deve resultar numa série de resultados PASS. Se o estado de qualquer componente resultar em FAIL após as novas tentativas, consulte a página de resolução de problemas do Kf.