Cette page a été traduite par l'API Cloud Translation.

Activer la fédération d'identité de charge de travail sur AKS et EKS.

Cet article explique comment activer la fédération d'identité de charge de travail pour les installations Apigee hybrid sur les plates-formes AKS et EKS.

Pour les installations sur GKE, suivez les instructions de la page Activer Workload Identity sur GKE.

Présentation

La fédération d'identité de charge de travail permet aux applications exécutées en dehors de Google Cloud d'emprunter l'identité d'un compte de service Google Cloud Platform en utilisant les identifiants d'un fournisseur d'identité externe.

La fédération d'identité de charge de travail peut vous aider à améliorer la sécurité en permettant aux applications d'utiliser les mécanismes d'authentification fournis par l'environnement externe et à remplacer les clés de compte de service.

Pour en savoir plus, consultez la page Bonnes pratiques d'utilisation de la fédération d'identité de charge de travail.

Remarque : Le composant apigee-logger n'est pas compatible avec la fédération d'identité de charge de travail. Consultez la page Problèmes connus.

Configurer la fédération d'identité de charge de travail

Pour utiliser la fédération d'identité de charge de travail avec Apigee hybrid, configurez d'abord votre cluster, puis appliquez la fonctionnalité à votre installation Apigee hybrid.

Avant de commencer

Ces instructions supposent que vous avez déjà configuré votre installation Apigee hybrid. Les comptes de service IAM et les comptes de service Kubernetes sont créés lors de l'installation initiale. Consultez la section Vue d'ensemble pour obtenir une présentation de l'installation d'Apigee hybrid.

Pour les installations sur AKS, assurez-vous d'avoir activé l'émetteur OpenID Connect (OIDC). Vous devez activer cette fonctionnalité afin que la fédération d'identité de charge de travail puisse accéder aux métadonnées OpenID Connect et au jeu de clés Web JSON (JWKS) pour le cluster.

Configurez votre cluster pour qu'il utilise la fédération d'identité de charge de travail.

Vérifiez que la configuration gcloud actuelle est définie sur l'ID de votre projet Google Cloud à l'aide de la commande suivante :
```
gcloud config get project
```

Si nécessaire, définissez la configuration gcloud actuelle :

gcloud config set project PROJECT_ID

Activez l'API Security Token Service:
Vérifiez que l'API Security Token Service est activée à l'aide de la commande suivante:
```
gcloud services list --enabled --project PROJECT_ID | grep sts.googleapis.com
```
Si l'API n'est pas activée:
Console

Enable the Security Token Service API.
Enable the API
Ligne de commande

Activez l'API avec la commande suivante:
```
gcloud services enable sts.googleapis.com --project PROJECT_ID
```
Créez le pool d'identités de charge de travail et le fournisseur.
Rôles requis
Pour obtenir les autorisations nécessaires pour configurer la fédération d'identité de charge de travail, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet:
- Administrateur de pools Workload Identity (roles/iam.workloadIdentityPoolAdmin)
- Administrateur de compte de service (roles/iam.serviceAccountAdmin)
Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.
Le rôle de base IAM "Propriétaire" (roles/owner) inclut également des autorisations permettant de configurer la fédération d'identité. Les rôles de base ne doivent pas être attribués dans un environnement de production, mais ils peuvent être attribués dans un environnement de développement ou de test.
Pour créer un pool d'identités de charge de travail et un fournisseur, procédez comme suit :
1. Déterminez l'URL de l'émetteur de votre cluster AKS :
  AKS
  az aks show -n NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Remplacez les éléments suivants :
  - NAME : nom du cluster.
  - RESOURCE_GROUP: groupe de ressources du cluster.
  La commande renvoie l'URL de l'émetteur. Vous aurez besoin de l'URL de l'émetteur à l'une des étapes suivantes.
  
  Si la commande ne renvoie aucune URL d'émetteur, vérifiez que vous avez bien activé la fonctionnalité d'émetteur OIDC.
  EKS
  aws eks describe-cluster --name NAME --query "cluster.identity.oidc.issuer" --output text
  Remplacez NAME par le nom du cluster.
  
  La commande renvoie l'URL de l'émetteur. Vous aurez besoin de l'URL de l'émetteur à l'une des étapes suivantes.
  Autres Kubernetes
  1. Connectez-vous à votre cluster Kubernetes et utilisez "kubectl" pour déterminer l'URL de l'émetteur de votre cluster:
    kubectl get --raw /.well-known/openid-configuration | jq -r .issuer
    
    Vous aurez besoin de l'URL de l'émetteur à l'une des étapes suivantes.
