Habilita Workload Identity con Apigee Hybrid

Estás viendo la versión 1.10 de la documentación de Apigee Hybrid. Para obtener más información, consulta las Versiones compatibles.

Version 1.10 

   Versiones compatibles:

• v1.13 (la más reciente)                        
• v1.12                         
• v1.11                         
• Lista de versiones compatibles

   Versiones no compatibles

• v1.10                                      
• v1.9                                         
• v1.8                                         
• v1.7                                         
• v1.6                                         
• v1.5                                         
• v1.4                                         
• v1.3                                         
• v1.2                                         
• v1.1                                         

En este tema, se explica cómo habilitar Workload Identity para Apigee Hybrid.

Nota: Apigee hybrid v.1.10 solo admite la federación de Workload Identity en GKE.

Descripción general

Workload Identity es una manera con la que las aplicaciones que se ejecutan dentro de GKE (Google Kubernetes Engine) pueden acceder a los servicios de Google Cloud. Para obtener descripciones generales de Workload Identity, consulta la siguiente documentación:

• Presentación de Workload Identity: La mejor autenticación para las aplicaciones de GKE
• Usa Workload Identity

Una cuenta de servicio de Google Cloud IAM es una identidad que una aplicación puede usar para realizar solicitudes a las API de Google. Estas cuentas de servicio se denominan GSA (Cuentas de servicio de Google) en el documento. Para obtener más información sobre las GSA, consulta Cuentas de servicio.

De manera independiente, Kubernetes también tiene el concepto de cuentas de servicio. Una cuenta de servicio proporciona una identidad para los procesos que se ejecutan en un pod. Las cuentas de servicio de Kubernetes son recursos de Kubernetes, mientras que las cuentas de servicio de Google son específicas de Google Cloud. Para obtener información sobre las cuentas de servicio de Kubernetes, consulta Configura cuentas de servicio para pods en la documentación de Kubernetes.

Con Apigee Hybrid 1.4 y versiones posteriores, Apigee crea y usa una cuenta de servicio de Kubernetes para cada tipo de componente. Si habilitas Workload Identity, los componentes híbridos pueden interactuar con las cuentas de servicio de Kubernetes.

Cuentas de servicio de Google en Apigee Hybrid sin Workload Identity

Sin usar Workload Identity, debes vincular las cuentas de servicio de Google a cada componente de tu archivo overrides.yaml con una referencia a un archivo de certificación o un Secret de Kubernetes. Por ejemplo:

• Archivos de certificación:

  watcher:
    serviceAccountPath: ./apigee-org/my-hybrid-project-apigee-watcher.json

  Consulta los siguientes vínculos:

  cassandra.backup.serviceAccountPath cassandra.restore.serviceAccountPath connectAgent.serviceAccountPath diagnostic.serviceAccountPath envs[].serviceAccountPaths.runtime envs[].serviceAccountPaths.synchronizer envs[].serviceAccountPaths.udca

  logger.serviceAccountPath mart.serviceAccountPath metrics.serviceAccountPath synchronizer.serviceAccountPath udca.serviceAccountPath watcher.serviceAccountPath

• Secret de Kubernetes:

  watcher:
    serviceAccountRef: my-watcher-k8s-secret

  Consulta los siguientes vínculos:

  cassandra.backup.serviceAccountRef cassandra.restore.serviceAccountRef connectAgent.serviceAccountRef diagnostic.serviceAccountRef envs[].serviceAccountRefs.runtime envs[].serviceAccountRefs.synchronizer envs[].serviceAccountRefs.udca

  logger.serviceAccountRef mart.serviceAccountRef metrics.serviceAccountRef synchronizer.serviceAccountRef udca.serviceAccountRef watcher.serviceAccountRef

Variables de entorno que se usan en estos procedimientos

En estos procedimientos, se usan las siguientes variables de entorno. Configúralos en el shell de comandos o reemplázalos en las muestras de código por los valores reales:

• PROJECT_ID: el ID del proyecto de Google Cloud.
• ORG_NAME: el nombre de tu organización de Apigee.
• ENV_NAME: el nombre del entorno de Apigee.
• NAMESPACE: el nombre de tu espacio de nombres de Apigee. Por lo general es apigee.
• CLUSTER_NAME: El nombre de tu clúster.
• CLUSTER_LOCATION: La región o la zona de tu clúster, por ejemplo: us-west1.
• APIGEECTL_HOME: El directorio en el que instalaste apigeectl.
• HYBRID_FILES: el directorio de tus archivos híbridos, por ejemplo, hybrid-base-directory/hybrid-files.

Verifica las variables de entorno:

echo $PROJECT_ID
echo $ORG_NAME
echo $ENV_NAME
echo $NAMESPACE
echo $CLUSTER_NAME
echo $CLUSTER_LOCATION
echo $APIGEECTL_HOME
echo $HYBRID_FILES

Inicializa cualquiera de las variables que necesitas:

export PROJECT_ID=my-project-id
export ORG_NAME=$PROJECT_ID
export ENV_NAME=my-environment-name
export NAMESPACE=apigee
export CLUSTER_NAME=my-cluster-name
export CLUSTER_LOCATION=my-cluster-location
export APIGEECTL_HOME=hybrid-base-directory/apigeectl
export HYBRID_FILES=hybrid-base-directory/hybrid-files

Workload Identity y archivos de claves de cuenta de servicio

Cuando se ejecuta Apigee Hybrid en GKE, la práctica estándar es crear y descargar claves privadas (archivos .json) para cada una de las cuentas de servicio. Cuando usas Workload Identity, no necesitas descargar claves privadas de cuentas de servicio ni agregarlas a los clústeres de GKE.

Si descargaste archivos de claves de cuenta de servicio como parte de la instalación de Apigee Hybrid, puedes borrarlos después de habilitar Workload Identity. En la mayoría de las instalaciones, residen en el directorio hybrid-base-directory/hybrid-files/service-accounts/.

Habilita Workload Identity para Apigee Hybrid

Para comenzar, sigue las instrucciones en Prepárate para habilitar Workload Identity a fin de actualizar los grupos de nodos y, luego, inicializar las variables antes de habilitar Workload Identity.

Luego, sigue las instrucciones en Configura workloadIdentityEnabled: true y crea cuentas de servicio para habilitar Workload Identity en la instalación de Apigee Hybrid.

Prepárate para habilitar Workload Identity

Antes de comenzar el proceso de instalación, sigue los pasos que se indican en esta sección.

1. Configura el proyecto como el que estás modificando:

   gcloud config set project $PROJECT_ID

2. Obtén las credenciales gcloud del clúster en el que habilitas Workload Identity con el siguiente comando:

   gcloud container clusters get-credentials ${CLUSTER_NAME} \
     --region ${CLUSTER_LOCATION} \
     --project ${PROJECT_ID}

   Nota: Si creaste un clúster zonal en lugar de un clúster regional, obtén las credenciales con el siguiente comando:

   gcloud container clusters get-credentials ${CLUSTER_NAME} \
     --zone ${CLUSTER_LOCATION} \
     --project ${PROJECT_ID}

3. Verifica que Workload Identity esté habilitada para el clúster de GKE que ejecuta Apigee con el siguiente comando:

   gcloud container clusters describe $CLUSTER_NAME --region $CLUSTER_LOCATION --project $PROJECT_ID

   Nota: Para clústeres zonales, usa lo siguiente:

   gcloud container clusters describe $CLUSTER_NAME --zone $CLUSTER_LOCATION --project $PROJECT_ID

   El resultado debería ser similar a lo siguiente:

   …
     …
     status: RUNNING
     subnetwork: default
     workloadIdentityConfig:
       workloadPool: my-project-id.svc.id.goog

   Si es necesario, habilita Workload Identity en el clúster. Esta operación puede demorar hasta 30 minutos:

     gcloud container clusters update $CLUSTER_NAME \
     --workload-pool=$PROJECT_ID.svc.id.goog \
     --project $PROJECT_ID \
     --region $CLUSTER_LOCATION

   Nota: Si creaste un clúster zonal en lugar de un clúster regional, usa el argumento --zone en lugar de --region como en el siguiente comando:

     gcloud container clusters update $CLUSTER_NAME \
     --workload-pool=$PROJECT_ID.svc.id.goog \
     --zone $CLUSTER_LOCATION \
     --project $PROJECT_ID

   Para obtener más información, consulta Habilita Workload Identity.

