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

Installer l'opérateur Apigee pour Kubernetes pour Apigee hybrid

Cette page s'applique à Apigee et à Apigee hybrid.

Consultez la documentation d'Apigee Edge.

Cette page décrit les étapes requises pour installer et configurer l'opérateur Apigee pour Kubernetes pour Apigee hybrid. 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.

Si vous n'utilisez pas Apigee hybrid, consultez Installer l'opérateur Apigee pour Kubernetes afin d'installer l'opérateur Apigee pour Kubernetes pour Apigee.

Avant de commencer

Avant de commencer, vérifiez que vous disposez des éléments suivants :

Rôles requis

Pour obtenir les autorisations nécessaires pour configurer les ressources requises pour installer et utiliser 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 des comptes de service : Administrateur de compte de service (roles/iam.serviceAccountAdmin)
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 grâce aux rôles personnalisés ou à d'autres rôles prédéfinis.

Tâches de configuration requises

Avant d'installer l'opérateur Apigee pour Kubernetes, assurez-vous d'effectuer les tâches suivantes pour configurer les ressources dont vous avez besoin pour utiliser la fonctionnalité :

Installez Apigee hybrid à l'aide de la version 1.15.0 ou ultérieure. Pour savoir comment installer Apigee hybrid, consultez Vue d'ensemble.
Créez un cluster Kubernetes chez un fournisseur de services cloud compatible avec Istio Gateway, tel que Google Cloud, Azure ou Amazon.
Remarque : Les instructions de ces procédures sont conçues pour fonctionner avec les installations sur n'importe quel fournisseur compatible avec Istio Gateway. Les étapes utilisant gcloud concernent la communication avec le projet Google Cloud qui contient votre instance Apigee hybrid.

Installez la passerelle Istio dans votre cluster K8s :

Pour les clusters sur GKE :

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal --set values.global.platform=gke -y

Pour les clusters sur d'autres fournisseurs :

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal -y

Déployez Istio Gateway dans votre cluster Kubernetes.
1. Créez un fichier nommé gateway.yaml avec le contenu suivant pour déployer Istio Gateway :
```
#gateway.yaml
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: istio-gateway
  namespace: default
  annotations:
    service.beta.kubernetes.io/port_80_health-probe_protocol: tcp
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.httpbin.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
```
  Remarque : L'annotation dans les métadonnées n'est nécessaire que pour les clusters sur AKS en raison du problème ouvert Istio 46769. Vous pouvez omettre les métadonnées pour les autres clusters Kubernetes.
2. Appliquez le fichier à votre cluster à l'aide de la commande suivante :
```
kubectl apply -f gateway.yaml
```

Vérifier la configuration d'Istio Gateway (facultatif)

Pour les besoins de ce guide, nous vous recommandons de déployer un exemple d'application httpbin dans l'espace de noms par défaut afin de tester la passerelle que vous avez déployée.

Déployez une application de backend sur votre cluster Kubernetes pour tester la passerelle.
1. Créez un fichier nommé target.yaml et collez-y le contenu suivant :
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 8080
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: docker.io/mccutchen/go-httpbin:v2.15.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 8080
EOF
```
  Conseil : Vous pouvez également enregistrer les lignes entre les balises <<EOF et EOF dans un fichier nommé target.yaml. Appliquez ensuite la configuration à votre cluster à l'aide de la commande suivante :
```
kubectl apply -f target.yaml
```
2. Déployez la ressource HTTPRoute sur votre cluster pour mapper le trafic de la passerelle à votre service de backend.
  Pour les besoins de ce guide, nous vous recommandons de déployer une passerelle et une ressource HTTPRoute externes en suivant les étapes décrites dans Créer une ressource HTTPRoute.
  
  Pour en savoir plus sur la ressource HTTPRoute, consultez Déployer HTTPRoute (pour les passerelles internes) ou Créer une ressource HTTPRoute (pour les passerelles externes).
  1. Créez une ressource HTTPRoute en suivant les instructions de la section Créer la ressource HTTPRoute à l'aide de la configuration YAML suivante :
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-bin-route
  namespace: default
spec:
  parentRefs:
  - name: istio-gateway
    namespace: default
  hostnames: ["example.httpbin.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
```
  2. Appliquez le fichier à votre cluster :
