Activer Workload Identity avec Apigee hybrid

Vous consultez actuellement la version 1.10 de la documentation d'Apigee hybrid. Pour en savoir plus, consultez la section Versions compatibles.

Version 1.10 

   Versions compatibles :

• v1.13 (la plus récente)
• v1.12
• v1.11                         
• Liste des versions compatibles

   Versions non compatibles :

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

Cet article explique comment activer Workload Identity pour Apigee hybrid.

Remarque : Apigee hybrid v.1.10 n'est compatible qu'avec la fédération d'identité de charge de travail sur GKE.

Présentation

Workload Identity permet aux applications s'exécutant dans GKE (Google Kubernetes Engine) d'accéder aux services Google Cloud. Pour en savoir plus sur Workload Identity, consultez les sections suivantes :

• Introducing Workload Identity: Better authentication for your GKE applications
• Utiliser Workload Identity

Un compte de service Google Cloud IAM est une identité qu'une application peut utiliser pour envoyer des requêtes à Google APIs. Ces comptes de service sont appelés GSA ("Google Service Accounts" ou comptes de service Google) dans ce document. Pour en savoir plus sur les GSA, consultez la section Comptes de service.

De son côté, Kubernetes utilise également le concept de comptes de service. Un compte de service fournit une identité pour les processus exécutés dans un pod. Les comptes de service Kubernetes sont des ressources Kubernetes, tandis que les comptes de service Google sont spécifiques à Google Cloud. Pour plus d'informations sur les comptes de service Kubernetes, consultez la section Configurer des comptes de service pour les pods dans la documentation de Kubernetes.

Avec Apigee hybrid 1.4 et versions ultérieures, Apigee crée et utilise un compte de service Kubernetes pour chaque type de composant. L'activation de Workload Identity permet aux composants hybrides d'interagir avec les comptes de service Kubernetes.

Comptes de service Google dans Apigee hybrid sans Workload Identity

Sans utiliser Workload Identity, vous devez associer les comptes de service Google à chaque composant de votre fichier overrides.yaml avec une référence à un fichier de certificat ou à un secret Kubernetes. Par exemple :

• Fichiers de certification :

  watcher:
    serviceAccountPath: ./apigee-org/my-hybrid-project-apigee-watcher.json

  Consultez les pages suivantes :

  cassandra.backup.serviceAccountPath cassandra.restore.serviceAccountPath connectAgent.serviceAccountPath diagnostic.serviceAccountPath envs[].serviceAccountPaths.runtime envs[].serviceAccountPaths.synchronizer envs[].serviceAccountPaths.udca

  logger.serviceAccountPath mart.serviceAccountPath metrics.serviceAccountPath synchronizer.serviceAccountPath udca.serviceAccountPath watcher.serviceAccountPath

• Secret Kubernetes :

  watcher:
    serviceAccountRef: my-watcher-k8s-secret

  Consultez les pages suivantes :

  cassandra.backup.serviceAccountRef cassandra.restore.serviceAccountRef connectAgent.serviceAccountRef diagnostic.serviceAccountRef envs[].serviceAccountRefs.runtime envs[].serviceAccountRefs.synchronizer envs[].serviceAccountRefs.udca

  logger.serviceAccountRef mart.serviceAccountRef metrics.serviceAccountRef synchronizer.serviceAccountRef udca.serviceAccountRef watcher.serviceAccountRef

Variables d'environnement utilisées dans ces procédures

Ces procédures utilisent les variables d'environnement suivantes. Définissez ces valeurs dans votre interface système ou remplacez-les dans les exemples de code par les valeurs réelles :

• PROJECT_ID : ID de votre projet Google Cloud.
• ORG_NAME : nom de votre organisation Apigee.
• ENV_NAME : nom de l'environnement Apigee.
• NAMESPACE : nom de votre espace de noms Apigee. Cette valeur est généralement définie sur apigee.
• CLUSTER_NAME : nom de votre cluster.
• CLUSTER_LOCATION : région ou zone de votre cluster (par exemple, us-west1).
• APIGEECTL_HOME : répertoire dans lequel vous avez installé apigeectl.
• HYBRID_FILES : répertoire des fichiers hybrides (par exemple, hybrid-base-directory/hybrid-files).

