Questa pagina è stata tradotta dall'API Cloud Translation.

Attivazione di Workload Identity con apigeectl

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

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

Panoramica

Workload Identity consente alle applicazioni in esecuzione in GKE (Google Kubernetes Engine) di accedere ai servizi Google Cloud. Per panoramiche di Workload Identity, consulta:

Un account di servizio Google Cloud IAM è un'identità che un'applicazione può utilizzare per effettuare richieste API di Google. Nel documento, questi account di servizio sono indicati come GSA (Google Service Account). Per saperne di più sui gruppi di account di servizio, 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 in esecuzione 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'attivazione di Workload Identity consente ai componenti ibride 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 in il file override.yaml con un riferimento a un file di certificazione o a un secret Kubernetes. Ad esempio:

File dei certificati:

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 queste opzioni nella shell dei comandi, oppure 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: nome dell'ambiente 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.
NAMESPACE: il tuo 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 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 degli account di servizio

Quando esegui Apigee Hybrid su GKE, la prassi standard è creare e scaricare le chiavi private (file .json) 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 nell'ambito dell'installazione di Apigee hybrid, puoi eliminarli dopo aver attivato Workload Identity. Nella maggior parte delle installazioni, risiedono nel Directory hybrid-base-directory/hybrid-files/service-accounts/.

Attivare Workload Identity per Apigee hybrid

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

Poi, segui le istruzioni in Impostare workloadIdentityEnabled: true e crea account di servizio per abilitare il carico di lavoro Identità sulla tua installazione ibrida Apigee.

Preparativi per l'attivazione di Workload Identity

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

Imposta il progetto da modificare:
```
gcloud config set project $PROJECT_ID
```
Ottieni le credenziali gcloud del cluster su cui stai abilitando il carico di lavoro Identità con il comando seguente:
```
gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --region ${CLUSTER_LOCATION} \
  --project ${PROJECT_ID}
```
Nota: se hai creato un cluster di zona anziché un cluster a livello di regione, Recupera le credenziali con il comando seguente:
```
gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --zone ${CLUSTER_LOCATION} \
  --project ${PROJECT_ID}
```

Verifica che Workload Identity sia abilitato per il cluster GKE che esegue Apigee con quanto segue :

gcloud container clusters describe $CLUSTER_NAME --region $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, consulta Abilitare Workload Identity.

Assicurati che Workload Identity sia abilitato in ogni pool di nodi.

Elenca i tuoi 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

Assicurati che Workload Identity sia abilitato 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 account di servizio Google

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

Controlla i nomi degli account di servizio Google per il tuo progetto con il seguente comando:

gcloud iam service-accounts list --project $PROJECT_ID

L'output dovrebbe avere il seguente aspetto:

Produzione

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 prod

Per gli 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 possono utilizzare:

Utilizza la create-service-account strumento incluso con apigee nella directory apigeectl/tools/. Questo strumento può creare tutti gli account di servizio con un unico comando o consentirti di crearli singolarmente.
create-service-account genera i file delle chiavi per ogni account di servizio e li scarica. Se utilizzi Workload Identity, non avrai bisogno di questi file di chiavi. Se temi per la sicurezza di questi file di chiavi, ti consigliamo di eliminarli. In alternativa, puoi utilizzare gcloud per creare gli account di servizio e assegnare loro i ruoli appropriati.
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 componente:

Produzione

Per gli 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 prod

Per gli ambienti non di produzione:

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

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

`gcloud`

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

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"

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"

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"

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"

Account di servizio: apigee-runtime, ruolo: Nessun ruolo assegnato.

Crea l'account:

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

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"

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"

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 degli override e applichi il metodo modifiche.

Aggiungi la riga in grassetto sottostante al tuo file overrides.yaml sotto la gcp stanza. In questo modo, attivi Workload Identity per l'installazione e attivi apigeectl per creare gli account di servizio Kubernetes quando applichi la configurazione:
```
gcp:
  projectID: "my-project-id"
  name: "my-project-id"
  region: "analytics-region"
  workloadIdentityEnabled: true
```
Aggiungi le righe in grassetto riportate di seguito al file overrides.yaml nella stanza cassandra. Viene attivata la creazione dell'account di servizio Kubernetes apigee-cassandra-backup:
```
cassandra:
  ...
  backup:
    enabled: true
```
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 dell'account di servizio Kubernetes apigee-cassandra-restore.