4. Asegúrate de que Workload Identity esté habilitada en cada grupo de nodos.
   1. Enumera tus grupos de nodos con el siguiente comando:

      gcloud container node-pools list \
        --cluster $CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID

      Deberías obtener un resultado similar al siguiente:

        NAME            MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
        apigee-runtime  e2-standard-4  100           1.23.12-gke.100
        apigee-data     e2-standard-4  100           1.23.12-gke.100

   2. Asegúrate de que Workload Identity esté habilitado para cada grupo de nodos mediante el siguiente comando en cada grupo de nodos:

      gcloud container node-pools update NODE_POOL_NAME \
        --cluster=$CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID \
        --workload-metadata=GKE_METADATA

      En el ejemplo anterior, NODE_POOL_NAME es el nombre de cada grupo de nodos.

Verifica o crea cuentas de servicio de Google

Las cuentas de servicio de Google se crean para muchos componentes de Apigee Hybrid durante la instalación. Usa este procedimiento para verificar las cuentas de servicio de Google y crear las que sean necesarias.

1. Verifica los nombres de las cuentas de servicio de Google de tu proyecto con el siguiente comando:

   gcloud iam service-accounts list --project $PROJECT_ID

   Deberías obtener un resultado similar al siguiente:

   Producción

   Para entornos que no son de producción, haz lo siguiente:

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-cassandra     apigee-cassandra@my_project_id.iam.gserviceaccount.com     False
   apigee-logger        apigee-logger@my_project_id.iam.gserviceaccount.com        False
   apigee-mart          apigee-mart@my_project_id.iam.gserviceaccount.com          False
   apigee-metrics       apigee-metrics@my_project_id.iam.gserviceaccount.com       False
   apigee-runtime       apigee-runtime@my_project_id.iam.gserviceaccount.com       False
   apigee-synchronizer  apigee-synchronizer@my_project_id.iam.gserviceaccount.com  False
   apigee-udca          apigee-udca@my_project_id.iam.gserviceaccount.com          False
   apigee-watcher       apigee-watcher@my_project_id.iam.gserviceaccount.com       False
   

   No producción

   Para entornos que no son de producción, haz lo siguiente:

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
   

   Sugerencia: Si tienes nombres personalizados para tus cuentas de servicio que no se corresponden con facilidad con los nombres de los componentes de Apigee, puedes determinar el rol de cada cuenta de servicio si verificas los roles asignados a ella y los comparas con los roles recomendados en Acerca de las cuentas de servicio.

   Usa el siguiente comando para verificar los roles asignados a una cuenta de servicio:

   gcloud projects get-iam-policy ${PROJECT_ID}  \
   --flatten="bindings[].members" \
   --format='table(bindings.role)' \
   --filter="SERVICE_ACCOUNT_NAME"

   Si necesitas crear cuentas de servicio de Google para tu proyecto, hay dos métodos que puedes usar:

   • Usa la herramienta create-service-account incluida con Apigee en el directorio apigeectl/tools/. Esta herramienta puede crear todas las cuentas de servicio con un solo comando o permitirte crearlas de forma individual.
     create-service-account genera archivos de claves para cada cuenta de servicio y los descarga. Con Workload Identity, no necesitarás estos archivos de claves. Si te preocupa la seguridad de estos archivos de claves, puedes borrarlos. También puedes usar gcloud para crear las cuentas de servicio y asignarles los adecuados.
   • Usa el comando gcloud iam service-accounts create para crear las cuentas de servicio de a una y el comando gcloud projects add-iam-policy-binding para asignar los roles adecuados a cada cuenta de servicio. Este método requiere que crees cada cuenta de servicio de forma individual, pero te permite evitar la descarga de los archivos de claves.

   create-service-account

   Usa el siguiente comando para crear una cuenta de servicio de Google para cada componente:

   Producción

   Para entornos que no son de producción, haz lo siguiente:

   $APIGEECTL_HOME/tools/create-service-account --env prod --dir $APIGEECTL_HOME/../service-accounts

   Este comando creará las siguientes cuentas de servicio:

   • apigee-cassandra
   • apigee-logger
   • apigee-mart
   • apigee-metrics
   • apigee-runtime
   • apigee-synchronizer
   • apigee-udca
   • apigee-watcher

   No producción

   Para entornos que no son de producción, haz lo siguiente:

   $APIGEECTL_HOME/tools/create-service-account --env non-prod --dir $APIGEECTL_HOME/../service-accounts

   Con este comando, se creará una sola cuenta de servicio, apigee-non-prod, con todos los roles asignados para administrar todos los componentes de Apigee.

   gcloud

   Crea las siguientes cuentas de servicio y asígnales roles.

   Sugerencia: Si quieres usar nombres personalizados, cambia el nombre de la cuenta de servicio de color rojo en la muestra de código por el nombre que quieres usar.

   1. Cuenta de servicio: apigee-cassandra, rol: roles/storage.objectAdmin

      Crea la cuenta:

      gcloud iam service-accounts create apigee-cassandra \
        --display-name="apigee-cassandra" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/storage.objectAdmin"
                  

   2. Cuenta de servicio: apigee-logger, rol: roles/logging.logWriter

      Crea la cuenta:

      gcloud iam service-accounts create apigee-logger \
        --display-name="apigee-logger" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-logger@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/logging.logWriter"
                  

   3. Cuenta de servicio: apigee-mart, rol: roles/apigeeconnect.Agent

      Crea la cuenta:

      gcloud iam service-accounts create apigee-mart \
        --display-name="apigee-mart" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-mart@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigeeconnect.Agent"
                  

   4. Cuenta de servicio: apigee-metrics, rol: roles/monitoring.metricWriter

      Crea la cuenta:

      gcloud iam service-accounts create apigee-metrics \
        --display-name="apigee-metrics" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/monitoring.metricWriter"
                  

   5. Cuenta de servicio: apigee-runtime, rol: Sin rol asignado.

      Crea la cuenta:

      gcloud iam service-accounts create apigee-runtime \
        --display-name="apigee-runtime" \
        --project $PROJECT_ID
                  

   6. Cuenta de servicio: apigee-synchronizer, rol: roles/apigee.synchronizerManager

      Crea la cuenta:

      gcloud iam service-accounts create apigee-synchronizer \
        --display-name="apigee-synchronizer" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.synchronizerManager"
                  

   7. Cuenta de servicio: apigee-udca, rol: roles/apigee.analyticsAgent

      Crea la cuenta:

      gcloud iam service-accounts create apigee-udca \
        --display-name="apigee-udca" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-udca@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.analyticsAgent"
                  

   8. Cuenta de servicio: apigee-watcher, rol: roles/apigee.runtimeAgent

      Crea la cuenta:

      gcloud iam service-accounts create apigee-watcher \
        --display-name="apigee-watcher" \
        --project $PROJECT_ID
                  

      Asigna el rol:

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.runtimeAgent"
                  

