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

Étape 5 : Configurer l'authentification du compte de service

Présentation

Cette étape explique comment configurer les méthodes d'authentification pour les comptes de service Google Cloud que vous avez créés à l'étape précédente.

Sélectionnez les instructions correspondant à la méthode d'authentification que vous souhaitez utiliser. Pour obtenir une présentation des différentes méthodes d'authentification, consultez Méthodes d'authentification des comptes de service dans Apigee hybrid.

Secrets Kubernetes

Comptes de service

Vous devrez créer des secrets Kubernetes pour les comptes de service suivants :

Production

apigee-cassandra
apigee-logger
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (si vous utilisez Monétisation pour Apigee hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca
apigee-watcher

Hors production

apigee-non-prod

Vous fournirez chacun de ces secrets lors de l'étape Créer le fichier de remplacement.

Cette procédure utilise les variables d'environnement facultatives suivantes :

$APIGEE_HELM_CHARTS_HOME
$APIGEE_NAMESPACE
$PROJECT_ID

Si vous ne les avez pas définies, remplacez la valeur appropriée pour chaque variable dans les exemples de code.

Créer des secrets Kubernetes

Créez les secrets Kubernetes pour stocker les clés du compte de service.

La commande kubectl create secret dans les exemples de code suivants a la structure suivante :

kubectl create secret generic SECRET_NAME \
  --from-file="client_secret.json=PATH_TO_SERVICE_ACCOUNT_KEY" \
  -n $APIGEE_NAMESPACE

Remarque : Les commandes suivantes supposent que vous avez téléchargé les fichiers de clé de compte de service dans le répertoire $APIGEE_HELM_CHARTS_HOME/service-accounts/ à l'étape 4 : Créer des comptes de service. Si vous avez téléchargé les clés dans un autre répertoire, modifiez les commandes pour utiliser le bon répertoire.

Production

kubectl create secret generic apigee-logger-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-logger.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-metrics.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-watcher.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-udca.json" \
  -n $APIGEE_NAMESPACE
    
kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mart.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-synchronizer.json" \
  -n $APIGEE_NAMESPACE

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-runtime.json" \
  -n $APIGEE_NAMESPACE

Si vous utilisez Monétisation pour Apigee hybrid, vous devez également créer un secret Kubernetes pour le compte de service apigee-mint-task-scheduler :

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Hors production

kubectl create secret generic apigee-non-prod-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/service-accounts/$PROJECT_ID-apigee-non-prod.json" \
  -n $APIGEE_NAMESPACE

Facultatif : Vous pouvez supprimer les fichiers JSON du compte de service après avoir créé les secrets Kubernetes.

Pour en savoir plus sur l'utilisation des secrets Kubernetes avec Apigee hybrid, consultez Stocker les clés de compte de service dans des secrets Kubernetes.

Fichiers JSON

Aucune étape supplémentaire n'est nécessaire pour configurer l'authentification avec des fichiers JSON. Passez à l'étape 6 : Créer des certificats TLS.

Vault

Configurer le stockage des codes secrets des comptes de service dans Vault

Installer le pilote CSI et le fournisseur Vault

Si vous n'avez pas encore installé le pilote CSI sur votre cluster à l'aide de Helm, suivez les instructions de la section Pilote CSI Secrets Store: installation. Pour en savoir plus, consultez la section Installer le fournisseur CSI Vault dans la documentation Vault.

Consultez Plates-formes et versions compatibles avec Apigee hybrid pour connaître les versions minimales du pilote CSI compatibles avec Apigee hybrid.

Créer des secrets, des règles et des rôles Vault

Utilisez l'UI ou les API Vault pour créer des secrets et accorder des autorisations aux comptes de service Kubernetes utilisés par Apigee hybrid pour lire ces secrets.

Créez les secrets spécifiques à l'organisation et à l'environnement au format suivant :

Clé secrète Données secrètes

Clé secrète	Données secrètes
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Remarque** : `mint` n'est requis que si vous utilisez Monetization for Apigee hybrid (v1.15.1 et versions ultérieures).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
    "cassandraBackup": "***",
    "cassandraRestore": "***",
    "connectAgent": "***",
    "logger": "***",
    "mart": "***",
    "metrics": "***",
    "mint": "***",
    "udca": "***",
    "watcher": "***"
}

Remarque : mint n'est requis que si vous utilisez Monetization for Apigee hybrid (v1.15.1 et versions ultérieures).

secret/data/apigee/envsakeys-ENV_NAME

{
    "runtime": "***",
    "synchronizer": "***",
    "udca": "***".
}

Remplacez "***" dans chaque paire par le contenu du fichier .json pour le compte de service Google correspondant au composant Apigee. apigee-cassandra-backup et apigee-cassandra-restore utilisent tous deux le compte de service apigee-cassandra. Exemple :

