Paso 11: Instala Apigee Hybrid con Helm

Version 1.15 (latest)

   Supported versions:

• v1.15 (latest)                        
• v1.14                        
• v1.13                         
• List of supported versions

   Unsupported versions:

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

Instala los componentes del entorno de ejecución de Apigee Hybrid

En este paso, usarás Helm para instalar los siguientes componentes de Apigee Hybrid:

• Operador de Apigee
• Almacén de datos de Apigee
• Telemetría de Apigee
• Apigee Redis
• Administrador de entrada de Apigee
• Organización de Apigee
• Tus entornos de Apigee

Instalarás los gráficos para cada entorno de a uno. La secuencia en la que instalas los componentes es importante.

Notas previas a la instalación

1. Si aún no instalaste Helm v3.14.2+, sigue las instrucciones que se indican en Instala Helm.

2. Apigee Hybrid usa barreras de seguridad de Helm para verificar la configuración antes de instalar o actualizar un gráfico. Es posible que veas información específica de la barrera de seguridad en el resultado de cada uno de los comandos de esta sección, por ejemplo:

   # Source: apigee-operator/templates/apigee-operators-guardrails.yaml
   apiVersion: v1
   kind: Pod
   metadata:
     name: apigee-hybrid-helm-guardrail-operator
     namespace:  APIGEE_NAMESPACE
     annotations:
       helm.sh/hook: pre-install,pre-upgrade
       helm.sh/hook-delete-policy: before-hook-creation,hook-succeeded
     labels:
       app: apigee-hybrid-helm-guardrail
   

   Si alguno de los comandos helm upgrade falla, puedes usar el resultado de la barrera de seguridad para ayudar a diagnosticar la causa. Consulta Diagnostica problemas con barreras de seguridad.

3. Antes de ejecutar cualquiera de los comandos de actualización o instalación de Helm, usa la función de prueba de validación de Helm; para ello, agrega --dry-run=server al final del comando. Consulta helm install --h para enumerar los comandos, las opciones y el uso compatibles.

Pasos de instalación

Selecciona las instrucciones de instalación para el tipo de autenticación de la cuenta de servicio en tu instalación híbrida:

Secretos de Kubernetes

1. Si no lo hiciste, navega a tu directorio APIGEE_HELM_CHARTS_HOME. Ejecuta los siguientes comandos desde ese directorio.
2. Instala el operador o controlador de Apigee:
   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles.
   1. Prueba de validación:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica la instalación del operador de Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Instala el almacén de datos de Apigee:

   1. Prueba de validación:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica que apigeedatastore esté en funcionamiento; para ello, comprueba su estado antes de continuar con el siguiente paso:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Instala la telemetría de Apigee:

   1. Prueba de validación:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Instala Apigee Redis:

   1. Prueba de validación:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Instala el administrador de entrada de Apigee:

   1. Prueba de validación:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager
      

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-ingressgateway-manager   2/2     2            2           16s
      

7. Instala la organización de Apigee. Si configuraste la variable de entorno $ORG_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Ejecución de prueba:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-env. Este nombre debe ser único entre los demás nombres de versiones de Helm de tu instalación. Por lo general, es igual a ENV_NAME. Sin embargo, si tu entorno tiene el mismo nombre que tu grupo de entornos, debes usar nombres de versión diferentes para el entorno y el grupo de entornos, por ejemplo, dev-env-release y dev-envgroup-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Instala los grupos de entornos (virtualhosts).
   1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:

      Prueba de validación:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-virtualhosts. Este nombre debe ser único y diferente de los otros nombres de versiones de Helm en tu instalación. Por lo general, es igual a ENV_GROUP. Sin embargo, si tu grupo de entornos tiene el mismo nombre que un entorno de tu instalación, debes usar nombres de versión diferentes para el grupo de entornos y el entorno, por ejemplo, dev-envgroup-release y dev-env-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
   3. Verifica el estado de ApigeeRouter (AR).

      La instalación de virtualhosts crea ApigeeRouteConfig (ARC), que crea de forma interna ApigeeRoute (AR) una vez que Apigee Watcher extrae detalles relacionados del grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

Archivos JSON

