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

Installer l'opérateur Apigee pour Kubernetes

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

Consultez la documentation d' Apigee Edge.

Cette page décrit la procédure d'installation et de configuration de l'opérateur Apigee pour Kubernetes. Pour en savoir plus sur les avantages de l'utilisation de l'opérateur Apigee pour Kubernetes, consultez Présentation de l'opérateur Apigee pour Kubernetes.

Avant de commencer

Avant d'installer l'opérateur Apigee pour Kubernetes, 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 Apigee pour Kubernetes : avant de commencer.

Rôles requis

Pour obtenir les autorisations nécessaires pour installer l'opérateur Apigee pour Kubernetes, 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 Apigee pour Kubernetes

Les sections suivantes décrivent les étapes à suivre pour installer et configurer l'opérateur Apigee pour Kubernetes :

Définissez des variables d'environnement.
Activez les API requises.
Récupérez et configurez les identifiants.
Installez l'opérateur Apigee pour Kubernetes.
Créez une identité de charge de travail.
Créez un environnement Apigee.
Vérifiez la configuration de GKE Gateway.

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 Apigee pour Kubernetes 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 résultat 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 :

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 communiquent avec le cluster GKE créé lors des étapes préalables.
Configurez les identifiants du compte de service pour vous connecter aux services Google Cloud :
```
gcloud iam service-accounts create apigee-apim-gsa
```

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 des 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 Apigee pour Kubernetes à l'étape suivante crée un compte de service Kubernetes (KSA) requis nommé apim-ksa dans l'espace de noms apim.helm Lorsqu'il est créé, le KSA contient l'annotation requise pour l'association à une identité de charge de travail utilisée par l'opérateur Apigee pour Kubernetes afin d'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 Apigee pour Kubernetes

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

Créez un espace de noms pour l'opérateur Apigee pour Kubernetes :
```
kubectl create ns apim
```

Installez les CRD de l'opérateur Apigee pour Kubernetes :

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.1.0 \
  --atomic

Installez l'opérateur Apigee pour Kubernetes :

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.1.0 \
  --set projectId=$PROJECT_ID \
  --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$PROJECT_ID \
  --set generateEnv=ENV_GENERATION_MODE \
  --atomic

Remplacez ENV_GENERATION_MODE par TRUE si vous souhaitez que l'opérateur crée un environnement Apigee lorsque l'opérateur Apigee pour Kubernetes est installé. Définissez ENV_GENERATION_MODE sur FALSE si vous souhaitez créer l'environnement manuellement après l'installation de l'opérateur. Pour en savoir plus, consultez Créer un environnement Apigee.

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.1.0	1.1.0
apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-1.1.0	1.1.0

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: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com

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 Apigee pour Kubernetes pour résoudre les problèmes d'installation.

Créer un environnement Apigee

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

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

Définissez le TOKEN requis pour la commande curl :

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

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.

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"

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 Apigee pour Kubernetes, consultez Résoudre les problèmes liés à l'opérateur Apigee pour Kubernetes pour trouver des solutions aux erreurs courantes.

Étapes suivantes

Créez une extension de service de trafic à l'aide de APIMExtensionPolicy ou de ApigeeBackendService :