```
kubectl apply -f httproute.yaml
```
3. Vérifiez la configuration de GKE Gateway pour vous assurer qu'elle fonctionne comme prévu.
  Remarque : La propagation des modifications appliquées peut prendre jusqu'à cinq minutes. Si vous n'obtenez pas le résultat attendu pour les étapes de cette section, patientez quelques minutes et réessayez.
  1. Obtenez les détails de la passerelle à l'aide de la commande suivante :
```
kubectl get gateway global-ext-lb1
```
    Le résultat doit se présenter comme suit :
```
NAME            CLASS   ADDRESS        PROGRAMMED   AGE
istio-gateway   istio   34.54.193.72   True         11d
```
    Vérifiez qu'une adresse IP est attribuée à la passerelle et que la valeur de PROGRAMMED est True.
  2. Décrivez la passerelle pour confirmer que la route est associée :
```
kubectl describe gateway istio-gateway
```
    Le résultat doit ressembler à ce qui suit :
```
...
  Listeners:
    Attached Routes: 1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
    Vérifiez que la valeur de "Routes associées" est définie sur 1, ce qui indique que la route est associée.
  3. Envoyer une requête à la passerelle
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Où GATEWAY_IP_ADDRESS est l'adresse IP de la passerelle. Vous pouvez récupérer l'adresse IP de la passerelle à l'aide de la commande suivante, où GATEWAY_NAME correspond au nom de la passerelle :
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses.value}"
```
    Exemple :
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    La réponse devrait ressembler à ceci :
```
{
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "http://example.httpbin.com",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://example.httpbin.com/get"
}
```
Installer l'opérateur Apigee pour Kubernetes

Cette procédure décrit les étapes nécessaires pour installer et configurer l'opérateur Apigee pour Kubernetes.
Installer et configurer l'opérateur Apigee pour Kubernetes

Les sections suivantes décrivent les étapes nécessaires à l'installation et à la configuration de l'opérateur Apigee pour Kubernetes :
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 APIGEE_ORG=APIGEE_ORG
```
Où :
- PROJECT_ID est l'ID du projet contenant votre instance Apigee Hybrid.
- APIGEE_ORG est le nom de l'organisation de votre instance Apigee Hybrid.
Vérifiez que les variables d'environnement sont correctement définies à l'aide de la commande suivante :
```
echo $PROJECT_ID $APIGEE_ORG
```
Créer et configurer le compte de service APIM

Créez un compte de service pour vous connecter au plan de configuration Apigee Hybrid.
1. Créez le compte de service apigee-apim-gsa pour vous connecter aux services Google Cloud
2. Attribuez le rôle Administrateur Apigee au compte de service que vous avez créé à l'aide de la commande suivante. Ce rôle est 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"
```
3. Téléchargez le fichier de clé JSON correspondant au compte de service.
  1. Créez et téléchargez le fichier de clé $PROJECT_ID-apigee-apim-gsa.json à l'aide de la commande suivante :
```
gcloud iam service-accounts keys create $PROJECT_ID-apigee-apim-gsa.json \
  --iam-account=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  --project=$PROJECT_ID
        
```
  2. Vérifiez que le fichier a été correctement téléchargé :
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Installer l'opérateur Apigee pour Kubernetes