1. Si no lo hiciste, navega a tu directorio APIGEE_HELM_CHARTS_HOME. Ejecuta los siguientes comandos desde ese directorio.
2. Instala el operador o controlador de Apigee:
   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles.
   1. Prueba de validación:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica la instalación del operador de Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Instala el almacén de datos de Apigee:

   1. Prueba de validación:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica que apigeedatastore esté en funcionamiento; para ello, comprueba su estado antes de continuar con el siguiente paso:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Instala la telemetría de Apigee:

   1. Prueba de validación:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Instala Apigee Redis:

   1. Prueba de validación:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Instala el administrador de entrada de Apigee:

   1. Prueba de validación:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager
      

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-ingressgateway-manager   2/2     2            2           16s
      

7. Instala la organización de Apigee. Si configuraste la variable de entorno $ORG_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Ejecución de prueba:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-env. Este nombre debe ser único entre los demás nombres de versiones de Helm de tu instalación. Por lo general, es igual a ENV_NAME. Sin embargo, si tu entorno tiene el mismo nombre que tu grupo de entornos, debes usar nombres de versión diferentes para el entorno y el grupo de entornos, por ejemplo, dev-env-release y dev-envgroup-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Instala los grupos de entornos (virtualhosts).
   1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:

      Prueba de validación:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-virtualhosts. Este nombre debe ser único y diferente de los otros nombres de versiones de Helm en tu instalación. Por lo general, es igual a ENV_GROUP. Sin embargo, si tu grupo de entornos tiene el mismo nombre que un entorno de tu instalación, debes usar nombres de versión diferentes para el grupo de entornos y el entorno, por ejemplo, dev-envgroup-release y dev-env-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
   3. Verifica el estado de ApigeeRouter (AR).

      La instalación de virtualhosts crea ApigeeRouteConfig (ARC), que crea de forma interna ApigeeRoute (AR) una vez que Apigee Watcher extrae detalles relacionados del grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

Vault

1. Si no lo hiciste, navega a tu directorio APIGEE_HELM_CHARTS_HOME. Ejecuta los siguientes comandos desde ese directorio.
2. Instala el operador o controlador de Apigee:
   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles.
   1. Prueba de validación:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica la instalación del operador de Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Instala el almacén de datos de Apigee:

   1. Prueba de validación:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica que apigeedatastore esté en funcionamiento; para ello, comprueba su estado antes de continuar con el siguiente paso:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Instala la telemetría de Apigee:

   1. Prueba de validación:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Instala Apigee Redis:

   1. Prueba de validación:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Instala el administrador de entrada de Apigee:

   1. Prueba de validación:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager
      

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-ingressgateway-manager   2/2     2            2           16s
      

7. Instala la organización de Apigee. Si configuraste la variable de entorno $ORG_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Ejecución de prueba:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-env. Este nombre debe ser único entre los demás nombres de versiones de Helm de tu instalación. Por lo general, es igual a ENV_NAME. Sin embargo, si tu entorno tiene el mismo nombre que tu grupo de entornos, debes usar nombres de versión diferentes para el entorno y el grupo de entornos, por ejemplo, dev-env-release y dev-envgroup-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Instala los grupos de entornos (virtualhosts).
   1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:

      Prueba de validación:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-virtualhosts. Este nombre debe ser único y diferente de los otros nombres de versiones de Helm en tu instalación. Por lo general, es igual a ENV_GROUP. Sin embargo, si tu grupo de entornos tiene el mismo nombre que un entorno de tu instalación, debes usar nombres de versión diferentes para el grupo de entornos y el entorno, por ejemplo, dev-envgroup-release y dev-env-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
   3. Verifica el estado de ApigeeRouter (AR).

      La instalación de virtualhosts crea ApigeeRouteConfig (ARC), que crea de forma interna ApigeeRoute (AR) una vez que Apigee Watcher extrae detalles relacionados del grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

WIF para GKE

