Se usó la API de Cloud Translation para traducir esta página.

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

Descripción general

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

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

Secretos de Kubernetes

Cuentas de servicio

Deberás 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 Monetization para Apigee Hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

No producción

apigee-non-prod

Proporcionarás cada uno de estos secretos durante el paso Crea 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 definiste estas variables, sustituye el valor adecuado para cada variable en las muestras de código.

Crea secretos de Kubernetes

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

El comando kubectl create secret en las siguientes muestras de código tiene la siguiente 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 supone que descargaste los archivos de claves de la cuenta de servicio en el directorio $APIGEE_HELM_CHARTS_HOME/service-accounts/ del Paso 4: Crear cuentas de servicio. Si descargaste las claves en un directorio diferente, 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 la 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 borrar los archivos JSON de la cuenta de servicio después de crear los objetos Secret de Kubernetes.

Para obtener más información sobre el uso de Secrets de Kubernetes con Apigee Hybrid, consulta Cómo almacenar claves de cuentas de servicio en Secrets de Kubernetes.

Archivos JSON

No se necesitan pasos adicionales para configurar la autenticación con archivos JSON. Continúa con el Paso 6: Crea certificados TLS.

Vault

Configura la opción para almacenar secretos de cuentas de servicio en Vault

Instala el controlador CSI y el proveedor de Vault

Si aún no instalaste el controlador de CSI en tu clúster con Helm, sigue las instrucciones que se indican en Controlador de CSI de Secrets Store: Instalación. Para obtener más información, consulta Instala el proveedor de CSI de Vault en la documentación de Vault.

Consulta Plataformas y versiones compatibles con Apigee Hybrid para conocer las versiones mínimas del controlador de CSI compatibles con Apigee Hybrid.

Crea políticas, secrets y roles de Vault

Usa la IU o las APIs de Vault a fin de crear secretos y otorgar permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leerlos.

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

Clave secreta Datos de los secretos

Clave secreta	Datos de los secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` solo es necesario si se usa la 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 la Monetización para Apigee Hybrid (v1.15.1 y versiones posteriores).

secret/data/apigee/envsakeys-ENV_NAME

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

Reemplaza "***" en cada par por el contenido del archivo .json de la cuenta de servicio de Google correspondiente al componente de Apigee. apigee-cassandra-backup y 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":...
...
}

Otorga 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 otorgue acceso al secreto de la organización:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para 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 para cada entorno.
En Vault, crea una política que otorgue acceso al secreto del entorno:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repite este paso para cada entorno.

Crea una secuencia de comandos 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: Quita apigee-mint-task-scheduler-${ORG_ENCODE} si no usas la Monetización para Apigee Hybrid.

Ejecuta la secuencia de comandos para generar la lista de nombres de cuentas de servicio a la que se 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, similar al 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 para los nombres de las cuentas de servicio de org y otra para el nombre de la cuenta de servicio de env para cada entorno. Las cuentas de servicio de org aparecen primero en la lista de resultados hasta apigee-logger-apigee-telemetry.

La lista de nombres de servicio de 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 de env tienen el patrón apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT y apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Sepáralos en listas separadas para cada entorno. Por ejemplo, el resultado del ejemplo anterior se puede separar en las siguientes dos listas:

Entorno dev:

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

Entorno prod:

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 las claves de su 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 para cada entorno.

Crear objetos `SecretProviderClass`

El recurso SecretProviderClass le indica al controlador de CSI con qué proveedor se debe comunicar cuando solicita secrets. Las claves de la cuenta de servicio deben configurarse a través de este objeto. En la siguiente tabla, se muestran los nombres de archivos (objectNames) que espera Apigee Hybrid:

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

Usa la siguiente plantilla de 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: Quita las líneas objectName: "mint" si no usas la Monetización para Apigee Hybrid.

VAULT_ADDRESS es el extremo en el que se ejecuta tu servidor de Vault. Si Vault se ejecuta en el mismo clúster que Apigee, el formato suele ser 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, usa la siguiente plantilla SecretProviderClass para configurar este recurso para los secretos específicos del entorno. Repite este paso para 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 extremo 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 suele ser http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

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

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

WIF para GKE

Prepárate para configurar la federación de identidades para cargas de trabajo para GKE

Verifica que la federación de identidades para cargas de trabajo para GKE esté habilitada en tu archivo de anulaciones. Debe habilitarse en el archivo de anulación en las siguientes propiedades.
- El campo namespace es obligatorio. Por ejemplo:
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Si usas una sola cuenta de servicio (que no es 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.
Verifica que la configuración actual de gcloud sea el ID de tu proyecto de Google Cloud con el siguiente comando:
```
gcloud config get project
```

Si es necesario, establece la configuración actual gcloud:

gcloud config set project $PROJECT_ID

Verifica que Workload Identity Federation for GKE esté habilitada para tu clúster de GKE. Cuando creaste el clúster en el Paso 1: Crea un clúster, el paso 6 fue 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'

El resultado debe tener el siguiente aspecto:

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

Si, en cambio, ves null en los resultados, ejecuta el siguiente comando para habilitar la federación de identidades para cargas de trabajo para 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 la federación de identidades para cargas de trabajo para GKE en cada grupo de nodos con los siguientes comandos. Esta operación puede demorar 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
```
En el ejemplo anterior, NODE_POOL_NAME es el nombre de cada grupo de nodos. En la mayoría de las instalaciones híbridas de Apigee, los dos grupos de nodos predeterminados se llaman apigee-data y apigee-runtime.