Configura workloadIdentityEnabled: true y crea cuentas de servicio

apigeectl crea cuentas de servicio de Kubernetes para cada componente de Apigee Hybrid cuando configuras workloadIdentityEnabled: true en tu archivo de anulación y aplicas los cambios.

1. Agrega la siguiente línea destacada a tu archivo overrides.yaml, en la estrofa gcp. Esto habilita Workload Identity para la instalación y activa apigeectl a fin de crear las cuentas de servicio de Kubernetes cuando aplicas la configuración:

   gcp:
     projectID: "my-project-id"
     name: "my-project-id"
     region: "analytics-region"
     workloadIdentityEnabled: true

2. Agrega la siguiente línea destacada a tu archivo overrides.yaml, en la estrofa cassandra: Esto activa la creación de la cuenta de servicio de Kubernetes apigee-cassandra-backup:

   cassandra:
     ...
     backup:
       enabled: true

3. Aplica los cambios con apigeectl con la marca --restore:

   $APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --restore

   Nota: La marca --restore activa la creación de la cuenta de servicio apigee-cassandra-restore de Kubernetes.
4. Verifica las cuentas de servicio con el siguiente comando:

   kubectl get sa -n $NAMESPACE

   El resultado debería ser similar al siguiente. Las cuentas de servicio de Kubernetes en negrita son las que deberás anotar con tus cuentas de servicio de Google:

   NAME                                                         SECRETS   AGE
   apigee-cassandra-backup                                      1         11m
   apigee-cassandra-restore                                     1         11m
   apigee-cassandra-schema-setup-my-project-id-123abcd-sa       1         11m
   apigee-cassandra-schema-val-my-project-id-123abcd            1         11m
   apigee-cassandra-user-setup-my-project-id-123abcd-sa         1         11m
   apigee-connect-agent-my-project-id-123abcd-sa                1         11m
   apigee-datastore-default-sa                                  1         11m
   apigee-ingressgateway                                        1         11m
   apigee-ingressgateway-my-project-id-123abcd                  1         11m
   apigee-ingressgateway-manager                                1         11m
   apigee-init                                                  1         11m
   apigee-mart-my-project-id-123abcd-sa                         1         11m
   apigee-metrics-sa                                            1         11m
   apigee-mint-task-scheduler-my-project-id-123abcd-sa          1         11m
   apigee-redis-default-sa                                      1         11m
   apigee-redis-envoy-default-sa                                1         11m
   apigee-runtime-my-project-id-env-name-234bcde-sa             1         11m
   apigee-synchronizer-my-project-id-env-name-234bcde-sa        1         11m
   apigee-udca-my-project-id-123abcd-sa                         1         11m
   apigee-udca-my-project-id-env-name-234bcde-sa                1         11m
   apigee-watcher-my-project-id-123abcd-sa                      1         11m
   default                                                      1         11m
       