2. Facultatif:Si l'émetteur OIDC n'est pas accessible au public, téléchargez le jeu de clés Web JSON (JWKS) du cluster :
  Remarque:Cette étape nécessite un accès kubectl à votre cluster.
  
  Conseil:Lorsque vous utilisez le fichier JWKS, vous devez importer un nouveau fichier JWKS chaque fois que vous modifiez les clés de signature du cluster.
```
kubectl get --raw /openid/v1/jwks > cluster-jwks.json
```
  Pour vérifier si votre fournisseur OIDC est accessible au public, vous devriez pouvoir accéder à son URL à l'aide d'une commande CURL et recevoir une réponse 200.
3. Créez un pool d'identités de charge de travail :
```
gcloud iam workload-identity-pools create POOL_ID \
  --location="global" \
  --description="DESCRIPTION" \
  --display-name="DISPLAY_NAME"
            
```
  Remplacez les éléments suivants :
  - POOL_ID : ID unique du pool.
  - DISPLAY_NAME: (facultatif) nom du pool.
  - DESCRIPTION: (facultatif) description du pool que vous choisissez. Cette description apparaît lorsque vous accordez l'accès aux identités du pool.
  Exemple :
```
gcloud iam workload-identity-pools create my-wi-pool --display-name="My workload pool" --description="My workload pool description"
```
4. Ajoutez le cluster en tant que fournisseur de pools d'identités de charge de travail. Choisissez la commande permettant de créer le fournisseur en fonction de l'accessibilité de votre émetteur OIDC : public ou non public :
  Accessible au public
  
  Si votre émetteur OIDC est accessible publiquement, créez le fournisseur à l'aide de la commande suivante:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --attribute-mapping="google.subject=assertion.sub"
  Non accessible au public
  
  Si votre émetteur OIDC n'est pas accessible publiquement, créez le fournisseur à l'aide de la commande suivante:
  gcloud iam workload-identity-pools providers create-oidc WORKLOAD_PROVIDER_ID \ --location="global" \ --workload-identity-pool="POOL_ID" \ --issuer-uri="ISSUER" \ --jwks-file="cluster-jwks.json" \ --attribute-mapping="google.subject=assertion.sub"
  Remarque Si vous effectuez une rotation de vos clés, vous devez importer le nouveau JWKS à chaque rotation de clé.
  La commande ne valide pas le JWKS du cluster. Si le JWKS est incorrect ou a expiré, les tentatives d'authentification suivantes peuvent échouer avec le message d'erreur Error connecting to the given credential's issuer.
  Remplacez les éléments suivants :
  - WORKLOAD_PROVIDER_ID: ID unique de fournisseur de pools d'identités de charge de travail de votre choix.
  - POOL_ID: ID du pool d'identités de charge de travail que vous avez créé précédemment.
  - ISSUER: Utilisez l'URL de l'émetteur que vous avez déterminée précédemment pour l'URI de l'émetteur .
  attribute-mapping="google.subject=assertion.sub" mappe le sujet Kubernetes au sujet IAM.

Créer les fichiers de configuration des identifiants

Pour déployer une charge de travail Kubernetes pouvant accéder aux ressources Google Cloud , vous devez d'abord créer un fichier de configuration des identifiants pour chaque compte de service IAM:

Listez les comptes de service IAM (également appelés "comptes de service Google") à l'aide de la commande suivante:
```
gcloud iam service-accounts list --project PROJECT_ID
```
Remarque:Vous avez probablement déjà créé les comptes de service IAM (également appelés "comptes de service Google") lors de l'installation initiale d'Apigee hybrid avec l'outil create-service-account. Pour obtenir la liste des comptes de service IAM requis par Apigee hybrid, consultez la section À propos des comptes de service. Consultez la section Étape 4: Créer des comptes de service du guide d'installation pour connaître la procédure de création des comptes de service IAM.

Vous devez créer les fichiers de configuration des identifiants pour les comptes de service IAM suivants:
Prod