Verifica que la federación de identidades para cargas de trabajo para GKE esté habilitada 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:"

Deberías obtener un resultado similar al siguiente:

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

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

Cuando usas la federación de identidades para cargas de trabajo en plataformas que no son de GKE, puedes usar los siguientes métodos para configurar la autenticación de la SA:

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

En este procedimiento, se usan las siguientes dos variables de entorno definidas en el Paso 2: Descarga los gráficos de Helm para Apigee. Estas variables son opcionales. Si no las definiste, sustituye la ruta de acceso del directorio adecuada para cada variable en las muestras de código.

$APIGEE_HELM_CHARTS_HOME: Es el directorio en el que descargaste los charts de Helm para Apigee, que se definen en el Paso 2: Descarga los charts de Helm para Apigee.
$PROJECT_ID: Es el ID de tu proyecto de Google Cloud, definido en la Parte 1: Configuración del proyecto y la organización -- Paso 1: Habilita las APIs.

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

Configura el clúster para usar la federación de identidades para cargas de trabajo.

Verifica que la configuración actual de gcloud sea el ID de tu proyecto de Google Cloud con el siguiente comando:
```
gcloud config get project
```

Si es necesario, establece la configuración actual gcloud:

gcloud config set project $PROJECT_ID

Habilita la API de Security Token Service:
Verifica que la API de 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, haz lo siguiente:
Console

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 proveedor y el grupo de identidades para cargas de trabajo.
Roles requeridos
Para obtener los permisos que necesitas para configurar la federación de Workload Identity, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:
- Administrador de grupos de identidades para cargas de trabajo (roles/iam.workloadIdentityPoolAdmin)
- Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin)
Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

De manera alternativa, el rol básico de propietario de IAM (roles/owner) también incluye permisos para configurar la federación de identidades. No deberías otorgar roles básicos en un entorno de producción, pero puedes otorgarlos en un entorno de desarrollo o de prueba.
Para crear un proveedor y un grupo de identidades para cargas de trabajo, haz lo siguiente:
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
  Reemplaza lo siguiente:
  - CLUSTER_NAME: Es el nombre del clúster.
  - RESOURCE_GROUP: Es el grupo de recursos del clúster.
  El comando genera la URL de la entidad emisora. Necesitarás la URL de la entidad emisora en uno de los siguientes pasos.
  
  Si el comando no devuelve una URL de la entidad emisora, verifica que hayas habilitado la función entidad emisora de OIDC.
  EKS
  aws eks describe-cluster --name CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Reemplaza CLUSTER_NAME por el nombre del clúster.
  
  El comando genera la URL de la entidad emisora. Necesitas la URL de la entidad emisora en uno de los siguientes pasos.
  Otro Kubernetes
  
  Conéctate a tu clúster de Kubernetes y usa `kubectl` para determinar la URL de la entidad emisora del clúster:
  kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
  Necesitas la URL de la entidad emisora en uno de los siguientes pasos.