Anota las cuentas de servicio de Kubernetes con las cuentas de servicio de Google

Para cada componente de Apigee, anota las cuentas de servicio de Kubernetes correspondientes con la cuenta de servicio de Google para el componente.

Componentes a nivel de la organización

Solo tendrás una instancia de cada cuenta de servicio de Kubernetes para tu organización de Apigee.

Componente	Cuenta de servicio de Kubernetes	Cuenta de servicio de Google
Cassandra	apigee-cassandra-backup	apigee-cassandra
	apigee-cassandra-restore	apigee-cassandra
	apigee-cassandra-schema-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-cassandra-schema-val-my-project-id-num-id1	apigee-cassandra
	apigee-cassandra-user-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-datastore-default-sa	apigee-cassandra
Apigee Connect	apigee-connect-agent-my-project-id-num-id1-sa	apigee-mart
MART	apigee-mart-my-project-id-num-id1-sa	apigee-mart
Métricas	apigee-metrics-sa	apigee-metrics
UDCA (nivel de organización)	apigee-udca-my-project-id-num-id1-sa	apigee-udca
Watcher	apigee-watcher-my-project-id-num-id1-sa	apigee-watcher

Componentes a nivel del entorno

Tendrás una instancia de cada cuenta de servicio de Kubernetes para cada entorno de Apigee.