Pour les environnements de production:
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-cassandra     apigee-cassandra@my_project_id.iam.gserviceaccount.com     False
apigee-mart          apigee-mart@my_project_id.iam.gserviceaccount.com          False
apigee-metrics       apigee-metrics@my_project_id.iam.gserviceaccount.com       False
apigee-runtime       apigee-runtime@my_project_id.iam.gserviceaccount.com       False
apigee-synchronizer  apigee-synchronizer@my_project_id.iam.gserviceaccount.com  False
apigee-udca          apigee-udca@my_project_id.iam.gserviceaccount.com          False
apigee-watcher       apigee-watcher@my_project_id.iam.gserviceaccount.com       False
```
Hors production

Pour les environnements hors production :
```
DISPLAY NAME         EMAIL                                                      DISABLED
apigee-non-prod      apigee-non-prod@my_project_id.iam.gserviceaccount.com      False
```
Conseil : Si les noms personnalisés de vos comptes de service ne correspondent pas facilement aux noms des composants Apigee, vous pouvez déterminer le rôle de chaque compte de service en vérifiant les rôles qui leur sont attribués et en les comparant aux rôles recommandés dans À propos des comptes de service.
Exécutez la commande suivante pour vérifier les rôles attribués à un compte de service :
```
gcloud projects get-iam-policy PROJECT_ID  \
  --flatten="bindings[].members" \
  --format='table(bindings.role)' \
  --filter="SERVICE_ACCOUNT_NAME"