{
    "cassandraBackup": "{
        "type": "service_account",
        "project_id": "myhybridorg",
        "private_key_id": "PRIVATE_KEY_ID",
        "private_key": "-----BEGIN PRIVATE KEY-----\nPRIVATE_KEY_TEXT\n-----END PRIVATE KEY-----\n",
        "client_email": "apigee-cassandra@myhybridorg.iam.gserviceaccount.com",
        "client_id": "123456789012345678901",
        "auth_uri": "https://accounts.google.com/o/oauth2/auth",
        "token_uri": "https://oauth2.googleapis.com/token",
        "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
        "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/apigee-cassandra%40myhybridorg.iam.gserviceaccount.com",
        "universe_domain": "googleapis.com"
    }",
    "cassandraRestore":...
...
}

Accordez l'accès au secret de l'organisation. Créez un fichier texte nommé orgsakeys-auth-policy.txt avec le contenu suivant :
```
path "secret/data/apigee/orgsakeys" {
    capabilities = ["read"]
}
```
Dans Vault, créez une règle autorisant l'accès au secret de l'organisation:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Pour chaque environnement, créez un fichier texte nommé envsakeys-ENV_NAME-auth-policy.txt avec le contenu suivant :
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
    capabilities = ["read"]
}
```
Répétez cette étape pour chaque environnement.
Dans Vault, créez une règle accordant l'accès au secret de l'environnement:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Répétez cette étape pour chaque environnement.

Créez un script nommé generate-encoded-sas.sh avec le contenu suivant :

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
done

echo $NAMES

Remarque : Supprimez apigee-mint-task-scheduler-${ORG_ENCODE} si vous n'utilisez pas la monétisation pour Apigee hybrid.

Exécutez le script pour générer la liste des noms de comptes de service à laquelle lier la règle:

./generate-encoded-sas.sh

Vous devriez obtenir la liste des noms de comptes de service Kubernetes séparés par une virgule, comme dans l'exemple suivant:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

Copiez le texte de sortie et séparez-le en listes, une liste pour les noms de compte de service org et une liste distincte pour le nom de compte de service env pour chaque environnement. Les comptes de service de type org apparaissent en premier dans la liste de sortie jusqu'à apigee-logger-apigee-telemetry.

org de l'exemple précédent :

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

Les noms de compte de service env suivent le format apigee-synchronizer-ORG_NAME-ENV_NAME-HASH_TEXT et apigee-runtime-ORG_NAME-ENV_NAME-HASH_TEXT. Séparez-les en listes distinctes pour chaque environnement. Par exemple, la sortie de l'exemple précédent peut être séparée en deux listes :

Environnement dev :

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

Environnement prod :

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

À l'aide de la règle, créez un rôle Vault qui lie les comptes de service Apigee spécifiques à l'organisation :

vault write auth/kubernetes/role/apigee-orgsakeys \
    bound_service_account_names=LIST_OF_ORG_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-orgsakeys-auth \
    ttl=1m

Pour chaque environnement, créez un rôle Vault pour ses clés de compte de service:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
    bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
    bound_service_account_namespaces=apigee \
    policies=apigee-envsakeys-ENV_NAME-auth \ 
    ttl=1m

Répétez cette étape pour chaque environnement.

Créer des objets `SecretProviderClass`

La ressource SecretProviderClass indique au pilote CSI avec quel fournisseur il doit communiquer lorsqu'il demande des secrets. Les clés du compte de service doivent être configurées via cet objet. Le tableau suivant présente les noms de fichiers (objectNames) attendus par Apigee hybrid:

Compte de service	Noms de fichiers de secrets attendus
Sauvegarde Cassandra	`cassandraBackup`
Restauration de Cassandra	`cassandraRestore`
Connexion de l'agent	`connectAgent`
Logger	`logger`
MART	`mart`
Métriques	`metrics`
Monétisation (si vous utilisez Monétisation pour Apigee hybrid)	`mint`
Environnement d'exécution	`runtime`
Synchronisateur	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Utilisez le modèle SecretProviderClass suivant pour configurer cette ressource pour les secrets spécifiques à l'organisation :

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-orgsakeys-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-orgsakeys
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "cassandraBackup"
                secretPath: ""
                secretKey: ""
            - objectName: "cassandraRestore"
                secretPath: ""
                secretKey: ""
            - objectName: "connectAgent"
                secretPath: ""
                secretKey: ""
            - objectName: "logger"
                secretPath: ""
                secretKey: ""
            - objectName: "mart"
                secretPath: ""
                secretKey: ""
            - objectName: "metrics"
                secretPath: ""
                secretKey: ""
            - objectName: "mint"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""
            - objectName: "watcher"
                secretPath: ""
                secretKey: ""

Remarque : Supprimez les lignes objectName: "mint" si vous n'utilisez pas la monétisation pour Apigee hybrid.

VAULT_ADDRESS est le point de terminaison sur lequel votre serveur Vault est exécuté. Si Vault s'exécute dans le même cluster qu'Apigee, le format est généralement http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Enregistrez le modèle dans un fichier nommé spc-org.yaml.

Appliquez la SecretProviderClass spécifique à l'organisation à votre espace de noms apigee :
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

Pour chaque environnement, utilisez le modèle SecretProviderClass suivant pour configurer cette ressource pour les secrets spécifiques à l'environnement. Répétez cette étape pour chaque environnement:

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
    name: apigee-envsakeys-ENV_NAME-spc
spec:
    provider: vault
    parameters:
        roleName: apigee-envsakeys-ENV_NAME
        vaultAddress: VAULT_ADDRESS
        # "objectName" is an alias used within the SecretProviderClass to reference
        # that specific secret. This will also be the filename containing the secret.
        # Apigee Hybrid expects these exact values so they must not be changed.
        # "secretPath" is the path in Vault where the secret should be retrieved.
        # "secretKey" is the key within the Vault secret response to extract a value from.
        objects: |
            - objectName: "runtime"
                secretPath: ""
                secretKey: ""
            - objectName: "synchronizer"
                secretPath: ""
                secretKey: ""
            - objectName: "udca"
                secretPath: ""
                secretKey: ""

VAULT_ADDRESS est le point de terminaison sur lequel votre serveur Vault est exécuté. Si Vault s'exécute dans le même cluster et le même espace de noms qu'Apigee, le format est généralement http://vault.$APIGEE_NAMESPACE.svc.cluster.local:VAULT_SERVICE_PORT.

Enregistrez le modèle dans un fichier nommé spc-env-ENV_NAME.yaml.

Pour chaque environnement, appliquez la SecretProviderClass spécifique à l'environnement à votre espace de noms Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Répétez cette étape pour chaque environnement.
Facultatif : Vous pouvez supprimer les fichiers JSON du compte de service après avoir créé les objets SecretProviderClass.

WIF pour GKE

Préparer la configuration de la fédération d'identité de charge de travail pour GKE

Vérifiez que la fédération d'identité de charge de travail pour GKE est activée dans votre fichier de remplacement. Il doit être activé dans le fichier de remplacement dans les propriétés suivantes.
- Veuillez renseigner l'élément namespace. Exemple :
```
instanceID: "hybrid-instance-1"
namespace: "apigee"
```
- Si vous utilisez un seul compte de service (hors production) pour tous les composants, spécifiez-le avec le code suivant : gcp.workloadIdentity.gsa. Exemple :
```
  gcp:
    workloadIdentity:
      enabled: true
      gsa: "apigee-non-prod@my-hybrid-project.iam.gserviceaccount.com"
  