1. Si no lo hiciste, navega a tu directorio APIGEE_HELM_CHARTS_HOME. Ejecuta los siguientes comandos desde ese directorio.
2. Instala el operador o controlador de Apigee:
   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles.
   1. Prueba de validación:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica la instalación del operador de Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Instala el almacén de datos de Apigee:

   1. Prueba de validación:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura las vinculaciones de la cuenta de servicio para Cassandra para Workload Identity Federation for GKE:

      El resultado del comando helm upgrade debería haber contenido comandos en la sección NOTAS. Sigue esos comandos para configurar las vinculaciones de la cuenta de servicio. Debería haber dos comandos con el siguiente formato:

      Producción

      gcloud iam service-accounts add-iam-policy-binding CASSANDRA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-cassandra-default]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-cassandra-default]" \
        --project PROJECT_ID
      

      Y

      Producción

      kubectl annotate serviceaccount apigee-cassandra-default \
        iam.gke.io/gcp-service-account=CASSANDRA_SERVICE_ACCOUNT_EMAIL \
        --namespace APIGEE_NAMESPACE
      

      No producción

      kubectl annotate serviceaccount apigee-cassandra-default \
        iam.gke.io/gcp-service-account=NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --namespace APIGEE_NAMESPACE
      

      Por ejemplo:

      Producción

      NOTES:
      For Cassandra backup GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-cassandra-default]" \
              --project my-project
      
        kubectl annotate serviceaccount apigee-cassandra-default \
              iam.gke.io/gcp-service-account=[e-mail] \
              --namespace apigee
      

      No producción

      NOTES:
      For Cassandra backup GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-cassandra-default]" \
              --project my-project
      
        kubectl annotate serviceaccount apigee-cassandra-default \
              iam.gke.io/gcp-service-account=[e-mail] \
              --namespace apigee
      

      Opcional: Si no deseas configurar la copia de seguridad de Cassandra en este momento, edita tu archivo de anulaciones para quitar o comentar la sección cassandra.backup antes de ejecutar el comando helm upgrade sin la marca --dry-run. Consulta Copia de seguridad y restablecimiento de Cassandra para obtener más información sobre la configuración de la copia de seguridad de Cassandra.

   3. Instala el gráfico:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   4. Verifica que apigeedatastore esté en funcionamiento; para ello, comprueba su estado antes de continuar con el siguiente paso:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Instala la telemetría de Apigee:

   1. Prueba de validación:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura las vinculaciones de la cuenta de servicio para Loggeer y Metrics para Workload Identity Federation for GKE:

      El resultado del comando helm upgrade debería haber contenido comandos en la sección NOTAS. Sigue esos comandos para configurar las vinculaciones de la cuenta de servicio. Debería haber dos comandos con el siguiente formato:

      Logger KSA: apigee-logger-apigee-telemetry

      gcloud iam service-accounts add-iam-policy-binding LOGGER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
        --project PROJECT_ID
      

      KSA de métricas: apigee-metrics-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding METRICS_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project PROJECT_ID

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project PROJECT_ID

      Por ejemplo:

      Producción

      NOTES:
      For GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        Logger KSA: apigee-logger-apigee-telemetry
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
              --project my-project
      
        Metrics KSA: apigee-metrics-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
              --project my-project
      

      No producción

      NOTES:
      For GKE Workload Identity, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
        Logger KSA: apigee-logger-apigee-telemetry
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-logger-apigee-telemetry]" \
              --project my-project
      
        Metrics KSA: apigee-metrics-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
              --project my-project
      

   3. Instala el gráfico:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   4. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

5. Instala Apigee Redis:

   1. Prueba de validación:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Instala el administrador de entrada de Apigee:

   1. Prueba de validación:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager
      

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-ingressgateway-manager   2/2     2            2           16s
      

7. Instala la organización de Apigee. Si configuraste la variable de entorno $ORG_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Configura las vinculaciones de cuentas de servicio para los componentes con alcance de la organización para Workload Identity Federation for GKE, MART, Apigee Connect, UDCA y Watcher.

      El resultado del comando helm upgrade debería haber contenido comandos en la sección NOTAS. Sigue esos comandos para configurar las vinculaciones de la cuenta de servicio. Debería haber cuatro comandos.

      Nota: Los nombres de las KSA incluyen un ID hash único para tu organización, por ejemplo, apigee-mart-my-project-123abcd-sa.

      KSA de MART: apigee-mart-PROJECT_ID-ORG_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding MART_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mart-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mart-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      KSA del agente de Connect: apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa

      Nota: Apigee Connect usa la cuenta de servicio de Google de MART.

      Producción

      gcloud iam service-accounts add-iam-policy-binding MART_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      KSA del programador de tareas de Mint: (si usas la Monetización para Apigee hybrid) apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding MINT_TASK_SCHEDULER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      UDCA KSA: apigee-udca-PROJECT_ID-ORG_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding UDCA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      KSA de Watcher: apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding WATCHER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Por ejemplo:

      Producción

      NOTES:
      For Apigee Organization GKE Workload Identity, my-project, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
      
        MART KSA: apigee-mart-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mart-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Connect Agent KSA: apigee-connect-agent-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-connect-agent-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Mint task scheduler KSA: apigee-mint-task-scheduler-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mint-task-scheduler-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Watcher KSA: apigee-watcher-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
              --project my-project
      

      No producción

      NOTES:
      For Apigee Organization GKE Workload Identity, my-project, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
        MART KSA: apigee-mart-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-mart-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Connect Agent KSA: apigee-connect-agent-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-connect-agent-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-1a2b3c4-sa]" \
              --project my-project
      
      
        Watcher KSA: apigee-watcher-my-project-1a2b3c4-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
              --project my-project
      

   3. Instala el gráfico:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   4. Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

8. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-env. Este nombre debe ser único entre los demás nombres de versiones de Helm de tu instalación. Por lo general, es igual a ENV_NAME. Sin embargo, si tu entorno tiene el mismo nombre que tu grupo de entornos, debes usar nombres de versión diferentes para el entorno y el grupo de entornos, por ejemplo, dev-env-release y dev-envgroup-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Configura las vinculaciones de cuentas de servicio para los componentes con alcance de entorno de Workload Identity Federation for GKE, Runtime, Synchronizer y UDCA.

      El resultado del comando helm upgrade debería haber contenido comandos en la sección NOTAS. Sigue esos comandos para configurar las vinculaciones de la cuenta de servicio. Debería haber cuatro comandos.

      Nota: Los nombres de las KSA incluyen un ID de hash único para tu entorno, por ejemplo, apigee-mart-my-project--myenv-abc1234-sa.

      KSA de tiempo de ejecución: apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding RUNTIME_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Sincronizador de KSA: apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding SYNCHRONIZER_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      UDCA KSA: apigee-udca-PROJECT_ID-ORG_HASH_ID-ENV_NAME-ENV_HASH_ID-sa

      Producción

      gcloud iam service-accounts add-iam-policy-binding UDCA_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      No producción

      gcloud iam service-accounts add-iam-policy-binding NON_PROD_SERVICE_ACCOUNT_EMAIL \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[apigee/apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa]" \
        --project PROJECT_ID
      

      Por ejemplo:

      NOTES:
      For Apigee Environment GKE Workload Identity, my-env, please make sure to add the following membership to the IAM policy binding using the respective kubernetes SA (KSA).
      
      
        Runtime KSA: apigee-runtime-my-project-my-env-b2c3d4e-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-runtime-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      
      
        Synchronizer KSA: apigee-synchronizer-my-project-my-env-b2c3d4e-sa
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-synchronizer-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      
      
        UDCA KSA: apigee-udca-my-project-my-env-b2c3d4e-sa:
        gcloud iam service-accounts add-iam-policy-binding [e-mail] \
              --role roles/iam.workloadIdentityUser \
              --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-my-env-b2c3d4e-sa]" \
              --project my-project
      

   3. Instala el gráfico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml
      

   4. Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

9. Instala los grupos de entornos (virtualhosts).
   1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:

      Prueba de validación:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-virtualhosts. Este nombre debe ser único y diferente de los otros nombres de versiones de Helm en tu instalación. Por lo general, es igual a ENV_GROUP. Sin embargo, si tu grupo de entornos tiene el mismo nombre que un entorno de tu instalación, debes usar nombres de versión diferentes para el grupo de entornos y el entorno, por ejemplo, dev-envgroup-release y dev-env-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
   3. Verifica el estado de ApigeeRouter (AR).

      La instalación de virtualhosts crea ApigeeRouteConfig (ARC), que crea de forma interna ApigeeRoute (AR) una vez que Apigee Watcher extrae detalles relacionados del grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

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

    Ir a Cargas de trabajo

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

WIF en otras plataformas

1. Si no lo hiciste, navega a tu directorio APIGEE_HELM_CHARTS_HOME. Ejecuta los siguientes comandos desde ese directorio.
2. Instala el operador o controlador de Apigee:
   Nota: En este paso, se requieren permisos elevados de clúster. Ejecuta helm -h o helm install -h para obtener más detalles.
   1. Prueba de validación:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade operator apigee-operator/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Verifica la instalación del operador de Apigee:

      helm ls -n APIGEE_NAMESPACE
      

      NAME       NAMESPACE       REVISION   UPDATED                                STATUS     CHART                                       APP VERSION
      operator   apigee   3          2025-06-26 00:42:44.492009 -0800 PST   deployed   apigee-operator-1.15.1   1.15.1
      

   4. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deploy apigee-controller-manager
      

      NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-controller-manager   1/1     1            1           34s
      

