Abilitazione di Workload Identity con apigeectl

Questo argomento spiega come abilitare Workload Identity per Apigee hybrid utilizzando apigeectl.

Se utilizzi i grafici Helm per installare e gestire Apigee hybrid, consulta Abilitazione di Workload Identity con grafici Helm.

Panoramica

Workload Identity è un modo per consentire alle applicazioni eseguite all'interno di GKE (Google Kubernetes Engine) di accedere ai servizi Google Cloud. Per una panoramica di Workload Identity, vedi:

Un account di servizio IAM di Google Cloud è un'identità che un'applicazione può utilizzare per effettuare richieste alle API di Google. Questi account di servizio sono indicati come "GSA (account di servizio Google)" nel documento. Per saperne di più sulle risorse di ricerca, consulta Account di servizio.

A parte, Kubernetes ha anche il concetto di account di servizio. 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 sugli account di servizio Kubernetes, consulta Configurare gli account di servizio 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'abilitazione di Workload Identity consente ai componenti ibridi di interagire con gli account di servizio Kubernetes.

Account di servizio Google in Apigee hybrid senza Workload Identity

Se non utilizzi Workload Identity, devi collegare gli account di servizio Google a ogni componente del file override.yaml con un riferimento a un file del certificato o a un secret di Kubernetes. Ad esempio:

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 cluster, ad esempio: us-west1.
  • ENV_NAME: assegna il nome dell'ambiente Apigee.
  • HYBRID_FILES: la tua 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.
  • NAMESPACE: lo spazio dei nomi Apigee (di solito "apigee").

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 tutte le variabili necessarie:

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

File delle chiavi di Workload Identity e dell'account di servizio

Durante l'esecuzione di Apigee hybrid su GKE, la pratica standard consiste nel creare e scaricare chiavi private (.json file) per ciascuno degli account di servizio. Quando utilizzi Workload Identity, non è necessario scaricare le chiavi private degli account di servizio e aggiungerle ai cluster GKE.

Se hai scaricato i file delle chiavi dell'account di servizio durante l'installazione di Apigee ibrida, 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 in Prepararsi per l'abilitazione di Workload Identity per aggiornare i pool di nodi e inizializzare le variabili prima di abilitare Workload Identity.

Poi, segui le istruzioni in Imposta workloadIdentityEnabled: true e crea account di servizio per abilitare Workload Identity nell'installazione di Apigee nell'installazione ibrida.

Preparati per abilitare Workload Identity

Prima di iniziare il processo 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. Utilizza il seguente comando per recuperare le credenziali gcloud del cluster su cui stai abilitando Workload Identity:
    gcloud container clusters get-credentials ${CLUSTER_NAME} \
      --region ${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

    L'output dovrebbe includere qualcosa del genere:

    …
      …
      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

    Per maggiori informazioni, consulta Abilitare Workload Identity.

  4. Assicurati che Workload Identity sia abilitato su ogni pool di nodi.
    1. Elenca i pool di nodi con il comando seguente:
      gcloud container node-pools list \
        --cluster $CLUSTER_NAME \
        --region $CLUSTER_LOCATION \
        --project $PROJECT_ID

      L'output dovrebbe essere simile al seguente:

        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 abilitato per ogni pool di nodi utilizzando il comando seguente 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 account di servizio Google

Gli account di servizio Google vengono creati per molti componenti ibridi di Apigee durante l'installazione. Utilizza questa procedura per verificare gli account di servizio Google e creare gli account necessari.

  1. Controlla i nomi degli account di servizio Google relativi al tuo progetto con il seguente comando:
    gcloud iam service-accounts list --project $PROJECT_ID

    L'output dovrebbe essere simile al seguente:

    Produzione

    Per 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 ambienti non di produzione:

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

    Se devi creare gli account di servizio Google per il tuo progetto, puoi utilizzare due metodi:

    • Utilizza lo strumento create-service-account incluso con apigee nella directory apigeectl/tools/. Questo strumento può creare tutti gli account di servizio con un singolo comando o consentirti di crearli singolarmente.
    • Utilizza il comando gcloud iam service-accounts create per creare gli account di servizio uno alla volta e il comando gcloud projects add-iam-policy-binding per assegnare i ruoli appropriati a ciascun account di servizio. Questo metodo richiede di creare 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 ogni componente:

    Produzione

    Per ambienti non di produzione:

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

    Questo comando creerà i seguenti account di servizio:

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

    Non di produzione

    Per ambienti non di produzione:

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

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

    gcloud

    Crea i seguenti account di servizio e assegna loro dei ruoli.

    1. Account di servizio: 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. Account di servizio: 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. Account di servizio: 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. Account di servizio: 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. Account di servizio: apigee-runtime, role: Nessun ruolo assegnato.

      Crea l'account:

      gcloud iam service-accounts create apigee-runtime \
        --display-name="apigee-runtime" \
        --project $PROJECT_ID
                  
    6. Account di servizio: 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. Account di servizio: 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. Account di servizio: 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 account di servizio

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

  1. Aggiungi la riga in grassetto di seguito al tuo file overrides.yaml nella stanza gcp. Questo consente a Workload Identity per la tua installazione e attiva apigeectl di creare gli account di servizio 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 di seguito al tuo file overrides.yaml nella stanza cassandra. Questa operazione attiva la creazione dell'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
  4. Verifica gli account di servizio con il comando seguente:
    kubectl get sa -n $NAMESPACE

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

Per ogni componente Apigee, annota gli account di servizio Kubernetes corrispondenti con l'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 Account di servizio Kubernetes Account di servizio 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
Guardatore apigee-watcher-my-project-id-num-id1-sa apigee-watcher

Componenti a livello di ambiente

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

Componente Account di servizio Kubernetes Account di servizio Google
Runtime Apigee apigee-runtime-my-project-id-env-name-num-id2-sa apigee-runtime
Sincronizzatore 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

Nei seguenti comandi utilizzano i nomi degli 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 l'account di servizio Kubernetes e l'account di servizio Google principale al ruolo IAM roles/iam.workloadIdentityUser.
  • Annota l'account di servizio Kubernetes con l'account di servizio Google.
  1. Associa i ruoli e annota gli account di servizio.

    Componenti a livello di organizzazione

    Annotare gli account di servizio Kubernetes per i componenti a livello di organizzazione. Dovrai eseguire questa operazione una volta per ogni componente nella tua organizzazione Apigee.

    • Cassandra

      Il componente Cassandra ha sei account di servizio 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

      Produzione

      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 l'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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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 KSA_NAMEvariabile di ambiente:

        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 l'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

      Produzione

      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 l'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 l'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

      Produzione

      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 l'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 l'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

      Produzione

      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 l'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 l'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)

      Produzione

      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 l'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 KSA_NAMEvariabili di ambiente:

        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 l'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

      Produzione

      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 l'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 l'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:

    • Tempo di esecuzione

      Produzione

      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 l'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 l'account di servizio:
        kubectl annotate serviceaccount \
          --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com
    • Sincronizzatore

      Produzione

      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 l'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 l'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)

      Produzione

      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 l'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 l'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 che i passaggi abbiano 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, dovrebbe essere visualizzata 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 chiavi private degli 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
    
  5. (Facoltativo) Puoi visualizzare lo stato dei tuoi account di servizio Kubernetes nella pagina Kubernetes: panoramica dei carichi di lavoro nella Google Cloud Console.

    Vai a Carichi di lavoro