Usando identidade de carga de trabalho com Google Cloud

Este guia descreve como configurar a identidade da carga de trabalho no GKE na AWS para controlar o acesso da carga de trabalho aos recursos do GCP. Inclui um exemplo de como acessar Google Cloud recursos do seu cluster usando a identidade.

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

Visão geral

Usos de identidade de carga de trabalho Google Cloud Permissões do IAM para controlar o acesso aGoogle Cloud recursos. Com a identidade da carga de trabalho, você pode atribuir diferentes funções do 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ê deve atribuir Google Cloud Funções do IAM para seus nós do GKE na AWS, concedendo 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 o Kubernetes versão v1.20 ou posterior.

  • Se o seu AWS VPC usar um proxy ou firewall, coloque na lista de permissões os seguintes URLs:

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

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

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

  • Habilite 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

Componha o pool WI e os nomes dos provedores

Cada Google Cloud O projeto cria automaticamente um pool de identidades de carga de trabalho gerenciada com um nome no formato PROJECT_ID.svc.id.goog . Da mesma forma,Google Cloud Cria um provedor de identidade cujo nome segue o padrão https://gkehub.googleapis.com/projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_ID . Para obter mais informações sobre pools de identidade de carga de trabalho, consulte Componentes habilitados para frota . Crie esses nomes a partir do ID do projeto e do ID da associação, conforme mostrado aqui:

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 o seguinte:

  • USER_PROJECT_NAME com o nome do projeto escolhido pelo usuário
  • PROJECT_MEMBERSHIP_NAME com o nome de associação 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) represente um Google Cloud conta de serviço (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 o seguinte:

  • KUBERNETES_NAMESPACE com o namespace do Kubernetes onde a conta de serviço do Kubernetes é definida
  • WORKLOAD_IDENTITY_TEST com um nome de carga de trabalho de sua escolha
  • KUBERNETES_SA_NAME com 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 de identidade da carga de trabalho em um ConfigMap. Quando um pod monta o ConfigMap, a Google Cloud CLI pode ler os detalhes de 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 um KSA no seu cluster de usuário com o mesmo nome e namespace 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 do token da conta de serviço e o ConfigMap criado acima.

  1. Crie o arquivo yaml do Pod de exemplo.

    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 seu cluster.

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

Usando Google Cloud identidade da carga de trabalho

Versões de SDK suportadas

Para usar o Google Cloud recurso de identidade de carga de trabalho, você deve construir seu código com um SDK que o suporte. Para obter uma lista de versões de SDK que suportamGoogle Cloud identidade da carga de trabalho, consulte Identidade da carga de trabalho da frota .

Código de exemplo usando identidade de carga de trabalho

Esta seção inclui código Python de exemplo que usa Google Cloud identidade da carga de trabalho. A conta de serviço neste exemplo usa uma identidade com privilégios de "Administrador do Cloud Storage" para listar todos os Google Cloud buckets do Cloud Storage do projeto.

  1. Execute um shell dentro do Pod.

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

  2. Execute um script para listar os buckets 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 seu Google Cloud projeto.

Para maiores informações