```
- Si vous utilisez un compte de service distinct pour chaque composant (installations de production), spécifiez le compte de service avec la propriété gsa du composant. Exemple :
```
  logger:
    gsa: "apigee-logger@my-hybrid-project.iam.gserviceaccount.com"
  
```
Consultez : gcp.workloadIdentity.enabled.
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

Vérifiez que Workload Identity Federation for GKE est activé dans votre cluster GKE. Lorsque vous avez créé le cluster à l'étape 1 : Créer un cluster, l'étape 6 consistait à activer la fédération d'identité de charge de travail pour GKE. Vérifiez qu'il est activé à l'aide de la commande suivante :

Clusters régionaux

gcloud container clusters describe $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

Cluster zonal

gcloud container clusters describe $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten 'workloadIdentityConfig'

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

  ---
  workloadPool: $PROJECT_ID.svc.id.goog

Si null s'affiche dans vos résultats, exécutez la commande suivante pour activer Workload Identity Federation pour GKE dans votre cluster :

Clusters régionaux

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

Cluster zonal

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

Activez la fédération d'identité de charge de travail pour GKE pour chaque pool de nœuds à l'aide des commandes suivantes. Cette opération peut prendre jusqu'à 30 minutes pour chaque nœud :
Clusters régionaux
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Cluster zonal
```
gcloud container node-pools update NODE_POOL_NAME \
  --cluster=$CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --workload-metadata=GKE_METADATA
