Activer Workload Identity avec apigeectl

Cet article explique comment activer Workload Identity pour Apigee hybrid à l'aide de apigeectl.

Si vous utilisez des charts Helm pour installer et gérer Apigee hybrid, consultez la page Activer Workload Identity avec des charts Helm.

Présentation

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

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

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

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

Comptes de service Google dans Apigee hybrid sans Workload Identity

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

Fichiers de certification :

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

Consultez cette page :

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

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

Secret Kubernetes :

watcher:
  serviceAccountRef: my-watcher-k8s-secret

Consultez cette page :

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

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

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

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

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

Vérifiez les variables d'environnement :

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

Initialisez l'une des variables dont vous avez besoin :

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

Workload Identity et fichiers de clé de compte de service

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

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

Activer Workload Identity pour Apigee hybrid

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

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

Préparer l'activation de Workload Identity

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

Définissez le projet sur le projet que vous modifiez :
```
gcloud config set project $PROJECT_ID
```
Obtenez les identifiants gcloud du cluster sur lequel vous activez Workload Identity à l'aide de la commande suivante :
```
gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --region ${CLUSTER_LOCATION} \
  --project ${PROJECT_ID}
```
Remarque : Si vous avez créé un cluster zonal au lieu d'un cluster régional, obtenez les identifiants à l'aide de la commande suivante :
```
gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --zone ${CLUSTER_LOCATION} \
  --project ${PROJECT_ID}
```

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

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

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

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

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

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

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

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

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

Assurez-vous que Workload Identity est activé sur chaque pool de nœuds.

Listez vos pools de nœuds à l'aide de la commande suivante :

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

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

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

Assurez-vous que Workload Identity est activé par pool de nœuds, en saisissant la commande suivante pour chaque pool de nœuds :
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Où NODE_POOL_NAME est le nom de chaque pool de nœuds.

Valider ou créer des comptes de service Google

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

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

gcloud iam service-accounts list --project $PROJECT_ID

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

Prod

Pour les environnements hors production :

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

Hors production

Pour les environnements hors production :

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

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

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

`create-service-account`

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

Prod

Pour les environnements hors production :

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

Cette commande crée les comptes de service suivants :

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

Hors production

Pour les environnements hors production :

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

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

`gcloud`

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

Créez le compte :

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

Attribuez le rôle :

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

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

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

Ajoutez la ligne en gras ci-dessous à votre fichier overrides.yaml dans le bloc de script gcp : Cela active Workload Identity pour votre installation et déclenche la création, par apigeectl, des comptes de service Kubernetes lorsque vous appliquez la configuration :
```
gcp:
  projectID: "my-project-id"
  name: "my-project-id"
  region: "analytics-region"
  workloadIdentityEnabled: true
```
Ajoutez les lignes en gras ci-dessous à votre fichier overrides.yaml dans le bloc de script cassandra : Cette opération déclenche la création du compte de service Kubernetes apigee-cassandra-backup :
```
cassandra:
  ...
  backup:
    enabled: true
```
Appliquez les modifications avec apigeectl avec l'option --restore :
```
$APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --restore
```
Remarque : L'option --restore déclenche la création du compte de service Kubernetes apigee-cassandra-restore.

Vérifiez les comptes de service à l'aide de la commande suivante :

kubectl get sa -n $NAMESPACE

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

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

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

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

Composants au niveau de l'organisation

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

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

Composants au niveau de l'environnement

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

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

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

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

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

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

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

Composants au niveau de l'organisation

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

Cassandra

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

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

Prod

apigee-cassandra-backup

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

apigee-cassandra-restore

Redéfinissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-cassandra-restore"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

apigee-datastore-default-sa

Redéfinissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-datastore-default-sa"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

apigee-cassandra-backup

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

apigee-cassandra-restore

Redéfinissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-cassandra-restore"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

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

Redéfinissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

apigee-datastore-default-sa

Redéfinissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-datastore-default-sa"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Apigee Connect

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

MART

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-mart-service-account-name"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Métriques Apigee

Prod

Définissez les variables d'environnement KSA_NAME et GSA_NAME :
```
GSA_NAME="apigee-metrics"
KSA_NAME="apigee-metrics-sa"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-metrics-sa"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

UDCA (au niveau de l'organisation)

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez les variables d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Apigee Watcher

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-watcher-service-account-name"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Pour chaque environnement :

Environnement d'exécution

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :
```
KSA_NAME="apigee-runtime-service-account-name"
```

Liez le rôle IAM :

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

Annotez le compte de service :

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

Synchronisateur

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

UDCA (au niveau de l'environnement)

Prod

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

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Hors production

Définissez la variable d'environnement KSA_NAME :

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

Liez le rôle IAM :

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

Annotez le compte de service :

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

Vérifiez si les étapes ont fonctionné :

gcloud config set project $PROJECT_ID

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

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

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

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

Si vous effectuez une mise à niveau à partir d'une installation précédente, nettoyez les secrets contenant des clés privées de compte de service :
```
kubectl delete secrets -n $NAMESPACE $(k get secrets -n $NAMESPACE | grep svc-account | awk '{print $1}')
```

Vérifiez les journaux :

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

(Facultatif) Vous pouvez consulter l'état de vos comptes de service Kubernetes sur la page Kubernetes : présentation des charges de travail de la console Google Cloud.
Accéder à la page Charges de travail

Remarque : Il est possible qu'un état d'erreur s'affiche pour les comptes de service apigee-cassandra-backup et apigee-cassandra-restore. En effet, vous n'effectuez pas de sauvegarde ni de restauration, et ces processus n'ont pas encore été entièrement configurés. Pour en savoir plus sur la sauvegarde et la restauration Cassandra, consultez la page Présentation de la sauvegarde feedbackCassandra.

Activer Workload Identity avec apigeectl

Présentation

Comptes de service Google dans Apigee hybrid sans Workload Identity

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

Workload Identity et fichiers de clé de compte de service

Activer Workload Identity pour Apigee hybrid

Préparer l'activation de Workload Identity

Valider ou créer des comptes de service Google

Prod

Hors production

create-service-account

Prod

Hors production

gcloud

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

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

Composants au niveau de l'organisation

Composants au niveau de l'environnement

Composants au niveau de l'organisation

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

Prod

Hors production

`create-service-account`

`gcloud`

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