3. Instala el almacén de datos de Apigee:

   1. Prueba de validación:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Si habilitaste la copia de seguridad o el restablecimiento de Cassandra, otorga a las cuentas de servicio de Kubernetes de Cassandra acceso para suplantar la identidad de la apigee-cassandracuenta de servicio de IAM asociada.
      1. Enumera las direcciones de correo electrónico de la cuenta de servicio de IAM para Cassandra:

         Producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-cassandra"

         No producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         El resultado debería ser similar al siguiente:

         Producción

         apigee-cassandra      [e-mail]      False
                           

         No producción

         apigee-non-prod       [e-mail]      False
                           

      2. Enumera las cuentas de servicio de Kubernetes de Cassandra:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-cassandra"

         El resultado debería ser similar al siguiente:

         apigee-cassandra-backup-sa                       0   7m37s
         apigee-cassandra-default                         0   7m12s
         apigee-cassandra-guardrails-sa                   0   6m43s
         apigee-cassandra-restore-sa                      0   7m37s
         apigee-cassandra-schema-setup-my-project-1a2b2c4 0   7m30s
         apigee-cassandra-schema-val-my-project-1a2b2c4   0   7m29s
         apigee-cassandra-user-setup-my-project-1a2b2c4   0   7m22s
                       

      3. Si creaste las cuentas de servicio de Kubernetes apigee-cassandra-backup-sa o apigee-cassandra-restore-sa, otórgales a cada una acceso para suplantar la cuenta de servicio de IAM apigee-cassandra con el siguiente comando:

         Producción

         Plantilla

         gcloud iam service-accounts add-iam-policy-binding \
           CASSANDRA_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-cassandra-backup-sa" \
             --role=roles/iam.workloadIdentityUser

         No producción

         Plantilla

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-cassandra-backup-sa" \
             --role=roles/iam.workloadIdentityUser

         Aquí:

         • CASSANDRA_IAM_SA_EMAIL: Es la dirección de correo electrónico de la cuenta de servicio de IAM de Cassandra.
         • PROJECT_NUMBER: Es el número del proyecto en el que creaste el grupo de identidades para cargas de trabajo.
           Nota: Debes usar el número de proyecto en el identificador de miembro. No se admite el uso del ID del proyecto. 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.
         • MAPPED_SUBJECT: Es la ServiceAccount de Kubernetes de la reclamación en tu token de ID. En la mayoría de las instalaciones híbridas, tendrá el formato system:serviceaccount:APIGEE_NAMESPACE:K8S_SA_NAME.
           • En el caso de apigee-cassandra-backup-sa, será algo similar a system:serviceaccount:apigee:apigee-cassandra-backup-sa.
           • En el caso de apigee-cassandra-restore-sa, será algo similar a system:serviceaccount:apigee:apigee-cassandra-restore-sa.
           Sugerencia: En el paso Agrega el clúster como proveedor de grupos de identidades para cargas de trabajo del Paso 5: Configura la autenticación de la cuenta de servicio, asignaste google.subject=assertions.sub. Por lo tanto, el valor de MAPPED_SUBJECT será el valor del token de ID después de "sub": . Para encontrar el asunto asignado a una cuenta de servicio de Kubernetes, busca el token de ID de sub seguido del nombre de la cuenta de servicio.

           Por ejemplo, puedes canalizar el contenido del token de ID a través de grep -E 'sub.*apigee-cassandra-backup-sa'.

   4. Verifica que apigeedatastore esté en funcionamiento; para ello, comprueba su estado antes de continuar con el siguiente paso:

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default
      

      NAME      STATE       AGE
      default   running    51s
      