2. Opcional: Si no se puede acceder públicamente a tu emisor de OIDC, descarga el conjunto de claves web JSON (JWKS) del clúster:
  Nota: Este paso requiere acceso de kubectl a tu clúster.
  
  Nota: Cuando uses el archivo JWKS, deberás subir un archivo nuevo cada vez que rotes las claves de firma del clúster.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Para verificar si tu proveedor de OIDC está disponible públicamente, deberías poder acceder a la URL del proveedor con un comando CURL y recibir una respuesta 200.
3. Crea un nuevo grupo de identidades para cargas de trabajo:
```
gcloud iam workload-identity-pools create POOL_ID \
    --location="global" \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
  Reemplaza lo siguiente:
  - POOL_ID: el ID único para el grupo.
  - DISPLAY_NAME: (Opcional) Es el nombre del grupo.
  - DESCRIPTION: (Opcional) Es una descripción del grupo que eliges. Esta descripción aparece cuando otorgas 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. Agrega el clúster como proveedor de grupos de identidades para cargas de trabajo. Elige el comando para crear el proveedor según si tu entidad emisora de OIDC es de acceso público o no es de acceso público:
  Accesible de forma pública
  
  Si se puede acceder públicamente a tu entidad emisora de OIDC, 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 no se puede acceder públicamente a tu emisor de OIDC, 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 venció, los intentos de autenticación posteriores podrían fallar con un mensaje de error Error connecting to the given credential's issuer.
  Reemplaza lo siguiente:
  - WORKLOAD_PROVIDER_ID: Un ID de proveedor de grupos de identidades para cargas de trabajo único que elijas.
  - POOL_ID: El ID del grupo de identidades para cargas de trabajo que creaste antes.
  - ISSUER: Usa la URL de la entidad emisora que determinaste antes para el URI de la entidad emisora .
  attribute-mapping="google.subject=assertion.sub" asigna el sujeto de Kubernetes al sujeto de IAM.

Crea los archivos de configuración de credenciales

Para implementar una carga de trabajo de Kubernetes que pueda acceder a recursos de Google Cloud , primero debes crear un archivo de configuración de credenciales para cada cuenta de servicio de IAM:

Enumera las cuentas de servicio de IAM (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 IAM (también llamadas “cuentas de servicio de Google”) durante la instalación inicial de Apigee hybrid con la herramienta create-service-account. Consulta Acerca de las cuentas de servicio para obtener una lista de las cuentas de servicio de IAM que necesita Apigee hybrid. Consulta el Paso 4: Crear cuentas de servicio de la guía de instalación para crear las cuentas de servicio de IAM.

Deberás crear los archivos de configuración de credenciales para las siguientes cuentas de servicio de IAM:
Producción

Para entornos de producción, haz lo siguiente:
```
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 la Monetización para Apigee hybrid en la versión v1.15.1 y versiones posteriores, también deberás crear el archivo de configuración de credenciales para 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

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 fácilmente con los nombres de los componentes de Apigee, puedes determinar el rol de cada cuenta de servicio verificando los roles que se le asignaron y comparándolos 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"
```
Ten en cuenta qué cuenta de servicio personalizada corresponde a cada SA de IAM que se indica en la lista anterior.

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

WIF: secretos

Este enfoque usa configuraciones de credenciales almacenadas en Secrets de Kubernetes. Cuando compiles tu archivo de anulaciones en el Paso 7: Crea las anulaciones, proporcionarás el nombre del secreto para cada cuenta de servicio con la propiedad serviceAccountRef o envs.serviceAccountRefs.

Crea los archivos de configuración de credenciales

Producción

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

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

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

Crea el archivo de configuración de credenciales para 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

Aquí:

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

Importante: credential-source-type se debe establecer en text.

Crea el archivo de configuración de credenciales para 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 para 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 para 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 para 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 para 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 para 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 la Monetización para Apigee Hybrid, también deberás crear el archivo de configuración de credenciales para 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 credenciales. El directorio puede tener cualquier nombre. Para este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea el archivo de configuración de credenciales para 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
```
Aquí:
- PROJECT_NUMBER: Es el número del proyecto que contiene el grupo de identidades para cargas de trabajo. Debe ser el número de proyecto, no el ID del proyecto.
- POOL_ID: El ID del grupo de identidades para cargas de trabajo
- WORKLOAD_PROVIDER_ID: El ID del proveedor de grupos de identidades para cargas de trabajo
Importante: credential-source-type se debe establecer en text.