Vérifiez les variables d'environnement :

echo $PROJECT_ID
echo $ORG_NAME
echo $ENV_NAME
echo $NAMESPACE
echo $CLUSTER_NAME
echo $CLUSTER_LOCATION
echo $APIGEECTL_HOME
echo $HYBRID_FILES

Initialisez l'une des variables dont vous avez besoin :

export PROJECT_ID=my-project-id
export ORG_NAME=$PROJECT_ID
export ENV_NAME=my-environment-name
export NAMESPACE=apigee
export CLUSTER_NAME=my-cluster-name
export CLUSTER_LOCATION=my-cluster-location
export APIGEECTL_HOME=hybrid-base-directory/apigeectl
export HYBRID_FILES=hybrid-base-directory/hybrid-files

Workload Identity et fichiers de clé de compte de service

Lorsque vous exécutez Apigee hybrid sur GKE, il est recommandé de créer et de télécharger des clés privées (fichiers .json) pour chacun des comptes de service. Si vous utilisez Workload Identity, vous n'avez pas besoin de télécharger les clés privées des comptes de service et de les ajouter aux clusters GKE.

Si vous avez téléchargé des fichiers de clé de compte de service dans le cadre de votre installation Apigee hybrid, vous pouvez les supprimer après avoir activé Workload Identity. Ils se situent dans le répertoire hybrid-base-directory/hybrid-files/service-accounts/ avec la plupart des installations.

Activer Workload Identity pour Apigee hybrid

Pour commencer, suivez les instructions de la page Préparer l'activation de Workload Identity pour mettre à jour les pools de nœuds et initialiser les variables avant d'activer Workload Identity.

Suivez ensuite les instructions de la page Définir workloadIdentityEnabled: true et créer des comptes de service pour activer Workload Identity sur votre installation Apigee hybrid.

Préparer l'activation de Workload Identity

Avant de commencer le processus d'installation, suivez les étapes de cette section.

1. Définissez le projet sur le projet que vous modifiez :

   gcloud config set project $PROJECT_ID

2. Obtenez les identifiants gcloud du cluster sur lequel vous activez Workload Identity à l'aide de la commande suivante :

   gcloud container clusters get-credentials ${CLUSTER_NAME} \
     --region ${CLUSTER_LOCATION} \
     --project ${PROJECT_ID}

   Remarque : Si vous avez créé un cluster zonal au lieu d'un cluster régional, obtenez les identifiants à l'aide de la commande suivante :

   gcloud container clusters get-credentials ${CLUSTER_NAME} \
     --zone ${CLUSTER_LOCATION} \
     --project ${PROJECT_ID}

3. Vérifiez à l'aide de la commande suivante que Workload Identity est activé pour le cluster GKE exécutant Apigee :

   gcloud container clusters describe $CLUSTER_NAME --region $CLUSTER_LOCATION --project $PROJECT_ID

   Remarque : Pour les clusters zonaux, utilisez la commande suivante :

   gcloud container clusters describe $CLUSTER_NAME --zone $CLUSTER_LOCATION --project $PROJECT_ID

   Le résultat doit inclure les éléments suivants :

   …
     …
     status: RUNNING
     subnetwork: default
     workloadIdentityConfig:
       workloadPool: my-project-id.svc.id.goog

   Si nécessaire, activez Workload Identity sur le cluster. Cette opération peut prendre jusqu'à 30 minutes :

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

   Remarque : Si vous avez créé un cluster zonal au lieu d'un cluster régional, utilisez l'argument --zone au lieu de --region, comme dans la commande suivante :

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

   Pour en savoir plus, consultez la page Activer Workload Identity.

