Habilita Workload Identity con Apigee Hybrid

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

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:

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:

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:

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

Verifica las variables de entorno:

echo $PROJECT_ID
echo $ORG_NAME
echo $ENV_NAME
echo $NAMESPACE
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_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 una de estas secciones, según los pasos que realices:

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}
  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

    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

    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
    

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

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

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