Esta página foi traduzida pela API Cloud Translation.

Aceda a clusters privados do Google Kubernetes Engine a partir de pools privadas do Cloud Build através do serviço de identidade para o GKE

Este tutorial descreve como aceder ao plano de controlo de um cluster privado do Google Kubernetes Engine (GKE) através de pools privados do Cloud Build. Este acesso permite-lhe usar o Cloud Build para implementar aplicações e gerir recursos num cluster do GKE privado. Este tutorial destina-se a administradores de plataformas, administradores de clusters e programadores. Parte do princípio de que está familiarizado com o GKE, o Cloud Build, o OpenID Connect e a gcloudferramenta de linha de comandos.

Os pools privados do Cloud Build e os planos de controlo do cluster do GKE são executados em redes de nuvem virtual privada (VPC) pertencentes à Google. Estas redes VPC estão intercambiadas com a sua própria rede VPC no Google Cloud. No entanto, o peering de redes VPC não suporta o peering transitivo, o que pode ser uma restrição quando usa pools privados do Cloud Build. Este tutorial apresenta uma solução que usa o serviço de identidade para o GKE para permitir que os trabalhadores num conjunto privado do Cloud Build acedam ao plano de controlo de um cluster privado do GKE.

Vista geral da arquitetura

O Serviço de identidade para o GKE é um proxy de autenticação para os planos de controlo do cluster do GKE. Encaminha pedidos para o servidor da API e valida tokens de ID emitidos por fornecedores de identidade do OpenID Connect (OIDC). Depois de o proxy validar com êxito um token de ID, o proxy adiciona cabeçalhos HTTP de roubo de identidade do utilizador ao pedido original e encaminha-o para o servidor da API. O proxy é executado como uma conta de serviço do Kubernetes que tem autorizações para se fazer passar por utilizadores e grupos.

O serviço de identidade para o proxy do GKE é executado como pods em nós do cluster. Um serviço do Kubernetes do tipo LoadBalancer expõe o proxy fora do cluster. Se o serviço de identidade para o GKE estiver ativado num cluster privado, o instalador adiciona uma anotação ao serviço Kubernetes para aprovisionar um equilibrador de carga de rede de encaminhamento interno. É possível aceder ao proxy através do balanceador de carga através de uma ligação de intercâmbio da rede da VPC, como a partir de um conjunto privado do Cloud Build, porque o proxy é executado em nós do cluster na sua rede da VPC.

Pode configurar o Google como um fornecedor de identidade OpenID Connect no Identity Service for GKE porque o sistema de autenticação OAuth 2.0 da Google está em conformidade com a especificação OpenID Connect. Para obter tokens de ID para uma conta de serviço Google, pode usar o método generateIdToken da API Service Account Credentials. Os tokens de ID são emitidos e assinados pela Google.

Em conjunto, esta solução permite o acesso ao plano de controlo do cluster do GKE privado através do proxy do serviço de identidade para o GKE. As compilações executadas num conjunto privado do Cloud Build estabelecem ligação ao proxy através de uma ligação de intercâmbio da rede da VPC. A compilação que está a ser executada no pool privado do Cloud Build é executada como uma conta de serviço Google. Esta conta de serviço Google pode obter um token de ID para autenticar no proxy a partir da API Service Account Credentials.

O diagrama seguinte mostra a arquitetura descrita no texto anterior:

Aceda a clusters privados do GKE através do Identity Service para o GKE

Toda a comunicação nesta solução ocorre através do espaço de endereços IP interno. Os trabalhadores no conjunto privado não precisam de conetividade de Internet pública.

As autorizações de gestão de identidade e acesso (IAM) concedidas a contas de utilizador e contas de serviço Google não se aplicam quando a autenticação é feita através do serviço de identidade para o GKE. Em alternativa, usa o controlo de acesso baseado em funções (CABF) do Kubernetes para gerir as autorizações de cluster destas contas.

Antes de começar

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.

Install the Google Cloud CLI.

Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro, tem de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

Install the Google Cloud CLI.

Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro, tem de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select a Google Cloud project.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Cloud Build, GKE, Identity-Aware Proxy (IAP), and Service Networking APIs APIs:

gcloud services enable cloudbuild.googleapis.com container.googleapis.com iap.googleapis.com servicenetworking.googleapis.com

Crie um cluster privado do GKE

No Cloud Shell, crie um cluster do GKE que não tenha acesso de cliente ao ponto final público do plano de controlo e que tenha o serviço de identidade para o GKE instalado:
```
gcloud container clusters create CLUSTER  \
  --enable-identity-service \
  --enable-ip-alias \
  --enable-master-authorized-networks \
  --enable-private-endpoint \
  --enable-private-nodes \
  --master-ipv4-cidr CONTROL_PLANE_CIDR \
  --network NETWORK\
  --release-channel regular \
  --scopes cloud-platform \
  --subnetwork SUBNET \
  --tags NODE_TAGS \
  --workload-pool PROJECT_ID.svc.id.goog \
  --zone ZONE
```
Substitua o seguinte:
- CLUSTER: o nome do cluster. Para este tutorial, use private-cluster.
- CONTROL_PLANE_CIDR: o intervalo de endereços IP do plano de controlo. Tem de ter um prefixo /28. Para este tutorial, pode usar 172.16.0.32/28.
- NETWORK: a rede VPC à qual o plano de controlo se liga. Para este tutorial, use default.
- SUBNET: a sub-rede à qual o plano de controlo do cluster do GKE se liga. A sub-rede tem de pertencer à rede de VPC especificada por NETWORK. Para este tutorial, use default.
- NODE_TAGS: uma lista separada por vírgulas de etiquetas de rede a aplicar aos nós. Para este tutorial, use private-cluster-node.
- PROJECT_ID: o ID do seu Google Cloud projeto.
- ZONE: a zona do cluster do GKE. Para este tutorial, use us-central1-f.
Tenha em atenção o seguinte acerca do comando:
- A flag --enable-identity-service ativa o serviço de identidade para o GKE no cluster. No seu próprio ambiente, pode ativar o serviço de identidade para o GKE num cluster existente.
- A flag --enable-private-endpoint configura o plano de controlo para ser acessível apenas através de endereços IP internos.
- A flag --enable-private-nodes configura os nós do cluster para terem apenas endereços IP internos.
- As flags --enable-master-authorized-networks e --enable-private-nodes permitem o acesso ao servidor da API apenas a partir das redes privadas especificadas pela flag --network.
- O sinalizador --workload-pool opcional ativa a federação de identidades da carga de trabalho para o GKE. Não é necessário para este tutorial.
Adicione uma regra de firewall que permita ao plano de controlo do cluster do GKE estabelecer ligação ao webhook de admissão de validação para recursos ClientConfig:
```
gcloud compute firewall-rules create allow-control-plane-clientconfig-webhook \
  --allow tcp:15000 \
  --network NETWORK\
  --source-ranges CONTROL_PLANE_CIDR\
  --target-tags NODE_TAGS
```
ClientConfig é um tipo de recurso personalizado (CRD) do Kubernetes que o serviço de identidade para GKE usa para configurar a forma de interagir com os fornecedores de identidade.

Registe o serviço de identidade para o GKE como uma aplicação cliente OAuth 2.0

Nesta secção, regista o serviço de identidade para o GKE como uma aplicação cliente através do sistema de autenticação OAuth 2.0 da Google.

Abra a página Credenciais na Google Cloud consola.

Abra a página Credenciais
Clique em Criar credenciais.
Selecione ID de cliente OAuth.

Se o ecrã de consentimento ainda não tiver sido configurado para o projeto do Google Cloud, clique em Configurar ecrã de consentimento. Siga a documentação sobre a configuração do ecrã de consentimento. Para este tutorial, defina os seguintes valores:
- O Tipo de utilizador pode ser Interno ou Externo. Para este tutorial, pode selecionar Interno.
- Os valores para Nome da app, Email de apoio técnico ao utilizador e Informações de contacto do programador são obrigatórios e podem ter qualquer valor.
- Não precisa de adicionar âmbitos para este tutorial.
Quando terminar de configurar o ecrã de consentimento, clique em Voltar ao painel de controlo e, em seguida, comece novamente a partir do passo 1 do procedimento atual.
Na lista Tipo de aplicação, selecione Aplicação Web.
No campo Nome, introduza um nome para o ID do cliente. Para este tutorial, use Identity Service for GKE.
Clique em Criar.

É apresentada uma caixa de diálogo. Copie o valor de O seu ID do cliente. Vai precisar dele mais tarde neste procedimento.
Clique em OK para fechar a caixa de diálogo.
No Cloud Shell, crie um diretório abaixo do diretório principal denominado cloud-build-private-pools-gke-tutorial e, em seguida, aceda a esse diretório:

mkdir -p ~/cloud-build-private-pools-gke-tutorial cd ~/cloud-build-private-pools-gke-tutorial
No novo diretório, crie um ficheiro YAML denominado client-config-patch.yaml com valores que precisa mais tarde para aplicar patches ao recurso ClientConfig do serviço de identidade para o GKE:
```
cat << EOF > client-config-patch.yaml
spec:
  authentication:
  - name: google-oidc
    oidc:
      clientID: CLIENT_ID
      cloudConsoleRedirectURI: https://console.cloud.google.com/kubernetes/oidc
      extraParams: prompt=consent,access_type=offline
      issuerURI: https://accounts.google.com
      kubectlRedirectURI: http://localhost:10000/callback
      scopes: email
      userClaim: email
      userPrefix: '-'
EOF
```
Substitua CLIENT_ID pelo ID de cliente OAuth do passo anterior.

Tenha em atenção o seguinte acerca da correção:
- Os tokens de ID emitidos pelo sistema de autenticação OAuth 2.0 da Google contêm um identificador numérico exclusivo na reivindicação sub (sujeito). A utilização deste identificador opaco em associações de funções dificulta a identificação do assunto de uma associação de funções. Por conseguinte, esta correção configura o serviço de identidade para o GKE de modo a usar a reivindicação de email dos tokens de ID para identificar os utilizadores em vez de usar a reivindicação sub predefinida.
- O âmbito do email é adicionado para que os tokens de ID emitidos incluam a reivindicação de email.
- Os campos cloudConsoleRedirectURI, extraParams, kubectlRedirectURI e scopes são usados quando os programadores se autenticam no cluster através do serviço de identidade para o GKE. Não são usadas quando as contas de serviço Google fazem a autenticação no cluster. O campo kubectlRedirectURI é obrigatório.
- O campo userPrefix é um prefixo para os utilizadores que autenticam através do fornecedor de identidade configurado. O valor '-' significa que não existe prefixo.
- O campo spec.authentication é uma matriz. Pode usar vários fornecedores de identidade OpenID Connect com o serviço de identidade para o GKE. Por exemplo, pode usar o Google como fornecedor de identidade para autenticar contas de serviço Google e um fornecedor de identidade diferente para autenticar programadores.
Para mais informações sobre os campos nesta configuração, consulte o artigo Use fornecedores de identidade externos para autenticar no GKE.

Crie uma conta de serviço Google para configurar o serviço de identidade para o GKE

No Cloud Shell, crie uma conta de serviço Google:
```
gcloud iam service-accounts create ISG_GSA \
  --display-name "Configure Identity Service for GKE"
```
Substitua ISG_GSA pelo nome que quer usar para a conta de serviço Google. Para este tutorial, use identity-service-for-gke.

Atribui esta conta de serviço Google a uma instância de VM do Compute Engine para configurar o serviço de identidade para o GKE e o controlo de acesso baseado em funções do Kubernetes no cluster.
Conceda a função Administrador do Kubernetes Engine no projeto à conta de serviço da Google:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
  --role roles/container.admin
```
Esta função fornece as autorizações necessárias para realizar as seguintes tarefas neste tutorial:
- Configure as definições do serviço de identidade para o GKE em clusters no projeto.
- Crie associações de funções e associações de funções de cluster no cluster.

Configure o serviço de identidade para o GKE

Para configurar o serviço de identidade para o GKE, tem de ter acesso ao plano de controlo do cluster. Neste tutorial, cria uma instância de VM do Compute Engine para aceder ao plano de controlo.

Precisa de acesso SSH à instância de VM. Para ativar o acesso SSH autenticado e autorizado a partir do exterior da rede VPC para a instância de VM, usa o encaminhamento TCP com o Identity-Aware Proxy (IAP). Esta funcionalidade permite o acesso SSH sem exigir que a instância de VM tenha um endereço IP público.

No Cloud Shell, crie uma regra de firewall que permita o acesso SSH através do encaminhamento TCP do IAP para quaisquer instâncias de VM que tenham a etiqueta de rede ssh-iap:
```
gcloud compute firewall-rules create allow-ssh-ingress-from-iap \
  --allow tcp:22 \
  --description "Allow SSH tunneling using Identity-Aware Proxy" \
  --network NETWORK \
  --source-ranges 35.235.240.0/20 \
  --target-tags ssh-iap
```
O intervalo de origem contém os endereços IP que o IAP usa para o encaminhamento TCP.
Crie uma instância de VM do Compute Engine na mesma rede VPC que o cluster do GKE:
```
gcloud compute instances create VM \
  --metadata enable-oslogin=TRUE \
  --network NETWORK \
  --no-address \
  --scopes cloud-platform,userinfo-email \
  --service-account ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
  --subnet SUBNET  \
  --tags ssh-iap \
  --zone ZONE
```
Substitua VM pelo nome que quer usar para a instância de VM. Para este tutorial, use identity-service-for-gke-configuration.

Tenha em atenção o seguinte acerca do comando acima:
- A flag --service-account associa a conta de serviço Google à instância de VM.
- O âmbito cloud-platform é necessário para aceder à API de credenciais da conta de serviço.
- O userinfo-email âmbito é útil quando cria uma instância de VM para gerir o controlo de acesso baseado em funções do Kubernetes. É opcional para este tutorial.
- A flag --no-address significa que a instância de VM é criada sem um endereço IP externo.
- O valor de metadados da instância enable-oslogin opcional ativa o início de sessão do SO na instância de VM. O Início de sessão do SO permite a gestão do acesso SSH a instâncias de VM através do IAM.
Copie o ficheiro de patch ClientConfig para a instância de VM:
```
gcloud compute scp client-config-patch.yaml VM:~ --tunnel-through-iap --zone ZONE
```
A flag --tunnel-through-iap indica ao gcloud que deve encaminhar a ligação através do IAP.
Estabeleça ligação à instância da VM através de SSH:
```
gcloud compute ssh VM --tunnel-through-iap --zone ZONE
```
Executa o resto dos comandos nesta secção a partir da sessão de SSH.
Instale a kubectl ferramenta de linhas de comando e o binário gke-gcloud-auth-plugin na instância da VM:
```
sudo apt-get install -y kubectl google-cloud-sdk-gke-gcloud-auth-plugin
```

Obtenha as credenciais para o cluster do GKE:

export USE_GKE_GCLOUD_AUTH_PLUGIN=True
gcloud container clusters get-credentials CLUSTER --zone ZONE

Aplique uma correção ao recurso ClientConfig predefinido:

kubectl patch clientconfig default \
    --namespace kube-public \
    --patch-file client-config-patch.yaml \
    --type merge

Extraia o campo certificateAuthorityData do recurso ClientConfig predefinido corrigido e armazene-o num ficheiro denominado certificateAuthorityData.pem:

kubectl get clientconfig default \
     --namespace kube-public \
     --output jsonpath='{.spec.certificateAuthorityData}' \
     | base64 --decode > certificateAuthorityData.pem

Extraia o campo do servidor do recurso ClientConfig predefinido corrigido e armazene-o num ficheiro denominado server.txt:
```
kubectl get clientconfig default \
     --namespace kube-public \
     --output jsonpath='{.spec.server}' > server.txt
```
Saia da sessão SSH:
```
exit
```

(Opcional) Valide a configuração do cluster

Antes de continuar, pode verificar se o serviço de identidade para o GKE foi configurado corretamente no cluster. Valida a configuração usando a conta de serviço Google anexada à instância de VM para fazer a autenticação no cluster através do serviço de identidade para o GKE.

No Cloud Shell, conceda a função Criador de tokens de identidade OpenID Connect da conta de serviço à própria conta de serviço:
```
gcloud iam service-accounts add-iam-policy-binding \
  ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
  --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
  --role roles/iam.serviceAccountOpenIdTokenCreator