```
Où NODE_POOL_NAME est le nom de chaque pool de nœuds. Dans la plupart des installations Apigee hybrid, les deux pools de nœuds par défaut sont nommés apigee-data et apigee-runtime.

Vérifiez que la fédération d'identité de charge de travail pour GKE est activée sur vos pools de nœuds à l'aide des commandes suivantes :

Clusters régionaux

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

Cluster zonal

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

gcloud container node-pools describe apigee-runtime \
  --cluster $CLUSTER_NAME \
  --zone $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:"

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

---
diskSizeGb: 100
diskType: pd-standard
...
workloadMetadataConfig:
  mode: GKE_METADATA

Conseil : Vous pouvez limiter la sortie au champ workloadMetadataConfig en redirigeant la sortie via grep avec l'indicateur -A 1 pour inclure la ligne suivante :

gcloud container node-pools describe apigee-data \
  --cluster $CLUSTER_NAME \
  --region $CLUSTER_LOCATION \
  --project $PROJECT_ID \
  --flatten "config:" | grep "workloadMetadataConfig" -A 1

WIF sur d'autres plates-formes

Si vous utilisez la fédération d'identité de charge de travail sur des plates-formes autres que GKE, vous pouvez utiliser les méthodes suivantes pour configurer l'authentification du compte de service :

Secrets Kubernetes
Fichiers JSON de compte de service
Vault

Dans les instructions suivantes, sélectionnez l'onglet correspondant à la méthode d'authentification que vous utilisez.

Cette procédure utilise les deux variables d'environnement suivantes définies à l'étape 2 : Télécharger les graphiques Helm Apigee. Ces variables sont facultatives. Si vous ne les avez pas définis, remplacez le chemin d'accès de répertoire approprié pour chaque variable dans les exemples de code.

$APIGEE_HELM_CHARTS_HOME : répertoire dans lequel vous avez téléchargé les charts Helm Apigee, définis à l'étape 2 : Télécharger les charts Helm Apigee.
$PROJECT_ID : ID de votre projet Google Cloud, défini dans la Partie 1 : Configuration du projet et de l'organisation – Étape 1 : Activer les API.

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.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Ligne de commande

Activez l'API à l'aide de 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 avec 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 l'être 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 CLUSTER_NAME -g RESOURCE_GROUP --query "oidcIssuerProfile.issuerUrl" -otsv
  Remplacez les éléments suivants :
  - CLUSTER_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 CLUSTER_NAME --query "cluster.identity.oidc.issuer" --output text
  Remplacez CLUSTER_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 libellés Kubernetes
  
  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 votre émetteur OIDC n'est pas accessible publiquement, 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 alternez 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 devez pouvoir accéder à l'URL de votre fournisseur avec 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 selon que votre émetteur OIDC est accessible publiquement ou non accessible publiquement :
  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 avec 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 faites tourner vos clés, vous devez importer le nouveau JWKS à chaque rotation des clés.
  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 À propos des comptes de service. Consultez l'étape 4 : Créer des comptes de service du guide d'installation pour savoir comment créer les comptes de service IAM.

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

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
```
Si vous utilisez Monétisation pour Apigee hybrid sur la version v1.15.1 ou ultérieure, vous devrez également créer le fichier de configuration des identifiants pour le compte de service apigee-mint-task-scheduler.
```
DISPLAY NAME                 EMAIL                                                              DISABLED
...
apigee-mint-task-scheduler   apigee-mint-task-scheduler@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 vous avez des noms personnalisés pour vos comptes de service qui 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 lui 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 quel compte de service personnalisé correspond à chaque compte de service IAM listé précédemment.

Créez un fichier de configuration des identifiants pour chaque compte de service IAM de la liste précédente.

WIF : secrets

Cette approche utilise des configurations d'identifiants stockées dans des secrets Kubernetes. Lorsque vous créez votre fichier de remplacement à l'Étape 7 : Créez les remplacements, vous fournissez le nom du secret pour chaque compte de service avec la propriété serviceAccountRef ou envs.serviceAccountRefs.

Créer les fichiers de configuration des identifiants

Production

Vous devrez créer les fichiers de configuration des identifiants pour les comptes de service suivants :

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler Si vous utilisez Monétisation pour Apigee hybrid.
apigee-runtime
apigee-synchronizer
apigee-udca

Créez un répertoire pour les fichiers de configuration des identifiants. Le répertoire peut porter n'importe quel nom. Pour cette procédure, le répertoire est nommé credential-configurations :
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Créez le fichier de configuration des identifiants pour apigee-cassandra :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Où :

PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
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

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

Créez le fichier de configuration des identifiants pour apigee-mart :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-metrics :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-runtime :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-synchronizer :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-udca :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-watcher :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Si vous utilisez la monétisation pour Apigee hybrid, vous devrez également créer le fichier de configuration des identifiants pour apigee-mint-task-scheduler :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

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

Hors production

Créez un répertoire pour le fichier de configuration des identifiants. Le répertoire peut porter n'importe quel nom. Pour cette procédure, le répertoire est nommé credential-configurations :
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Créez le fichier de configuration des identifiants pour le compte de service apigee-non-prod dans le répertoire credential-configurations à l'aide de la commande suivante :
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Où :
- PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
- 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
Important : credential-source-type doit être défini sur text.

Créer les secrets Kubernetes

Créez les secrets Kubernetes pour stocker les fichiers de configuration des identifiants de chaque compte de service.

La commande kubectl create secret dans les exemples de code suivants a la structure suivante :

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

Production

Créez le fichier secret pour apigee-cassandra :

kubectl create secret generic apigee-cassandra-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-cassandra.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-mart :

kubectl create secret generic apigee-mart-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mart.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-metrics :

kubectl create secret generic apigee-metrics-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-metrics.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-runtime :

kubectl create secret generic apigee-runtime-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-runtime.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-synchronizer :

kubectl create secret generic apigee-synchronizer-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-synchronizer.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-udca :

kubectl create secret generic apigee-udca-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-udca.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-watcher :

kubectl create secret generic apigee-watcher-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-watcher.json" \
  -n APIGEE_NAMESPACE

Si vous utilisez la monétisation pour Apigee hybrid, créez le fichier secret pour apigee-mint-task-scheduler :

kubectl create secret generic apigee-mint-task-scheduler-svc-account \
  --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-mint-task-scheduler.json" \
  -n APIGEE_NAMESPACE

Créez le fichier secret pour apigee-non-prod :

Hors production

kubectl create secret generic apigee-non-prod-svc-account \
        --from-file="client_secret.json=$APIGEE_HELM_CHARTS_HOME/credential-configurations/$PROJECT_ID-apigee-non-prod.json" \
        -n APIGEE_NAMESPACE

WIF : fichiers

Cette approche utilise les fichiers de configuration des identifiants au lieu des fichiers de clé de compte de service Google. Lorsque vous créez votre fichier de remplacement à l'Étape 7 : Créer les remplacements, vous fournissez le chemin d'accès au fichier de configuration des identifiants pour chaque propriété serviceAccountPath ou envs.serviceAccountPaths.

Production

Vous devrez créer les fichiers de configuration des identifiants dans les répertoires de graphiques correspondants :

Compte de service	Répertoire des charts Helm Apigee
`apigee-cassandra`	`apigee-datastore/`
`apigee-mart`	`apigee-org/`
`apigee-metrics`	`apigee-telemetry/`
`apigee-mint-task-scheduler` (si vous utilisez Monétisation pour Apigee hybrid)	`apigee-org/`
`apigee-runtime`	`apigee-env/`
`apigee-synchronizer`	`apigee-env/`
`apigee-udca`	`apigee-org/` `apigee-env/`
`apigee-watcher`	`apigee-org/`

Créez les fichiers de configuration des identifiants à l'aide des commandes suivantes :

apigee-cassandra :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-cassandra-credential-configuration.json

Où :

PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
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

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

apigee-mart :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mart-credential-configuration.json

apigee-metrics :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-metrics-credential-configuration.json

apigee-runtime :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-runtime-credential-configuration.json

apigee-synchronizer :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-synchronizer-credential-configuration.json

apigee-udca :

Le compte de service apigee-udca est utilisé par les graphiques apigee-org et apigee-env.

Créez le fichier de configuration des identifiants dans le répertoire du graphique apigee-org.

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json

Copiez le fichier de configuration des identifiants dans le répertoire de chart apigee-env.

cp $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-udca-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-udca-credential-configuration.json

apigee-watcher :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-watcher-credential-configuration.json

Si vous utilisez la "monétisation pour Apigee hybrid", vous devrez également créer le fichier de configuration des identifiants pour apigee-mint-task-scheduler :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-mint-task-scheduler-credential-configuration.json

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

Hors production

Vous devrez créer le fichier de configuration des identifiants et le copier dans les répertoires de chart correspondants :

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

Créez le fichier de configuration des identifiants dans le répertoire du graphique apigee-datastore à l'aide de la commande suivante :
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
--service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
--credential-source-file=/var/run/service-account/token \
--credential-source-type=text \
--output-file=$APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json
```
Où :
- PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
- 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
Important : credential-source-type doit être défini sur text.

Copiez le fichier de configuration des identifiants dans les répertoires de chart apigee-env, apigee-org/ et apigee-telemetry/.

cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-env/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-org/apigee-non-prod-credential-configuration.json
cp $APIGEE_HELM_CHARTS_HOME/apigee-datastore/apigee-non-prod-credential-configuration.json \
  $APIGEE_HELM_CHARTS_HOME/apigee-telemetry/apigee-non-prod-credential-configuration.json

WIF: Vault

Cette approche utilise des configurations d'identifiants stockées dans un gestionnaire de secrets externe, Hashicorp Vault. Lorsque vous créez votre fichier de remplacement à l'étape 7 : Créer les remplacements, vous fournissez des secrets de coffre-fort au niveau de l'organisation et de l'environnement avec les propriétés serviceAccountSecretProviderClass ou envs.serviceAccountSecretProviderClass.

Créer les fichiers de configuration des identifiants

Production

Vous devrez créer les fichiers de configuration des identifiants pour les comptes de service suivants :

apigee-cassandra
apigee-mart
apigee-metrics
apigee-mint-task-scheduler (si vous utilisez Monétisation pour Apigee hybrid)
apigee-runtime
apigee-synchronizer
apigee-udca

Créez un répertoire pour les fichiers de configuration des identifiants. Le répertoire peut porter n'importe quel nom. Pour cette procédure, le répertoire est nommé credential-configurations :
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```

Créez le fichier de configuration des identifiants pour apigee-cassandra :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-cassandra@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-cassandra-credential-configuration.json

Où :

PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
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

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

Créez le fichier de configuration des identifiants pour apigee-mart :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mart@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mart-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-metrics :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-metrics@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-metrics-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-runtime :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-runtime@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-runtime-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-synchronizer :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-synchronizer@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-synchronizer-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-udca :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-udca@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-udca-credential-configuration.json

Créez le fichier de configuration des identifiants pour apigee-watcher :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-watcher@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-watcher-credential-configuration.json

Si vous utilisez la monétisation pour Apigee hybrid, vous devrez également créer le fichier de configuration des identifiants pour apigee-mint-task-scheduler :

gcloud iam workload-identity-pools create-cred-config \
  projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-mint-task-scheduler@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-mint-task-scheduler-credential-configuration.json

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

Hors production

Créez un répertoire pour le fichier de configuration des identifiants. Le répertoire peut porter n'importe quel nom. Pour cette procédure, le répertoire est nommé credential-configurations :
```
mkdir $APIGEE_HELM_CHARTS_HOME/credential-configurations
```
Créez le fichier de configuration des identifiants pour le compte de service apigee-non-prod dans le répertoire credential-configurations à l'aide de la commande suivante :
```
gcloud iam workload-identity-pools create-cred-config \
projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/WORKLOAD_PROVIDER_ID \
  --service-account=apigee-non-prod@$PROJECT_ID.iam.gserviceaccount.com \
  --credential-source-file=/var/run/service-account/token \
  --credential-source-type=text \
  --output-file=$APIGEE_HELM_CHARTS_HOME/credential-configurations/apigee-non-prod-credential-configuration.json
```
Où :
- PROJECT_NUMBER : numéro de projet du projet contenant le pool d'identités de charge de travail Il doit s'agir du numéro de projet et non de l'ID de projet.
  Conseil : Vous pouvez trouver le numéro de projet à l'aide de la commande suivante :
```
gcloud projects describe $PROJECT_ID --format="value(projectNumber)"
```
  "
- 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
Important : credential-source-type doit être défini sur text.

Installer le pilote CSI et le fournisseur Vault

Consultez Plates-formes et versions compatibles avec Apigee hybrid pour connaître les versions minimales du pilote CSI compatibles avec Apigee hybrid.

Créer des secrets, des règles et des rôles Vault

Utilisez l'UI ou les API Vault pour créer des secrets et accorder des autorisations aux comptes de service Kubernetes utilisés par Apigee hybrid pour lire ces secrets.

Créez les secrets spécifiques à l'organisation et à l'environnement au format suivant :

Clé secrète Données secrètes

Clé secrète	Données secrètes
secret/data/apigee/orgsakeys	{ "cassandraBackup": "*", "cassandraRestore": "", "connectAgent": "", "logger": "", "mart": "", "metrics": "", "mint": "", "udca": "", "watcher": "" } Remarque** : `mint` n'est requis que si vous utilisez Monetization for Apigee hybrid (v1.15.1 et versions ultérieures).
secret/data/apigee/envsakeys-`ENV_NAME`	{ "runtime": "*", "synchronizer": "", "udca": "**". }

secret/data/apigee/orgsakeys

{
  "cassandraBackup": "***",
  "cassandraRestore": "***",
  "connectAgent": "***",
  "logger": "***",
  "mart": "***",
  "metrics": "***",
  "mint": "***",
  "udca": "***",
  "watcher": "***"
}

Remarque : mint n'est requis que si vous utilisez Monetization for Apigee hybrid (v1.15.1 et versions ultérieures).

secret/data/apigee/envsakeys-ENV_NAME

{
  "runtime": "***",
  "synchronizer": "***",
  "udca": "***".
    }

Production

Remplacez "***" dans chaque paire par le contenu du fichier de configuration des identifiants pour le compte de service Google correspondant au composant Apigee. apigee-cassandra-backup et apigee-cassandra-restore utilisent tous deux le compte de service apigee-cassandra. Exemple :

{
  "cassandraBackup": "{
    "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-cassandra@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Hors production

Remplacez "***" dans chaque paire par le contenu du fichier de configuration des identifiants pour le compte de service apigee-non-prod. apigee-cassandra-backup et apigee-cassandra-restore utilisent tous deux le compte de service apigee-cassandra. Exemple :

{
  "cassandraBackup": "{
    "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-non-prod@my-project.iam.gserviceaccount.com:generateAccessToken",
    "credential_source": {
      "file": "/var/run/service-account/token",
      "format": {
        "type": "text"
      }
    }
  }",
  "cassandraRestore":...
...
}

Accordez l'accès au secret de l'organisation. Créez un fichier texte nommé orgsakeys-auth-policy.txt avec le contenu suivant :
```
path "secret/data/apigee/orgsakeys" {
  capabilities = ["read"]
}
```
Dans Vault, créez une règle autorisant l'accès au secret de l'organisation:
```
vault policy write apigee-orgsakeys-auth orgsakeys-auth-policy.txt
```
Pour chaque environnement, créez un fichier texte nommé envsakeys-ENV_NAME-auth-policy.txt avec le contenu suivant :
```
path "secret/data/apigee/envsakeys-ENV_NAME" {
  capabilities = ["read"]
}
```
Répétez cette étape pour chaque environnement.
Dans Vault, créez une règle accordant l'accès au secret de l'environnement:
```
vault policy write apigee-envsakeys-ENV_NAME-auth envsakeys-ENV_NAME-auth-policy.txt
```
Répétez cette étape pour chaque environnement.

Créez un script nommé generate-encoded-sas.sh avec le contenu suivant :

# generate-encoded-sas.sh

ORG=$APIGEE_ORG            # Apigee organization name
ENVS=$APIGEE_ENV_LIST      # comma separated env names, for example: dev,prod

ORG_SHORT_NAME=$(echo $ORG | head -c 15)
ENCODE=$(echo -n $ORG | shasum -a 256 | head -c 7)
ORG_ENCODE=$(echo "$ORG_SHORT_NAME-$ENCODE")
NAMES=apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-${ORG_ENCODE},apigee-cassandra-schema-val-${ORG_ENCODE},apigee-cassandra-user-setup-${ORG_ENCODE},apigee-mart-${ORG_ENCODE},apigee-mint-task-scheduler-${ORG_ENCODE},apigee-connect-agent-${ORG_ENCODE},apigee-watcher-${ORG_ENCODE},apigee-udca-${ORG_ENCODE},apigee-metrics-apigee-telemetry,apigee-open-telemetry-collector-apigee-telemetry,apigee-logger-apigee-telemetry

for ENV in ${ENVS//,/ }
  do
    ENV_SHORT_NAME=$(echo $ENV | head -c 15)
    ENCODE=$(echo -n $ORG:$ENV | shasum -a 256 | head -c 7)
    ENV_ENCODE=$(echo "$ORG_SHORT_NAME-$ENV_SHORT_NAME-$ENCODE")
    NAMES+=,apigee-synchronizer-${ENV_ENCODE},apigee-runtime-${ENV_ENCODE}
  done

echo $NAMES

Remarque : Supprimez apigee-mint-task-scheduler-${ORG_ENCODE} si vous n'utilisez pas la monétisation pour Apigee hybrid.

Exécutez le script pour générer la liste des noms de comptes de service à laquelle lier la règle:

./generate-encoded-sas.sh

Vous devriez obtenir la liste des noms de comptes de service Kubernetes séparés par une virgule, comme dans l'exemple suivant:

./generate-encoded-sas.sh
apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try,apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhy
bridorg-dev-ee52aca,apigee-synchronizer-myhybridorg-prod-2d0221c,ap
igee-runtime-myhybridorg-prod-2d0221c

org de l'exemple précédent :

apigee-manager,apigee-cassandra-default,apigee-cassandra-backup-sa,
apigee-cassandra-restore-sa,apigee-cassandra-schema-setup-myhybrido
rg-5b044c1,apigee-cassandra-schema-val-myhybridorg-5b044c1,apigee-c
assandra-user-setup-myhybridorg-5b044c1,apigee-mart-myhybridorg-5b0
44c1,apigee-mint-task-scheduler-myhybridorg-5b044c1,apigee-connect-
agent-myhybridorg-5b044c1,apigee-watcher-myhybridorg-5b044c1,apigee
-udca-myhybridorg-5b044c1,apigee-metrics-apigee-telemetry,apigee-op
en-telemetry-collector-apigee-telemetry,apigee-logger-apigee-teleme
try

Environnement dev :

apigee-synchronizer-myhybridorg-dev-ee52aca,apigee-runtime-myhybrid
org-dev-ee52aca

Environnement prod :

apigee-synchronizer-myhybridorg-prod-2d0221c,apigee-runtime-myhybri
dorg-prod-2d0221c

À l'aide de la règle, créez un rôle Vault qui lie les comptes de service Apigee spécifiques à l'organisation :

vault write auth/kubernetes/role/apigee-orgsakeys \
  bound_service_account_names=LIST_OF_ORG_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-orgsakeys-auth \
  ttl=1m

Pour chaque environnement, créez un rôle Vault pour ses clés de compte de service:

vault write auth/kubernetes/role/apigee-envsakeys-ENV_NAME \
  bound_service_account_names=LIST_OF_ENV_NAME_SA_NAMES \
  bound_service_account_namespaces=apigee \
  policies=apigee-envsakeys-ENV_NAME-auth \ 
  ttl=1m

Répétez cette étape pour chaque environnement.

Créer des objets `SecretProviderClass`

Compte de service	Noms de fichiers de secrets attendus
Sauvegarde Cassandra	`cassandraBackup`
Restauration de Cassandra	`cassandraRestore`
Connexion de l'agent	`connectAgent`
MART	`mart`
Métriques	`metrics`
Monétisation (si vous utilisez Monétisation pour Apigee hybrid)	`mint`
Environnement d'exécution	`runtime`
Synchronisateur	`synchronizer`
UDCA	`udca`
Watcher	`watcher`

Utilisez le modèle SecretProviderClass suivant pour configurer cette ressource pour les secrets spécifiques à l'organisation :

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-orgsakeys-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-orgsakeys
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
      objects: |
      - objectName: "cassandraBackup"
        secretPath: ""
        secretKey: ""
      - objectName: "cassandraRestore"
        secretPath: ""
        secretKey: ""
      - objectName: "connectAgent"
        secretPath: ""
        secretKey: ""
      - objectName: "logger"
        secretPath: ""
        secretKey: ""
      - objectName: "mart"
        secretPath: ""
        secretKey: ""
      - objectName: "metrics"
        secretPath: ""
        secretKey: ""
      - objectName: "mint"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""
      - objectName: "watcher"
        secretPath: ""
        secretKey: ""

Remarque : Supprimez les lignes objectName: "mint" si vous n'utilisez pas la monétisation pour Apigee hybrid.

Enregistrez le modèle dans un fichier nommé spc-org.yaml.

Appliquez la SecretProviderClass spécifique à l'organisation à votre espace de noms apigee :
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-org.yaml
```

apiVersion: secrets-store.csi.x-k8s.io/v1
kind: SecretProviderClass
metadata:
  name: apigee-envsakeys-ENV_NAME-spc
spec:
  provider: vault
  parameters:
    roleName: apigee-envsakeys-ENV_NAME
    vaultAddress: VAULT_ADDRESS
    # "objectName" is an alias used within the SecretProviderClass to reference
    # that specific secret. This will also be the filename containing the secret.
    # Apigee Hybrid expects these exact values so they must not be changed.
    # "secretPath" is the path in Vault where the secret should be retrieved.
    # "secretKey" is the key within the Vault secret response to extract a value from.
    objects: |
      - objectName: "runtime"
        secretPath: ""
        secretKey: ""
      - objectName: "synchronizer"
        secretPath: ""
        secretKey: ""
      - objectName: "udca"
        secretPath: ""
        secretKey: ""

Enregistrez le modèle dans un fichier nommé spc-env-ENV_NAME.yaml.

Pour chaque environnement, appliquez la SecretProviderClass spécifique à l'environnement à votre espace de noms Apigee:
```
kubectl -n $APIGEE_NAMESPACE apply -f spc-env-ENV_NAME.yaml
```
Répétez cette étape pour chaque environnement.

Étape suivante

1 2 3 4 5 (SUITE) Étape 6 : Créer des certificats TLS 7 8 9 10 11