4. Instala la telemetría de Apigee:

   1. Prueba de validación:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade telemetry apigee-telemetry/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry
      

      NAME               STATE     AGE
      apigee-telemetry   running   55s
      

   4. Otorga a las cuentas de servicio de Kubernetes de telemetría acceso para actuar en nombre de la apigee-metricscuenta de servicio de IAM asociada.
      1. Enumera la dirección de correo electrónico de la cuenta de servicio de IAM para las métricas:

         Producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-metrics"

         El resultado debería ser similar al siguiente:

         apigee-metrics   [e-mail]   False

         No producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         El resultado debería ser similar al siguiente:

         apigee-non-prod   [e-mail]   False

      2. Enumera las cuentas de servicio de Kubernetes de telemetría:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "telemetry"

         El resultado debería ser similar al siguiente:

         apigee-metrics-apigee-telemetry                    0   42m
         apigee-open-telemetry-collector-apigee-telemetry   0   37m

      3. Otorga a cada una de las cuentas de servicio de Kubernetes de telemetría acceso para suplantar la cuenta de servicio de IAM apigee-metrics con el siguiente comando:

         Producción

         KSA de métricas de Apigee: apigee-metrics-apigee-telemetry a apigee-metrics cuenta de servicio de IAM de Google

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           METRICS_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-metrics-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         KSA del recopilador de OpenTelemetry de Apigee: apigee-open-telemetry-collector-apigee-telemetry a apigee-metrics cuenta de servicio de IAM de Google

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           METRICS_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-open-telemetry-collector-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         No producción

         KSA de métricas de Apigee: apigee-metrics-apigee-telemetry a apigee-non-prod cuenta de servicio de IAM de Google

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-metrics-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

         KSA del recopilador de OpenTelemetry de Apigee: apigee-open-telemetry-collector-apigee-telemetry a apigee-non-prod cuenta de servicio de IAM de Google

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-open-telemetry-collector-apigee-telemetry" \
             --role=roles/iam.workloadIdentityUser

5. Instala Apigee Redis:

   1. Prueba de validación:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade redis apigee-redis/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su estado:

      kubectl -n APIGEE_NAMESPACE get apigeeredis default
      

      NAME      STATE     AGE
      default   running   79s
      

6. Instala el administrador de entrada de Apigee:

   1. Prueba de validación:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade ingress-manager apigee-ingress-manager/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba su disponibilidad:

      kubectl -n APIGEE_NAMESPACE get deployment apigee-ingressgateway-manager
      

      NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
      apigee-ingressgateway-manager   2/2     2            2           16s
      

7. Instala la organización de Apigee. Si configuraste la variable de entorno $ORG_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Ejecución de prueba:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml \
        --dry-run=server
      

   2. Instala el gráfico:

      helm upgrade $ORG_NAME apigee-org/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado de la organización correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeorg
      

      NAME                      STATE     AGE
      my-project-123abcd        running   4m18s
      

   4. Otorga a las cuentas de servicio de Kubernetes con alcance en la organización acceso para actuar en nombre de las cuentas de servicio de IAM asociadas.
      1. Enumera las direcciones de correo electrónico de las cuentas de servicio de IAM que usan los componentes apigee-mart, apigee-udca y apigee-watcher:

         Producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mart\|apigee-udca\|apigee-watcher"

         El resultado debería ser similar al siguiente:

         apigee-mart      [e-mail]      False
         apigee-udca      [e-mail]      False
         apigee-watcher   [e-mail]   False
         

         Si usas la Monetización para Apigee Hybrid, también obtén la dirección de correo electrónico de la cuenta de servicio apigee-mint-task-scheduler.

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mint-task-scheduler"

         El resultado debería ser similar al siguiente:

         apigee-mint-task-scheduler   [e-mail]   False
         

         No producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         El resultado debería ser similar al siguiente:

         apigee-non-prod     [e-mail]         False
                           

      2. Enumera las cuentas de servicio de Kubernetes con alcance en la organización:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-connect-agent\|apigee-mart\|apigee-udca\|apigee-watcher"

         El resultado debería ser similar al siguiente:

         apigee-connect-agent-my-project-123abcd         0   1h4m
         apigee-mart-my-project-123abcd                  0   1h4m
         apigee-mint-task-scheduler-my-project-123abcd   0   1h3m
         apigee-udca-my-project-123abcd                  0   1h2m
         apigee-watcher-my-project-123abcd               0   1h1m
                       

      3. Usa los siguientes comandos para otorgar a las cuentas de servicio de Kubernetes con alcance en la organización acceso para suplantar las cuentas de servicio de IAM asociadas de la siguiente manera:

         Producción

         KSA del agente de Connect: Cuenta de servicio de Kubernetes apigee-connect-agent-ORG_NAME-ORG_HASH_ID a cuenta de servicio de IAM apigee-mart.

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MART_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-connect-agent-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA de MART: Cuenta de servicio de Kubernetes para la cuenta de servicio de IAM de apigee-mart.apigee-mart-ORG_NAME-ORG_HASH_ID MART y el agente de Connect usan la misma cuenta de servicio de IAM.

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MART_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mart-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del programador de tareas de Mint: (si usas la Monetización para Apigee hybrid)

         apigee-mint-task-scheduler-ORG_NAME-ORG_HASH_ID Cuenta de servicio de Kubernetes a apigee-mint-task-scheduler cuenta de servicio de IAM

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_MINT_TASK_SCHEDULER_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mint-task-scheduler-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del UDCA con permiso de la organización: Cuenta de servicio de Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID a cuenta de servicio de IAM apigee-udca.

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_UDCA_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del observador: Cuenta de servicio de Kubernetes para apigee-watcher cuenta de servicio de IAM.apigee-watcher-ORG_NAME-ORG_HASH_ID

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           APIGEE_WATCHER_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-watcher-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         No producción

         KSA del agente de Connect: Cuenta de servicio de Kubernetes apigee-connect-agent-ORG_NAME-ORG_HASH_ID a cuenta de servicio de IAM apigee-non-prod.

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-connect-agent-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA de MART: Cuenta de servicio de Kubernetes para la cuenta de servicio de IAM de apigee-non-prod.apigee-mart-ORG_NAME-ORG_HASH_ID

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mart-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del programador de tareas de Mint: (si usas la Monetización para Apigee hybrid)

         apigee-mint-task-scheduler-ORG_NAME-UUIORG_HASH_IDD Cuenta de servicio de Kubernetes a apigee-non-prod cuenta de servicio de IAM

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-mint-task-scheduler-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del UDCA con permiso de la organización: Cuenta de servicio de Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID a cuenta de servicio de IAM apigee-non-prod.

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

         KSA del observador: Cuenta de servicio de Kubernetes para apigee-non-prod cuenta de servicio de IAM.apigee-watcher-ORG_NAME-ORG_HASH_ID

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-watcher-my-org-123abcd" \
             --role=roles/iam.workloadIdentityUser

