Étape 11 : Installer Apigee hybrid à l'aide de Helm

Installer les composants d'exécution Apigee hybrid

Au cours de cette étape, vous allez utiliser Helm pour installer les composants Apigee hybrid suivants :

  • Opérateur Apigee
  • Datastore Apigee
  • Télémétrie Apigee
  • Apigee Redis
  • Gestionnaire d'entrée Apigee
  • Organisation Apigee
  • Votre ou vos environnements Apigee

Vous installerez les graphiques pour chaque environnement un par un. L'ordre d'installation des composants est important.

Remarques préalables à l'installation

  1. Si vous n'avez pas encore installé Helm v3.14.2+, suivez les instructions de la section Installer Helm.

  2. Apigee hybrid utilise des garde-fous Helm pour vérifier la configuration avant d'installer ou de mettre à niveau un chart. Vous pouvez voir des informations spécifiques aux garde-fous dans la sortie de chacune des commandes de cette section, par exemple : 

    # 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 l'une des commandes helm upgrade échoue, vous pouvez utiliser la sortie des garde-fous pour diagnostiquer la cause. Consultez Diagnostiquer les problèmes liés aux garde-fous.

  3. Remarque : Avant d'exécuter des commandes de mise à niveau ou d'installation Helm, utilisez la fonctionnalité de simulation de Helm en ajoutant --dry-run=server à la fin de la commande. Consultez helm install --h pour répertorier les commandes, les options et l'utilisation compatibles.

Procédure d'installation

Sélectionnez les instructions d'installation correspondant au type d'authentification du compte de service dans votre installation hybride :

Secrets Kubernetes

  1. Si ce n'est pas le cas, accédez à votre répertoire APIGEE_HELM_CHARTS_HOME. Exécutez les commandes suivantes à partir de ce répertoire.
  2. Installez Apigee Operator/Controller :
    1. Effectuez un dry run : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml \
  --dry-run=server
    2. Installez le chart : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    3. Vérifiez l'installation de l'opérateur 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. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez le datastore Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez que apigeedatastore est opérationnel en vérifiant son état avant de passer à l'étape suivante :

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    51s

  4. Installez la télémétrie Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   55s

  5. Installez Apigee Redis :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   79s

  6. Installez le gestionnaire d'entrée Apigee :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez l'organisation Apigee. Si vous avez défini la variable d'environnement $ORG_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

      kubectl -n APIGEE_NAMESPACE get apigeeorg

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

  8. Installez l'environnement.

    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-env. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_NAME. Toutefois, si votre environnement porte le même nom que votre groupe d'environnements, vous devez utiliser des noms de version différents pour l'environnement et le groupe d'environnements (par exemple, dev-env-release et dev-envgroup-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                       STATE     AGE   GATEWAYTYPE
apigee-my-project-my-env   running   3m1s
  9. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :

      Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-virtualhosts. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_GROUP. Toutefois, si le nom de votre groupe d'environnements est identique à celui d'un environnement de votre installation, vous devez utiliser des noms de version différents pour le groupe d'environnements et l'environnement (par exemple, dev-envgroup-release et dev-env-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=$ENV_GROUP \
  -f overrides.yaml
    3. Vérifiez l'état de la ressource ApigeeRoute (AR).

      L'installation de virtualhosts crée ApigeeRouteConfig (ARC) qui crée ApigeeRoute en interne une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR correspondant est en cours d'exécution : 

      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

Fichiers JSON

  1. Si ce n'est pas le cas, accédez à votre répertoire APIGEE_HELM_CHARTS_HOME. Exécutez les commandes suivantes à partir de ce répertoire.
  2. Installez Apigee Operator/Controller :
    1. Effectuez un dry run : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml \
  --dry-run=server
    2. Installez le chart : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    3. Vérifiez l'installation de l'opérateur 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. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez le datastore Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez que apigeedatastore est opérationnel en vérifiant son état avant de passer à l'étape suivante :

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    51s

  4. Installez la télémétrie Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   55s

  5. Installez Apigee Redis :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   79s

  6. Installez le gestionnaire d'entrée Apigee :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez l'organisation Apigee. Si vous avez défini la variable d'environnement $ORG_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

      kubectl -n APIGEE_NAMESPACE get apigeeorg

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

  8. Installez l'environnement.

    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-env. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_NAME. Toutefois, si votre environnement porte le même nom que votre groupe d'environnements, vous devez utiliser des noms de version différents pour l'environnement et le groupe d'environnements (par exemple, dev-env-release et dev-envgroup-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                       STATE     AGE   GATEWAYTYPE
apigee-my-project-my-env   running   3m1s
  9. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :

      Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-virtualhosts. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_GROUP. Toutefois, si le nom de votre groupe d'environnements est identique à celui d'un environnement de votre installation, vous devez utiliser des noms de version différents pour le groupe d'environnements et l'environnement (par exemple, dev-envgroup-release et dev-env-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=$ENV_GROUP \
  -f overrides.yaml
    3. Vérifiez l'état de la ressource ApigeeRoute (AR).

      L'installation de virtualhosts crée ApigeeRouteConfig (ARC) qui crée ApigeeRoute en interne une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR correspondant est en cours d'exécution : 

      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 ce n'est pas le cas, accédez à votre répertoire APIGEE_HELM_CHARTS_HOME. Exécutez les commandes suivantes à partir de ce répertoire.
  2. Installez Apigee Operator/Controller :
    1. Effectuez un dry run : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml \
  --dry-run=server
    2. Installez le chart : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    3. Vérifiez l'installation de l'opérateur 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. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez le datastore Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez que apigeedatastore est opérationnel en vérifiant son état avant de passer à l'étape suivante :

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    51s

  4. Installez la télémétrie Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   55s

  5. Installez Apigee Redis :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   79s

  6. Installez le gestionnaire d'entrée Apigee :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez l'organisation Apigee. Si vous avez défini la variable d'environnement $ORG_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

      kubectl -n APIGEE_NAMESPACE get apigeeorg

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

  8. Installez l'environnement.

    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-env. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_NAME. Toutefois, si votre environnement porte le même nom que votre groupe d'environnements, vous devez utiliser des noms de version différents pour l'environnement et le groupe d'environnements (par exemple, dev-env-release et dev-envgroup-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                       STATE     AGE   GATEWAYTYPE
apigee-my-project-my-env   running   3m1s
  9. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :

      Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-virtualhosts. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_GROUP. Toutefois, si le nom de votre groupe d'environnements est identique à celui d'un environnement de votre installation, vous devez utiliser des noms de version différents pour le groupe d'environnements et l'environnement (par exemple, dev-envgroup-release et dev-env-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=$ENV_GROUP \
  -f overrides.yaml
    3. Vérifiez l'état de la ressource ApigeeRoute (AR).

      L'installation de virtualhosts crée ApigeeRouteConfig (ARC) qui crée ApigeeRoute en interne une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR correspondant est en cours d'exécution : 

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

  1. Si ce n'est pas le cas, accédez à votre répertoire APIGEE_HELM_CHARTS_HOME. Exécutez les commandes suivantes à partir de ce répertoire.
  2. Installez Apigee Operator/Controller :
    1. Effectuez un dry run : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml \
  --dry-run=server
    2. Installez le chart : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    3. Vérifiez l'installation de l'opérateur 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. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez le datastore Apigee :

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

    2. Configurez les liaisons de compte de service pour Cassandra pour Workload Identity Federation for GKE :

      Le résultat de la commande helm upgrade aurait dû contenir des commandes dans la section NOTES. Suivez ces commandes pour configurer les liaisons de compte de service. Il doit contenir deux commandes au format suivant :

      Production

      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

      Hors production

      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

      Et :

      Production

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

      Hors production

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

      Exemple :

      Production

      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 apigee-cassandra@my-project.iam.gserviceaccount.com \
        --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=apigee-cassandra@my-project.iam.gserviceaccount.com \
        --namespace apigee

      Hors production

      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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --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=apigee-non-prod@my-project.iam.gserviceaccount.com \
        --namespace apigee

      Facultatif : Si vous ne souhaitez pas configurer la sauvegarde Cassandra pour le moment, modifiez votre fichier de remplacement pour supprimer ou commenter la strophe cassandra.backup avant d'exécuter la commande helm upgrade sans l'indicateur --dry-run. Pour en savoir plus sur la configuration de la sauvegarde Cassandra, consultez Sauvegarde et restauration Cassandra.

    3. Installez le chart :

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

    4. Vérifiez que apigeedatastore est opérationnel en vérifiant son état avant de passer à l'étape suivante :

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    51s

  4. Installez la télémétrie Apigee :

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

    2. Configurez les liaisons de compte de service pour Loggeer et Metrics pour la fédération d'identité de charge de travail pour GKE :

      Le résultat de la commande helm upgrade aurait dû contenir des commandes dans la section NOTES. Suivez ces commandes pour configurer les liaisons de compte de service. Il doit contenir deux commandes au format suivant :

      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 sur les métriques : apigee-metrics-sa

      Production

      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

      Hors production

      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

      Exemple :

      Production

      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 apigee-logger@my-project.iam.gserviceaccount.com \
        --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 apigee-metrics@my-project.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project my-project

      Hors production

      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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-metrics-sa]" \
        --project my-project

    3. Installez le chart :

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

    4. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   55s

  5. Installez Apigee Redis :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   79s

  6. Installez le gestionnaire d'entrée Apigee :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez l'organisation Apigee. Si vous avez défini la variable d'environnement $ORG_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

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

    2. Configurez les liaisons de compte de service pour les composants à portée d'organisation pour Workload Identity Federation for GKE, MART, Apigee Connect, UDCA et Watcher.

      Le résultat de la commande helm upgrade aurait dû contenir des commandes dans la section NOTES. Suivez ces commandes pour configurer les liaisons de compte de service. Il devrait y avoir quatre commandes.

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

      Production

      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

      Hors production

      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 de l'agent Connect : apigee-connect-agent-PROJECT_ID-ORG_HASH_ID-sa

      Production

      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

      Hors production

      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

      Planificateur de tâches Mint KSA : (si vous utilisez Monétisation pour Apigee hybrid) apigee-mint-task-scheduler-PROJECT_ID-ORG_HASH_ID-sa

      Production

      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

      Hors production

      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

      Production

      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

      Hors production

      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

      Observateur KSA : apigee-watcher-PROJECT_ID-ORG_HASH_ID-sa

      Production

      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

      Hors production

      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

      Exemple :

      Production

      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 apigee-mart@my-project.iam.gserviceaccount.com \
        --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 apigee-mart@my-project.iam.gserviceaccount.com \
        --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 apigee-mint-task-scheduler@my-project.iam.gserviceaccount.com \
        --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 apigee-udca@my-project.iam.gserviceaccount.com \
        --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 apigee-watcher@my-project.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
        --project my-project

      Hors production

      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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --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 apigee-non-prod@my-project.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-watcher-my-project-1a2b3c4-sa]" \
        --project my-project

    3. Installez le chart :

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

    4. Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

      kubectl -n APIGEE_NAMESPACE get apigeeorg

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

  8. Installez l'environnement.

    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-env. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_NAME. Toutefois, si votre environnement porte le même nom que votre groupe d'environnements, vous devez utiliser des noms de version différents pour l'environnement et le groupe d'environnements (par exemple, dev-env-release et dev-envgroup-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Configurez les liaisons de compte de service pour les composants à portée d'environnement pour Workload Identity Federation for GKE, Runtime, Synchronizer et UDCA.

      Le résultat de la commande helm upgrade aurait dû contenir des commandes dans la section NOTES. Suivez ces commandes pour configurer les liaisons de compte de service. Il devrait y avoir quatre commandes.

      KSA d'exécution : apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Production

      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

      Hors production

      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

      Synchroniseur KSA : apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa

      Production

      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

      Hors production

      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

      Production

      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

      Hors production

      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

      Exemple :

      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 apigee-runtime@my-project.iam.gserviceaccount.com \
        --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 apigee-synchronizer@my-project.iam.gserviceaccount.com \
        --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 apigee-udca@my-project.iam.gserviceaccount.com \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:my-project.svc.id.goog[apigee/apigee-udca-my-project-my-env-b2c3d4e-sa]" \
        --project my-project

    3. Installez le chart :

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

    4. Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                       STATE     AGE   GATEWAYTYPE
apigee-my-project-my-env   running   3m1s
  9. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :

      Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-virtualhosts. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_GROUP. Toutefois, si le nom de votre groupe d'environnements est identique à celui d'un environnement de votre installation, vous devez utiliser des noms de version différents pour le groupe d'environnements et l'environnement (par exemple, dev-envgroup-release et dev-env-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=$ENV_GROUP \
  -f overrides.yaml
    3. Vérifiez l'état de la ressource ApigeeRoute (AR).

      L'installation de virtualhosts crée ApigeeRouteConfig (ARC) qui crée ApigeeRoute en interne une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR correspondant est en cours d'exécution : 

      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. (Facultatif) Vous pouvez consulter l'état de vos comptes de service Kubernetes sur la page Kubernetes : présentation des charges de travail de Google Cloud console.

    Accéder à la page Charges de travail

WIF sur d'autres plates-formes

  1. Si ce n'est pas le cas, accédez à votre répertoire APIGEE_HELM_CHARTS_HOME. Exécutez les commandes suivantes à partir de ce répertoire.
  2. Installez Apigee Operator/Controller :
    1. Effectuez un dry run : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml \
  --dry-run=server
    2. Installez le chart : 
      helm upgrade operator apigee-operator/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

    3. Vérifiez l'installation de l'opérateur 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. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez le datastore Apigee :

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

    2. Installez le chart :

      helm upgrade datastore apigee-datastore/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml
    3. Si vous avez activé la sauvegarde ou la restauration de Cassandra, accordez aux comptes de service Kubernetes Cassandra l'accès à l'identité du compte de service IAM apigee-cassandra associé.
      1. Répertoriez les adresses e-mail du compte de service IAM pour Cassandra :

        Production

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

        Hors production

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

        Le résultat doit ressembler à ce qui suit :

        Production

        apigee-cassandra      apigee-cassandra@my-project.iam.gserviceaccount.com      False

        Hors production

        apigee-non-prod       apigee-non-prod@my-project.iam.gserviceaccount.com      False
      2. Listez les comptes de service Kubernetes Cassandra : 
        kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-cassandra"

        Le résultat doit ressembler à ce qui suit :

        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 vous avez créé les comptes de service Kubernetes apigee-cassandra-backup-sa ou apigee-cassandra-restore-sa, accordez à chacun d'eux l'accès pour emprunter l'identité du compte de service IAM apigee-cassandra à l'aide de la commande suivante :

        Production

        Modèle

        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

        Exemple

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

        Hors production

        Modèle

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --member="principal://iam.googleapis.com/projects/1234567890/locations/global/workloadIdentityPools/my-pool/subject/system:serviceaccount:apigee:apigee-cassandra-backup-sa" \
    --role=roles/iam.workloadIdentityUser

        Où :

        • CASSANDRA_IAM_SA_EMAIL : adresse e-mail du compte de service IAM Cassandra.
        • PROJECT_NUMBER : numéro de projet du projet dans lequel vous avez créé le pool d'identités de charge de travail.
        • POOL_ID : ID du pool d'identités de charge de travail.
        • MAPPED_SUBJECT : compte de service Kubernetes à partir de la revendication de votre jeton d'identification. Dans la plupart des installations hybrides, il se présente au format suivant : system:serviceaccount:APIGEE_NAMESPACE:K8S_SA_NAME.
          • Pour apigee-cassandra-backup-sa, cela ressemblera à system:serviceaccount:apigee:apigee-cassandra-backup-sa.
          • Pour apigee-cassandra-restore-sa, cela ressemblera à system:serviceaccount:apigee:apigee-cassandra-restore-sa.

    4. Vérifiez que apigeedatastore est opérationnel en vérifiant son état avant de passer à l'étape suivante :

      kubectl -n APIGEE_NAMESPACE get apigeedatastore default

      NAME      STATE       AGE
default   running    51s

  4. Installez la télémétrie Apigee :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeetelemetry apigee-telemetry

      NAME               STATE     AGE
apigee-telemetry   running   55s
    4. Accordez aux comptes de service Kubernetes de télémétrie l'accès nécessaire pour emprunter l'identité du compte de service IAM apigee-metrics associé.
      1. Listez l'adresse e-mail du compte de service IAM pour les métriques :

        Production

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

        Le résultat doit ressembler à ce qui suit :

        apigee-metrics   apigee-metrics@my-project.iam.gserviceaccount.com   False

        Hors production

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

        Le résultat doit ressembler à ce qui suit :

        apigee-non-prod   apigee-non-prod@my-project.iam.gserviceaccount.com   False
      2. Listez les comptes de service Kubernetes de télémétrie : 
        kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "telemetry"

        Le résultat doit ressembler à ce qui suit :

        apigee-metrics-apigee-telemetry                    0   42m
apigee-open-telemetry-collector-apigee-telemetry   0   37m
      3. Accordez à chacun des comptes de service Kubernetes de télémétrie l'accès nécessaire pour emprunter l'identité du compte de service IAM apigee-metrics à l'aide de la commande suivante :

        Production

        Métriques Apigee KSA : compte de service Google IAM apigee-metrics-apigee-telemetry à apigee-metrics

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-metrics@my-project.iam.gserviceaccount.com \
    --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 du collecteur Apigee OpenTelemetry : apigee-open-telemetry-collector-apigee-telemetry vers le compte de service Google IAM apigee-metrics

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-metrics@my-project.iam.gserviceaccount.com \
    --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

        Hors production

        Métriques Apigee KSA : compte de service Google IAM apigee-metrics-apigee-telemetry à apigee-non-prod

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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 du collecteur Apigee OpenTelemetry : apigee-open-telemetry-collector-apigee-telemetry vers le compte de service Google IAM apigee-non-prod

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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. Installez Apigee Redis :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant son état :

      kubectl -n APIGEE_NAMESPACE get apigeeredis default

      NAME      STATE     AGE
default   running   79s

  6. Installez le gestionnaire d'entrée Apigee :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant sa disponibilité :

      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. Installez l'organisation Apigee. Si vous avez défini la variable d'environnement $ORG_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

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

    2. Installez le chart :

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

    3. Vérifiez qu'elle est opérationnelle en vérifiant l'état de l'organisation correspondante :

      kubectl -n APIGEE_NAMESPACE get apigeeorg

      NAME                      STATE     AGE
my-project-123abcd        running   4m18s
    4. Accordez aux comptes de service Kubernetes de portée organisationnelle l'accès nécessaire pour emprunter l'identité des comptes de service IAM associés.
      1. Listez les adresses e-mail des comptes de service IAM utilisés par les composants apigee-mart, apigee-udca et apigee-watcher :

        Production

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

        Le résultat doit ressembler à ce qui suit :

        apigee-mart      apigee-mart@my-project.iam.gserviceaccount.com      False
apigee-udca      apigee-udca@my-project.iam.gserviceaccount.com      False
apigee-watcher   apigee-watcher@my-project.iam.gserviceaccount.com   False

        Si vous utilisez Monétisation pour Apigee hybrid, obtenez également l'adresse e-mail du compte de service apigee-mint-task-scheduler.

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

        Le résultat doit ressembler à ce qui suit :

        apigee-mint-task-scheduler   apigee-mint-task-scheduler@my-project.iam.gserviceaccount.com   False

        Hors production

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

        Le résultat doit ressembler à ce qui suit :

        apigee-non-prod     apigee-non-prod@my-project.iam.gserviceaccount.com         False
      2. Listez les comptes de service Kubernetes à portée d'organisation : 
        kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-connect-agent\|apigee-mart\|apigee-udca\|apigee-watcher"

        Le résultat doit ressembler à ce qui suit :

        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. Utilisez les commandes suivantes pour accorder aux comptes de service Kubernetes de portée organisationnelle l'autorisation d'emprunter l'identité des comptes de service IAM associés :

        Production

        Compte de service Kubernetes de l'agent Connect : apigee-connect-agent-ORG_NAME-ORG_HASH_ID compte de service Kubernetes vers le compte de service IAM apigee-mart.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-mart@my-project.iam.gserviceaccount.com \
    --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 MART : compte de service Kubernetes apigee-mart-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-mart. MART et l'agent Connect utilisent le même compte de service IAM.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-mart@my-project.iam.gserviceaccount.com \
    --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

        Planificateur de tâches Mint KSA (si vous utilisez Monétisation pour Apigee hybrid)

        Compte de service Kubernetes apigee-mint-task-scheduler-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-mint-task-scheduler.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-mint-task-scheduler@my-project.iam.gserviceaccount.com \
    --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 UDCA au niveau de l'organisation : compte de service Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-udca.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-udca-task-scheduler@my-project.iam.gserviceaccount.com \
    --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 du contrôleur : compte de service Kubernetes apigee-watcher-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-watcher.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-watcher@my-project.iam.gserviceaccount.com \
    --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

        Hors production

        Compte de service Kubernetes de l'agent Connect : apigee-connect-agent-ORG_NAME-ORG_HASH_ID compte de service Kubernetes vers le compte de service IAM apigee-non-prod.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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 MART : compte de service Kubernetes apigee-mart-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-non-prod.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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

        Planificateur de tâches Mint KSA (si vous utilisez Monétisation pour Apigee hybrid)

        Compte de service Kubernetes apigee-mint-task-scheduler-ORG_NAME-UUIORG_HASH_IDD vers le compte de service IAM apigee-non-prod.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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 UDCA au niveau de l'organisation : compte de service Kubernetes apigee-udca-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-non-prod.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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 du contrôleur : compte de service Kubernetes apigee-watcher-ORG_NAME-ORG_HASH_ID vers le compte de service IAM apigee-non-prod.

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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. Installez l'environnement.

    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :

    1. Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-env. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_NAME. Toutefois, si votre environnement porte le même nom que votre groupe d'environnements, vous devez utiliser des noms de version différents pour l'environnement et le groupe d'environnements (par exemple, dev-env-release et dev-envgroup-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

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

    3. Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :

      kubectl -n APIGEE_NAMESPACE get apigeeenv

      NAME                       STATE     AGE   GATEWAYTYPE
apigee-my-project-my-env   running   3m1s
    4. Accordez aux comptes de service Kubernetes à portée d'environnement l'accès nécessaire pour emprunter l'identité des comptes de service IAM associés.
      1. Listez l'adresse e-mail des comptes de service IAM utilisés par les composants apigee-runtime, apigee-synchronizer et apigee-udca :

        Production

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

        Hors production

        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"

        Le résultat doit ressembler à ce qui suit :

        Production

        apigee-runtime         apigee-runtime@my-project.iam.gserviceaccount.com         False
apigee-synchronizer    apigee-synchronizer@my-project.iam.gserviceaccount.com      False
apigee-udca            apigee-udca@my-project.iam.gserviceaccount.com         False

        Hors production

        apigee-non-prod     apigee-non-prod@my-project.iam.gserviceaccount.com         False
      2. Listez les comptes de service Kubernetes à portée d'environnement : 
        kubectl get serviceaccount -n APIGEE_NAMESPACE | grep "apigee-runtime\|apigee-synchronizer\|apigee-udca"

        Le résultat doit ressembler à ce qui suit :

        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
      3. Utilisez la commande suivante pour accorder aux comptes de service Kubernetes à portée d'environnement l'accès permettant d'emprunter l'identité des comptes de service IAM associés :

        Production

        Runtime KSA : apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA vers apigee-runtime SA Google IAM

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-runtime@my-project.iam.gserviceaccount.com \
    --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 du synchronisateur : KSA apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa vers le compte de service Google IAM apigee-synchronizer

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-synchronizer@my-project.iam.gserviceaccount.com \
    --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

        Compte de service Kubernetes : apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa vers apigee-udca compte de service IAM Google

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-udca@my-project.iam.gserviceaccount.com \
    --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

        Hors production

        Runtime KSA : apigee-runtime-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa KSA vers apigee-non-prod SA Google IAM

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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

        Hors production

        KSA du synchronisateur : KSA apigee-synchronizer-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa vers le compte de service Google IAM apigee-non-prod

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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

        Hors production

        Compte de service Kubernetes : apigee-udca-PROJECT_ID-ENV_NAME-ENV_HASH_ID-sa vers apigee-non-prod compte de service IAM Google

        Code

        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

        Exemple

        gcloud iam service-accounts add-iam-policy-binding \
  apigee-non-prod@my-project.iam.gserviceaccount.com \
    --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. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :

      Effectuez un dry run :

      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 est un nom utilisé pour suivre l'installation et les mises à niveau du graphique apigee-virtualhosts. Ce nom doit être unique par rapport aux autres noms de version Helm de votre installation. Il s'agit généralement de la même valeur que ENV_GROUP. Toutefois, si le nom de votre groupe d'environnements est identique à celui d'un environnement de votre installation, vous devez utiliser des noms de version différents pour le groupe d'environnements et l'environnement (par exemple, dev-envgroup-release et dev-env-release). Pour en savoir plus sur les versions dans Helm, consultez Trois concepts importants dans la documentation Helm.

    2. Installez le chart :

      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set envgroup=$ENV_GROUP \
  -f overrides.yaml
    3. Vérifiez l'état de la ressource ApigeeRoute (AR).

      L'installation de virtualhosts crée ApigeeRouteConfig (ARC) qui crée ApigeeRoute en interne une fois que l'observateur Apigee extrait les détails liés au groupe d'environnement du plan de contrôle. Par conséquent, vérifiez que l'état d'AR correspondant est en cours d'exécution : 

      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

Étape suivante

À l'étape suivante, vous allez configurer la passerelle d'entrée Apigee et déployer un proxy pour tester votre installation.

(SUIVANT) Étape 1 : Exposer l'entrée Apigee 2