Étape 5 : Configurer l'authentification du compte de service Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Présentation

Secrets Kubernetes

Comptes de service

Production

Hors production

Créer des secrets Kubernetes

Production

Hors production

Fichiers JSON

Vault

Configurer le stockage des codes secrets des comptes de service dans Vault

Installer le pilote CSI et le fournisseur Vault

Créer des secrets, des règles et des rôles Vault

Créer des objets SecretProviderClass

WIF pour GKE

Préparer la configuration de la fédération d'identité de charge de travail pour GKE

Clusters régionaux

Cluster zonal

Clusters régionaux

Cluster zonal

Clusters régionaux

Cluster zonal

Clusters régionaux

Cluster zonal

WIF sur d'autres plates-formes

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 libellés Kubernetes

Accessible au public

Non accessible au public

Créer les fichiers de configuration des identifiants

Production

Hors production

WIF : secrets

Créer les fichiers de configuration des identifiants

Production

Hors production

Créer les secrets Kubernetes

Production

Hors production

WIF : fichiers

Production

Hors production

WIF: Vault

Créer les fichiers de configuration des identifiants

Production

Hors production

Installer le pilote CSI et le fournisseur Vault

Créer des secrets, des règles et des rôles Vault

Production

Hors production

Créer des objets SecretProviderClass

Étape suivante

Étape 5 : Configurer l'authentification du compte de service

Créer des objets `SecretProviderClass`

Créer des objets `SecretProviderClass`