Crea los secretos de Kubernetes

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

El comando kubectl create secret en las siguientes muestras de código tiene la siguiente 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 para 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 para 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 para 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 para 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 para 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 para 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 para 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 la Monetización para Apigee Hybrid, crea el archivo secreto para 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 para 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

En este enfoque, se usan los archivos de configuración de credenciales en lugar de los archivos de claves de la cuenta de servicio de Google. Cuando compiles tu archivo de anulaciones en el Paso 7: Crea las anulaciones, proporcionarás la ruta de acceso al archivo de configuración de credenciales para cada propiedad serviceAccountPath o envs.serviceAccountPaths.

Producción

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

Cuenta de servicio	Directorio de gráficos de Helm para Apigee
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-mint-task-scheduler` (Si usas la Monetización de 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

Aquí:

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

Importante: credential-source-type se debe establecer en 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:

Los gráficos apigee-org y apigee-env usan la cuenta de servicio apigee-udca.

Crea el archivo de configuración de credenciales en el directorio del gráfico 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 credenciales en el directorio del gráfico apigee-env.

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 utilizas la href="monetization-for-hybrid">Monetización para Apigee Hybrid, también deberás crear el archivo de configuración de credenciales para 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 credenciales y copiarlo en los directorios de gráficos correspondientes:

Cuenta de servicio	Gráfico de Helm para 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
```
Aquí:
- PROJECT_NUMBER: Es el número del proyecto que contiene el grupo de identidades para cargas de trabajo. Debe ser el número de proyecto, no el ID del proyecto.
- POOL_ID: El ID del grupo de identidades para cargas de trabajo
- WORKLOAD_PROVIDER_ID: El ID del proveedor de grupos de identidades para cargas de trabajo
Importante: credential-source-type se debe establecer en text.

Copia el archivo de configuración de credenciales en el directorio del gráfico 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 enfoque usa configuraciones de credenciales almacenadas en un administrador de secretos externo, Hashicorp Vault. Cuando compiles tu archivo de anulaciones en el Paso 7: Crea las anulaciones, proporcionarás secretos de Vault a nivel de la organización y del entorno con las propiedades serviceAccountSecretProviderClass o envs.serviceAccountSecretProviderClass.

Crea los archivos de configuración de credenciales

Producción

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

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

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

Crea el archivo de configuración de credenciales para 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

Aquí:

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

Importante: credential-source-type se debe establecer en text.