Installez les définitions de ressources personnalisées (CRD) Kubernetes et l'opérateur Apigee pour Kubernetes :
1. Créer un espace de noms pour l'opérateur Apigee pour Kubernetes
```
kubectl create namespace apim
```
2. Installez les définitions de ressources personnalisées (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
```
3. 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 serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$APIGEE_ORG \
  --set apigeeEnv=ENV_NAME \
  --set-file serviceAccountKeyFileContent=$PROJECT_ID-apigee-apim-gsa-key.json \
  --atomic
```
  Où ENV_NAME correspond au nom de l'environnement Apigee hybrid dans lequel vous souhaitez installer l'opérateur Apigee pour Kubernetes.
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-09-01 00:17:03.399810627 +0000 UTC  deployed  apigee-apim-operator-crds-1.1.0  1.1.0
apigee-apim-operator  apim  1  2025-09-01 00:15:00.362829981 +0000 UTC  deployed  apigee-apim-operator-helm-1.1.0  1.1.0
```
5. Vérifiez que le compte de service Kubernetes (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
```
6. Vérifiez que l'opérateur Apigee pour Kubernetes 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 l'état n'est pas "Running" (En cours d'exécution) ou si "READY" (PRÊT) n'affiche pas "1/1", consultez la section "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 hybride Apigee

Pour utiliser l'opérateur Apigee pour Kubernetes dans Apigee hybrid, vous devez créer un environnement avec un indicateur spécial pour l'extension de service.
1. Obtenez un jeton pour vous authentifier auprès de l'API Apigee.
  Sur la ligne de commande, obtenez vos identifiants d'authentification gcloud, comme le montre l'exemple suivant :
```
TOKEN=$(gcloud auth print-access-token)
```
  Pour vérifier que votre jeton a été renseigné, utilisez echo, comme le montre l'exemple suivant :
```
echo $TOKEN
```
  Votre jeton doit s'afficher sous forme de chaîne encodée.
  
  Pour en savoir plus, consultez la section présentation de l'outil de ligne de commande gcloud.
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_DISPLAY_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 que vous souhaitez 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 que vous souhaitez créer.
    - ENV_TYPE correspond au type d'environnement que vous souhaitez créer. Par exemple, INTERMEDIATE ou COMPREHENSIVE.
  Vérifiez que l'environnement a bien été créé :
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Pour en savoir plus, consultez Créer un environnement dans les instructions d'installation d'Apigee hybrid.
3. Créez un groupe d'environnements à l'aide de la commande suivante :
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups" -H "Content-Type:application/json" -d '{
     "name": "'"$ENV_GROUP"'",
     "hostnames":["'"$DOMAIN"'"]
   }'
```
  Où :
  - ENV_GROUP (Obligatoire) Le nom de l'environnement peut contenir des lettres minuscules, des tirets et des chiffres. Il doit commencer par une lettre minuscule. Ce nom servira d'identifiant et ne sera pas modifiable après sa création.
  - DOMAIN (Obligatoire) Il s'agit du nom d'hôte utilisé par tous les proxys déployés dans les environnements de ce groupe. Il doit s'agir d'un domaine que vous gérez. L'adresse peut être le domaine lui-même, comme example.com, ou elle peut inclure un sous-domaine tel que my-proxies.example.com. Si vous ne possédez pas de domaine géré, vous pouvez saisir un espace réservé pour le moment. Vous pouvez modifier l'adresse du domaine ultérieurement.
  Pour en savoir plus, consultez Créer un groupe d'environnements dans les instructions d'installation d'Apigee hybrid.
4. Associez l'environnement au groupe d'environnements que vous venez de créer à l'aide de la commande suivante :
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups/$ENV_GROUP/attachments" -H "Content-Type:application/json" -d '{
     "environment": "'"$ENV_NAME"'",
   }'
```
Installer l'environnement Apigee hybrid à l'aide de Helm

La procédure d'installation du nouvel environnement dans le cluster Apigee hybrid est semblable à celle que vous avez utilisée pour installer d'autres environnements dans votre cluster. Cela est nécessaire pour ajouter des informations sur les nouveaux environnements et groupes d'environnements à notre cluster Kubernetes dans lequel Apigee Hybrid a été installé.
1. Générez le certificat TLS pour le domaine du groupe d'environnements à l'aide de la commande suivante :
```
openssl req -nodes -new -x509 -keyout $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.key -out $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem -subj "/CN=$DOMAIN" -addext "subjectAltName = DNS:$DOMAIN" -days 3650
```
  Où :
  - APIGEE_HELM_CHARTS_HOME (obligatoire) : répertoire dans lequel vous avez téléchargé les charts Helm Apigee lors de l'installation d'Apigee hybrid.