Componente	Cuenta de servicio de Kubernetes	Cuenta de servicio de Google
Entorno de ejecución de Apigee	apigee-runtime-my-project-id-env-name-num-id2-sa	apigee-runtime
Sincronizador	apigee-synchronizer-my-project-id-env-name-num-id2-sa	apigee-synchronizer
UDCA (nivel de entorno)	apigee-udca-my-project-id-env-name-num-id2-sa	apigee-udca

IMPORTANTE: Si los nombres de tus cuentas de servicio no coinciden con los nombres predeterminados que creó create-service-account, en los siguientes comandos se reemplaza el nombre de la cuenta de servicio rojo por nombre de servicio correcto de la cuenta del componente. Por ejemplo, si tu cuenta de servicio de Cassandra se llama my-cassandra-accnt-1, reemplaza apigee-cassandra por ese nombre en el comando.

En los siguientes comandos, se usan los nombres de las cuentas de servicio de Kubernetes que muestra el comando kubectl get sa -n $NAMESPACE, por ejemplo: apigee-cassandra-schema-val-hybrid-example-project-123abcd.

En este procedimiento, harás lo siguiente para cada cuenta de servicio de Kubernetes:

• Vincula la cuenta de servicio de Kubernetes y la cuenta de servicio principal de Google al rol de IAM roles/iam.workloadIdentityUser.
• Anota la cuenta de servicio de Kubernetes con la cuenta de servicio de Google.

1. Vincula los roles y anota las cuentas de servicio.

   Componentes a nivel de la organización

   Anota las cuentas de servicio de Kubernetes para los componentes a nivel de la organización. Deberás hacer esto una vez por cada componente de la organización de Apigee.

   • Cassandra

     El componente Cassandra tiene seis cuentas de servicio de Kubernetes asociadas:

     • apigee-cassandra-backup
     • apigee-cassandra-restore
     • apigee-cassandra-schema-setup
     • apigee-cassandra-schema-val (val = validación)
     • apigee-cassandra-user-setup
     • apigee-datastore-default

     Producción

     apigee-cassandra-backup

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-cassandra"
        KSA_NAME="apigee-cassandra-backup"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-restore

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-setup-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-schema-setup-service-account-name"

        Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     2. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-val-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-user-setup-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-datastore-default-sa

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     apigee-cassandra-backup

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-non-prod"
        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-restore

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-setup-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-schema-setup-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-val-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-user-setup-service-account-name

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-datastore-default-sa

     1. Vuelve a definir la variable de entorno KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Apigee Connect

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • MART

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-mart-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-mart-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Métricas de Apigee

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-metrics"
        KSA_NAME="apigee-metrics-sa"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-metrics-sa"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • UDCA (nivel de organización)

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define las variables de entorno KSA_NAME:

        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Vincula el rol de IAM:

          gcloud iam service-accounts add-iam-policy-binding \
            --role roles/iam.workloadIdentityUser \
            --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
            $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

          kubectl annotate serviceaccount \
            --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Apigee Watcher

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-watcher"
        KSA_NAME="apigee-watcher-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-watcher-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   Haz lo siguiente para cada entorno:

   • Entorno de ejecución

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-runtime"
        KSA_NAME="apigee-runtime-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-runtime-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Sincronizador

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-synchronizer"
        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • UDCA (nivel de entorno)

     Producción

     1. Define las variables de entorno KSA_NAME y GSA_NAME:

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-env-level-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     No producción

     1. Define la variable de entorno KSA_NAME:

        KSA_NAME="apigee-udca-env-level-service-account-name"

     2. Vincula el rol de IAM:

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Anota la cuenta de servicio:

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

2. Verifica si funcionaron los pasos:

   gcloud config set project $PROJECT_ID
   

   Selecciona una cuenta de servicio de Kubernetes para probar, por ejemplo: apigee-cassandra-backup.

   KSA_NAME="kubernetes-service-account-name"
   

   kubectl run --rm -it --image google/cloud-sdk:slim \
     --namespace $NAMESPACE workload-identity-test\
     -- gcloud auth list

   Si no ve el símbolo del sistema, presione Intro.

   Si los pasos se ejecutaron correctamente, deberías ver una respuesta como la siguiente:

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