Verifica gli account di servizio con il seguente comando:

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
Tempo di esecuzione Apigee	`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 degli account di servizio non corrispondono ai nomi predefiniti creati da create-service-account, nei comandi seguenti sostituisci il nome dell'account di servizio rosso con il nome corretto per il componente. Ad esempio: se il tuo account di servizio Cassandra è denominato my-cassandra-accnt-1, sostituisci apigee-cassandra con lo stesso nome nel comando.

Nei comandi seguenti, utilizza 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.

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

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

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

Ridefinisci la variabile di ambiente KSA_NAME:
```
KSA_NAME="apigee-cassandra-restore"
```

Collega 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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:

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

Collega 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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:

KSA_NAME="apigee-cassandra-schema-val-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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:

KSA_NAME="apigee-cassandra-user-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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

Aggiungi un'annotazione all'account di servizio:

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

Non prod

apigee-cassandra-backup

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-non-prod"
KSA_NAME="apigee-connect-agent-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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:
```
KSA_NAME="apigee-cassandra-restore"
```

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

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

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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:

KSA_NAME="apigee-cassandra-schema-val-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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:

KSA_NAME="apigee-cassandra-user-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

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

Ridefinisci la KSA_NAMEvariabile di ambiente:
```
KSA_NAME="apigee-datastore-default-sa"
```

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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-connect-agent-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-connect-agent-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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-mart"
KSA_NAME="apigee-mart-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-mart-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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

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

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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:
```
KSA_NAME="apigee-metrics-sa"
```

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

Aggiungi un'annotazione all'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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-org-level-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

Aggiungi un'annotazione all'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

Definisci le KSA_NAMEvariabili di ambiente:

KSA_NAME="apigee-udca-org-level-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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-watcher"
KSA_NAME="apigee-watcher-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-watcher-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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-runtime"
KSA_NAME="apigee-runtime-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-runtime-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

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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-synchronizer"
KSA_NAME="apigee-synchronizer-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-synchronizer-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

Aggiungi un'annotazione all'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

Definisci le variabili di ambiente KSA_NAME e GSA_NAME:

GSA_NAME="apigee-udca"
KSA_NAME="apigee-udca-env-level-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

Aggiungi un'annotazione all'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

Definisci la variabile di ambiente KSA_NAME:

KSA_NAME="apigee-udca-env-level-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

Aggiungi un'annotazione all'account di servizio:

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

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 vedere una risposta simile alla seguente:

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

Se esegui l'upgrade da un'installazione precedente, ripulisci i secret che contenevano le chiavi private dell'account di servizio:
```
kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
```

Controlla i log:

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

(Facoltativo) Puoi visualizzare lo stato dei tuoi account di servizio Kubernetes in Kubernetes: pagina Panoramica dei carichi di lavoro nella Google Cloud Console.
Vai a Carichi di lavoro

Nota: potresti visualizzare uno stato di errore per gli account servizio apigee-cassandra-backup e apigee-cassandra-restore. Il motivo è che al momento non stai eseguendo il backup o il ripristino e questi processi non sono stati completamente configurato. Per ulteriori informazioni sul backup e sul ripristino di Cassandra, consulta feedbackCassandra backup overview.

Attivazione di Workload Identity con apigeectl

Panoramica

Account di servizio Google in Apigee hybrid senza Workload Identity

Variabili di ambiente utilizzate in queste procedure

File delle chiavi di Workload Identity e degli account di servizio

Attivare Workload Identity per Apigee hybrid

Preparativi per l'attivazione di Workload Identity

Verificare o creare account di servizio Google

Produzione

Non prod

create-service-account

Produzione

Non prod

gcloud

Imposta workloadIdentityEnabled: true e crea account di servizio

Annota gli account di servizio Kubernetes con gli account di servizio Google

Componenti a livello di organizzazione

Componenti a livello di ambiente

Componenti a livello di organizzazione

Produzione

Non prod

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

Produzione

Non di produzione

`create-service-account`

`gcloud`

Imposta `workloadIdentityEnabled: true` e crea account di servizio