2. Encodez le certificat public TLS au format Base64 à l'aide de la commande suivante :
```
cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem | base64 -w0 > $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem.base64
```
3. Mettez à jour le fichier overrides.yaml en ajoutant l'entrée suivante sous "envs" :
```
- name: ENV_NAME
  serviceAccountPaths:
    # Provide the path relative to the apigee-env chart directory.
    synchronizer: SYNCHRONIZER_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-synchronizer.json"
    runtime: RUNTIME_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-runtime.json"
    udca: UDCA_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-udca.json"
```
  Où *_SERVICE_ACCOUNT_FILEPATH (obligatoire) est le fichier de clé JSON du compte de service que vous avez utilisé lors de l'installation d'Apigee hybrid. Pour en savoir plus, consultez Créer les remplacements dans les instructions d'installation d'Apigee hybrid.
4. Ajoutez l'entrée suivante dans le fichier overrides.yaml sous virtualhosts.
```
- name: 
  selector:
    app: apigee-ingressgateway
    ingress_name: INGRESS_NAME
  sslCertPath: certs/keystore_$ENV_GROUP.pem
  sslKeyPath: certs/keystore_$ENV_GROUP.key
```
  Où INGRESS_NAME (obligatoire) est le nom de la passerelle d'entrée Apigee pour votre déploiement. Pour en savoir plus, cliquez ici.
5. Installer l'environnement et le groupe d'environnements
  1. Installez l'environnement.
    
    Vous devez installer un environnement à la fois. Spécifiez l'environnement avec --set env=ENV_NAME. Si vous avez défini la variable d'environnement $ENV_NAME dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes :
    
    Effectuez un dry run :
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml \
  --dry-run=server
```
    Installez le chart :
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml
```
    Vérifiez qu'il est opérationnel en vérifiant l'état de l'environnement correspondant :
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Installez les groupes d'environnements (virtualhosts).
    1. Vous devez installer un groupe d'environnements (hôte virtuel) à la fois. Spécifiez le groupe d'environnement avec --set envgroup=ENV_GROUP. Si vous avez défini la variable d'environnement $ENV_GROUP dans votre interface système, vous pouvez l'utiliser dans les commandes suivantes : Répétez les commandes suivantes pour chaque groupe d'environnements mentionné dans votre fichier overrides.yaml :
      Effectuez un dry run :
      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml \ --dry-run=server
      Installez le chart :
      helm upgrade $ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml
      Remarque : ENV_GROUP doit être unique dans l'espace de noms apigee. Par exemple, si vous disposez d'un environnement et d'un groupe d'environnements prod, vous devez définir ce nom sur prod-envgroup. Le nom du groupe d'environnements ultérieur doit toujours être prod.
  Votre organisation Apigee Hybrid est désormais prête avec le nouvel environnement pour tester l'extension de service.
  
  Poursuivez avec les procédures de la section Créer une APIMExtensionPolicy pour créer une règle d'extension.

Installer l'opérateur Apigee pour Kubernetes pour Apigee hybrid Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Rôles requis

Tâches de configuration requises

Vérifier la configuration d'Istio Gateway (facultatif)

Installer l'opérateur Apigee pour Kubernetes

Installer et configurer l'opérateur Apigee pour Kubernetes

Définir des variables d'environnement

Créer et configurer le compte de service APIM

Installer l'opérateur Apigee pour Kubernetes

Créer un environnement hybride Apigee

Installer l'environnement Apigee hybrid à l'aide de Helm

Installer l'opérateur Apigee pour Kubernetes pour Apigee hybrid