8. Instala el entorno.

   Debes instalar un entorno a la vez. Especifica el entorno con --set env=ENV_NAME. Si configuraste la variable de entorno $ENV_NAME en tu shell, puedes usarla en los siguientes comandos:

   1. Prueba de validación:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-env. Este nombre debe ser único entre los demás nombres de versiones de Helm de tu instalación. Por lo general, es igual a ENV_NAME. Sin embargo, si tu entorno tiene el mismo nombre que tu grupo de entornos, debes usar nombres de versión diferentes para el entorno y el grupo de entornos, por ejemplo, dev-env-release y dev-envgroup-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_RELEASE_NAME apigee-env/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set env=$ENV_NAME \
        -f overrides.yaml
      

   3. Para verificar que esté en funcionamiento, comprueba el estado del entorno correspondiente:

      kubectl -n APIGEE_NAMESPACE get apigeeenv
      

      NAME                       STATE     AGE   GATEWAYTYPE
      apigee-my-project-my-env   running   3m1s
      

   4. Otorga a las cuentas de servicio de Kubernetes con alcance para el entorno acceso para actuar en nombre de las cuentas de servicio de IAM asociadas.
      1. Enumera las direcciones de correo electrónico de las cuentas de servicio de IAM que usan los componentes apigee-runtime, apigee-synchronizer y apigee-udca:

         Producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-runtime\|apigee-synchronizer\|apigee-udca"

         No producción

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-non-prod"

         gcloud iam service-accounts list --project PROJECT_ID | grep "apigee-mart\|apigee-udca\|apigee-watcher"

         El resultado debería ser similar al siguiente:

         Producción

         apigee-runtime         [e-mail]         False
         apigee-synchronizer    [e-mail]      False
         apigee-udca            [e-mail]         False
                           

         No producción

         apigee-non-prod     [e-mail]         False
                           

      2. Enumera las cuentas de servicio de Kubernetes con alcance para el entorno:

         kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-runtime\|apigee-synchronizer\|apigee-udca"

         El resultado debería ser similar al siguiente:

         apigee-runtime-my-project--my-env-cdef123          0   19m
         apigee-synchronizer-my-project-my-env-cdef123      0   17m
         apigee-udca-my-project-123abcd                     0   1h29m
         apigee-udca-my-project-my-env-cdef123              0   22m
                       

         Nota: Es posible que veas cuentas de servicio de Kubernetes apigee-udca con alcance a nivel de la organización y del entorno. En este paso, otorga acceso a la cuenta de servicio apigee-udca con alcance en el entorno.
      3. Usa el siguiente comando para otorgar a las cuentas de servicio de Kubernetes con alcance en el entorno acceso para suplantar las cuentas de servicio de IAM asociadas de la siguiente manera:

         Producción

         KSA de tiempo de ejecución: KSA para apigee-runtime SA de IAM de Googleapigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           RUNTIME_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-runtime-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         KSA de Synchronizer: KSA de apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa a SA de IAM de Google apigee-synchronizer

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           SYNCHRONIZER_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-synchronizer-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         KSA de UDCA: KSA de apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa a SA de IAM de Google apigee-udca

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           UDCA_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         No producción

         KSA de tiempo de ejecución: KSA para apigee-non-prod SA de IAM de Googleapigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-runtime-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         No producción

         KSA de Synchronizer: KSA de apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa a SA de IAM de Google apigee-non-prod

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-synchronizer-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

         No producción

         KSA de UDCA: KSA de apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa a SA de IAM de Google apigee-non-prod

         Código

         gcloud iam service-accounts add-iam-policy-binding \
           NON_PROD_IAM_SA_EMAIL \
             --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
             --role=roles/iam.workloadIdentityUser

         Ejemplo

         gcloud iam service-accounts add-iam-policy-binding \
           [e-mail] \
             --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-udca-my-project-my-env-cdef123" \
             --role=roles/iam.workloadIdentityUser

