Guia de início rápido do Kf

Neste guia de início rápido, você irá configurar um cluster do GKE, instalar o Kf e as dependências dele. Depois, implantará um aplicativo de amostra do Cloud Foundry.

Antes de começar

Visão geral

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

• Seu cluster do GKE precisa atender aos seguintes requisitos:

  • 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, veja 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 existente em um canal de lançamento se você tiver uma versão estática do GKE.

  • Identidade da carga de trabalho ativada.

  • O Artifact Registry está ativado.

  • Anthos Service Mesh (ASM).

  • Tekton instalado. Consulte a Matriz de dependências para a versão.

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

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

A seção Limpar tem instruções sobre como excluir o cluster.

Ativar o suporte para o Compute Engine

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

   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

3. Make sure that billing is enabled for your Google Cloud project.

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

   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

5. Make sure that billing is enabled for your Google Cloud project.

6. Ative a API Compute Engine.

   Ativar a API

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 Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.
  Observação: para instalações atuais da CLI gcloud, defina as propriedades compute/region e compute/zone. Quando você define os locais padrão, você evita erros como este na gcloud CLI: One of [--zone, --region] must be supplied: Please specify location.

Criar e preparar um novo cluster do GKE

Configurar 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 reconectar mais tarde, precisará configurar as variáveis novamente.

Observação: antes de configurar as variáveis de ambiente, não se esqueça de verificar a matriz de dependências na página Downloads do Kf para a versão Kf fornecida.

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 será associada a uma conta de serviço do Kubernetes por meio da Identidade da carga de trabalho. Isso evita a necessidade de 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 de carga de trabalho no documento Visão geral da segurança.

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

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

2. Permita que a conta de serviço modifique sua própria política. O controlador Kf usará esse parâmetro para adicionar novos (nomes) espaços à política, permitindo a reutilização da Identidade da carga de trabalho.

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

3. Dê o papel de métricas de monitoramento para acesso de gravação ao Cloud Monitoring.

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

4. Dê o papel de geração de registros para acesso de gravação no Cloud Logging.

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

Criar cluster do GKE

Observação: para fins de demonstração, estas instruções usam um cluster zonal. 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} \
  --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}.svc.id.goog" \
  --service-account="${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com"

Definir regras de firewall

O Kf requer a abertura de algumas portas de firewall. O nó mestre precisa ser capaz de 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 \
  "${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
  --project=${CLUSTER_PROJECT_ID} \
  --role="roles/iam.workloadIdentityUser" \
  --member="serviceAccount:${CLUSTER_PROJECT_ID}.svc.id.goog[kf/controller]"

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} \
     --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} \
     --location=${COMPUTE_REGION} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role='roles/artifactregistry.writer'

3. Configure a autenticação local.

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

Instalar dependências de software no cluster

Observação: antes de instalar algo, verifique a matriz de dependências na página Downloads do Kf para a versão do Kf fornecida.

1. Instalar o Service Mesh.

   Observação: consulte a matriz de dependências para a versão correta.

2. Instale o Tekton:

   Observação: consulte a matriz de dependências para a versão correta.

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

Instalar o Kf

1. Consulte Criar e preparar um cluster do GKE para Kf para criar um cluster preparado para executar o Kf.

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

   Observação: muitos dos comandos deste guia dependem dessas variáveis de ambiente. Se você se desconectar do ambiente shell e se reconectar posteriormente, será necessário configurar as variáveis novamente.

3. Instale a CLI:

   Linux

   Isso instalará 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/${KF_VERSION}/kf-linux /tmp/kf
   chmod a+x /tmp/kf
   sudo mv /tmp/kf /usr/local/bin/kf

   Mac

   Isso instalará kf para todos os usuários no sistema.

   gsutil 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

   Isso instalará kf na sua 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/${KF_VERSION}/kf-linux ~/bin/kf
   chmod a+x ~/bin/kf
   echo "export PATH=$HOME/bin:$PATH" >> ~/.bashrc
   source ~/.bashrc

   Windows

   O download do arquivo kf no diretório atual será feito. Adicione-o ao caminho se você quiser chamar de outro local que não seja diretório atual.

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

4. Instale os componentes do servidor:

   Linux e Mac

   Isso fará o download do kf.yaml no diretório atual.

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

   Windows

   Isso fará o download do kf.yaml no diretório atual.

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

5. Configurar secrets:

   export WI_ANNOTATION=iam.gke.io/gcp-service-account=${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com
   
   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}.iam.gserviceaccount.com\"}}" | kubectl apply -f -

6. Defina os padrões Kf, esses valores podem ser alterados posteriormente. O exemplo abaixo usa modelos de domínio com um provedor de DNS curinga para fornecer a cada espaç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

   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é 10 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 Kafka.

Como enviar um aplicativo

Pré-requisitos

Para concluir esta seção, é necessário:

1. Kf instalado em um cluster do GKE compatível. Consulte Instalar o Kf para ver as instruções.
2. Um .kubeconfig que segmenta o cluster do Kf. Se você criou o cluster de acordo com as instruções deste documento, isso já será feito. Você pode gerar explicitamente a configuração com gcloud container clusters get-credentials ${CLUSTER_NAME} --zone ${CLUSTER_LOCATION}
3. A CLI kf instalada e no seu caminho. Consulte Instalar o Kf para ver as instruções.
4. A CLI git instalada e no seu caminho.

Prepare o espaço

1. Criar novo espaço:

   kf create-space test-space

2. Direcione o espaço:

   kf target -s test-space

Enviar o app de teste do Cloud Foundry

1. Clone o repositório do test-app:

   git clone https://github.com/cloudfoundry-samples/test-app go-test-app
   cd go-test-app

2. Envie o app:

   kf push test-app

3. Encontre o URL do aplicativo:

   1. Use a formatação de saída para recuperar apenas a rota:

      kf app test-app --output 'jsonpath={.status.urls[0]}'

   2. Ou para uma abordagem de CF mais tradicional:

      kf apps

   Observação: o app definiu a propriedade de rota aleatória.

4. Abra o URL no seu navegador.

Limpeza

Essas etapas precisam remover todos os componentes criados na seção Criar e preparar um novo cluster do GKE.

1. Exclua o cluster do GKE:

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

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

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

3. 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}.iam.gserviceaccount.com" \
     --role="roles/storage.admin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/iam.serviceAccountAdmin"
   
   gcloud projects remove-iam-policy-binding ${CLUSTER_PROJECT_ID} \
     --member="serviceAccount:${CLUSTER_NAME}-sa@${CLUSTER_PROJECT_ID}.iam.gserviceaccount.com" \
     --role="roles/monitoring.metricWriter"

4. Excluir repositório de imagens de contêiner:

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