Attivazione di Workload Identity con Apigee hybrid

Attualmente stai visualizzando la versione 1.9 della documentazione di Apigee hybrid. This version is end of life. You should upgrade to a newer version. Per ulteriori informazioni, consulta Versioni supportate.

Version 1.9 (unsupported)

   Supported versions:

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

   Unsupported versions:

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

Questo argomento spiega come attivare Workload Identity per Apigee hybrid.

Nota:Apigee hybrid v.1.9 supporta solo la federazione delle identità per i carichi di lavoro su GKE.

Panoramica

Workload Identity è un modo per le applicazioni in esecuzione in GKE (Google Kubernetes Engine) di accedere ai servizi Google Cloud. Per le panoramiche di Workload Identity, consulta:

• Introduzione di Workload Identity: migliore autenticazione per le applicazioni GKE
• Utilizzo di Workload Identity

Un account di servizio Google Cloud IAM è un'identità che un'applicazione può utilizzare per effettuare richieste alle API di Google. Questi service account sono denominati GSA (Google Service Accounts) nel documento. Per saperne di più sui service account, consulta Service account.

Kubernetes ha anche il concetto di service account. Un account di servizio fornisce un'identità per i processi eseguiti in un pod. Gli account di servizio Kubernetes sono risorse Kubernetes, mentre gli account di servizio Google sono specifici di Google Cloud. Per informazioni sui service account Kubernetes, consulta Configurare i service account per i pod nella documentazione di Kubernetes.

Con Apigee hybrid 1.4 e versioni successive, Apigee crea e utilizza un account di servizio Kubernetes per ogni tipo di componente. L'attivazione di Workload Identity consente ai componenti ibridi di interagire con i service account Kubernetes.

Account di servizio Google in Apigee hybrid senza Workload Identity

Senza utilizzare Workload Identity, devi collegare i service account Google a ogni componente nel file overrides.yaml con un riferimento a un file di certificato o a un secret Kubernetes. Ad esempio:

• File di certificazione:

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

  Vedi:

  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

  Vedi:

  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

Variabili di ambiente utilizzate in queste procedure

Queste procedure utilizzano le seguenti variabili di ambiente. Imposta questi valori nella shell dei comandi o sostituiscili negli esempi di codice con i valori effettivi:

• APIGEECTL_HOME: la directory in cui hai installato apigeectl.
• CLUSTER_LOCATION: la regione o la zona del tuo cluster, ad esempio: us-west1.
• ENV_NAME: il nome dell'ambiente Apigee.
• NAMESPACE: lo spazio dei nomi Kubernetes che utilizzi per Apigee hybrid. Di solito apigee.
• HYBRID_FILES: la directory dei file ibridi, ad esempio hybrid-base-directory/hybrid-files.
• ORG_NAME: il nome della tua organizzazione Apigee.
• PROJECT_ID: l'ID del tuo progetto Google Cloud.

Verifica le variabili di ambiente:

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

Inizializza le variabili che ti servono:

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

Workload Identity e file delle chiavi del account di servizio

Quando esegui Apigee Hybrid su GKE, la prassi standard è creare e scaricare chiavi private (file .json) per ciascuno dei service account. Quando utilizzi Workload Identity, non devi scaricare le chiavi private del account di servizio e aggiungerle ai cluster GKE.

Se hai scaricato i file delle chiavi del account di servizio nell'ambito dell'installazione di Apigee hybrid, puoi eliminarli dopo aver abilitato Workload Identity. Nella maggior parte delle installazioni, si trovano nella directory hybrid-base-directory/hybrid-files/service-accounts/.

Abilita Workload Identity per Apigee hybrid

Per iniziare, segui le istruzioni riportate in Preparati ad attivare Workload Identity per aggiornare i pool di nodi e inizializzare le variabili prima di attivare Workload Identity.

Poi, segui una di queste sezioni, a seconda dei passaggi che stai eseguendo:

• Abilita Workload Identity per una nuova installazione. Segui queste istruzioni per una nuova installazione di Apigee hybrid o se non hai ancora installato ASM nell'installazione ibrida.
• Esegui l'upgrade di un'installazione per utilizzare Workload Identity. Segui queste istruzioni per abilitare Workload Identity nell'installazione esistente di Apigee hybrid.

Prepararsi ad attivare Workload Identity

Prima di iniziare la procedura di installazione, segui i passaggi descritti in questa sezione.

1. Imposta il progetto su quello che stai modificando:

   gcloud config set project $PROJECT_ID

2. Recupera le credenziali gcloud del cluster su cui stai attivando Workload Identity con il seguente comando:

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

   Nota:se hai creato un cluster di zona anziché un cluster regionale, recupera le credenziali con il seguente comando:

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

3. Verifica che Workload Identity sia abilitato per il cluster GKE che esegue Apigee con il seguente comando:

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

   Nota:per i cluster zonali utilizza:

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

   L'output dovrebbe includere quanto segue:

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

   Se necessario, abilita Workload Identity sul cluster. Questa operazione può richiedere fino a 30 minuti:

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

   Nota: se hai creato un cluster zonale anziché un cluster regionale, utilizza l'argomento --zone anziché --region come nel seguente comando:

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

   Per maggiori informazioni, vedi Abilitare Workload Identity.

4. Assicurati che Workload Identity sia abilitato in ogni pool di nodi.
   1. Elenca i tuoi pool di nodi con il seguente comando:

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

      L'output dovrebbe essere simile a questo:

        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. Assicurati che Workload Identity sia abilitata per ogni pool di nodi utilizzando il seguente comando per ciascun pool di nodi:

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

      dove NODE_POOL_NAME è il nome di ogni pool di nodi.

Verificare o creare service account Google

Durante l'installazione vengono creati account di servizio Google per molti componenti di Apigee hybrid. Utilizza questa procedura per verificare i service account Google e crearne di nuovi, se necessario.

1. Controlla i nomi dei service account Google per il tuo progetto con il seguente comando:

   gcloud iam service-accounts list --project $PROJECT_ID

   L'output dovrebbe essere simile a questo:

   Prod

   Per gli ambienti non di produzione:

   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
   

   Non di produzione

   Per gli ambienti non di produzione:

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

   Suggerimento:se hai nomi personalizzati per i tuoi service account che non corrispondono facilmente ai nomi dei componenti Apigee, puoi determinare il ruolo di ogni account di servizio controllando i ruoli assegnati e confrontandoli con i ruoli consigliati in Informazioni sui service account.

   Utilizza questo comando per controllare i ruoli assegnati a un account di servizio:

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

   Se devi creare i service account Google per il tuo progetto, puoi utilizzare due metodi:

   • Utilizza lo strumento create-service-account incluso in Apigee nella directory apigeectl/tools/. Questo strumento può creare tutti i service account con un unico comando o consentirti di crearli singolarmente.
     create-service-account genera i file delle chiavi per ogni service account e li scarica. Se utilizzi Workload Identity, non avrai bisogno di questi file di chiavi. Se ti preoccupa la sicurezza di questi file di chiavi, potresti volerli eliminare. In alternativa, puoi utilizzare gcloud per creare i service account e assegnare i ruoli appropriati.
   • Utilizza il comando gcloud iam service-accounts create per creare i service account uno alla volta e il comando gcloud projects add-iam-policy-binding per assegnare i ruoli appropriati a ogni account di servizio. Questo metodo richiede la creazione di ogni account di servizio singolarmente, ma ti consente di evitare di scaricare i file delle chiavi.

   create-service-account

   Utilizza il seguente comando per creare un account di servizio Google per componente:

   Prod

   Per gli ambienti non di produzione:

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

   Questo comando creerà i seguenti service account:

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

   Non di produzione

   Per gli ambienti non di produzione:

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

   Questo comando creerà un singolo service account, apigee-non-prod, con tutti i ruoli assegnati necessari per gestire tutti i componenti Apigee.

   gcloud

   Crea i seguenti service account e assegna loro i ruoli.

   Suggerimento:se vuoi utilizzare nomi personalizzati, modifica il nome dell'account di servizio rosso nell'esempio di codice con il nome che vuoi utilizzare.

   1. Service account: apigee-cassandra, ruolo: roles/storage.objectAdmin

      Crea l'account:

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

      Assegna il ruolo:

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

   2. Service account: apigee-logger, ruolo: roles/logging.logWriter

      Crea l'account:

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

      Assegna il ruolo:

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

   3. Service account: apigee-mart, ruolo: roles/apigeeconnect.Agent

      Crea l'account:

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

      Assegna il ruolo:

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

   4. Service account: apigee-metrics, ruolo: roles/monitoring.metricWriter

      Crea l'account:

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

      Assegna il ruolo:

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

   5. Service account: apigee-runtime, ruolo: nessun ruolo assegnato.

      Crea l'account:

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

   6. Service account: apigee-synchronizer, ruolo: roles/apigee.synchronizerManager

      Crea l'account:

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

      Assegna il ruolo:

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

   7. Service account: apigee-udca, ruolo: roles/apigee.analyticsAgent

      Crea l'account:

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

      Assegna il ruolo:

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

   8. Service account: apigee-watcher, ruolo: roles/apigee.runtimeAgent

      Crea l'account:

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

      Assegna il ruolo:

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

Imposta workloadIdentityEnabled: true e crea service account

apigeectl crea service account Kubernetes per ogni componente di Apigee Hybrid quando imposti workloadIdentityEnabled: true nel file di override e applichi le modifiche.

1. Aggiungi la riga in grassetto riportata di seguito al file overrides.yaml nella sezione gcp. In questo modo viene abilitata Workload Identity per l'installazione e viene attivato apigeectl per creare i service account Kubernetes quando applichi la configurazione:

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

2. Aggiungi le righe in grassetto riportate di seguito al file overrides.yaml nella sezione cassandra. Viene attivata la creazione del account di servizio Kubernetes apigee-cassandra-backup:

   cassandra:
     ...
     backup:
       enabled: true

3. Applica le modifiche con apigeectl con il flag --restore:

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

   Nota: il flag --restore attiva la creazione del service account Kubernetes apigee-cassandra-restore.
4. Verifica i service account con il seguente comando:

   kubectl get sa -n $NAMESPACE

   L'output dovrebbe essere simile al seguente. I service account Kubernetes in grassetto sono quelli che dovrai annotare con i tuoi service account 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
       

Annota i service account Kubernetes con i service account Google

Per ogni componente Apigee, annota i service account Kubernetes corrispondenti con il account di servizio Google per il componente.

Componenti a livello di organizzazione

Avrai una sola istanza di ogni account di servizio Kubernetes per la tua organizzazione Apigee.

Componente	Service account Kubernetes	Service account 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
Metriche	apigee-metrics-sa	apigee-metrics
UDCA (a livello di organizzazione)	apigee-udca-my-project-id-num-id1-sa	apigee-udca
Watcher	apigee-watcher-my-project-id-num-id1-sa	apigee-watcher

Componenti a livello di ambiente

Avrai un'istanza di ogni account di servizio Kubernetes per ogni ambiente Apigee.

Componente	Service account Kubernetes	Service account Google
Apigee Runtime	apigee-runtime-my-project-id-env-name-num-id2-sa	apigee-runtime
Synchronizer	apigee-synchronizer-my-project-id-env-name-num-id2-sa	apigee-synchronizer
UDCA (a livello di ambiente)	apigee-udca-my-project-id-env-name-num-id2-sa	apigee-udca