9. Instala los grupos de entornos (virtualhosts).
   1. Debes instalar un grupo de entornos (virtualhost) a la vez. Especifica el grupo de entornos con --set envgroup=ENV_GROUP. Si configuraste la variable de entorno $ENV_GROUP en tu shell, puedes usarla en los siguientes comandos. Repite los siguientes comandos para cada grupo de entornos mencionado en tu archivo overrides.yaml:

      Prueba de validación:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml \
        --dry-run=server
      

      ENV_GROUP_RELEASE_NAME es un nombre que se usa para hacer un seguimiento de la instalación y las actualizaciones del gráfico apigee-virtualhosts. Este nombre debe ser único y diferente de los otros nombres de versiones de Helm en tu instalación. Por lo general, es igual a ENV_GROUP. Sin embargo, si tu grupo de entornos tiene el mismo nombre que un entorno de tu instalación, debes usar nombres de versión diferentes para el grupo de entornos y el entorno, por ejemplo, dev-envgroup-release y dev-env-release. Para obtener más información sobre las versiones en Helm, consulta Tres conceptos importantes en la documentación de Helm.

   2. Instala el gráfico:

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
        --install \
        --namespace APIGEE_NAMESPACE \
        --atomic \
        --set envgroup=$ENV_GROUP \
        -f overrides.yaml
      

      Nota: ENV_GROUP debe ser único en el espacio de nombres apigee. Por ejemplo, si tienes un entorno y un grupo de entornos prod, debes establecer este nombre en prod-envgroup. El nombre del grupo de entornos posterior debe ser prod.
   3. Verifica el estado de ApigeeRouter (AR).

      La instalación de virtualhosts crea ApigeeRouteConfig (ARC), que crea de forma interna ApigeeRoute (AR) una vez que Apigee Watcher extrae detalles relacionados del grupo de entornos desde el plano de control. Por lo tanto, verifica que el estado de AR correspondiente esté en ejecución:

      kubectl -n APIGEE_NAMESPACE get arc
      

      NAME                                STATE   AGE
      apigee-org1-dev-egroup                       2m
      

      kubectl -n APIGEE_NAMESPACE get ar
      

      NAME                                                        STATE     AGE
      apigee-ingressgateway-internal-chaining-my-project-123abcd   running   19m
      my-project-myenvgroup-000-321dcba                            running   2m30s
      

¡Felicitaciones!

Instalaste y configuraste de forma correcta el plano del entorno de ejecución híbrido de Apigee.

Próximo paso

En el siguiente paso, configurarás la puerta de enlace de entrada de Apigee y, además, implementarás un proxy para probar tu instalación.

(SIGUIENTE) Paso 1: Expón la entrada de Apigee 2