Esta página se ha traducido con Cloud Translation API.

Paso 5: Configura la autenticación de la cuenta de servicio

Información general

En este paso se explica cómo configurar los métodos de autenticación de las cuentas de servicio de Google Cloud que has creado en el paso anterior.

Selecciona las instrucciones del método de autenticación que quieras usar. Consulta Métodos de autenticación de cuentas de servicio en Apigee hybrid para ver una descripción general de los diferentes métodos de autenticación.

Secretos de Kubernetes

Cuentas de servicio

Deberá crear secretos de Kubernetes para las siguientes cuentas de servicio:

Producción

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (si usas Monetización para Apigee Hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

No producción

apigee-non-prod

Deberá proporcionar cada uno de estos secretos durante el paso Crear el archivo de anulaciones.

En este procedimiento se usan las siguientes variables de entorno opcionales:

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Si no ha definido estas variables, sustituya el valor adecuado de cada variable en los ejemplos de código.

Crear secretos de Kubernetes

Crea los secretos de Kubernetes para almacenar las claves de la cuenta de servicio.

El comando kubectl create secret de los siguientes ejemplos de código tiene la estructura:

kubectl create secret generic SECRET_NAME \
  --from-file="client_secret.json=PATH_TO_SERVICE_ACCOUNT_KEY" \
  -n $APIGEE_NAMESPACE

Nota: En los siguientes comandos se da por hecho que has descargado los archivos de claves de las cuentas de servicio en el directorio $APIGEE_HELM_CHARTS_HOME/service-accounts/ del paso 4: Crea cuentas de servicio. Si has descargado las claves en otro directorio, edita los comandos para usar el directorio correcto.

Producción

kubectl create secret generic apigee-logger-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-logger.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-metrics.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-watcher.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-udca.json" \
  -n $APIGEE_NAMESPACE
    
kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mart.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-synchronizer.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-runtime.json" \
  -n $APIGEE_NAMESPACE

Si usas Monetización para Apigee hybrid, también debes crear un secreto de Kubernetes para la cuenta de servicio apigee-mint-task-scheduler:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

No producción

kubectl create secret generic apigee-non-prod-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-non-prod.json" \
  -n $APIGEE_NAMESPACE

Opcional: Puedes eliminar los archivos JSON de la cuenta de servicio después de crear los secretos de Kubernetes.

Para obtener más información sobre cómo usar secretos de Kubernetes con Apigee hybrid, consulta Almacenar claves de cuentas de servicio en secretos de Kubernetes.

Archivos JSON

No es necesario seguir ningún paso adicional para configurar la autenticación con archivos JSON. Ve al paso 6: Crea certificados TLS.

Vault

Configurar el almacenamiento de secretos de cuentas de servicio en Vault

Instalar el controlador de CSI y el proveedor de Vault

Si aún no has instalado el controlador CSI en tu clúster con Helm, sigue las instrucciones que se indican en Controlador CSI de Secrets Store: instalación. Para obtener más información, consulta el artículo Instalar el proveedor de CSI de Vault en la documentación de Vault.

Consulta las plataformas y versiones compatibles con Apigee hybrid para ver las versiones mínimas del controlador CSI compatibles con Apigee hybrid.

Crear secretos, políticas y roles de Vault

Usa la interfaz de usuario o las APIs de Vault para crear secretos y conceder permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leer esos secretos.

Crea los secretos específicos de la organización y del entorno con el siguiente formato:

Clave secreta Datos secretos

Clave secreta	Datos secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` solo es necesario si se usa Monetización para Apigee hybrid (v1.15.1 y versiones posteriores).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
    "cassandraBackup": "***",
    "cassandraRestore": "***",
    "connectAgent": "***",
    "logger": "***",
    "mart": "***",
    "metrics": "***",
    "mint": "***",
    "udca": "***",
    "watcher": "***"
}

Nota: mint solo es necesario si se usa Monetización para Apigee hybrid (v1.15.1 y versiones posteriores).

secret/data/apigee/envsakeys-ENV_NAME

{
    "runtime": "***",
    "synchronizer": "***",
    "udca": "***".
}

Sustituye el "***" de cada par por el contenido del archivo .json de la cuenta de servicio de Google correspondiente al componente de Apigee. Tanto apigee-cassandra-backup como apigee-cassandra-restore usan la cuenta de servicio apigee-cassandra. Por ejemplo:

{
    "cassandraBackup": "{
        "type": "service_account",
        "project_id": "myhybridorg",
        "private_key_id": "PRIVATE_KEY_ID",
        "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY_TEXT\n-----END PRIVATE KEY-----\n",
        "client_email": "apigee-cassandra@myhybridorg.iam.gserviceaccount.com",
        "client_id": "123456789012345678901",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/apigee-cassandra%40myhybridorg.iam.gserviceaccount.com",
        "universe_domain": "googleapis.com"
    }",
    "cassandraRestore":...
...
}

Concede acceso al secreto de la organización. Crea un archivo de texto llamado orgsakeys-auth-policy.txt con el siguiente contenido:
```
path "secret/data/apigee/orgsakeys" {
    capabilities = ["read"]
}
```
En Vault, crea una política que conceda acceso al secreto de la organización:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
En cada entorno, crea un archivo de texto llamado envsakeys-ENV_NAME-auth-policy.txt con el siguiente contenido:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Repite este paso en cada entorno.
En Vault, crea una política que conceda acceso al secreto del entorno:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repite este paso en cada entorno.

Crea una secuencia de comandos llamada generate-encoded-sas.sh con el siguiente contenido:

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
done

echo $NAMES

Nota: Elimina apigee-mint-task-scheduler-${ORG_ENCODE} si no usas Monetización de Apigee Hybrid.

Ejecuta la secuencia de comandos para generar la lista de nombres de cuentas de servicio a las que se va a vincular la política:

./generate-encoded-sas.sh

El resultado debe ser una lista de nombres de cuentas de servicio de Kubernetes separados por comas, como en el siguiente ejemplo:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

Copia el texto de salida y sepáralo en listas. Una lista para los nombres de las cuentas de servicio org y otra para los nombres de las cuentas de servicio env de cada entorno. Las cuentas de servicio de org son las primeras de la lista de resultados, hasta apigee-logger-apigee-telemetry.

Lista de nombres de servicios org del ejemplo anterior:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

Los nombres de las cuentas de servicio env siguen el patrón apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT y apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Sepáralos en listas independientes para cada entorno. Por ejemplo, la salida del ejemplo anterior se puede separar en las dos listas siguientes:

dev entorno:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod entorno:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Con la política, crea un rol de Vault que vincule las cuentas de servicio de Apigee específicas de la organización:

vault write auth/kubernetes/role/apigee-orgsakeys \
    bound_service_account_names=LIST_OF_ORG_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-orgsakeys-auth \
    ttl=1m

En cada entorno, crea un rol de Vault para sus claves de cuenta de servicio:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
    bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-envsakeys-ENV_NAME-auth \ 
    ttl=1m

Repite este paso en cada entorno.

Crear objetos `SecretProviderClass`

El recurso SecretProviderClass indica al controlador CSI con qué proveedor debe comunicarse al solicitar secretos. Las claves de cuenta de servicio deben configurarse a través de este objeto. En la siguiente tabla se muestran los nombres de archivo (objectNames) que espera Apigee Hybrid:

Cuenta de servicio	Nombres de archivo de secretos esperados
Copia de seguridad de Cassandra	`cassandraBackup`
Restauración de Cassandra	`cassandraRestore`
Agente de Connect	`connectAgent`
Logger	`logger`
MART	`mart`
Métricas	`metrics`
Monetización (si usa Monetización para Apigee Hybrid)	`mint`
Tiempo de ejecución	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Usa la siguiente plantilla SecretProviderClass para configurar este recurso para los secretos específicos de la organización:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-orgsakeys-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-orgsakeys
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "cassandraBackup"
                secretPath: ""
                secretKey: ""
            - objectName: "cassandraRestore"
                secretPath: ""
                secretKey: ""
            - objectName: "connectAgent"
                secretPath: ""
                secretKey: ""
            - objectName: "logger"
                secretPath: ""
                secretKey: ""
            - objectName: "mart"
                secretPath: ""
                secretKey: ""
            - objectName: "metrics"
                secretPath: ""
                secretKey: ""
            - objectName: "mint"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""
            - objectName: "watcher"
                secretPath: ""
                secretKey: ""

Nota: Elimina las líneas objectName: "mint" si no usas Monetización para Apigee Hybrid.

VAULT_ADDRESS es el endpoint en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster que Apigee, el formato será generalmente http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Guarda la plantilla en un archivo llamado spc-org.yaml.

Aplica el SecretProviderClass específico de la organización a tu espacio de nombres de Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

En cada entorno, utilice la siguiente plantilla SecretProviderClass para configurar este recurso con los secretos específicos del entorno. Repite este paso en cada entorno:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-envsakeys-ENV_NAME-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-envsakeys-ENV_NAME
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "runtime"
                secretPath: ""
                secretKey: ""
            - objectName: "synchronizer"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""

VAULT_ADDRESS es el endpoint en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster y espacio de nombres que Apigee, el formato será http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Guarda la plantilla en un archivo llamado spc-env-ENV_NAME.yaml.

En cada entorno, aplica el SecretProviderClass específico del entorno a tu espacio de nombres de Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repite este paso en cada entorno.
Opcional: Puedes eliminar los archivos JSON de la cuenta de servicio después de crear los objetos SecretProviderClass.

WIF para GKE

Preparar la configuración de Workload Identity Federation para GKE

Verifica que Workload Identity Federation para GKE esté habilitado en tu archivo de anulaciones. Debe habilitarse en el archivo de anulaciones en las siguientes propiedades.
- Es obligatorio rellenar el campo "namespace". Por ejemplo:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Si usas una sola cuenta de servicio (no de producción) para todos los componentes, especifícala con: gcp.workloadIdentity.gsa. Por ejemplo:
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Si usas una cuenta de servicio independiente para cada componente (instalaciones de producción), especifica la cuenta de servicio con la propiedad gsa del componente. Por ejemplo:
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Consulta: gcp.workloadIdentity.enabled.
Comprueba que la configuración gcloud actual esté definida en el ID de tu proyecto de Google Cloud con el siguiente comando:
```
gcloud config get project
```

Si es necesario, define la configuración actual de gcloud:

gcloud config set project $PROJECT_ID

Verifica que Workload Identity Federation para GKE esté habilitado en tu clúster de GKE. Cuando creaste el clúster en el paso 1: Crea un clúster, el paso 6 consistía en habilitar Workload Identity Federation for GKE. Confirma que está habilitado con el siguiente comando:

Clústeres regionales

gcloud container clusters describe $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

Clústeres zonales

gcloud container clusters describe $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

La salida debería tener este aspecto:

  ---
  workloadPool: $PROJECT_ID.svc.id.goog

Si ves null en los resultados, ejecuta el siguiente comando para habilitar Workload Identity Federation for GKE en tu clúster:

Clústeres regionales

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

Clústeres zonales

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

Habilita Workload Identity Federation para GKE en cada grupo de nodos con los siguientes comandos. Esta operación puede tardar hasta 30 minutos por cada nodo:
Clústeres regionales
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Clústeres zonales
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Donde NODE_POOL_NAME es el nombre de cada grupo de nodos. En la mayoría de las instalaciones de Apigee hybrid, los dos grupos de nodos predeterminados se denominan apigee-data y apigee-runtime.

Verifica que Workload Identity Federation for GKE esté habilitado en tus grupos de nodos con los siguientes comandos:

Clústeres regionales

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

Clústeres zonales

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

La salida debería tener un aspecto similar a este:

---
diskSizeGb: 100
diskType: pd-standard
...
workloadMetadataConfig:
  mode: GKE_METADATA

Nota: Puedes limitar el resultado al campo workloadMetadataConfig canalizando el resultado a través de grep con la marca -A 1 para incluir la siguiente línea:

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:" | grep "workloadMetadataConfig" -A 1

WIF en otras plataformas

Si usas Workload Identity Federation en plataformas que no sean GKE, puedes usar los siguientes métodos para configurar la autenticación de cuentas de servicio:

Secretos de Kubernetes
Archivos JSON de cuentas de servicio
Vault

En las siguientes instrucciones, elige la pestaña del método de autenticación que estés usando.

En este procedimiento se usan las dos variables de entorno siguientes, definidas en el paso 2: descarga los gráficos de Helm de Apigee. Estas variables son opcionales. Si no los has definido, sustituye la ruta de directorio adecuada por cada variable en los ejemplos de código.

$APIGEE_HELM_CHARTS_HOME: directorio en el que has descargado los gráficos de Helm de Apigee, definidos en el paso 2: Descarga los gráficos de Helm de Apigee.
$PROJECT_ID: tu ID de proyecto de Google Cloud, definido en la parte 1: configuración del proyecto y de la organización (paso 1: habilitar APIs).

En las instalaciones de AKS, asegúrate de haber habilitado el emisor de OpenID Connect (OIDC). Debes habilitar esta función para que la federación de identidades de carga de trabajo pueda acceder a los metadatos de OpenID Connect y al conjunto de claves web JSON (JWKS) del clúster.

Configura tu clúster para que use la federación de identidades de cargas de trabajo.

Comprueba que la configuración gcloud actual se ha definido en el ID de tu proyecto de Google Cloud con el siguiente comando:
```
gcloud config get project
```

Si es necesario, define la configuración actual de gcloud:

gcloud config set project $PROJECT_ID

Habilita la API Security Token Service:
Comprueba que la API Security Token Service esté habilitada con el siguiente comando:
```
gcloud services list --enabled --project $PROJECT_ID | grep sts.googleapis.com
```
Si la API no está habilitada:
Consola

Enable the Security Token Service API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Línea de comandos

Habilita la API con el siguiente comando:
```
gcloud services enable sts.googleapis.com --project $PROJECT_ID
```
Crea el grupo de identidades de carga de trabajo y el proveedor.
Roles obligatorios
Para obtener los permisos que necesitas para configurar la federación de identidades de carga de trabajo, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el proyecto:
- Administrador de grupos de Workload Identity (roles/iam.workloadIdentityPoolAdmin)
- Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

También puedes usar el rol básico Propietario de gestión de identidades y accesos (roles/owner), que incluye permisos para configurar la federación de identidades. No debes conceder roles básicos en un entorno de producción, pero sí puedes hacerlo en un entorno de desarrollo o de pruebas.
Para crear un grupo de identidades de carga de trabajo y un proveedor, sigue estos pasos:
1. Determina la URL de la entidad emisora de tu clúster de AKS:
  AKS
  az aks show -n CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Haz los cambios siguientes:
  - CLUSTER_NAME: el nombre del clúster.
  - RESOURCE_GROUP: el grupo de recursos del clúster.
  El comando muestra la URL de la entidad emisora. Necesitarás la URL del emisor en uno de los siguientes pasos.
  
  Si el comando no devuelve una URL de emisor, comprueba que hayas habilitado la función Emisor de OIDC.
  EKS
  aws eks describe-cluster --name CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Sustituye CLUSTER_NAME por el nombre del clúster.
  
  El comando muestra la URL de la entidad emisora. Necesitarás la URL del emisor en uno de los siguientes pasos.
  Otros Kubernetes
  
  Conéctate a tu clúster de Kubernetes y usa `kubectl` para determinar la URL de la entidad emisora de tu clúster:
  kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
  Necesitarás la URL del emisor en uno de los siguientes pasos.
2. Opcional: Si tu emisor de OIDC no es accesible públicamente, descarga el conjunto de claves web JSON (JWKS) del clúster:
  Nota: Para completar este paso, debes tener acceso a kubectl en tu clúster.
  
  Nota: Cuando uses el archivo JWKS, tendrás que subir un archivo JWKS nuevo cada vez que rotes las claves de firma del clúster.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Para comprobar si tu proveedor de OIDC está disponible públicamente, deberías poder acceder a su URL con un comando CURL y recibir una respuesta 200.
3. Crea un grupo de identidades de carga de trabajo:
```
gcloud iam workload-identity-pools create POOL_ID \
    --location="global" \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
  Haz los cambios siguientes:
  - POOL_ID: ID único del grupo.
  - DISPLAY_NAME: (opcional) nombre del grupo.
  - DESCRIPTION: (Opcional) Descripción del grupo que elijas. Esta descripción aparece cuando concedes acceso a identidades de grupo.
  Por ejemplo:
```
gcloud iam workload-identity-pools create my-wi-pool --display-name="My workload pool" --description="My workload pool description"
```
4. Añade el clúster como proveedor de grupos de identidades de carga de trabajo. Elige el comando para crear el proveedor en función de si tu emisor de OIDC es accesible públicamente o no accesible públicamente:
  Acceso público
  
  Si tu emisor de OIDC es accesible públicamente, crea el proveedor con el siguiente comando:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --attribute-mapping="google.subject=assertion.sub"
  No es accesible públicamente
  
  Si tu emisor de OIDC no es accesible públicamente, crea el proveedor con el siguiente comando:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --jwks-file="cluster-jwks.json" \ --attribute-mapping="google.subject=assertion.sub"
  Nota: Si rotas tus claves, debes subir el nuevo JWKS con cada rotación de claves.
  El comando no valida el JWKS del clúster. Si el JWKS está mal formado o ha caducado, es posible que los intentos de autenticación posteriores fallen y se muestre el mensaje de error Error connecting to the given credential's issuer.
  Haz los cambios siguientes:
  - WORKLOAD_PROVIDER_ID: un ID de proveedor de grupos de identidades de carga de trabajo único que elijas.
  - POOL_ID: el ID del grupo de identidades de carga de trabajo que has creado anteriormente.
  - ISSUER: usa la URL de la entidad emisora que has determinado anteriormente para el URI de la entidad emisora .
  attribute-mapping="google.subject=assertion.sub" asigna el asunto de Kubernetes al asunto de gestión de identidades y accesos.

Crear los archivos de configuración de credenciales

Para desplegar una carga de trabajo de Kubernetes que pueda acceder a los Google Cloud recursos, primero debes crear un archivo de configuración de credenciales para cada cuenta de servicio de gestión de identidades y accesos:

Lista las cuentas de servicio de gestión de identidades y accesos (también llamadas "cuentas de servicio de Google") con el siguiente comando:
```
gcloud iam service-accounts list --project $PROJECT_ID
```
Nota: Lo más probable es que ya hayas creado las cuentas de servicio de gestión de identidades y accesos (también llamadas "cuentas de servicio de Google") durante la instalación inicial de Apigee hybrid con la herramienta create-service-account. Consulta la lista de cuentas de servicio de gestión de identidades y accesos que necesita Apigee hybrid en el artículo Acerca de las cuentas de servicio. Consulta el paso 4: Crea cuentas de servicio de la guía de instalación para crear las cuentas de servicio de IAM.

Deberá crear los archivos de configuración de credenciales de las siguientes cuentas de servicio de gestión de identidades y accesos:
Producción

En entornos de producción:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-cassandra     apigee-cassandra@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
```
Si usas Monetización para Apigee hybrid en la versión v1.15.1 o posterior, también tendrás que crear el archivo de configuración de credenciales de la cuenta de servicio apigee-mint-task-scheduler.
```
DISPLAY NAME                 EMAIL                                                              DISABLED
...
apigee-mint-task-scheduler   apigee-mint-task-scheduler@my_project_id.iam.gserviceaccount.com   False
...
```
No producción

En entornos que no sean de producción:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
```
Nota: Si tienes nombres personalizados para tus cuentas de servicio que no se corresponden fácilmente con los nombres de los componentes de Apigee, puedes determinar el rol de cada cuenta de servicio comprobando los roles que tiene asignados y comparándolos con los roles recomendados en Acerca de las cuentas de servicio.
Usa el siguiente comando para comprobar 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"
```
Anota qué cuenta de servicio personalizada corresponde a cada cuenta de servicio de IAM de la lista anterior.

Crea un archivo de configuración de credenciales para cada cuenta de servicio de IAM de la lista anterior.

WIF: secrets

Este enfoque usa configuraciones de credenciales almacenadas en secretos de Kubernetes. Cuando crees el archivo de anulaciones en el paso 7: Crea las anulaciones, debes proporcionar el nombre del secreto de cada cuenta de servicio con la propiedad serviceAccountRef o envs.serviceAccountRefs.

Crear los archivos de configuración de credenciales

Producción

Deberá crear los archivos de configuración de credenciales de las siguientes cuentas de servicio:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Si usas Monetización para Apigee Hybrid.
apigee-runtime
apigee-synchronizer
apigee-udca

Crea un directorio para los archivos de configuración de las credenciales. El directorio puede tener cualquier nombre. En este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crea el archivo de configuración de credenciales de apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Donde:

PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
POOL_ID: el ID del grupo de identidades de carga de trabajo.
WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo

Importante: credential-source-type debe tener el valor text.

Crea el archivo de configuración de credenciales de apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Si usas Monetización para Apigee hybrid, también tendrás que crear el archivo de configuración de credenciales de apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Nota: No crees un archivo de configuración de credenciales para la cuenta de servicio apigee-logger.

No producción

Crea un directorio para el archivo de configuración de las credenciales. El directorio puede tener cualquier nombre. En este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea el archivo de configuración de credenciales de la cuenta de servicio apigee-non-prod en el directorio credential-configurations con el siguiente comando:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Donde:
- PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
- POOL_ID: el ID del grupo de identidades de carga de trabajo.
- WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo
Importante: credential-source-type debe tener el valor text.

Crear los secretos de Kubernetes

Crea los secretos de Kubernetes para almacenar los archivos de configuración de las credenciales de cada cuenta de servicio.

El comando kubectl create secret de los siguientes ejemplos de código tiene la estructura:

kubectl create secret generic SECRET_NAME \
        --from-file="client_secret.json=PATH_TO_CREDENTIAL_CONFIGURATION_FILE" \
        -n APIGEE_NAMESPACE

Producción

Crea el archivo secreto de apigee-cassandra:

kubectl create secret generic apigee-cassandra-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-cassandra.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-mart:

kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mart.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-metrics:

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-metrics.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-runtime:

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-runtime.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-synchronizer:

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-synchronizer.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-udca:

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-udca.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-watcher:

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-watcher.json" \
  -n APIGEE_NAMESPACE

Si usas Monetización para Apigee Hybrid, crea el archivo secreto de apigee-mint-task-scheduler:

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Crea el archivo secreto de apigee-non-prod:

No producción

kubectl create secret generic apigee-non-prod-svc-account \
        --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-non-prod.json" \
        -n APIGEE_NAMESPACE

WIF: archivos

Este método usa los archivos de configuración de credenciales en lugar de los archivos de clave de cuenta de servicio de Google. Cuando crees el archivo de anulaciones en el paso 7: Crea las anulaciones, debes proporcionar la ruta al archivo de configuración de credenciales de cada propiedad serviceAccountPath o envs.serviceAccountPaths.

Producción

Deberá crear los archivos de configuración de las credenciales en los directorios de gráficos correspondientes:

Cuenta de servicio	Directorio de gráficos de Helm de Apigee
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-mint-task-scheduler` (Si usas Monetización para Apigee hybrid)	`apigee-org/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Crea los archivos de configuración de credenciales con los siguientes comandos:

apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-cassandra-credential-configuration.json

Donde:

PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
POOL_ID: el ID del grupo de identidades de carga de trabajo.
WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo

Importante: credential-source-type debe tener el valor text.

apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mart-credential-configuration.json

apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-metrics-credential-configuration.json

apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-runtime-credential-configuration.json

apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-synchronizer-credential-configuration.json

apigee-udca:

La cuenta de servicio apigee-udca se usa en los gráficos apigee-org y apigee-env.

Crea el archivo de configuración de credenciales en el directorio de gráficos apigee-org.

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json

Copia el archivo de configuración de las credenciales en el directorio apigee-env del gráfico.

cp $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-udca-credential-configuration.json

apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-watcher-credential-configuration.json

Si usas href="monetization-for-hybrid">Monetización de Apigee hybrid, también tendrás que crear el archivo de configuración de credenciales de apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mint-task-scheduler-credential-configuration.json

Nota: No crees un archivo de configuración de credenciales para la cuenta de servicio apigee-logger.

No producción

Deberás crear el archivo de configuración de las credenciales y copiarlo en los directorios de gráficos correspondientes:

Cuenta de servicio	Gráfico de Helm de Apigee
`apigee-non-prod`	`apigee-datastore/` `apigee-telemetry/` `apigee-org/` `apigee-env/`

Crea el archivo de configuración de credenciales en el directorio del gráfico apigee-datastore con el siguiente comando:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
--service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
--credential-source-file=/var/run/service-account/token \
--credential-source-type=text \
--output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json
```
Donde:
- PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
- POOL_ID: el ID del grupo de identidades de carga de trabajo.
- WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo
Importante: credential-source-type debe tener el valor text.

Copia el archivo de configuración de credenciales en los directorios de gráficos apigee-env, apigee-org/ y apigee-telemetry/.

cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-non-prod-credential-configuration.json

WIF: Vault

Este método usa configuraciones de credenciales almacenadas en un gestor de secretos externo, HashiCorp Vault. Cuando crees el archivo de anulaciones en el paso 7: Crea las anulaciones, proporciona secretos de Vault a nivel de organización y de entorno con las propiedades serviceAccountSecretProviderClass o envs.serviceAccountSecretProviderClass.

Crear los archivos de configuración de credenciales

Producción

Deberá crear los archivos de configuración de credenciales de las siguientes cuentas de servicio:

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (Si usas Monetización para Apigee hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca

Crea un directorio para los archivos de configuración de las credenciales. El directorio puede tener cualquier nombre. En este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Crea el archivo de configuración de credenciales de apigee-cassandra:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Donde:

PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
POOL_ID: el ID del grupo de identidades de carga de trabajo.
WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo

Importante: credential-source-type debe tener el valor text.

Crea el archivo de configuración de credenciales de apigee-mart:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-metrics:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-runtime:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-synchronizer:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-udca:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Crea el archivo de configuración de credenciales de apigee-watcher:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Si usas Monetización para Apigee hybrid, también tendrás que crear el archivo de configuración de credenciales de apigee-mint-task-scheduler:

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

Nota: No crees un archivo de configuración de credenciales para la cuenta de servicio apigee-logger.

No producción

Crea un directorio para el archivo de configuración de las credenciales. El directorio puede tener cualquier nombre. En este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea el archivo de configuración de credenciales de la cuenta de servicio apigee-non-prod en el directorio credential-configurations con el siguiente comando:
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Donde:
- PROJECT_NUMBER: número del proyecto que contiene el grupo de identidades de carga de trabajo. Debe ser el número de proyecto, no el ID de proyecto.
  Nota: Puedes encontrar el número de proyecto con el siguiente comando:
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- POOL_ID: el ID del grupo de identidades de carga de trabajo.
- WORKLOAD_PROVIDER_ID: el ID del proveedor de grupos de identidades de carga de trabajo
Importante: credential-source-type debe tener el valor text.

Instalar el controlador de CSI y el proveedor de Vault

Consulta las plataformas y versiones compatibles con Apigee hybrid para ver las versiones mínimas del controlador CSI compatibles con Apigee hybrid.

Crear secretos, políticas y roles de Vault

Usa la interfaz de usuario o las APIs de Vault para crear secretos y conceder permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leer esos secretos.

Crea los secretos específicos de la organización y del entorno con el siguiente formato:

Clave secreta Datos secretos

Clave secreta	Datos secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` solo es necesario si se usa Monetization para Apigee hybrid (v1.15.1 y versiones posteriores).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
  "cassandraBackup": "***",
  "cassandraRestore": "***",
  "connectAgent": "***",
  "logger": "***",
  "mart": "***",
  "metrics": "***",
  "mint": "***",
  "udca": "***",
  "watcher": "***"
}

Nota: mint solo es necesario si se usa Monetization para Apigee hybrid (v1.15.1 y versiones posteriores).

secret/data/apigee/envsakeys-ENV_NAME

{
  "runtime": "***",
  "synchronizer": "***",
  "udca": "***".
    }

Producción

Sustituye "***" en cada par por el contenido del archivo de configuración de credenciales de la cuenta de servicio de Google correspondiente al componente de Apigee. Tanto apigee-cassandra-backup como apigee-cassandra-restore usan la cuenta de servicio apigee-cassandra. Por ejemplo:

{
  "cassandraBackup": "{
    "universe_domain": "googleapis.com",
    "type": "external_account:,"
    "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
    "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
    "token_url": "https://sts.googleapis.com/v1/token",
    "service
    "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-cassandra@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

No producción

Sustituye "***" en cada par por el contenido del archivo de configuración de credenciales de la cuenta de servicio apigee-non-prod. Tanto apigee-cassandra-backup como apigee-cassandra-restore usan la cuenta de servicio apigee-cassandra. Por ejemplo:

{
  "cassandraBackup": "{
    "universe_domain": "googleapis.com",
    "type": "external_account:,"
    "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
    "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
    "token_url": "https://sts.googleapis.com/v1/token",
    "service
    "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-non-prod@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Concede acceso al secreto de la organización. Crea un archivo de texto llamado orgsakeys-auth-policy.txt con el siguiente contenido:
```
path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
```
En Vault, crea una política que conceda acceso al secreto de la organización:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
En cada entorno, crea un archivo de texto llamado envsakeys-ENV_NAME-auth-policy.txt con el siguiente contenido:
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Repite este paso en cada entorno.
En Vault, crea una política que conceda acceso al secreto del entorno:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repite este paso en cada entorno.

Crea una secuencia de comandos llamada generate-encoded-sas.sh con el siguiente contenido:

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
  do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
  done

echo $NAMES

Nota: Elimina apigee-mint-task-scheduler-${ORG_ENCODE} si no usas Monetización de Apigee Hybrid.

Ejecuta la secuencia de comandos para generar la lista de nombres de cuentas de servicio a las que se va a vincular la política:

./generate-encoded-sas.sh

El resultado debe ser una lista de nombres de cuentas de servicio de Kubernetes separados por comas, como en el siguiente ejemplo:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

Lista de nombres de servicios org del ejemplo anterior:

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

dev entorno:

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

prod entorno:

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

Con la política, crea un rol de Vault que vincule las cuentas de servicio de Apigee específicas de la organización:

vault write auth/kubernetes/role/apigee-orgsakeys \
  bound_service_account_names=LIST_OF_ORG_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-orgsakeys-auth \
  ttl=1m

En cada entorno, crea un rol de Vault para sus claves de cuenta de servicio:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
  bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-envsakeys-ENV_NAME-auth \ 
  ttl=1m

Repite este paso en cada entorno.

Crear objetos `SecretProviderClass`

Cuenta de servicio	Nombres de archivo de secretos esperados
Copia de seguridad de Cassandra	`cassandraBackup`
Restauración de Cassandra	`cassandraRestore`
Agente de Connect	`connectAgent`
MART	`mart`
Métricas	`metrics`
Monetización (si usa Monetización para Apigee Hybrid)	`mint`
Tiempo de ejecución	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Usa la siguiente plantilla SecretProviderClass para configurar este recurso para los secretos específicos de la organización:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgsakeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgsakeys
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
      objects: |
      - objectName: "cassandraBackup"
        secretPath: ""
        secretKey: ""
      - objectName: "cassandraRestore"
        secretPath: ""
        secretKey: ""
      - objectName: "connectAgent"
        secretPath: ""
        secretKey: ""
      - objectName: "logger"
        secretPath: ""
        secretKey: ""
      - objectName: "mart"
        secretPath: ""
        secretKey: ""
      - objectName: "metrics"
        secretPath: ""
        secretKey: ""
      - objectName: "mint"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""
      - objectName: "watcher"
        secretPath: ""
        secretKey: ""

Nota: Elimina las líneas objectName: "mint" si no usas Monetización para Apigee Hybrid.

Guarda la plantilla en un archivo llamado spc-org.yaml.

Aplica el SecretProviderClass específico de la organización a tu espacio de nombres de Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

En cada entorno, utilice la siguiente plantilla SecretProviderClass para configurar este recurso con los secretos específicos del entorno. Repite este paso en cada entorno:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-envsakeys-ENV_NAME-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-envsakeys-ENV_NAME
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
    objects: |
      - objectName: "runtime"
        secretPath: ""
        secretKey: ""
      - objectName: "synchronizer"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""

Guarda la plantilla en un archivo llamado spc-env-ENV_NAME.yaml.

En cada entorno, aplica el SecretProviderClass específico del entorno a tu espacio de nombres de Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repite este paso en cada entorno.

Paso siguiente

1 2 3 4 5 Paso 6: Crea certificados TLS 7 8 9 10 11

Paso 5: Configura la autenticación de la cuenta de servicio Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Información general

Secretos de Kubernetes

Cuentas de servicio

Producción

No producción

Crear secretos de Kubernetes

Producción

No producción

Archivos JSON

Vault

Configurar el almacenamiento de secretos de cuentas de servicio en Vault

Instalar el controlador de CSI y el proveedor de Vault

Crear secretos, políticas y roles de Vault

Crear objetos SecretProviderClass

WIF para GKE

Preparar la configuración de Workload Identity Federation para GKE

Clústeres regionales

Clústeres zonales

Clústeres regionales

Clústeres zonales

Clústeres regionales

Clústeres zonales

Clústeres regionales

Clústeres zonales

WIF en otras plataformas

Configura tu clúster para que use la federación de identidades de cargas de trabajo.

Consola

Línea de comandos

Roles obligatorios

AKS

EKS

Otros Kubernetes

Acceso público

No es accesible públicamente

Crear los archivos de configuración de credenciales

Producción

No producción

WIF: secrets

Crear los archivos de configuración de credenciales

Producción

No producción

Crear los secretos de Kubernetes

Producción

No producción

WIF: archivos

Producción

No producción

WIF: Vault

Crear los archivos de configuración de credenciales

Producción

No producción

Instalar el controlador de CSI y el proveedor de Vault

Crear secretos, políticas y roles de Vault

Producción

No producción

Crear objetos SecretProviderClass

Paso siguiente

Paso 5: Configura la autenticación de la cuenta de servicio

Crear objetos `SecretProviderClass`

Crear objetos `SecretProviderClass`