Esta página foi traduzida pela API Cloud Translation.

Autenticar em APIs do Google Cloud de cargas de trabalho da frota de confiança compartilhada

Nesta página, mostramos como configurar seus aplicativos para autenticação nas APIs doGoogle Cloud , como a API Compute Engine ou a API AI Platform, em frotas que têm um modelo de confiança compartilhada. Se a frota tiver um modelo de confiança mista, consulte Autenticar em APIs Google Cloud de cargas de trabalho de frota de confiança mista (prévia).

Esta página é destinada a administradores e operadores de plataforma e engenheiros de segurança que querem autenticar programaticamente cargas de trabalho da frota em APIs do Google Cloud. Para saber mais sobre as funções de usuário e as tarefas de exemplo referenciadas na documentação do Google Cloud, consulte Funções e tarefas comuns do usuário do GKE.

Antes de ler esta página, você deve conhecer os seguintes conceitos:

Sobre a federação de identidade da carga de trabalho da frota para ambientes de confiança compartilhada

Com a federação de identidade da carga de trabalho da frota, é possível autenticar cargas de trabalho da frota nas APIs Google Cloud usando mecanismos de autenticação Google Cloud integrados e do Kubernetes. A federação de identidade da carga de trabalho da frota elimina a necessidade de usar métodos menos seguros, como montagem de tokens de acesso em pods ou armazenamento de credenciais de longa duração.

Por padrão, o projeto host da frota usa um pool de identidade da carga de trabalho gerenciado pelo Google para provisionar identidades para entidades em toda a frota. Qualquer entidade na frota ou no projeto host da frota que tenha o mesmo identificador do IAM é considerada a mesma coisa pelo IAM. Essa igualdade de identidade implícita é útil ao conceder acesso em grande reduzir escalonamento horizontal ambientes de confiança compartilhada, como frotas de locatário único, em que não importa se outras entidades recebem permissões semelhantes em recursos sem querer.

Antes de começar

Verifique se você tem as seguintes ferramentas de linha de comando instaladas:
- A versão mais recente da Google Cloud CLI, que inclui gcloud, a ferramenta de linha de comando para interagir com Google Cloud.
- kubectl
Se você estiver usando o Cloud Shell como ambiente shell para interagir com Google Cloud, essas ferramentas estarão instaladas.
Verifique se você inicializou a CLI gcloud para usar com seu projeto.

Prepare seus clusters

Antes que os aplicativos da sua frota recebam uma identidade federada, os clusters em que eles são executados precisam ser registrados para sua frota e configurados corretamente para usar a federação de identidade da carga de trabalho da frota. As seções a seguir descrevem como configurar a federação de identidade da carga de trabalho da frota para diferentes tipos de clusters.

GKE

Para clusters do GKE, faça o seguinte:

Ative a federação de identidade da carga de trabalho do GKE no cluster do Google Kubernetes Engine, se ela ainda não estiver ativada.
Registre o cluster na frota.

Também é possível ativar a federação de identidade da carga de trabalho para o GKE durante o processo de criação de cluster e registro de frota.

Clusters fora de Google Cloud

Os seguintes tipos de cluster ativam automaticamente a Federação de identidade da carga de trabalho da frota e são registrados na frota durante a criação do cluster:

Google Distributed Cloud (somente software) no VMware
Google Distributed Cloud (somente software) em bare metal
GKE na AWS
GKE no Azure

Clusters anexados

Os clusters anexados do EKS e do AKS registrados usando a GKE Multi-cloud são registrados com a federação de identidade da carga de trabalho da frota ativada por padrão. Os clusters anexados podem ser registrados com a federação de identidade da carga de trabalho da frota ativada se atenderem aos requisitos necessários. Siga as instruções para o tipo de cluster em Como registrar um cluster.

Usar a federação de identidade da carga de trabalho da frota em aplicativos

As etapas a seguir mostram como configurar uma carga de trabalho em um cluster registrado para usar a federação de identidade da carga de trabalho da frota:

Encontre o nome do pool de identidades e do provedor de identidade da carga de trabalho do cluster:
```
gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"
```
Substitua:
- MEMBERSHIP_ID: o nome da assinatura do cluster. Geralmente é o nome do cluster.
- FLEET_PROJECT_ID: o ID do projeto host da frota.
O resultado será assim:
```
IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL
NAME: projects/FLEET_PROJECT_ID/locations/MEMBERSHIP_LOCATION/memberships/MEMBERSHIP_ID
```
Essa saída contém as seguintes informações:
- IDENTITY_PROVIDER: o provedor de identidade do cluster.
- MEMBERSHIP_LOCATION: o local da assinatura da frota. Geralmente, é igual ao local do cluster.
- WORKLOAD_IDENTITY_POOL: o nome do pool de identidade da carga de trabalho associado à sua frota. Esse valor tem a sintaxe FLEET_PROJECT_ID.svc.id.goog.
Crie um namespace do Kubernetes. Também é possível usar qualquer namespace existente, incluindo o namespace default.
```
kubectl create namespace NAMESPACE
```
Substitua NAMESPACE pelo nome do namespace.
Crie uma nova conta de serviço do Kubernetes no namespace: Também é possível usar qualquer ServiceAccount atual, incluindo a default no namespace.
```
kubectl create serviceaccount KSA_NAME \
    --namespace=NAMESPACE
```
Substitua KSA_NAME pelo nome da conta de serviço.

Salve o seguinte manifesto adc-config-map.yaml como : Esse ConfigMap contém a configuração do ADC para cargas de trabalho.

kind: ConfigMap
apiVersion: v1
metadata:
  namespace: NAMESPACE
  name: my-cloudsdk-config
data:
  config: |
    {
      "type": "external_account",
      "audience": "identitynamespace:WORKLOAD_IDENTITY_POOL:IDENTITY_PROVIDER",
      "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
      "token_url": "https://sts.googleapis.com/v1/token",
      "credential_source": {
        "file": "/var/run/secrets/tokens/gcp-ksa/token"
      }
    }

Implante o ConfigMap:
```
kubectl create -f adc-config-map.yaml
```

Salve o seguinte manifesto como workload-config.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  namespace:  NAMESPACE
spec:
  serviceAccountName: KSA_NAME
  containers:
  - name: sample-container
    image: google/cloud-sdk:slim
    command: ["sleep","infinity"]
    env:
    - name: GOOGLE_APPLICATION_CREDENTIALS
      value: /var/run/secrets/tokens/gcp-ksa/google-application-credentials.json
    volumeMounts:
    - name: gcp-ksa
      mountPath: /var/run/secrets/tokens/gcp-ksa
      readOnly: true
  volumes:
  - name: gcp-ksa
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          path: token
          audience: WORKLOAD_IDENTITY_POOL
          expirationSeconds: 172800
      - configMap:
          name: my-cloudsdk-config
          optional: false
          items:
          - key: "config"
            path: "google-application-credentials.json"

Quando você implanta essa carga de trabalho, o volume gcp-ksa no pod contém os seguintes dados:

Os dados no ConfigMap que você implantou como um arquivo chamado google-application-credentials.json. Esse arquivo é um arquivo de configuração de credenciais do ADC.
O token da conta de serviço do Kubernetes como token. O Kubernetes monta um JWT assinado para a conta de serviço como um arquivo de token de conta de serviço projetado.

O contêiner no pod monta o volume gcp-ksa no caminho /var/run/secrets/tokens/gcp-ksa e configura o ADC para procurar o arquivo JSON de configuração de credenciais nesse caminho.

Implantar a carga de trabalho:
```
kubectl apply -f workload-config.yaml
```

Alternativa: representar uma conta de serviço do IAM

