Usar Workload Identity con Google Cloud

En esta guía se describe cómo configurar la identidad de carga de trabajo en GKE en AWS para controlar el acceso de las cargas de trabajo a los recursos de GCP. Incluye un ejemplo de cómo acceder a los recursos de tu clúster mediante la identidad. Google Cloud

Para obtener información sobre cómo usar identidades de carga de trabajo con cuentas de IAM de AWS para controlar el acceso a recursos de AWS, consulta el artículo Usar Workload Identity con AWS.

Información general

Workload Identity usa Google Cloud permisos de gestión de identidades y accesos (IAM) para controlar el acceso a losGoogle Cloud recursos. Con Workload Identity, puedes asignar diferentes roles de IAM a cada carga de trabajo. Este control pormenorizado de los permisos te permite seguir el principio de mínimos accesos. Si no usas Workload Identity, debes asignar Google Cloud roles de gestión de identidades y accesos a tus nodos de GKE en AWS, lo que significa que todas las cargas de trabajo de esos nodos tendrán los mismos permisos que el propio nodo.

Requisitos previos

  • Crea un clúster de usuarios con la versión 1.20 o posterior de Kubernetes.

  • Si tu VPC de AWS usa un proxy o un cortafuegos, añade las siguientes URLs a la lista de permitidos:

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

  • En tu directorio de anthos-aws, usa anthos-gke para cambiar el contexto a tu clúster de usuarios. 

    cd anthos-aws
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
     Sustituye CLUSTER_NAME por el nombre de tu clúster de usuario.

  • Habilita los cuatro servicios nuevos necesarios para esta función con los siguientes 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

Crear los nombres del grupo y del proveedor de WI

Cada Google Cloud proyecto crea automáticamente un grupo de identidades de carga de trabajo gestionado con un nombre con el formato PROJECT_ID.svc.id.goog. Del mismo modo,Google Cloud crea un proveedor de identidades cuyo nombre sigue el patrón https://gkehub.googleapis.com/projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_ID. Para obtener más información sobre los grupos de Workload Identity, consulta Componentes habilitados para flotas. Crea estos nombres a partir del ID de tu proyecto y del ID de miembro, tal como se muestra a continuación:

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"

Haz los cambios siguientes:

  • USER_PROJECT_NAME con el nombre de proyecto de usuario que haya elegido el usuario
  • PROJECT_MEMBERSHIP_NAME con el nombre de grupo de miembros del clúster

Crear un enlace de política de gestión de identidades y accesos

Crea un enlace de política para permitir que una cuenta de servicio de Kubernetes (KSA) suplante a una Google Cloud cuenta de servicio (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

Haz los cambios siguientes:

  • KUBERNETES_NAMESPACE con el espacio de nombres de Kubernetes en el que se define la cuenta de servicio de Kubernetes
  • WORKLOAD_IDENTITY_TEST con el nombre de carga de trabajo que elijas
  • KUBERNETES_SA_NAME con el nombre de la cuenta de servicio de Kubernetes asociada a la aplicación

Crear un mapa de configuración de SDK

Ejecuta la secuencia de comandos shell que se indica a continuación para almacenar los detalles de la identidad de carga de trabajo en un ConfigMap. Cuando un pod monta el ConfigMap, la CLI de Google Cloud puede leer los detalles de la identidad de la carga de trabajo.

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

Crear una cuenta de servicio de Kubernetes

Crea un KSA en tu clúster de usuario con el mismo nombre y espacio de nombres que se usaron en el enlace de 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

Crear un pod

A continuación, crea un pod con la proyección de token de la cuenta de servicio y el ConfigMap que has creado anteriormente.

  1. Crea el archivo YAML del Pod de ejemplo.

    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. Aplica el archivo YAML del pod a tu clúster.

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

Usar Google Cloud Workload Identity

Versiones del SDK compatibles

Para usar la función de Google Cloud identidad de carga de trabajo, debes compilar tu código con un SDK que la admita. Para ver una lista de las versiones del SDK que admiten la identidad de cargas de trabajo, consulta Identidad de cargas de trabajo de flotas.Google Cloud

Código de ejemplo que usa Workload Identity

En esta sección se incluye un ejemplo de código de Python que usa la identidad de carga de trabajo de Google Cloud . La cuenta de servicio de este ejemplo usa una identidad con privilegios de "Administrador de Cloud Storage" para enumerar todos los segmentos de Cloud Storage del proyecto Google Cloud .

  1. Ejecuta un shell en el pod.

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

  2. Ejecuta una secuencia de comandos para enumerar los contenedores de almacenamiento del proyecto.

    # 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

    Sustituye USER_PROJECT_NAME por tu Google Cloud proyecto.

Para obtener más información