Crea el archivo de configuración de credenciales para 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 para 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 para 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 para 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 para 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 para 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 la Monetización para Apigee Hybrid, también deberás crear el archivo de configuración de credenciales para 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 credenciales. El directorio puede tener cualquier nombre. Para este procedimiento, el directorio se llama credential-configurations:
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Crea el archivo de configuración de credenciales para 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
```
Aquí:
- PROJECT_NUMBER: Es el número del proyecto que contiene el grupo de identidades para cargas de trabajo. Debe ser el número de proyecto, no el ID del proyecto.
  Sugerencia: 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 para cargas de trabajo
- WORKLOAD_PROVIDER_ID: El ID del proveedor de grupos de identidades para cargas de trabajo
Importante: credential-source-type se debe establecer en text.

Instala el controlador CSI y el proveedor de Vault

Consulta Plataformas y versiones compatibles con Apigee Hybrid para conocer las versiones mínimas del controlador de CSI compatibles con Apigee Hybrid.

Crea políticas, secrets y roles de Vault

Usa la IU o las APIs de Vault a fin de crear secretos y otorgar permisos a las cuentas de servicio de Kubernetes que usa Apigee Hybrid para leerlos.

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

Clave secreta Datos de los secretos

Clave secreta	Datos de los secretos
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Nota:** `mint` solo se requiere si se usa la 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 se requiere si se usa la Monetización para Apigee Hybrid (v1.15.1 y versiones posteriores).

secret/data/apigee/envsakeys-ENV_NAME

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

Producción

Reemplaza "***" 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. apigee-cassandra-backup y 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

Reemplaza "***" en cada par por el contenido del archivo de configuración de credenciales de la cuenta de servicio apigee-non-prod. apigee-cassandra-backup y 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":...
...
}

Otorga 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 otorgue acceso al secreto de la organización:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Para 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 para cada entorno.
En Vault, crea una política que otorgue acceso al secreto del entorno:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Repite este paso para cada entorno.

Crea una secuencia de comandos 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: Quita apigee-mint-task-scheduler-${ORG_ENCODE} si no usas la Monetización para Apigee Hybrid.

Ejecuta la secuencia de comandos para generar la lista de nombres de cuentas de servicio a la que se 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, similar al 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

La lista de nombres de servicio de 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

Entorno dev:

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

Entorno prod:

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 las claves de su 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 para cada entorno.

Crear objetos `SecretProviderClass`

Cuenta de servicio	Nombres de archivos de secrets esperados
Copia de seguridad de Cassandra	`cassandraBackup`
Restablecimiento de Cassandra	`cassandraRestore`
Agente de Connect	`connectAgent`
MART	`mart`
Métricas	`metrics`
Monetización (si usas Monetización para Apigee Hybrid)	`mint`
Entorno de ejecución	`runtime`
Sincronizador	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Usa la siguiente plantilla de 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: Quita las líneas objectName: "mint" si no usas la 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, usa la siguiente plantilla SecretProviderClass para configurar este recurso para los secretos específicos del entorno. Repite este paso para 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.

Para cada entorno, aplica la SecretProviderClass específica del entorno a tu espacio de nombres de Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Repite este paso para cada entorno.

Próximo paso

1 2 3 4 5 (NEXT) Step 6: Create TLS certificates 7 8 9 10 11

Paso 5: Configura la autenticación de la cuenta de servicio Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Descripción general

Secretos de Kubernetes

Cuentas de servicio

Producción

No producción

Crea secretos de Kubernetes

Producción

No producción

Archivos JSON

Vault

Configura la opción para almacenar secretos de cuentas de servicio en Vault

Instala el controlador CSI y el proveedor de Vault

Crea políticas, secrets y roles de Vault

Crear objetos SecretProviderClass

WIF para GKE

Prepárate para configurar la federación de identidades para cargas de trabajo 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 el clúster para usar la federación de identidades para cargas de trabajo.

Console

Línea de comandos

Roles requeridos

AKS

EKS

Otro Kubernetes

Accesible de forma pública

No es accesible públicamente

Crea los archivos de configuración de credenciales

Producción

No producción

WIF: secretos

Crea los archivos de configuración de credenciales

Producción

No producción

Crea los secretos de Kubernetes

Producción

No producción

WIF: archivos

Producción

No producción

WIF: Vault

Crea los archivos de configuración de credenciales

Producción

No producción

Instala el controlador CSI y el proveedor de Vault

Crea políticas, secrets y roles de Vault

Producción

No producción

Crear objetos SecretProviderClass

Próximo paso

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

Crear objetos `SecretProviderClass`

Crear objetos `SecretProviderClass`