```
Esta função fornece a autorização iam.serviceAccounts.getOpenIdToken necessária para pedir tokens de ID para a conta de serviço à API Service Account Credentials.
Estabeleça ligação à instância da VM através de SSH:
```
gcloud compute ssh VM --tunnel-through-iap --zone ZONE
```
Executa o resto dos comandos nesta secção a partir da sessão de SSH.
Peça um token de acesso do OAuth 2.0 ao servidor de metadados para a conta de serviço Google associada à instância de VM, usando o ID do cliente OAuth como a reivindicação aud (público-alvo) pedida:
```
ACCESS_TOKEN=$(curl --silent --header "Metadata-Flavor: Google" \
http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
       | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')
```
O corpo da resposta do servidor de metadados é um documento JSON. O comando usa um script Python inline para extrair o campo access_token do corpo da resposta.

Peça um token de ID à API Service Account Credentials para a conta de serviço Google associada à instância de VM:

ID_TOKEN=$(curl --silent --request POST \
    --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
    --header "Authorization: Bearer $ACCESS_TOKEN" \
    --header "Content-Type: application/json; charset=utf-8" \
"https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/ISG_GSA@PROJECT_ID.iam.gserviceaccount.com:generateIdToken" \
       | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')

Tenha em atenção o seguinte acerca do comando acima:

O campo audience no JSON do corpo do pedido especifica a reivindicação aud (público-alvo) pedida do token de ID.
O token de acesso do passo anterior é usado para autenticar na API.

Veja as reivindicações no token de ID:

echo $ID_TOKEN \
    | cut -d. -f2 \
    | base64 --decode --ignore-garbage 2> /dev/null \
    | python3 -m json.tool

Verifique se a reivindicação email contém o endereço de email da conta de serviço Google.

Use o token de ID para fazer a autenticação no plano de controlo através do serviço de identidade para o GKE:
```
kubectl get namespaces \
    --certificate-authority certificateAuthorityData.pem \
    --server $(cat server.txt) \
    --token $ID_TOKEN
```
O resultado é semelhante ao seguinte:
```
  Error from server (Forbidden): namespaces is forbidden: User "ISG_GSA@PROJECT_ID.iam.gserviceaccount.com" cannot list resource "namespaces" in API group "" at the cluster scope
```
Este erro é esperado. Embora a conta de serviço Google tenha recebido autorizações da IAM em clusters do GKE no projeto, as autorizações da IAM não se aplicam quando se autentica através do serviço de identidade para o GKE. Em alternativa, configura o acesso através do controlo de acesso baseado em funções (CABF) do Kubernetes.
Crie uma associação de funções de cluster que conceda a função de cluster view à conta de serviço Google quando a conta de serviço se autentica no cluster através do fornecedor OpenID Connect da Google:
```
kubectl create clusterrolebinding ISG_GSA-cluster-view \
    --clusterrole view \
    --user ISG_GSA@PROJECT_ID.iam.gserviceaccount.com
```
Se definir um valor userPrefix diferente de - no ClientConfig no seu próprio ambiente, adicione o prefixo ao valor da flag --user neste comando.

Aceda ao cluster do GKE através do serviço de identidade para o GKE:

kubectl get namespaces \
    --certificate-authority certificateAuthorityData.pem \
    --server $(cat server.txt) \
    --token $ID_TOKEN

O resultado é semelhante ao seguinte:

NAME                      STATUS   AGE
anthos-identity-service   Active   1h
default                   Active   1h
kube-node-lease           Active   1h
kube-public               Active   1h
kube-system               Active   1h

Saia da sessão SSH:
```
exit
```

Crie um contexto para a ferramenta `kubectl`

O comando kubectl pode usar um ficheiro kubeconfig para configurar o acesso a clusters. Um ficheiro kubeconfig contém um ou mais contextos. Cada contexto tem um nome e, opcionalmente, inclui informações de conetividade do cluster, credenciais usadas para autenticar no cluster e um espaço de nomes predefinido.

Nesta secção, cria um ficheiro kubeconfig com um contexto. O contexto inclui detalhes de conetividade do serviço de identidade para o proxy do GKE para o seu cluster. Não adiciona credenciais de utilizador ao ficheiro kubeconfig.

No Cloud Shell, copie os ficheiros que contêm os dados da autoridade de certificação e o URL do servidor da instância de VM para o diretório atual:
```
gcloud compute scp VM:~/certificateAuthorityData.pem VM:~/server.txt . \
    --tunnel-through-iap --zone ZONE
```
Crie um contexto e uma configuração de cluster que vai usar mais tarde para se ligar ao cluster do GKE a partir do Cloud Build:
```
kubectl config set-context private-cluster \
    --cluster private-cluster \
    --kubeconfig kubeconfig
```
A flag --kubeconfig cria a configuração do contexto e do cluster num novo ficheiro denominado kubeconfig no diretório atual.

Este comando usa o nome do cluster do GKE como o nome da configuração do cluster para o contexto. No seu próprio ambiente, pode usar um nome de configuração de cluster diferente no contexto.

Defina o campo certificateAuthorityData na configuração do cluster:

kubectl config set-cluster private-cluster \
    --certificate-authority certificateAuthorityData.pem \
    --embed-certs \
    --kubeconfig kubeconfig

Defina o campo server na configuração do cluster:

kubectl config set-cluster private-cluster \
    --kubeconfig kubeconfig \
    --server $(cat server.txt)

Crie uma conta de serviço Google para o Cloud Build

No Cloud Shell, crie uma conta de serviço Google para executar compilações no conjunto privado do Cloud Build:
```
gcloud iam service-accounts create CB_GSA \
  --description "Runs builds on Cloud Build private pools" \
  --display-name "Cloud Build private pool"
```
Substitua CB_GSA pelo nome que quer usar para a conta de serviço Google. Para este tutorial, use cloud-build-private-pool.
Conceda a função de conta de serviço do Cloud Build no projeto à conta de serviço da Google:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/cloudbuild.builds.builder
```
Esta função fornece as autorizações predefinidas da conta de serviço do Cloud Build gerida pela Google.
Conceda a função Criador de tokens de identidade OpenID Connect da conta de serviço na conta de serviço Google à própria conta de serviço:
```
gcloud iam service-accounts add-iam-policy-binding \
    CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.serviceAccountOpenIdTokenCreator
```
Esta função fornece a autorização iam.serviceAccounts.getOpenIdToken necessária para pedir tokens de ID para a conta de serviço à API Service Account Credentials.
Estabeleça ligação à instância da VM através de SSH:
```
gcloud compute ssh VM --tunnel-through-iap --zone ZONE
```
Executa o resto dos comandos nesta secção a partir da sessão de SSH.
Na sessão SSH, crie uma associação de funções do cluster do Kubernetes que conceda a função do cluster cluster-admin à conta de serviço Google quando a conta de serviço se autentica no cluster através do fornecedor OpenID Connect da Google:
```
kubectl create clusterrolebinding CB_GSA-cluster-admin \
    --clusterrole cluster-admin \
    --user CB_GSA@PROJECT_ID.iam.gserviceaccount.com
```
A função de cluster cluster-admin concede autorizações extensivas ao nível do cluster. No seu próprio ambiente, pode usar uma função de cluster que faculte apenas as autorizações necessárias para as tarefas que o Cloud Build executa. Também pode usar associações de funções para conceder autorizações apenas a espaços de nomes específicos.

Se definir um userPrefix no ClientConfig no seu próprio ambiente, tem de adicionar esse prefixo ao valor da flag --user neste comando.
Saia da sessão SSH:
```
exit
```

Crie um pool privado do Cloud Build

No Cloud Shell, atribua um intervalo de endereços IP na sua rede VPC para a ligação com o conjunto privado:
```
gcloud compute addresses create RESERVED_RANGE_NAME \
--addresses RESERVED_RANGE_START_IP\
    --description "Cloud Build private pool reserved range" \
    --global \
    --network NETWORK \
    --prefix-length RESERVED_RANGE_PREFIX_LENGTH \
    --purpose VPC_PEERING
```
Substitua o seguinte:
- RESERVED_RANGE_NAME: o nome do intervalo de endereços IP atribuído que aloja o pool privado do Cloud Build. Para este tutorial, use cloud-build-private-pool.
- RESERVED_RANGE_START_IP: o primeiro endereço IP do intervalo de endereços IP atribuído. Para este tutorial, use 192.168.12.0.
- RESERVED_RANGE_PREFIX_LENGTH: o comprimento do prefixo (máscara de sub-rede) do intervalo de endereços IP atribuído. O comprimento do prefixo tem de ser /23 ou um número inferior, por exemplo, /22 ou /21. Um número inferior significa um intervalo de endereços maior. Para este tutorial, use 23 e não introduza a barra / inicial.

Crie uma regra de firewall para permitir o tráfego de entrada do intervalo de endereços IP reservados para outros recursos na sua rede VPC:

gcloud compute firewall-rules create allow-private-pools-ingress \
    --allow all \
    --network NETWORK \
    --source-ranges RESERVED_RANGE_START_IP/RESERVED_RANGE_PREFIX_LENGTH

Crie uma ligação de serviço privado para ligar a sua rede VPC ao serviço Service Networking:
```
gcloud services vpc-peerings connect \
    --network NETWORK \
    --ranges RESERVED_RANGE_NAME \
    --service servicenetworking.googleapis.com
```
As pools privadas do Cloud Build executam trabalhadores através da rede de serviços. A ligação de serviço privado permite que a sua rede VPC comunique com o conjunto privado no intervalo atribuído de endereços IP internos, através de uma ligação de interligação de redes VPC.

A criação da ligação de serviço privado pode demorar alguns minutos.

Se usar uma VPC partilhada no seu próprio ambiente, para obter informações sobre os passos adicionais para criar a ligação de serviço privado, consulte o artigo Configure o seu ambiente.
Crie um pool privado do Cloud Build numa rede VPC pertencente à Google que esteja em peering com a sua rede VPC:
```
gcloud builds worker-pools create PRIVATE_POOL_NAME \
   --no-public-egress \
   --peered-network projects/PROJECT_ID/global/networks/NETWORK \
   --region REGION
```
Substitua o seguinte:
- PRIVATE_POOL_NAME: o nome do conjunto privado. Para este tutorial, use private-pool.
- REGION: a região a usar para o pool privado. Para este tutorial, use us-central1.
A flag --no-public-egress significa que os trabalhadores no grupo privado não têm endereços IP públicos. No seu próprio ambiente, pode remover esta flag se quiser que os trabalhadores no conjunto privado tenham conetividade com a Internet através de endereços IP públicos.

Para ver informações sobre opções de configuração adicionais, como o tipo de máquina e o tamanho do disco para os trabalhadores no pool privado, consulte o artigo Crie e faça a gestão de pools privados.

Valide a solução

Nesta secção, valida a solução executando uma compilação no pool privado do Cloud Build. A compilação acede ao cluster privado do GKE.

No Cloud Shell, crie um contentor do Cloud Storage para armazenar registos de compilação do Cloud Build:
```
gcloud storage buckets create gs://PROJECT_ID-build-logs --location=REGION
```
Crie um ficheiro de configuração de compilação para o Cloud Build:
```
cat << "EOF" > cloudbuild.yaml
steps:
- id: list-services
  name: gcr.io/google.com/cloudsdktool/google-cloud-cli
  entrypoint: bash
  args:
  - -eEuo
  - pipefail
  - -c
  - |-
    kubectl config use-context $_KUBECTL_CONTEXT

    ACCESS_TOKEN=$$(curl --silent \
        --header "Metadata-Flavor: Google" \
        http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token \
        | python3 -c 'import json, sys; print(json.load(sys.stdin).get("access_token"))')

    ID_TOKEN=$$(curl --silent --request POST \
        --data '{"audience": "CLIENT_ID", "includeEmail": true}' \
        --header "Authorization: Bearer $$ACCESS_TOKEN" \
        --header "Content-Type: application/json; charset=utf-8" \
        "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/$_SERVICE_ACCOUNT:generateIdToken" \
        | python3 -c 'import json, sys; print(json.load(sys.stdin).get("token"))')

    kubectl get services --namespace $_NAMESPACE --token $$ID_TOKEN

logsBucket: gs://PROJECT_ID-build-logs

options:
  env:
  - KUBECONFIG=/workspace/$_KUBECONFIG

substitutions:
  _KUBECONFIG: kubeconfig
  _KUBECTL_CONTEXT: private-cluster
  _NAMESPACE: default

serviceAccount: projects/$PROJECT_ID/serviceAccounts/$_SERVICE_ACCOUNT
EOF
```
O passo no ficheiro de configuração da compilação faz o seguinte:
1. Muda para o contexto kubectl especificado pela substituição _KUBECTL_CONTEXT. O valor de substituição predefinido é private-cluster.
2. Obtém um token de acesso do servidor de metadados. A chave de acesso é emitida para a conta de serviço Google que executa a compilação.
3. Gera um token de ID através da API de credenciais da conta de serviço. O pedido de geração do token de ID é autenticado através do token de acesso. A reivindicação aud (público-alvo) pedida do token de ID é o ID de cliente OAuth 2.0 especificado pela substituição _CLIENT_ID.
4. Lista os serviços Kubernetes no espaço de nomes especificado pela substituição _NAMESPACE. O valor de substituição predefinido é default. O pedido é autenticado através do token de ID gerado no comando anterior.
Tenha em atenção o seguinte acerca do ficheiro de configuração de compilação:
- O caráter $ é o prefixo das substituições. $$ é usado para a expansão de parâmetros do bash e a substituição de comandos.
- As substituições _KUBECONFIG e _KUBECTL_CONTEXT permitem especificar diferentes ficheiros kubeconfig e diferentes contextos quando executa uma compilação. Estas substituições permitem-lhe gerir várias configurações de clusters através de um único ficheiro kubeconfig com vários contextos ou através de vários ficheiros kubeconfig.
- A substituição _SERVICE_ACCOUNT não tem um valor predefinido. Tem de fornecer um valor para esta substituição quando executar uma compilação.
- O bloco options define a variável de ambiente KUBECONFIG para todos os passos na compilação.
- O passo de compilação usa a imagem do criador gcr.io/google.com/cloudsdktool/google-cloud-cli. Esta é uma imagem de contentor grande e demora algum tempo a extraí-la do registo para o trabalhador do grupo privado. Para reduzir o tempo necessário para extrair a imagem do criador, pode criar uma imagem do criador personalizada que contenha apenas as ferramentas necessárias para o passo de compilação, como curl, kubectl e Python.
Para mais informações sobre scripts de shell inline em ficheiros de configuração de compilação, consulte o artigo Executar scripts bash.
Execute uma compilação com o ficheiro de configuração de compilação e os ficheiros no diretório atual:
```
gcloud builds submit \
    --config cloudbuild.yaml \
    --region REGION \
    --substitutions _SERVICE_ACCOUNT=CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --worker-pool projects/PROJECT_ID/locations/REGION/workerPools/PRIVATE_POOL_NAME
```
O comando carrega todos os ficheiros que se encontram no diretório atual para o Cloud Storage para utilização pelo Cloud Build. O passo de compilação usa o ficheiro kubeconfig para estabelecer ligação ao cluster do GKE.

Perto do final do resultado, vê linhas semelhantes às seguintes:
```
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.0.0.1     <none>        443/TCP   2h
```
Este resultado mostra que o trabalhador do pool privado se ligou ao plano de controlo do cluster através do proxy de autenticação do Identity Service para GKE.

Resolução de problemas

Se não conseguir estabelecer ligação à instância de VM através de SSH, adicione a flag --troubleshoot para ajudar a descobrir a causa dos problemas de conetividade:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --troubleshoot

Se receber a mensagem Error from server (NotFound): clientconfigs.authentication.gke.io "default" not found quando aplicar o patch ao ClientConfig predefinido no cluster do GKE, certifique-se de que criou a regra de firewall conforme descrito na secção Criar um cluster do GKE privado. Verifique se a regra de firewall existe:

gcloud compute firewall-rules describe allow-control-plane-clientconfig-webhook

Se não conseguir autenticar-se no serviço de identidade para o proxy do GKE, procure erros nos registos dos pods na implementação gke-oidc-service:

gcloud compute ssh VM --tunnel-through-iap --zone ZONE --command \
    'kubectl logs deployment/gke-oidc-service \
         --namespace anthos-identity-service --all-containers'

Se tiver outros problemas com este tutorial, recomendamos que reveja estes documentos:

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

Elimine o projeto

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimine os recursos

Se quiser manter o projeto que usou neste tutorial, elimine os recursos individuais:

No Cloud Shell, elimine o pool privado do Cloud Build:

gcloud builds worker-pools delete PRIVATE_POOL_NAME --region REGION --quiet

Elimine a ligação de serviço privada à rede de serviços:

gcloud services vpc-peerings delete --network NETWORK \
  --service servicenetworking.googleapis.com --quiet --async

Elimine o intervalo de endereços IP atribuído aos grupos privados do Cloud Build:
```
gcloud compute addresses delete RESERVED_RANGE_NAME --global --quiet
```
Elimine o contentor do Cloud Storage e todo o respetivo conteúdo:
```
gcloud storage rm gs://PROJECT_ID-build-logs --recursive
```

Elimine o cluster do GKE:

gcloud container clusters delete CLUSTER --zone ZONE --quiet --async

Elimine a instância de VM do Compute Engine:

gcloud compute instances delete VM --zone ZONE --quiet

Elimine as regras de firewall:

gcloud compute firewall-rules delete allow-private-pools-ingress --quiet

gcloud compute firewall-rules delete allow-ssh-ingress-from-iap --quiet

gcloud compute firewall-rules delete allow-control-plane-clientconfig-webhook --quiet

Remova as associações de funções IAM:

gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/cloudbuild.builds.builder

gcloud projects remove-iam-policy-binding PROJECT_ID \
    --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/container.admin

gcloud iam service-accounts remove-iam-policy-binding \
    CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --member serviceAccount:CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.serviceAccountOpenIdTokenCreator

gcloud iam service-accounts remove-iam-policy-binding \
    ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --member serviceAccount:ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.serviceAccountOpenIdTokenCreator

Elimine as contas de serviço Google:

gcloud iam service-accounts delete CB_GSA@PROJECT_ID.iam.gserviceaccount.com \
   --quiet

gcloud iam service-accounts delete ISG_GSA@PROJECT_ID.iam.gserviceaccount.com \
   --quiet

Elimine o ID de cliente OAuth 2.0

Aceda à página Credenciais na Google Cloud consola:

Abra a página Credenciais
Selecione o seu projeto na lista do seletor de projetos.
Na tabela de IDs de cliente OAuth 2.0, localize a linha referente a Serviço de identidade para o GKE e, de seguida, clique no ícone Eliminar cliente OAuth.
Na caixa de diálogo, clique em Eliminar.

O que se segue?

Saiba como aceder a clusters do Anthos a partir do Cloud Build com o gateway de ligação.
Saiba como aceder a clusters privados do GKE com pools privados do Cloud Build através da Cloud VPN.
Saiba como criar clusters privados do GKE com proxies de rede para acesso ao plano de controlo.
Saiba como aceder a recursos externos numa rede privada através de um IP externo estático.
Descubra o Serviço de identidade do GKE. O GKE Identity Service permite-lhe gerir a autenticação de fornecedores de identidade externos numa frota de clusters do Anthos.

Aceda a clusters privados do Google Kubernetes Engine a partir de pools privadas do Cloud Build através do serviço de identidade para o GKE Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Vista geral da arquitetura

Antes de começar

Crie um cluster privado do GKE

Registe o serviço de identidade para o GKE como uma aplicação cliente OAuth 2.0

Crie uma conta de serviço Google para configurar o serviço de identidade para o GKE

Configure o serviço de identidade para o GKE

(Opcional) Valide a configuração do cluster

Crie um contexto para a ferramenta kubectl

Crie uma conta de serviço Google para o Cloud Build

Crie um pool privado do Cloud Build

Valide a solução

Resolução de problemas

Limpar

Elimine o projeto

Elimine os recursos

Elimine o ID de cliente OAuth 2.0

O que se segue?

Aceda a clusters privados do Google Kubernetes Engine a partir de pools privadas do Cloud Build através do serviço de identidade para o GKE

Crie um contexto para a ferramenta `kubectl`