Versão 2.1

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

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

Ativar o suporte para o Compute Engine

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  4. Ative a API Compute Engine.

    Ativar a API

Ativar e configurar o GKE

Antes de começar, veja se você realizou as seguintes tarefas:

Defina as configurações padrão da gcloud usando um dos métodos a seguir:

  • Use gcloud init se quiser orientações para definir os padrões.
  • Use gcloud config para definir individualmente a região, a zona e o ID do projeto.

Como usar o gcloud init

Se você receber o erro One of [--zone, --region] must be supplied: Please specify location, conclua esta seção.

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você estiver usando SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine para clusters zonais ou uma região para clusters regionais ou de Autopilot.

Como usar o gcloud config

  • Defina o ID do projeto padrão:
    gcloud config set project PROJECT_ID
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone COMPUTE_ZONE
  • Se você estiver trabalhando com clusters de Autopilot ou regionais, defina a região do Compute padrão:
    gcloud config set compute/region COMPUTE_REGION
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Criar e preparar um novo cluster do GKE

Configurar as variáveis de ambiente

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.1.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.1.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.

  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

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. A preparação de um ambiente do Google Kubernetes Engine para produção tem várias recomendações úteis, incluindo como configurar regras de firewall.

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

  1. Instalar o Service Mesh.

  2. Instale o Tekton:

    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

  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

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

  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}