4. Assurez-vous que Workload Identity est activé sur chaque pool de nœuds.
   1. Listez vos pools de nœuds à l'aide de la commande suivante :

      gcloud container node-pools list \
        --cluster $CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID

      Le résultat doit se présenter sous la forme suivante :

        NAME            MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
        apigee-runtime  e2-standard-4  100           1.23.12-gke.100
        apigee-data     e2-standard-4  100           1.23.12-gke.100

   2. Assurez-vous que Workload Identity est activé par pool de nœuds, en saisissant la commande suivante pour chaque pool de nœuds :

      gcloud container node-pools update NODE_POOL_NAME \
        --cluster=$CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID \
        --workload-metadata=GKE_METADATA

      Où NODE_POOL_NAME est le nom de chaque pool de nœuds.

Valider ou créer des comptes de service Google

Les comptes de service Google sont créés pour de nombreux composants hybrides Apigee lors de l'installation. Cette procédure vous permet de valider les comptes de service Google et de créer les autres comptes potentiellement nécessaires.

1. Vérifiez les noms des comptes de service Google de votre projet à l'aide de la commande suivante :

   gcloud iam service-accounts list --project $PROJECT_ID

   Le résultat doit se présenter sous la forme suivante :

   Prod

   Pour les environnements hors production :

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-cassandra     apigee-cassandra@my_project_id.iam.gserviceaccount.com     False
   apigee-logger        apigee-logger@my_project_id.iam.gserviceaccount.com        False
   apigee-mart          apigee-mart@my_project_id.iam.gserviceaccount.com          False
   apigee-metrics       apigee-metrics@my_project_id.iam.gserviceaccount.com       False
   apigee-runtime       apigee-runtime@my_project_id.iam.gserviceaccount.com       False
   apigee-synchronizer  apigee-synchronizer@my_project_id.iam.gserviceaccount.com  False
   apigee-udca          apigee-udca@my_project_id.iam.gserviceaccount.com          False
   apigee-watcher       apigee-watcher@my_project_id.iam.gserviceaccount.com       False
   

   Hors production

   Pour les environnements hors production :

   DISPLAY NAME         EMAIL                                                      DISABLED
   apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
   

   Conseil : Si les noms personnalisés de vos comptes de service ne correspondent pas facilement aux noms des composants Apigee, vous pouvez déterminer le rôle de chaque compte de service en vérifiant les rôles qui leur sont attribués et en les comparant aux rôles recommandés dans À propos des comptes de service.

   Exécutez la commande suivante pour vérifier les rôles attribués à un compte de service :

   gcloud projects get-iam-policy ${PROJECT_ID}  \
   --flatten="bindings[].members" \
   --format='table(bindings.role)' \
   --filter="SERVICE_ACCOUNT_NAME"

   Si vous devez créer les comptes de service Google pour votre projet, deux méthodes s'offrent à vous :

   • Utiliser l'outil create-service-account inclus avec Apigee dans le répertoire apigeectl/tools/. Cet outil permet de créer tous les comptes de service à l'aide d'une seule commande, ou vous permet de les créer un par un.
     create-service-account génère des fichiers de clé pour chaque compte de service, puis les télécharge. Avec Workload Identity, vous n'avez pas besoin de ces fichiers de clés. Si la sécurité de ces fichiers de clé vous préoccupe, vous pouvez les supprimer. Vous pouvez également utiliser gcloud pour créer les comptes de service et leur attribuer les rôles appropriés.
   • Exécuter la commande gcloud iam service-accounts create pour créer les comptes de service un par un, et la commande gcloud projects add-iam-policy-binding pour attribuer les rôles appropriés à chaque compte de service. Cette méthode nécessite de créer chaque compte de service individuellement, mais elle vous évite de devoir télécharger les fichiers de clé.

   create-service-account

   Utilisez la commande suivante pour créer un compte de service Google par composant :

   Prod

   Pour les environnements hors production :

   $APIGEECTL_HOME/tools/create-service-account --env prod --dir $APIGEECTL_HOME/../service-accounts

   Cette commande crée les comptes de service suivants :

   • apigee-cassandra
   • apigee-logger
   • apigee-mart
   • apigee-metrics
   • apigee-runtime
   • apigee-synchronizer
   • apigee-udca
   • apigee-watcher

   Hors production

   Pour les environnements hors production :

   $APIGEECTL_HOME/tools/create-service-account --env non-prod --dir $APIGEECTL_HOME/../service-accounts

   Cette commande crée un seul compte de service, apigee-non-prod, avec tous les rôles nécessaires attribués pour gérer l'ensemble des composants Apigee.

   gcloud

   Créez les comptes de service suivants et attribuez-leur des rôles.

   Conseil : Si vous souhaitez utiliser des noms personnalisés, remplacez le nom du compte de service en rouge dans l'exemple de code par le nom que vous souhaitez utiliser.

   1. Compte de service : apigee-cassandra, rôle : roles/storage.objectAdmin

      Créez le compte :

      gcloud iam service-accounts create apigee-cassandra \
        --display-name="apigee-cassandra" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/storage.objectAdmin"
                  

   2. Compte de service : apigee-logger, rôle : roles/logging.logWriter

      Créez le compte :

      gcloud iam service-accounts create apigee-logger \
        --display-name="apigee-logger" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-logger@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/logging.logWriter"
                  

   3. Compte de service : apigee-mart, rôle : roles/apigeeconnect.Agent

      Créez le compte :

      gcloud iam service-accounts create apigee-mart \
        --display-name="apigee-mart" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-mart@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigeeconnect.Agent"
                  

   4. Compte de service : apigee-metrics, rôle : roles/monitoring.metricWriter

      Créez le compte :

      gcloud iam service-accounts create apigee-metrics \
        --display-name="apigee-metrics" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/monitoring.metricWriter"
                  

   5. Compte de service : apigee-runtime, rôle : aucun rôle attribué.

      Créez le compte :

      gcloud iam service-accounts create apigee-runtime \
        --display-name="apigee-runtime" \
        --project $PROJECT_ID
                  

   6. Compte de service : apigee-synchronizer, rôle : roles/apigee.synchronizerManager

      Créez le compte :

      gcloud iam service-accounts create apigee-synchronizer \
        --display-name="apigee-synchronizer" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.synchronizerManager"
                  

   7. Compte de service : apigee-udca, rôle : roles/apigee.analyticsAgent

      Créez le compte :

      gcloud iam service-accounts create apigee-udca \
        --display-name="apigee-udca" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-udca@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.analyticsAgent"
                  

   8. Compte de service : apigee-watcher, rôle : roles/apigee.runtimeAgent

      Créez le compte :

      gcloud iam service-accounts create apigee-watcher \
        --display-name="apigee-watcher" \
        --project $PROJECT_ID
                  

      Attribuez le rôle :

      gcloud projects add-iam-policy-binding $PROJECT_ID \
        --member="serviceAccount:apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com" \
        --role="roles/apigee.runtimeAgent"
                  

