Habilita Workload Identity con apigeectl

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

Si usas gráficos de Helm para instalar y administrar Apigee Hybrid, consulta Habilita Workload Identity con gráficos de Helm.

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:

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:

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.
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.
NAMESPACE: tu espacio de nombres de Apigee (por lo general, “Apigee”).

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

Configura el proyecto como el que estás modificando:
```
gcloud config set project $PROJECT_ID
```

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}

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.

Asegúrate de que Workload Identity esté habilitada en cada grupo de nodos.

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

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.

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.

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"

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"

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"

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"

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

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"

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"

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.

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

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.

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

Define las variables de entorno KSA_NAME y GSA_NAME:

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

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

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

Vuelve a definir la variable de entorno KSA_NAME:
```
KSA_NAME="apigee-cassandra-restore"
```

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

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

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

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

Vuelve a definir la variable de entorno KSA_NAME:

KSA_NAME="apigee-cassandra-schema-val-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

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

Vuelve a definir la variable de entorno KSA_NAME:

KSA_NAME="apigee-cassandra-user-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

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

Vuelve a definir la variable de entorno KSA_NAME:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-non-prod"
KSA_NAME="apigee-connect-agent-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

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

Vuelve a definir la variable de entorno KSA_NAME:
```
KSA_NAME="apigee-cassandra-restore"
```

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

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

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

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

Vuelve a definir la variable de entorno KSA_NAME:

KSA_NAME="apigee-cassandra-schema-val-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

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

Vuelve a definir la variable de entorno KSA_NAME:

KSA_NAME="apigee-cassandra-user-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

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

Vuelve a definir la variable de entorno KSA_NAME:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-connect-agent-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-connect-agent-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-mart-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-mart-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

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

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

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

Define la variable de entorno KSA_NAME:
```
KSA_NAME="apigee-metrics-sa"
```

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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-org-level-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

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

Define las variables de entorno KSA_NAME:

KSA_NAME="apigee-udca-org-level-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-watcher"
KSA_NAME="apigee-watcher-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-watcher-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-runtime"
KSA_NAME="apigee-runtime-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-runtime-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-synchronizer"
KSA_NAME="apigee-synchronizer-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-synchronizer-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

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

Define las variables de entorno KSA_NAME y GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-env-level-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

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

Define la variable de entorno KSA_NAME:

KSA_NAME="apigee-udca-env-level-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

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

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

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}')
```

Verifica los registros:

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

(Opcional) Puedes ver el estado de tus cuentas de servicio de Kubernetes en la página Descripción general de las cargas de trabajo de Kubernetes en la consola de Google Cloud.
Ir a Cargas de trabajo

Nota: Es posible que veas un estado de error para las cuentas de servicio apigee-cassandra-backup y apigee-cassandra-restore. Esto se debe a que actualmente no ejecutas la copia de seguridad ni el restablecimiento, y estos procesos aún no están configurados por completo. Para obtener más información sobre la copia de seguridad y el restablecimiento de Cassandra, consulta Descripción general de la copia de seguridad de Cassandra.

Habilita Workload Identity con apigeectl

Descripción general

Cuentas de servicio de Google en Apigee Hybrid sin Workload Identity

Variables de entorno que se usan en estos procedimientos

Workload Identity y archivos de claves de cuenta de servicio

Habilita Workload Identity para Apigee Hybrid

Prepárate para habilitar Workload Identity

Verifica o crea cuentas de servicio de Google

Producción

No producción

create-service-account

Producción

No producción

gcloud

Configura workloadIdentityEnabled: true y crea cuentas de servicio

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

Componentes a nivel de la organización

Componentes a nivel del entorno

Componentes a nivel de la organización

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

Producción

No producción

`create-service-account`

`gcloud`

Configura `workloadIdentityEnabled: true` y crea cuentas de servicio