Como usar a identidade da carga de trabalho com o Google Cloud

Neste guia, descrevemos como configurar a identidade da carga de trabalho em clusters do Anthos na AWS para controlar o acesso da carga de trabalho aos recursos do GCP. Ele inclui um exemplo de como acessar os recursos do Google Cloud a partir do cluster usando a identidade.

Para informações sobre como usar identidades de carga de trabalho com contas do AWS IAM para controlar o acesso a recursos do AWS, consulte Como usar identidade de carga de trabalho com o AWS.

Visão geral

A identidade da carga de trabalho usa as permissões do Google Cloud IAM para controlar o acesso aos recursos do Google Cloud. Com a identidade da carga de trabalho, é possível atribuir diferentes papéis de IAM a cada carga de trabalho. Esse controle refinado de permissões permite que você siga o princípio do privilégio mínimo. Sem a identidade da carga de trabalho, você precisa atribuir papéis do Google Cloud IAM aos clusters do Anthos em nós da AWS, dando a todas as cargas de trabalho nesses nós as mesmas permissões que o próprio nó.

Pré-requisitos

  • Crie um cluster de usuários com a versão v1.20 ou posterior do Kubernetes Kubernetes.

  • Se a VPC da AWS usar um proxy ou firewall, inclua os seguintes URLs na lista de permissões:

    • securetoken.googleapis.com
    • iamcredentials.googleapis.com
    • sts.googleapis.com

  • No diretório anthos-aws, use anthos-gke para alternar o contexto para o cluster de usuário. 

    cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
    Substitua CLUSTER_NAME pelo nome do cluster de usuários.

  • Ative os quatro novos serviços necessários para esse recurso com os seguintes comandos:

    gcloud services enable securetoken.googleapis.com
gcloud services enable iam.googleapis.com
gcloud services enable iamcredentials.googleapis.com
gcloud services enable sts.googleapis.com

Escrever o pool do WI e os nomes dos provedores

Cada projeto do Google Cloud cria automaticamente um pool de identidades de carga de trabalho gerenciado com um nome no formato PROJECT_ID.svc.id.goog. Da mesma forma, o Google Cloud cria um provedor de identidade com o nome que segue o padrão https://gkehub.googleapis.com/projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_ID. Para mais informações sobre pools de identidade da carga de trabalho, consulte Componentes ativados da frota. Escreva estes nomes no ID do projeto e da assinatura, como mostrado a seguir:

export PROJECT_ID=USER_PROJECT_NAME
export CLUSTER_MEMBERSHIP_ID=PROJECT_MEMBERSHIP_NAME
export IDP="https://gkehub.googleapis.com/projects/${PROJECT_ID}/locations/global/memberships/${CLUSTER_MEMBERSHIP_ID}"
export WI_POOL="${PROJECT_ID}.svc.id.goog"

Substitua:

  • USER_PROJECT_NAME pelo nome do projeto do usuário escolhido.
  • PROJECT_MEMBERSHIP_NAME pelo nome de assinatura do cluster

Criar uma vinculação de política do IAM

Crie uma vinculação de política para permitir que uma conta de serviço do Kubernetes (KSA) personifique uma conta de serviço do Google Cloud (GSA).

export K8S_NAMESPACE=KUBERNETES_NAMESPACE
export KSA_NAME=KUBERNETES_SA_NAME
export GCP_SA_EMAIL="WORKLOAD_IDENTITY_TEST@${PROJECT_ID}.iam.gserviceaccount.com"
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:$WI_POOL[$K8S_NAMESPACE/$KSA_NAME]" $GCP_SA_EMAIL

Substitua:

  • KUBERNETES_NAMESPACE é o namespace do Kubernetes em que a conta de serviço do Kubernetes está definida.
  • WORKLOAD_IDENTITY_TEST com um nome de carga de trabalho de sua escolha
  • KUBERNETES_SA_NAME é o nome da conta de serviço do Kubernetes anexada ao aplicativo;

Criar um mapa de configuração do SDK

Execute o script de shell abaixo para armazenar os detalhes da identidade da carga de trabalho em um ConfigMap. Quando um pod ativa o ConfigMap, a Google Cloud CLI pode ler os detalhes da identidade da carga de trabalho.

cat << EOF > cfmap.yaml
kind: ConfigMap
apiVersion: v1
metadata:
  namespace: ${K8S_NAMESPACE}
  name: my-cloudsdk-config
data:
  config: |
    {
      "type": "external_account",
      "audience": "identitynamespace:${WI_POOL}:${IDP}",
      "service_account_impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/${GCP_SA_EMAIL}: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"
      }
    }
EOF

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f cfmap.yaml

Criar uma conta de serviço do Kubernetes

Crie uma KSA no cluster de usuário com o mesmo nome e namespace que foi usado na vinculação do IAM.

cat << EOF > k8s-service-account.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ${KSA_NAME}
  namespace: ${K8S_NAMESPACE}
EOF

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f k8s-service-account.yaml

Criar um pod

Em seguida, crie um pod com a projeção de token da conta de serviço e o ConfigMap criados acima.

  1. Crie o arquivo yaml do pod de amostra.

    cat << EOF > sample-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: sample-pod
  namespace: ${K8S_NAMESPACE}
spec:
  serviceAccountName: ${KSA_NAME}
  containers:
  - command:
    - /bin/bash
    - -c
    - while :; do echo '.'; sleep 500 ; done
    image: google/cloud-sdk
    name: cloud-sdk
    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: ${WI_POOL}
          expirationSeconds: 172800
      - configMap:
          name: my-cloudsdk-config
          optional: false
          items:
           - key: "config"
             path: "google-application-credentials.json"
EOF

  2. Aplique o YAML do pod ao cluster.

    env HTTPS_PROXY=http://localhost:8118 \
 kubectl apply -f sample-pod.yaml

Como usar a identidade da carga de trabalho do Google Cloud

Versões compatíveis do SDK

Para usar o recurso de identidade de carga de trabalho do Google Cloud, crie seu código com um SDK compatível. Para ver uma lista de versões do SDK compatíveis com a identidade da carga de trabalho do Google Cloud, consulte Identidade da carga de trabalho da frota.

Exemplo de código usando a identidade da carga de trabalho

Nesta seção, incluímos um código Python de amostra que usa a identidade da carga de trabalho do Google Cloud. A conta de serviço neste exemplo usa uma identidade com privilégios "Administrador do Cloud Storage" para listar todos os buckets do Cloud Storage do projeto do Google Cloud.

  1. Execute um shell no pod.

    env HTTPS_PROXY=http://localhost:8118 \
kubectl exec -it sample-pod -- bash

  2. Execute um script para listar os intervalos de armazenamento do projeto.

    # execute these commands inside the Pod
pip install --upgrade google-cloud-storage

cat << EOF > sample-list-bucket.py
from google.cloud import storage
storage_client = storage.Client()
buckets = storage_client.list_buckets()

for bucket in buckets:
  print(bucket.name)
EOF

env GOOGLE_CLOUD_PROJECT=USER_PROJECT_NAME \
 python3 sample-list-bucket.py

    Substitua USER_PROJECT_NAME pelo ID do projeto do Google Cloud.

Para mais informações