IMPORTANTE:se i nomi dei account di servizio non corrispondono ai nomi predefiniti creati da create-service-account, nei comandi seguenti sostituisci il nomaccount di serviziont rosso con il nome corretto deaccount di serviziont per il componente. Ad esempio, se il tuo account di servizio Cassandra si chiama my-cassandra-accnt-1, sostituisci apigee-cassandra con questo nome nel comando.

Nei seguenti comandi utilizza i nomi dei account di servizio Kubernetes restituiti dal comando kubectl get sa -n $NAMESPACE, ad esempio: apigee-cassandra-schema-val-hybrid-example-project-123abcd.

In questa procedura, per ogni account di servizio Kubernetes:

• Associa il account di servizio Kubernetes e il account di servizio Google principale al ruolo IAM roles/iam.workloadIdentityUser.
• Annota il account di servizio Kubernetes con il account di servizio Google.

1. Associa i ruoli e annota i service account.

   Componenti a livello di organizzazione

   Aggiungi annotazioni agli account di servizio Kubernetes per i componenti a livello di organizzazione. Devi farlo una volta per ogni componente della tua organizzazione Apigee.

   • Cassandra

     Il componente Cassandra ha sei service account Kubernetes associati:

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

     Prod

     apigee-cassandra-backup

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     apigee-cassandra-restore

     1. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

        Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     apigee-cassandra-backup

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-cassandra-restore"

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Ridefinisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-datastore-default-sa"

     2. Associa il ruolo 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. Annota il account di servizio:

        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. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

   • MART

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

   • Metriche Apigee

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

        KSA_NAME="apigee-metrics-sa"

     2. Associa il ruolo 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. Annota il account di servizio:

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

   • UDCA (a livello di organizzazione)

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci le variabili di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

          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. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

   Per ogni ambiente:

   • Runtime

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

   • Synchronizer

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

   • UDCA (a livello di ambiente)

     Prod

     1. Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

     Non di produzione

     1. Definisci la variabile di ambiente KSA_NAME:

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

     2. Associa il ruolo 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. Annota il account di servizio:

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

2. Verifica se i passaggi hanno funzionato:

   gcloud config set project $PROJECT_ID
   

   Seleziona un account di servizio Kubernetes da testare, ad esempio: 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

   Se non vedi un prompt dei comandi, prova a premere Invio.

   Se i passaggi sono stati eseguiti correttamente, dovresti visualizzare una risposta simile alla seguente:

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

3. Se esegui l'upgrade da un'installazione precedente, pulisci i secret che contenevano le chiavi private del account di servizio:

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

4. Controlla i log:

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

Eseguire l'upgrade di un'installazione per utilizzare Workload Identity

Segui queste istruzioni per aggiungere Workload Identity a un'installazione ibrida esistente.

Ecco un esempio che mostra i service account Google (GSA) creati per 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

Di seguito è riportato un esempio di service account Kubernetes (KSA) creato per 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

Dove: ORG_NAME e ENV_NAME potrebbero essere una versione abbreviata dei nomi dell'organizzazione e dell'ambiente.

1. Aggiungi il ruolo Workload Identity a ogni account di servizio:

   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
   

   Ad esempio, se stai impostando le autorizzazioni per Apigee Synchronizer, esegui:

   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. Annota ogni KSA con i dettagli della GSA:

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

   Ad esempio, se stai impostando le autorizzazioni per Apigee Synchronizer, esegui:

   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. Verifica se i passaggi hanno funzionato:

   gcloud config set project $PROJECT_ID
   

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

   Se non vedi un prompt dei comandi, prova a premere Invio.

   Se i passaggi sono stati eseguiti correttamente, dovresti visualizzare una risposta simile alla seguente:

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

4. Se esegui l'upgrade da un'installazione precedente, pulisci i secret che contenevano le chiavi private del account di servizio:

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

5. Controlla i log:

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