```
Notez le compte de service personnalisé correspondant à chaque compte de service IAM listé dans la liste précédente.

Créez un fichier de configuration des identifiants pour chaque compte de service IAM de la liste précédente. Vous aurez besoin de ces fichiers de configuration des identifiants pour configurer Apigee hybrid pour qu'il utilise la fédération d'identité de charge de travail :

Code

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=SERVICE_ACCOUNT_EMAIL \
  --credential-source-file=/var/
  --credential-source-type=text \
  --output-file=SERVICE_ACCOUNT_NAME-credential-configuration.json

Exemple

gcloud iam workload-identity-pools create-cred-config \
  projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider \
  --service-account=apigee-cassandra@myhybridporg.iam.gserviceaccount.com \
  --credential-source-file=/var/
  --credential-source-type=text \
  --output-file=apigee-cassandra-credential-configuration.json

Où :

PROJECT_NUMBER: numéro du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro du projet, et non de l'ID.
POOL_ID : ID du pool d'identités de charge de travail
WORKLOAD_PROVIDER_ID : ID du fournisseur du pool d'identités de charge de travail
SERVICE_ACCOUNT_EMAIL: adresse e-mail du compte de service, si vous avez configuré votre compte de service Kubernetes pour utiliser l'emprunt d'identité de compte de service IAM.

Important:credential-source-type doit être défini sur text.

Remarque:Ne créez pas de fichier de configuration des identifiants pour le compte de service apigee-logger.

Le fichier de configuration des identifiants permet aux [bibliothèques clientes Cloud](/apis/docs/cloud-client-libraries), à la CLI gcloud et à Terraform de déterminer les éléments suivants:

Où obtenir des identifiants externes
Quel pool d'identités de charge de travail et quel fournisseur utiliser
À quel compte de service emprunter l'identité

Configurer Apigee hybrid pour utiliser la fédération d'identité de charge de travail

Copiez ou déplacez chaque fichier de sortie (SERVICE_ACCOUNT_NAME-credential-configuration.json) dans les répertoires de chart (ou leurs sous-répertoires) suivants. Il s'agit des fichiers que vous avez créés à l'étape Créer les fichiers de configuration des identifiants.

Prod

Compte de service	Répertoire des graphiques Helm Apigee
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Hors production

Compte de service	Graphique Helm Apigee
`apigee-non-prod`	`apigee-datastore/` `apigee-telemetry/` `apigee-org/` `apigee-env/`

Apportez les modifications globales suivantes au fichier de remplacement de votre cluster :

Code

gcp:
  workloadIdentity:
    enabled: false # must be set to false to use Workload Identity Federation
  federatedWorkloadIdentity:
    enabled: true
    audience: "AUDIENCE"
    credentialSourceFile: "/var/run/service-account/token"

Exemple

gcp:
  workloadIdentity:
    enabled: false
  federatedWorkloadIdentity:
    enabled: true
    audience: "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider"
    credentialSourceFile: "/var/run/service-account/token"

Où: AUDIENCE est l'audience autorisée du fournisseur d'identité de charge de travail. Pour trouver la valeur, recherchez le terme audience: dans l'un des fichiers de configuration des identifiants. La valeur de l'audience est identique dans chaque fichier de configuration des identifiants.

Par exemple, dans l'exemple de fichier apigee-udca-credential-configuration.json suivant:

{
  "universe_domain": "googleapis.com",
  "type": "external_account:,"
  "audience": "//iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider",
  "subject_token_type": "urn:ietf:params:oauth: token-type:jwt",
  "token_url": "https://sts.googleapis.com/v1/token",
  "service
  "impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/apigee-udca@myhybridproject.iam.gserviceaccount.com:generateAccessToken",
  "credential_source": {
    "file": "/var/run/service-account/token",
    "format": {
      "type": "text"
    }
  }
}

La valeur de l'audience est //iam.googleapis.com/projects/123123123123/locations/global/workloadIdentityPools/my-wi-pool/providers/my-wi-provider.

Configurez les remplacements pour chaque composant à l'aide de la fédération d'identité de charge de travail. Sélectionnez les instructions correspondant aux fichiers de certificat, aux secrets Kubernetes ou à Vault en fonction de votre installation.

Fichier de certification

Remplacez la valeur de serviceAccountPath par le fichier source des identifiants du compte de service IAM correspondant. Il doit s'agir du chemin d'accès relatif au répertoire de chart. Exemple :

envs:
- name: ENVIRONMENT_NAME
  serviceAccountPaths:
    synchronizer: apigee-synchronizer-credential-configuration.json
    runtime: apigee-runtime-credential-configuration.json
    udca: udca-credential-configuration.json

mart:
  serviceAccountPath: mart-credential-configuration.json

connectAgent:
  serviceAccountPath: mart-credential-configuration.json

metrics:
  serviceAccountPath: metrics-credential-configuration.json

udca:
  serviceAccountPath: UDCA_SERVICE_ACCOUNT_FILEPATH

watcher:
  serviceAccountPath: WATCHER_SERVICE_ACCOUNT_FILEPATH

Secret K8s

Créez un secret Kubernetes à l'aide du fichier source des identifiants pour chaque fichier de configuration des identifiants.

kubectl create secret -n APIGEE_NAMESPACE generic SECRET_NAME --from-file="client_secret.json=CREDENTIAL_CONFIGURATION_FILE"

Exemple :

kubectl create secret -n apigee generic udca-workoad-identity-secret --from-file="client_secret.json=./apigee-udca-credential-configuration.json"

Remplacez la valeur de serviceAccountRef par le nouveau secret. Exemple :
```
udca:
  serviceAccountRef: udca-workoad-identity-secret