Définir workloadIdentityEnabled: true et créer des comptes de service

apigeectl crée des comptes de service Kubernetes pour chaque composant Apigee hybrid lorsque vous définissez workloadIdentityEnabled: true dans votre fichier de remplacement et appliquez les modifications.

1. Ajoutez la ligne en gras ci-dessous à votre fichier overrides.yaml dans le bloc de script gcp : Cela active Workload Identity pour votre installation et déclenche la création, par apigeectl, des comptes de service Kubernetes lorsque vous appliquez la configuration :

   gcp:
     projectID: "my-project-id"
     name: "my-project-id"
     region: "analytics-region"
     workloadIdentityEnabled: true

2. Ajoutez les lignes en gras ci-dessous à votre fichier overrides.yaml dans le bloc de script cassandra : Cette opération déclenche la création du compte de service Kubernetes apigee-cassandra-backup :

   cassandra:
     ...
     backup:
       enabled: true

3. Appliquez les modifications avec apigeectl avec l'option --restore :

   $APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --restore

   Remarque : L'option --restore déclenche la création du compte de service Kubernetes apigee-cassandra-restore.
4. Vérifiez les comptes de service à l'aide de la commande suivante :

   kubectl get sa -n $NAMESPACE

   La sortie doit se présenter sous la forme suivante. Les comptes de service Kubernetes en gras sont ceux que vous devrez annoter avec vos comptes de service Google :

   NAME                                                         SECRETS   AGE
   apigee-cassandra-backup                                      1         11m
   apigee-cassandra-restore                                     1         11m
   apigee-cassandra-schema-setup-my-project-id-123abcd-sa       1         11m
   apigee-cassandra-schema-val-my-project-id-123abcd            1         11m
   apigee-cassandra-user-setup-my-project-id-123abcd-sa         1         11m
   apigee-connect-agent-my-project-id-123abcd-sa                1         11m
   apigee-datastore-default-sa                                  1         11m
   apigee-ingressgateway                                        1         11m
   apigee-ingressgateway-my-project-id-123abcd                  1         11m
   apigee-ingressgateway-manager                                1         11m
   apigee-init                                                  1         11m
   apigee-mart-my-project-id-123abcd-sa                         1         11m
   apigee-metrics-sa                                            1         11m
   apigee-mint-task-scheduler-my-project-id-123abcd-sa          1         11m
   apigee-redis-default-sa                                      1         11m
   apigee-redis-envoy-default-sa                                1         11m
   apigee-runtime-my-project-id-env-name-234bcde-sa             1         11m
   apigee-synchronizer-my-project-id-env-name-234bcde-sa        1         11m
   apigee-udca-my-project-id-123abcd-sa                         1         11m
   apigee-udca-my-project-id-env-name-234bcde-sa                1         11m
   apigee-watcher-my-project-id-123abcd-sa                      1         11m
   default                                                      1         11m
       

Annoter les comptes de service Kubernetes avec les comptes de service Google

Pour chaque composant Apigee, annotez les comptes de service Kubernetes correspondants avec le compte de service Google du composant.

Composants au niveau de l'organisation

Vous ne disposez que d'une seule instance de chaque compte de service Kubernetes pour votre organisation Apigee.

Composant	Compte de service Kubernetes	Compte de service Google
Cassandra	apigee-cassandra-backup	apigee-cassandra
	apigee-cassandra-restore	apigee-cassandra
	apigee-cassandra-schema-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-cassandra-schema-val-my-project-id-num-id1	apigee-cassandra
	apigee-cassandra-user-setup-my-project-id-num-id1-sa	apigee-cassandra
	apigee-datastore-default-sa	apigee-cassandra
Apigee Connect	apigee-connect-agent-my-project-id-num-id1-sa	apigee-mart
MART	apigee-mart-my-project-id-num-id1-sa	apigee-mart
Métriques	apigee-metrics-sa	apigee-metrics
UDCA (au niveau de l'organisation)	apigee-udca-my-project-id-num-id1-sa	apigee-udca
Watcher	apigee-watcher-my-project-id-num-id1-sa	apigee-watcher

Composants au niveau de l'environnement

Vous disposez d'une instance de chaque compte de service Kubernetes pour chaque environnement Apigee.

Composant	Compte de service Kubernetes	Compte de service Google
Environnement d'exécution Apigee :	apigee-runtime-my-project-id-env-name-num-id2-sa	apigee-runtime
Synchronisateur	apigee-synchronizer-my-project-id-env-name-num-id2-sa	apigee-synchronizer
UDCA (au niveau de l'environnement)	apigee-udca-my-project-id-env-name-num-id2-sa	apigee-udca

IMPORTANT : Si les noms de votre compte de service ne correspondent pas aux noms par défaut créés par create-service-account, remplacez dans les commandes suivantes le nom du compte de service en rouge par le nom du compte de service approprié pour le composant. Par exemple, si le compte de service Cassandra s'appelle my-cassandra-accnt-1, remplacez apigee-cassandra par ce nom dans la commande.

Dans les commandes suivantes, utilisez les noms de compte de service Kubernetes renvoyés par la commande kubectl get sa -n $NAMESPACE, par exemple : apigee-cassandra-schema-val-hybrid-example-project-123abcd.

Dans cette procédure, pour chaque compte de service Kubernetes, vous allez :

• associer le compte de service Kubernetes et le compte de service Google principal au rôle IAM roles/iam.workloadIdentityUser ;
• annoter le compte de service Kubernetes avec le compte de service Google ;

1. lier les rôles et annoter les comptes de service.

   Composants au niveau de l'organisation

   Annotez les comptes de service Kubernetes pour les composants au niveau de l'organisation. Vous devrez effectuer cette opération pour chaque composant de votre organisation Apigee.

   • Cassandra

     Le composant Cassandra est associé à six comptes de service Kubernetes :

     • apigee-cassandra-backup
     • apigee-cassandra-restore
     • apigee-cassandra-schema-setup
     • apigee-cassandra-schema-val (val = validation)
     • apigee-cassandra-user-setup
     • apigee-datastore-default

     Prod

     apigee-cassandra-backup

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

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

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-restore

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-restore"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-setup-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-setup-service-account-name"

        Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     2. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-val-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-user-setup-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     apigee-datastore-default-sa

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-datastore-default-sa"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     apigee-cassandra-backup

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-non-prod"
        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-restore

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-restore"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-setup-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-setup-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-schema-val-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-cassandra-user-setup-service-account-name

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

     apigee-datastore-default-sa

     1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-datastore-default-sa"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Apigee Connect

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-connect-agent-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • MART

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-mart-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-mart-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Métriques Apigee

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

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

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-metrics-sa"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • UDCA (au niveau de l'organisation)

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez les variables d'environnement KSA_NAME :

        KSA_NAME="apigee-udca-org-level-service-account-name"

     2. Liez le rôle IAM :

          gcloud iam service-accounts add-iam-policy-binding \
            --role roles/iam.workloadIdentityUser \
            --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
            $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

          kubectl annotate serviceaccount \
            --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Apigee Watcher

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-watcher"
        KSA_NAME="apigee-watcher-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-watcher-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   Pour chaque environnement :

   • Environnement d'exécution

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-runtime"
        KSA_NAME="apigee-runtime-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-runtime-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • Synchronisateur

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-synchronizer"
        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-synchronizer-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

   • UDCA (au niveau de l'environnement)

     Prod

     1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-env-level-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=$GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     Hors production

     1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-udca-env-level-service-account-name"

     2. Liez le rôle IAM :

        gcloud iam service-accounts add-iam-policy-binding \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
          $GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com

     3. Annotez le compte de service :

        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com

2. Vérifiez si les étapes ont fonctionné :

   gcloud config set project $PROJECT_ID
   

   Sélectionnez un compte de service Kubernetes à tester, par exemple : apigee-cassandra-backup.

   KSA_NAME="kubernetes-service-account-name"
   

   kubectl run --rm -it --image google/cloud-sdk:slim \
     --namespace $NAMESPACE workload-identity-test\
     -- gcloud auth list

   Si l'invite de commande ne s'affiche pas, essayez d'appuyer sur la touche Entrée.

   Si les étapes ont été correctement exécutées, vous devriez obtenir une réponse semblable à celle-ci :

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

3. Si vous effectuez une mise à niveau à partir d'une installation précédente, nettoyez les secrets contenant des clés privées de compte de service :

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

4. Vérifiez les journaux :

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

Mettre à niveau une installation pour utiliser Workload Identity

Suivez ces instructions pour ajouter Workload Identity à une installation hybride existante.

Voici un exemple illustrant les comptes de service Google (GSA) créés pour Apigee :

gcloud iam service-accounts list --filter "apigee"

DISPLAY NAME       EMAIL                                                  DISABLED
apigee-cassandra   apigee-cassandra@PROJECT_ID.iam.gserviceaccount.com    False
apigee-connect     apigee-connect@PROJECT_ID.iam.gserviceaccount.com      False
apigee-runtime     apigee-runtime@PROJECT_ID.iam.gserviceaccount.com      False
apigee-metrics     apigee-metrics@PROJECT_ID.iam.gserviceaccount.com      False
apigee-mart        apigee-mart@PROJECT_ID.iam.gserviceaccount.com         False
apigee-watcher     apigee-watcher@PROJECT_ID.iam.gserviceaccount.com      False
apigee-sync        apigee-sync@PROJECT_ID.iam.gserviceaccount.com         False
apigee-udca        apigee-udca@$PROJECT_ID.iam.gserviceaccount.com        False

Voici un exemple de comptes de service Kubernetes (KSA) créés pour Apigee :

kubectl get sa -n $NAMESPACE

apigee-cassandra-schema-setup-ORG_NAME-cb84b88-sa             1         xxd
apigee-cassandra-user-setup-ORG_NAME-cb84b88-sa               1         xxd
apigee-connect-agent-ORG_NAME-cb84b88-sa                      1         xxd
apigee-init                                                   1         xxd
apigee-mart-ORG_NAME-cb84b88-sa                               1         xxd
apigee-metrics-apigee-telemetry                               1         xxd
apigee-runtime-ORG_NAME-ENV_NAME-1d0dc5e-sa                   1         xxd
apigee-synchronizer-ORG_NAME-ENV_NAME-1d0dc5e-sa              1         xxd
apigee-udca-ORG_NAME-ENV_NAME-1d0dc5e-sa                      1         xxd
apigee-watcher-ORG_NAME-cb84b88                               1         xxd

Où : ORG_NAME et ENV_NAME peuvent être une version abrégée des noms de l'organisation et de l'environnement.

1. Ajoutez le rôle Workload Identity à chaque compte de service :

   gcloud iam service-accounts add-iam-policy-binding \
     --role roles/iam.workloadIdentityUser \
     --member "serviceAccount:$PROJECT_ID.svc.id.goog[$NAMESPACE/$KSA_NAME]" \
     GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com
   

   Par exemple, si vous définissez les autorisations pour le synchronisateur Apigee, vous devez exécuter :

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

   gcloud iam service-accounts add-iam-policy-binding --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apigee/$KSA_NAME]" apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
   

2. Annotez chaque KSA avec les détails des GSA :

   kubectl annotate serviceaccount \
     --namespace $NAMESPACE \
     $KSA_NAME \
     iam.gke.io/gcp-service-account=GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com
   

   Par exemple, si vous définissez les autorisations pour le synchronisateur Apigee, vous devez exécuter :

   export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
   

   kubectl annotate serviceaccount --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
   

3. Vérifiez si les étapes ont fonctionné :

   gcloud config set project $PROJECT_ID
   

     kubectl run --rm -it --image google/cloud-sdk:slim \
       --namespace $NAMESPACE workload-identity-test\
       -- gcloud auth list

   Si l'invite de commande ne s'affiche pas, essayez d'appuyer sur la touche Entrée.

   Si les étapes ont été correctement exécutées, vous devriez obtenir une réponse semblable à celle-ci :

                      Credentialed Accounts
   ACTIVE  ACCOUNT
   *       GSA@PROJECT_ID.iam.gserviceaccount.com

4. Si vous effectuez une mise à niveau à partir d'une installation précédente, nettoyez les secrets contenant des clés privées de compte de service :

   kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
   

5. Vérifiez les journaux :

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