Activer Workload Identity avec Apigee hybrid

Cet article explique comment activer Workload Identity pour Apigee hybrid.

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 :

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.
  • NAMESPACE : espace de noms Kubernetes que vous utilisez pour Apigee hybrid. En général, 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.

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 l'une de ces sections, en fonction des étapes que vous êtes en train d'effectuer :

Préparer l'activation de Workload Identity

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

  1. Définissez le projet sur le projet que vous modifiez :
    gcloud config set project $PROJECT_ID
  2. 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}
  3. 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

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

  4. Assurez-vous que Workload Identity est activé sur chaque pool de nœuds.
    1. 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
    2. 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

      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.

  1. 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.
    • 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.

    1. 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"
                  
    2. 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"
                  
    3. 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"
                  
    4. 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"
                  
    5. 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
                  
    6. 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"
                  
    7. 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"
                  
    8. 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.

  1. 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
  2. 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
  3. Appliquez les modifications avec apigeectl avec l'option --restore :
    $APIGEECTL_HOME/apigeectl apply -f overrides/overrides.yaml --restore
  4. 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

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 ;
  1. 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

      1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :
        GSA_NAME="apigee-cassandra"
        KSA_NAME="apigee-cassandra-backup"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-restore"
      2. 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
      3. 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

      1. 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
      2. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-datastore-default-sa"
      2. 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
      3. 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

      1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :
        GSA_NAME="apigee-non-prod"
        KSA_NAME="apigee-connect-agent-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-restore"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-setup-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-schema-val-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-cassandra-user-setup-service-account-name"
      2. 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
      3. 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

      1. Redéfinissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-datastore-default-sa"
      2. 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
      3. 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

      1. Définissez les variables d'environnement KSA_NAME et GSA_NAME :
        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-connect-agent-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-connect-agent-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-mart"
        KSA_NAME="apigee-mart-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-mart-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-metrics"
        KSA_NAME="apigee-metrics-sa"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-metrics-sa"
      2. 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
      3. 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

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

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-org-level-service-account-name"
      2. 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
      3. 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

      1. Définissez les variables d'environnement KSA_NAME :

        KSA_NAME="apigee-udca-org-level-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-watcher"
        KSA_NAME="apigee-watcher-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-watcher-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-runtime"
        KSA_NAME="apigee-runtime-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-runtime-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-synchronizer"
        KSA_NAME="apigee-synchronizer-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-synchronizer-service-account-name"
      2. 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
      3. 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

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

        GSA_NAME="apigee-udca"
        KSA_NAME="apigee-udca-env-level-service-account-name"
      2. 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
      3. 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

      1. Définissez la variable d'environnement KSA_NAME :

        KSA_NAME="apigee-udca-env-level-service-account-name"
      2. 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
      3. 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
  2. Vérifiez si les étapes ont fonctionné :
    gcloud config set project $PROJECT_ID
    

    Sélectionnez un compte de service Kubernetes à tester, par exemple : apigee-cassandra-backup.

    KSA_NAME="kubernetes-service-account-name"
    
    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
  3. 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}')
    
  4. Vérifiez les journaux :
    kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer
    

Mettre à niveau une installation pour utiliser Workload Identity

Suivez ces instructions pour ajouter Workload Identity à une installation hybride existante.

Voici un exemple illustrant les comptes de service Google (GSA) créés pour Apigee :

gcloud iam service-accounts list --filter "apigee"
DISPLAY NAME       EMAIL                                                  DISABLED
apigee-cassandra   apigee-cassandra@PROJECT_ID.iam.gserviceaccount.com    False
apigee-connect     apigee-connect@PROJECT_ID.iam.gserviceaccount.com      False
apigee-runtime     apigee-runtime@PROJECT_ID.iam.gserviceaccount.com      False
apigee-metrics     apigee-metrics@PROJECT_ID.iam.gserviceaccount.com      False
apigee-mart        apigee-mart@PROJECT_ID.iam.gserviceaccount.com         False
apigee-watcher     apigee-watcher@PROJECT_ID.iam.gserviceaccount.com      False
apigee-sync        apigee-sync@PROJECT_ID.iam.gserviceaccount.com         False
apigee-udca        apigee-udca@$PROJECT_ID.iam.gserviceaccount.com        False

Voici un exemple de comptes de service Kubernetes (KSA) créés pour Apigee :

kubectl get sa -n $NAMESPACE
apigee-cassandra-schema-setup-ORG_NAME-cb84b88-sa             1         xxd
apigee-cassandra-user-setup-ORG_NAME-cb84b88-sa               1         xxd
apigee-connect-agent-ORG_NAME-cb84b88-sa                      1         xxd
apigee-init                                                   1         xxd
apigee-mart-ORG_NAME-cb84b88-sa                               1         xxd
apigee-metrics-apigee-telemetry                               1         xxd
apigee-runtime-ORG_NAME-ENV_NAME-1d0dc5e-sa                   1         xxd
apigee-synchronizer-ORG_NAME-ENV_NAME-1d0dc5e-sa              1         xxd
apigee-udca-ORG_NAME-ENV_NAME-1d0dc5e-sa                      1         xxd
apigee-watcher-ORG_NAME-cb84b88                               1         xxd
  1. Ajoutez le rôle Workload Identity à chaque compte de service :
    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
    

    Par exemple, si vous définissez les autorisations pour le synchronisateur Apigee, vous devez exécuter :

    export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
    
    gcloud iam service-accounts add-iam-policy-binding --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apigee/$KSA_NAME]" apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
    
  2. Annotez chaque KSA avec les détails des GSA :
    kubectl annotate serviceaccount \
      --namespace $NAMESPACE \
      $KSA_NAME \
      iam.gke.io/gcp-service-account=GSA_NAME@$PROJECT_ID.iam.gserviceaccount.com
    

    Par exemple, si vous définissez les autorisations pour le synchronisateur Apigee, vous devez exécuter :

    export KSA_NAME=$(kubectl get sa -n apigee -l app=apigee-synchronizer,env=$ENV_NAME,org=$ORG_NAME --output=jsonpath={.items..metadata.name})
    
    kubectl annotate serviceaccount --namespace $NAMESPACE $KSA_NAME iam.gke.io/gcp-service-account=apigee-sync@$PROJECT_ID.iam.gserviceaccount.com
    
  3. 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
  4. 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}')
    
  5. Vérifiez les journaux :
    kubectl logs -n $NAMESPACE -l app=apigee=synchronizer,env=$ENV_NAME,org=$ORG_NAME apigee-synchronizer