```

Vault

Mettez à jour la clé de compte de service SAKEY pour chaque compte de service dans Vault avec le fichier de source des identifiants correspondant. La procédure est similaire pour tous les composants. Par exemple, pour UDCA:

SAKEY=$(cat .apigee-udca-credential-configuration.json); kubectl -n APIGEE_NAMESPACE exec vault-0 -- vault kv patch secret/apigee/orgsakeys udca="$SAKEY"

Pour en savoir plus, consultez la page Storing service account keys in Hashicorp Vault.

Appliquez les modifications à chaque composant concerné à l'aide de la commande helm upgrade :

Si vous avez mis à jour les clés de compte de service Vault, mettez à jour le graphique apigee-operator.

helm upgrade operator apigee-operator/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

Mettez à jour les autres charts concernés dans l'ordre suivant :

helm upgrade datastore apigee-datastore/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

helm upgrade telemetry apigee-telemetry/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

helm upgrade $ORG_NAME apigee-org/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  -f overrides.yaml

Mettez à jour le chart apigee-env pour chaque environnement, en remplaçant $ENV_RELEASE_NAME et ENV_NAME à chaque fois:

helm upgrade $ENV_RELEASE_NAME apigee-env/ \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml

Consultez la documentation de référence de Helm sur Apigee hybrid pour obtenir la liste des composants et des charts correspondants.

Accorder l'accès aux comptes de service Kubernetes

Listez les comptes de service Kubernetes à l'aide de la commande suivante:
```
kubectl get sa -n APIGEE_NAMESPACE
```
Remarque:Les graphiques Apigee hybrid ont créé les comptes de service Kubernetes nécessaires pour chaque composant lorsque vous avez exécuté les commandes helm upgrade.

Important:Vous n'utiliserez pas tous les comptes de service Kubernetes listés par cette commande.

Accordez aux comptes de service Kubernetes l'accès nécessaire pour usurper l'identité des comptes de service IAM associés, comme indiqué dans le tableau suivant. Le tableau présente les noms des comptes de service IAM Apigee par défaut. Si vous utilisez des noms de comptes de service personnalisés, utilisez les comptes de service IAM correspondants:

Comptes de service Kubernetes	Compte de service IAM
Comptes de service Kubernetes au niveau de l'organisation
`apigee-connect-agent-ORG_NAME-ORG_HASH_ID`	`apigee-mart`
`apigee-mart-ORG_NAME-ORG_HASH_ID`	`apigee-mart`
`apigee-metrics-apigee-telemetry`	`apigee-metrics`
`apigee-open-telemetry-collector-apigee-telemetry`	`apigee-metrics`
`apigee-udca-ORG_NAME-ORG_HASH_ID`	`apigee-udca`
`apigee-watcher-ORG_NAME-ORG_HASH_ID`	`apigee-watcher`
Comptes de service Kubernetes au niveau de l'environnement
`apigee-runtime-ORG_NAME-ENV_NAME-ENV_HASH_ID`	`apigee-runtime`
`apigee-synchronizer-ORG_NAME-ENV_NAME-ENV_HASH_ID`	`apigee-synchronizer`
Sauvegarde et restauration de bases de données Cassandra (si activées)
`apigee-cassandra-backup-sa`	`apigee-cassandra`
`apigee-cassandra-restore-sa`	`apigee-cassandra`

Où :

ORG_NAME: 15 premiers caractères du nom de votre organisation.
ORG_HASH_ID: ID de hachage unique du nom complet de votre organisation.
ENV_NAME: 15 premiers caractères du nom de votre environnement.
ENV_HASH_ID: ID de hachage unique des noms de votre organisation et de votre environnement.

Exemple :

apigee-connect-agent-myhybridorg-123abcd
apigee-runtime-myhybridorg-prodenv-234bcde

Accordez à chaque compte de service Kubernetes l'accès nécessaire pour emprunter l'identité du compte de service IAM approprié à l'aide de la commande suivante:

gcloud iam service-accounts add-iam-policy-binding \
  IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/subject/MAPPED_SUBJECT" \
    --role=roles/iam.workloadIdentityUser

Où :

IAM_SA_NAME : nom du compte de service.
PROJECT_ID: ID du projet associé à l'organisation Apigee.
PROJECT_NUMBER: numéro de projet du projet dans lequel vous avez créé le pool d'identités de charge de travail.
POOL_ID : ID du pool d'identités de charge de travail.
MAPPED_SUBJECT: compte de service Kubernetes à partir de la revendication de votre jeton d'identification que vous avez mappée sur google.subject. Par exemple, si vous avez mappé google.subject=assertions.sub et que votre jeton d'ID contient "sub": "system:serviceaccount:default:my-kubernetes-serviceaccount", alors MAPPED_SUBJECT est system:serviceaccount:default:my-kubernetes-serviceaccount.

Pour en savoir plus sur la fédération d'identité de charge de travail et les bonnes pratiques, consultez la page Bonnes pratiques d'utilisation de la fédération d'identité de charge de travail.

Activer la fédération d'identité de charge de travail sur AKS et EKS.

Présentation

Configurer la fédération d'identité de charge de travail

Avant de commencer

Configurez votre cluster pour qu'il utilise la fédération d'identité de charge de travail.

Console

Ligne de commande

Rôles requis

AKS

EKS

Autres Kubernetes

Accessible au public

Non accessible au public

Créer les fichiers de configuration des identifiants

Prod

Hors production

Code

Exemple

Configurer Apigee hybrid pour utiliser la fédération d'identité de charge de travail

Prod

Hors production

Code

Exemple

Fichier de certification

Secret K8s

Vault

Accorder l'accès aux comptes de service Kubernetes