Installer l'opérateur Apigee APIM pour Kubernetes

Cette page s'applique à Apigee, mais pas à Apigee hybrid.

Consultez la documentation d' Apigee Edge.

Preview — Apigee APIM Operator for Kubernetes

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

Cette page décrit les étapes requises pour installer et configurer l'opérateur APIM Apigee pour Kubernetes (version Preview). Pour en savoir plus sur les avantages de l'utilisation de l'opérateur APIM, consultez la page Présentation de l'opérateur APIM Apigee pour Kubernetes.

Avant de commencer

Avant de commencer à installer l'opérateur APIM, assurez-vous de disposer des rôles et des autorisations requis pour effectuer les étapes et d'avoir effectué les tâches préalables décrites dans la section APIM Operator: Avant de commencer.

Rôles requis

Pour obtenir les autorisations nécessaires pour installer l'opérateur APIM, demandez à votre administrateur de vous accorder les rôles IAM suivants sur l'organisation:

• Créer et gérer le cluster GKE : Administrateur de conteneur (roles/container.admin)
• Créer et gérer des comptes de service : Administrateur de compte de service (roles/iam.serviceAccountAdmin)
• Créer et gérer des extensions de service : Administrateur d'extensions de service (roles/networkservices.serviceExtensionsAdmin)
• Créer et gérer des groupes de points de terminaison du réseau (NEG) : Administrateur d'instances Compute (roles/compute.instanceAdmin)
• Créer et gérer des services backend : Administrateur de l'équilibreur de charge Compute (roles/compute.loadBalancerAdmin)
• Créer et gérer des ressources Apigee : Administrateur Apigee (roles/apigee.admin)

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Installer et configurer l'opérateur APIM

Les sections suivantes décrivent les étapes requises pour installer et configurer l'opérateur APIM:

1. Définissez des variables d'environnement.
2. Activez les API requises.
3. Récupérer et configurer des identifiants
4. Installez l'opérateur APIM.
5. Créez une identité de charge de travail.
6. Créez un environnement Apigee.
7. Vérifiez que GKE Gateway est configuré.

Définir des variables d'environnement

Dans le projet Google Cloud qui contient votre instance Apigee, utilisez la commande suivante pour définir des variables d'environnement:

export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export APIGEE_ORG=APIGEE_ORG

Où :

• PROJECT_ID est l'ID du projet associé à votre instance Apigee.
• CLUSTER_NAME correspond au nom de votre cluster GKE.
• REGION correspond à la région de votre cluster GKE.
• APIGEE_ORG est défini sur la même valeur que PROJECT_ID.

Pour vérifier que les variables d'environnement sont correctement définies, exécutez la commande suivante:

echo $PROJECT_ID $CLUSTER_NAME $REGION $APIGEE_ORG

Activer les API requises

L'opérateur APIM nécessite l'accès aux API suivantes:

Nom	Titre
apigee.googleapis.com	API Apigee
compute.googleapis.com	API Compute Engine
networkservices.googleapis.com	API Network Services
container.googleapis.com	API Google Kubernetes Engine

Utilisez la commande suivante pour vérifier que les API requises sont activées:

gcloud services list --project=${PROJECT_ID}

Si les API requises ne sont pas répertoriées dans la sortie de la commande, activez-les:

gcloud services enable apigee.googleapis.com --project=${PROJECT_ID}
gcloud services enable compute.googleapis.com --project=${PROJECT_ID}
gcloud services enable networkservices.googleapis.com --project=${PROJECT_ID}
gcloud services enable container.googleapis.com --project=${PROJECT_ID}

Récupérer et configurer des identifiants

Récupérez les identifiants de votre cluster et créez un compte de service pour vous connecter aux services Google Cloud :

1. Obtenez les identifiants du cluster à l'aide de la commande suivante:

   gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION} --project=${PROJECT_ID}

   Ces identifiants permettent de communiquer avec le cluster GKE créé lors des étapes préalables.

2. Configurez des identifiants de compte de service pour vous connecter aux services Google Cloud :

   gcloud iam service-accounts create apigee-apim-gsa

3. Attribuez les rôles et les autorisations requis au compte de service que vous avez créé à l'aide des commandes suivantes :
   • Rôle Administrateur Apigee: requis pour créer et gérer des ressources Apigee.

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role "roles/apigee.admin"

   • Rôle administrateur des extensions de service: requis pour créer et gérer des extensions de service.

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role "roles/networkservices.serviceExtensionsAdmin"

   • Rôle d'administrateur réseau: requis pour gérer l'accès à Apigee à l'aide d'extensions de service.

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role "roles/compute.networkAdmin"

   • Rôle administrateur de l'équilibreur de charge: obligatoire pour gérer l'accès entre les groupes de points de terminaison du réseau (NEG) et les services de backend.

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role "roles/compute.loadBalancerAdmin"

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role "roles/iam.workloadIdentityUser"

Créer une identité de charge de travail

L'installation helm de l'opérateur APIM à l'étape suivante crée un compte de service Kubernetes (KSA) requis nommé apim-ksa dans l'espace de noms apim. Lors de sa création, le KSA contient l'annotation requise pour l'associer à une identité de charge de travail utilisée par l'opérateur APIM pour accéder aux ressources Apigee et Service Networking requises.

Pour créer l'identité de charge de travail, utilisez la commande suivante:

gcloud iam service-accounts add-iam-policy-binding apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com --role roles/iam.workloadIdentityUser --member "serviceAccount:${PROJECT_ID}.svc.id.goog[apim/apim-ksa]"

Cette commande lie la clé d'accès côté client au compte de service Google que vous avez créé dans Récupérer et configurer des identifiants et attribue le rôle workloadIdentityUser.

La propagation des modifications apportées à l'identité de la charge de travail dans le système peut prendre quelques minutes, voire sept minutes ou plus.

Pour vérifier que l'identité de charge de travail est créée, exécutez les commandes suivantes:

gcloud config set project $PROJECT_ID

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

Le résultat doit ressembler à ce qui suit :

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

Installer les définitions de ressources personnalisées (CRD) et l'opérateur APIM

Installez les définitions de ressources personnalisées (CRD) Kubernetes et l'opérateur APIM:

1. Créez un espace de noms pour l'opérateur APIM:

   kubectl create ns apim

2. Installez les définitions de ressources personnalisées (CRD) de l'opérateur APIM :

   helm install apigee-apim-crds oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds --version 0.6.0 -n apim --atomic

3. Installez l'opérateur APIM:

   helm install apigee-apim-operator oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm --version 0.6.0 --set project_id=${PROJECT_ID} --set serviceAccount=apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com --set apigeeOrg=${PROJECT_ID} --set generateEnv=TRUE --set apigeeMgmtUrl="https://apigee.googleapis.com" -n apim --atomic

4. Vérifiez que l'installation s'est bien terminée:

   helm list -n apim

   Le résultat doit ressembler à ce qui suit :

   NAME                	NAMESPACE	REVISION	UPDATED                                	STATUS  	CHART                          	APP VERSION
   apigee-apim-crds    	apim     	1       	2025-02-01 00:17:03.399810627 +0000 UTC	deployed	apigee-apim-operator-crds-0.6.0	0.6.0      
   apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-0.6.0	0.6.0   

5. Vérifiez que la KSA a été créée avec l'annotation requise:

   kubectl describe serviceaccounts apim-ksa -n apim

   Le résultat doit ressembler à ce qui suit :

   Name:                apim-ksa
   Namespace:           apim
   ...
   Annotations:         iam.gke.io/gcp-service-account: [e-mail]

6. Vérifiez que l'opérateur APIM est opérationnel dans les pods du cluster:

   kubectl get pods -n apim

   Le résultat doit ressembler à ce qui suit :

   NAME                                    READY   STATUS    RESTARTS     AGE
   apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0            8m34s
   

   Si STATUS n'est pas Running ou si READY n'affiche pas 1/1, consultez la section Résoudre les problèmes liés à l'opérateur APIM pour résoudre les problèmes d'installation.

Créer un environnement Apigee

Si vous avez installé l'opérateur APIM à l'aide de generateEnv=TRUE à l'étape précédente, l'opérateur crée un environnement Apigee lorsque la règle d'extension APIM est créée et appliquée. Le nom du nouvel environnement portera le préfixe apim-enabled-dep-env.

Si vous avez installé l'opérateur APIM avec generateEnv=FALSE, vous devez créer un environnement Apigee:

1. Définissez le TOKEN requis pour la commande curl:

   export TOKEN=$(gcloud auth print-access-token)

2. Créez l'environnement à l'aide de l'une des commandes suivantes :
   • Pour les organisations avec abonnement 2021:

     curl -X POST "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/environments" -H \
        "Authorization: Bearer $TOKEN" -H "content-type:application/json" \
         -d '{
           "name": "ENV_NAME",
           "properties": {
               "apigee-service-extension-enabled":"true"
         }
       }'

     où ENV_NAME est le nom de l'environnement à créer.

   • Pour les organisations avec abonnement 2024 et paiement à l'usage:

     curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H "Content-Type:application/json" -d '{
       "name": ENV_NAME,
       "displayName": ENV_NAME,
       "state": "ACTIVE",
       "deploymentType": "PROXY",
       "apiProxyType": "PROGRAMMABLE",
       "type" : ENV_TYPE,
       "properties": {
         "property": [
           {
             "name": "apigee-service-extension-enabled", 
             "value": "true"  
           }
         ]
       }
     }'

     Où :

     • ENV_NAME est le nom de l'environnement à créer.
     • ENV_TYPE est le type d'environnement à créer. Par exemple, INTERMEDIATE ou COMPREHENSIVE.
     Remarque: L'environnement créé à cette étape, ou créé par l'opérateur APIM, est un environnement intermédiaire ou complet, pour prendre en charge l'utilisation de proxys extensibles. Cette fonctionnalité ne peut pas être utilisée avec les environnements de base.
3. Associez l'environnement à votre instance Apigee:

   curl -i -X POST -H "Authorization: Bearer $TOKEN" \
       "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/instances/INSTANCE_NAME/attachments" \
       -H "Content-Type:application/json" -d '{"environment": "ENV_NAME"}'
   }'

   Où :

   • INSTANCE_NAME est le nom de votre instance Apigee.
   • ENV_NAME correspond au nom de l'environnement que vous avez créé à l'étape précédente.

Résoudre les problèmes

Si vous rencontrez des problèmes lors de l'installation de l'opérateur APIM, consultez la section Résoudre les problèmes liés à l'opérateur APIM pour trouver des solutions aux erreurs courantes.

Étape suivante

• Utiliser les règles Apigee avec l'opérateur APIM
• Ajoutez des règles Apigee à la passerelle GKE.