Como alternativa, é possível configurar as contas de serviço do Kubernetes nos clusters para imitar as contas de serviço do IAM e realizar todas as ações autorizadas que elas podem realizar. Essa abordagem pode aumentar a sobrecarga de manutenção, porque você precisa gerenciar os pares de contas de serviço no IAM e no Kubernetes.

Na maioria dos casos, recomendamos que você faça referência direta aos principais do Kubernetes nas políticas de permissão do IAM para conceder acesso aos recursos doGoogle Cloud seguindo as instruções em Usar a federação de identidade da carga de trabalho da frota em aplicativos.

Encontre o nome do pool de identidades e do provedor de identidade da carga de trabalho do cluster:
```
gcloud container fleet memberships describe MEMBERSHIP_ID \
    --project=FLEET_PROJECT_ID \
    --format="table(authority.identityProvider,authority.workloadIdentityPool,name)"
```
Substitua:
- MEMBERSHIP_ID: o nome da assinatura do cluster. Geralmente é o nome do cluster.
- FLEET_PROJECT_ID: o ID do projeto host da frota.
O resultado será assim:
```
IDENTITY_PROVIDER: IDENTITY_PROVIDER
WORKLOAD_IDENTITY_POOL: WORKLOAD_IDENTITY_POOL
NAME: projects/FLEET_PROJECT_ID/locations/MEMBERSHIP_LOCATION/memberships/MEMBERSHIP_ID
```
Essa saída contém as seguintes informações:
- IDENTITY_PROVIDER: o provedor de identidade do cluster.
- MEMBERSHIP_LOCATION: o local da assinatura. Geralmente, é igual ao local do cluster.
- WORKLOAD_IDENTITY_POOL: o nome do pool de identidade da carga de trabalho associado à sua frota. Esse valor tem a sintaxe FLEET_PROJECT_ID.svc.id.goog.
Crie uma conta de serviço do IAM que seu aplicativo possa imitar. Também é possível usar qualquer conta de serviço do IAM.
```
gcloud iam service-accounts create IAM_SA_NAME \
    --project=IAM_SA_PROJECT_ID
```
Substitua:
- IAM_SA_NAME: o nome da sua conta de serviço do IAM.
- IAM_SA_PROJECT_ID: o ID do projeto que contém sua conta de serviço do IAM. Ele pode ser diferente do seu projeto host da frota.
Conceda à conta de serviço do IAM todas as permissões necessárias para acessar as APIs do Google Cloud adicionando as políticas de permissão do IAM necessárias. Para isso, use gcloud iam service-accounts add-iam-policy-binding ou outro método. Descubra quais permissões são necessárias para usar as APIs do Google Cloud na documentação de cada serviço e consulte uma lista completa de papéis predefinidos com as permissões necessárias em Noções básicas sobre papéis.
Crie uma conta de serviço do Kubernetes em um namespace. Também é possível usar uma Kubernetes ServiceAccount e qualquer namespace, incluindo a default ServiceAccount e o namespace default.
```
kubectl create serviceaccount KSA_NAME \
    --namespace=NAMESPACE
```
Substitua:
- KSA_NAME: o nome da ServiceAccount.
- NAMESPACE: o nome do namespace.

Crie uma política de permissão do IAM que permita que uma ServiceAccount do Kubernetes em um namespace específico no cluster personifique a conta de serviço do IAM:

gcloud iam service-accounts add-iam-policy-binding IAM_SA_NAME@IAM_SA_PROJECT_ID.iam.gserviceaccount.com \
    --project=IAM_SA_PROJECT_ID \
    --role=roles/iam.workloadIdentityUser \
    --member="serviceAccount:WORKLOAD_IDENTITY_POOL[NAMESPACE/KSA_NAME]"

Substitua WORKLOAD_IDENTITY_POOL pelo nome do pool de identidade da carga de trabalho.

Salve o seguinte manifesto adc-config-map.yaml como : Esse ConfigMap contém a configuração do ADC para cargas de trabalho.

kind: ConfigMap
apiVersion: v1
metadata:
  namespace: K8S_NAMESPACE
  name: my-cloudsdk-config
data:
  config: |
    {
      "type": "external_account",
      "audience": "identitynamespace:WORKLOAD_IDENTITY_POOL:IDENTITY_PROVIDER",
      "service_account_impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/IAM_SA_NAME@GSA_PROJECT_ID.iam.gserviceaccount.com:generateAccessToken",
      "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
      "token_url": "https://sts.googleapis.com/v1/token",
      "credential_source": {
        "file": "/var/run/secrets/tokens/gcp-ksa/token"
      }
    }

Substitua:

IAM_SA_NAME: o nome da conta de serviço do IAM a ser imitada.
IAM_SA_PROJECT_ID, o ID do projeto da conta de serviço do IAM.

Salve o seguinte manifesto como workload-config.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  namespace:  K8S_NAMESPACE
spec:
  serviceAccountName: KSA_NAME
  containers:
  - name: my-container
    image: my-image
    command: ["sleep","infinity"]
    env:
      - name: GOOGLE_APPLICATION_CREDENTIALS
        value: /var/run/secrets/tokens/gcp-ksa/google-application-credentials.json
    volumeMounts:
    - name: gcp-ksa
      mountPath: /var/run/secrets/tokens/gcp-ksa
      readOnly: true
  volumes:
  - name: gcp-ksa
    projected:
      defaultMode: 420
      sources:
      - serviceAccountToken:
          path: token
          audience: WORKLOAD_IDENTITY_POOL
          expirationSeconds: 172800
      - configMap:
          name: my-cloudsdk-config
          optional: false
          items:
            - key: "config"
              path: "google-application-credentials.json"

Quando você implanta essa carga de trabalho, o volume gcp-ksa no pod contém os seguintes dados:

Os dados no ConfigMap que você implantou como um arquivo chamado google-application-credentials.json. Esse arquivo é um arquivo de configuração de credenciais do ADC.
O token da conta de serviço do Kubernetes como token. O Kubernetes monta um JWT assinado para a conta de serviço como um arquivo de token de conta de serviço projetado.

O contêiner no pod monta o volume gcp-ksa no caminho /var/run/secrets/tokens/gcp-ksa e configura o ADC para procurar o arquivo JSON de configuração de credenciais nesse caminho.

Implantar a carga de trabalho:
```
kubectl apply -f workload-config.yaml
```

Verificar a configuração da federação de identidade da carga de trabalho da frota

Nesta seção, você vai criar um bucket do Cloud Storage e acessá-lo em um pod que usa a federação de identidade da carga de trabalho da frota. Antes de realizar essas etapas, verifique se você configurou a federação de identidade da carga de trabalho seguindo as instruções na seção Usar a federação de identidade da carga de trabalho da frota em aplicativos.

Esta seção não mostra como verificar a federação de identidade da carga de trabalho usando o método de personificação da conta de serviço do IAM.

Encontre o número do projeto:

gcloud projects describe FLEET_PROJECT_ID \
    --format="value(projectNumber)"

O resultado será assim:

1234567890

Crie um bucket do Cloud Storage:

gcloud storage buckets create gs://FLEET_PROJECT_ID-test-bucket \
    --location=LOCATION

Substitua LOCATION por um local Google Cloud.

Crie uma política de permissão do IAM que conceda acesso ao bucket à conta de serviço criada:
```
gcloud storage buckets add-iam-policy-binding gs://FLEET_PROJECT_ID-test-bucket \
    --condition=None \
    --role=roles/storage.objectViewer \
    --member=principal://iam.googleapis.com/projects/FLEET_PROJECT_NUMBER/locations/global/workloadIdentityPools/FLEET_PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME
```
Substitua:
- FLEET_PROJECT_NUMBER: o número numérico do projeto.
- FLEET_PROJECT_ID: o ID do projeto.
- NAMESPACE: o nome do namespace do Kubernetes que executa seu pod da seção anterior.
- KSA_NAME: o nome da ServiceAccount do Kubernetes que o pod da seção anterior usa.
Prática recomendada: crie políticas de permissão do IAM que ofereçam o menor número de permissões no recurso específico que a carga de trabalho precisa acessar.

Abra uma sessão do shell no pod:

kubectl exec -it pods/my-pod --namespace=NAMESPACE -- /bin/bash

Tente listar os objetos no bucket:

curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
"https://storage.googleapis.com/storage/v1/b/FLEET_PROJECT_ID-test-bucket/o"

A saída é esta:

{
  "kind": "storage#objects"
}

Autenticar a partir do seu código

Quando você usa as bibliotecas de cliente do Cloud, as bibliotecas de autenticação usam automaticamente o ADC para procurar credenciais para autenticar nos serviços do Google Cloud . Use as bibliotecas de cliente do Cloud compatíveis com a federação de identidade da carga de trabalho. Veja a seguir o mínimo necessário de versões das bibliotecas de cliente do Cloud, além de instruções sobre como verificar a versão atual:

C++

A maioria das bibliotecas de cliente doGoogle Cloud para C++ é compatível com a federação de identidade usando um objeto ChannelCredentials, que é criado chamando grpc::GoogleDefaultCredentials(). Para inicializar essa credencial, crie as bibliotecas de cliente com a versão 1.36.0 ou posteriores do gRPC.

A biblioteca de cliente do Cloud Storage para C++ usa a API REST, não a gRPC. Portanto, ela não é compatível com a federação de identidade.

Go

As bibliotecas de cliente do Go são compatíveis com a federação de identidade se usarem a versão v0.0.0-20210218202405-ba52d332ba99 ou posteriores do módulo golang.org/x/oauth2.

Para verificar qual versão deste módulo sua biblioteca de cliente usa, execute os seguintes comandos:

cd $GOPATH/src/cloud.google.com/go
go list -m golang.org/x/oauth2

Java

As bibliotecas de cliente do Java aceitam federação de identidade se usarem a versão 0.24.0 ou posteriores do artefato com.google.auth:google-auth-library-oauth2-http.

Para verificar qual versão desse artefato a biblioteca de cliente usa, execute o seguinte comando do Maven no diretório do aplicativo:

mvn dependency:list -DincludeArtifactIds=google-auth-library-oauth2-http

Node.js

As bibliotecas de cliente do Node.js são compatíveis com a federação de identidade se usarem a versão 7.0.2 ou posteriores do pacote google-auth-library.

Para verificar qual versão desse pacote sua biblioteca de cliente usa, execute o seguinte comando no diretório do seu aplicativo:

npm list google-auth-library

Ao criar um objeto GoogleAuth, é possível especificar um ID de projeto ou permitir que GoogleAuth encontre o ID do projeto automaticamente. Para encontrar o ID do projeto automaticamente, a conta de serviço no arquivo de configuração precisa ter o papel de navegador (roles/browser), ou um papel com permissões equivalentes no projeto. Para ver detalhes, consulte o README do pacote google-auth-library.

Python

As bibliotecas de cliente do Python são compatíveis com a federação de identidade se usarem a versão 1.27.0 ou posteriores do pacote google-auth.

Para verificar qual versão desse pacote sua biblioteca de cliente usa, execute o seguinte comando no ambiente em que o pacote está instalado:

pip show google-auth

Para especificar um ID de projeto para o cliente de autenticação, defina a variável de ambiente GOOGLE_CLOUD_PROJECT ou permita que o cliente encontre o ID do projeto automaticamente. Para encontrar o ID do projeto automaticamente, a conta de serviço no arquivo de configuração precisa ter o papel de Navegador (roles/browser) ou um papel com permissões equivalentes no projeto. Para ver detalhes, consulte o guia do usuário do pacote google-auth.

A seguir

Conheça as práticas recomendadas para organizar suas frotas ao usar a federação de identidade da carga de trabalho da frota.