Installer l'opérateur Apigee APIM pour Kubernetes

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

Consultez la documentation d' Apigee Edge.

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

Avant de commencer

Avant de commencer à installer l'opérateur APIM, assurez-vous de disposer des rôles et autorisations requis pour effectuer les étapes, et d'avoir effectué les tâches préalables décrites dans Opérateur APIM : 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 conteneurs (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 de 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 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.

Installer et configurer l'opérateur APIM

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

1. Définissez des variables d'environnement.
2. Activez les API requises.
3. Récupérez et configurez les 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 les 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 contenant votre instance Apigee.
• CLUSTER_NAME correspond au nom de votre cluster GKE.
• REGION est 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 d'accéder 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 figurent pas 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 les 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 sont utilisés pour communiquer avec le cluster GKE créé lors des étapes préalables.

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

   gcloud iam service-accounts create apigee-apim-gsa

3. Attribuez les rôles et autorisations requis au compte de service que vous avez créé à l'aide des commandes suivantes :
   • Rôle d'administrateur Apigee : requis pour créer et gérer les 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 d'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 d'administrateur de l'équilibreur de charge : requis 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 de l'opérateur APIM helm à l'étape suivante crée un compte de service Kubernetes (KSA) requis nommé apim-ksa dans l'espace de noms apim. Une fois créé, le KSA contient l'annotation requise pour l'association à 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 le KSA au compte de service Google que vous avez créé dans Récupérer et configurer les identifiants et attribue le rôle workloadIdentityUser.

La propagation des modifications apportées à Workload Identity dans le système peut prendre quelques minutes, voire sept minutes ou plus.

Pour vérifier que l'identité de charge de travail a bien été créée, utilisez les commandes suivantes :

gcloud config set project $PROJECT_ID

kubectl run --rm -it --image google/cloud-sdk:slim \
  --namespace apim workload-identity-test \
  --overrides='{ "spec": { "serviceAccountName": "apim-ksa" } }'  \
  -- 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 -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds \
     --version 1.0.0 \
     --atomic

3. Installez l'opérateur APIM :

   helm install apigee-apim-operator -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm \
     --version 1.0.0 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=TRUE \
     --atomic

4. Vérifiez que l'installation s'est bien déroulé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-1.0.0	1.0.0
   apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-1.0.0	1.0.0   

5. Vérifiez que le KSA a été créé 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 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 sera précédé du 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/$APIGEE_ORG/environments" -H \
       "Authorization: Bearer $TOKEN" -H "content-type:application/json" \
         -d '{
           "name": "ENV_NAME",
           "displayName": "ENV_NAME",
           "state": "ACTIVE",
           "deploymentType": "PROXY",
           "apiProxyType": "PROGRAMMABLE",
           "properties": {
             "property": [
               {
                 "name": "apigee-service-extension-enabled",
                 "value": "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" : "COMPREHENSIVE",
       "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éé lors de cette étape ou par l'opérateur APIM est un environnement intermédiaire ou complet, pour permettre l'utilisation de proxys extensibles. Cette fonctionnalité ne peut pas être utilisée avec les environnements de base.

   Pour vérifier que l'environnement a bien été créé :

   curl -i -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"

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 est le nom de l'environnement que vous avez créé à l'étape précédente.

   Pour vérifier l'état de l'opération d'association d'environnement :

   curl -X GET -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/operations/OPERATION_ID"

   Où OPERATION_ID est l'ID de l'opération d'association de l'environnement.

Résoudre les problèmes

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

Étapes suivantes

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