3. Si actualizas desde una instalación anterior, limpia los secretos que contenían claves privadas de cuentas de servicio:

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

4. Verifica los registros:

   kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer
   

Actualiza una instalación para usar Workload Identity

Sigue estas instrucciones para agregar Workload Identity a una instalación híbrida existente.

A continuación, se muestra un ejemplo de las cuentas de servicio de Google (GSA) que se crearon para Apigee:

gcloud iam service-accounts list --filter "apigee"

DISPLAY NAME       EMAIL                                                  DISABLED
apigee-cassandra   apigee-cassandra@PROJECT_ID.iam.gserviceaccount.com    False
apigee-connect     apigee-connect@PROJECT_ID.iam.gserviceaccount.com      False
apigee-runtime     apigee-runtime@PROJECT_ID.iam.gserviceaccount.com      False
apigee-metrics     apigee-metrics@PROJECT_ID.iam.gserviceaccount.com      False
apigee-mart        apigee-mart@PROJECT_ID.iam.gserviceaccount.com         False
apigee-watcher     apigee-watcher@PROJECT_ID.iam.gserviceaccount.com      False
apigee-sync        apigee-sync@PROJECT_ID.iam.gserviceaccount.com         False
apigee-udca        apigee-udca@$PROJECT_ID.iam.gserviceaccount.com        False

A continuación, se muestra un ejemplo de las cuentas de servicio de Kubernetes (KSA) creadas para Apigee:

kubectl get sa -n $NAMESPACE

apigee-cassandra-schema-setup-ORG_NAME-cb84b88-sa             1         xxd
apigee-cassandra-user-setup-ORG_NAME-cb84b88-sa               1         xxd
apigee-connect-agent-ORG_NAME-cb84b88-sa                      1         xxd
apigee-init                                                   1         xxd
apigee-mart-ORG_NAME-cb84b88-sa                               1         xxd
apigee-metrics-apigee-telemetry                               1         xxd
apigee-runtime-ORG_NAME-ENV_NAME-1d0dc5e-sa                   1         xxd
apigee-synchronizer-ORG_NAME-ENV_NAME-1d0dc5e-sa              1         xxd
apigee-udca-ORG_NAME-ENV_NAME-1d0dc5e-sa                      1         xxd
apigee-watcher-ORG_NAME-cb84b88                               1         xxd

Estos son los parámetros: ORG_NAME y ENV_NAMEpueden ser versiones abreviadas de los nombres de la organización y el entorno.

1. Agrega la función de Workload Identity a cada cuenta de servicio:

   gcloud iam service-accounts add-iam-policy-binding \
     --role roles/iam.workloadIdentityUser \
     --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
     GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com
   

   Por ejemplo, si configuras los permisos para Apigee Synchronizer, debes ejecutar lo siguiente:

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

   gcloud iam service-accounts add-iam-policy-binding --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apigee/$KSA_NAME]" apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
   

2. Anota cada KSA con los detalles de GSA:

   kubectl annotate serviceaccount \
     --namespace $NAMESPACE \
     $KSA_NAME \
     iam.gke.io/gcp-service-account=GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com
   

   Por ejemplo, si configuras los permisos para Apigee Synchronizer, debes ejecutar lo siguiente:

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

   kubectl annotate serviceaccount --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
   

3. Verifica si funcionaron los pasos:

   gcloud config set project $PROJECT_ID
   

     kubectl run --rm -it --image google/cloud-sdk:slim \
       --namespace $NAMESPACE workload-identity-test\
       -- gcloud auth list

   Si no ve el símbolo del sistema, presione Intro.

   Si los pasos se ejecutaron correctamente, deberías ver una respuesta como la siguiente:

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

4. Si actualizas desde una instalación anterior, limpia los secretos que contenían claves privadas de cuentas de servicio:

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

5. Verifica los registros:

   kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer