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

Opérateur APIM: Avant de commencer

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

Consultez la documentation d' Apigee Edge.

Cette page décrit la procédure à suivre avant d'installer et de 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.

Rôles requis

Pour obtenir les autorisations nécessaires pour configurer les ressources requises pour installer et utiliser 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 Google Kubernetes Engine (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.

Tâches de configuration requises

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

Provisionnez une instance Apigee à l'aide de la version 1-15-0-apigee-4 ou ultérieure.
Vous pouvez afficher les versions des instances sur la page Détails de l'instance de l'interface utilisateur Apigee dans la console Google Cloud .Accédez à la page Instances de la console Google Cloud pour sélectionner une instance et afficher ses détails :
Accéder à la page "Instances"

Vous pouvez utiliser APIM Operator avec une organisation Apigee avec abonnement ou Pay-as-you-go. Pour en savoir plus sur le provisionnement des instances Apigee payantes, consultez Avant de commencer.
Installez la Google Cloud CLI.

Une fois la Google Cloud CLI installée, exécutez la commande gcloud components update pour obtenir les derniers composants gcloud.
Installez et configurez l'outil de ligne de commande kubectl.
Installez Helm (version 3.14.3 ou ultérieure).
Créez un cluster GKE à l'aide de la version 1.27 ou ultérieure de GKE avec la fédération d'identité de charge de travail pour GKE et GKE Gateway activés.

Si vous disposez déjà d'un cluster qui répond à ces critères, vous pouvez ignorer cette étape.

La fédération d'identité de charge de travail pour GKE est activée par défaut lorsque vous utilisez le mode Autopilot pour créer et gérer vos clusters. Pour en savoir plus, consultez la présentation d'Autopilot.

Pour connaître les étapes nécessaires à la création d'un cluster avec Workload Identity Federation for GKE et GKE Gateway activés à l'aide d'Autopilot, consultez Déployer des passerelles.

Remarque : Si vous utilisez le mode Standard pour créer et gérer vos clusters, vous devez activer manuellement la fédération d'identité de charge de travail pour GKE et GKE Gateway. Pour en savoir plus, consultez Workload Identity et Déployer des passerelles.
Déployez une passerelle GKE sur votre cluster.
Vous pouvez choisir de configurer et de déployer une passerelle interne ou une passerelle externe à utiliser avec l'opérateur APIM. Si vous choisissez de déployer une passerelle interne, un sous-réseau proxy réservé et un VPC partagé sont requis. Pour tester les étapes de ce guide, nous vous recommandons de déployer une passerelle externe. Pour en savoir plus, consultez Exigences du contrôleur GKE Gateway.
Remarque : Si vous prévoyez de déployer plusieurs passerelles GKE dans la même région, elles doivent être du même type (internes ou externes). Vous ne pouvez pas déployer une passerelle interne et une passerelle externe dans la même région. Les exemples de configurations de ce guide utilisent une passerelle externe.

Pour déployer GKE Gateway, suivez la procédure décrite dans Déployer une passerelle externe. Lorsque vous créez la passerelle, utilisez la configuration yaml suivante :
```
# gateway.yaml
kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: global-ext-lb1
  namespace: default
spec:
  gatewayClassName: gke-l7-global-external-managed
  listeners:
    - name: http
      protocol: HTTP
      allowedRoutes:
        kinds:
          - kind: HTTPRoute
        namespaces:
          from: All
      port: 80
```
Appliquez le fichier à votre cluster :
```
kubectl apply -f gateway.yaml
```

Déployez une application backend sur votre cluster.

Pour déployer l'application de backend exposée par la passerelle global-ext-lb1 que vous avez créée et déployée :

Créez un fichier nommé target.yaml :

Copiez ce qui suit dans le nouveau fichier :

# target.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: http
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
  namespace: http
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  namespace: http
  labels:
    app: httpbin
    service: httpbin
spec:
  type: LoadBalancer
  ports:
    - name: https
      port: 80
      targetPort: 80
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
  namespace: http
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
        - image: docker.io/kennethreitz/httpbin
          imagePullPolicy: IfNotPresent
          name: httpbin
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: 1
              memory: 1024Mi
            limits:
              cpu: 1
              memory: 1024Mi

Appliquez la configuration à votre cluster comme suit :
```
kubectl apply -f target.yaml
```

Pour en savoir plus sur le déploiement d'applications de backend sur des clusters GKE, consultez Déployer les applications de démonstration.

Déployez la ressource HTTPRoute dans votre cluster pour mapper le trafic de la passerelle à votre service de backend.
Pour en savoir plus sur la ressource HTTPRoute, consultez Déployer HTTPRoute (pour les passerelles internes) ou Créer une HTTPRoute (pour les passerelles externes).

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. Lorsque vous créez la ressource HTTPRoute, utilisez la configuration yaml suivante en remplaçant HOST_NAME par le nom d'hôte que vous souhaitez utiliser :
```
# httproute.yaml
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: http-bin-route
  namespace: http
spec:
  parentRefs:
    - kind: Gateway
      name: global-ext-lb1
      namespace: default
  hostnames:
    - HOST_NAME
  rules:
    - matches:
        - path:
            value: /
      backendRefs:
        - name: httpbin
          kind: Service
          port: 80
          namespace: http
```
Appliquez le fichier à votre cluster :
```
kubectl apply -f httproute.yaml
```
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 ne voyez pas le résultat attendu pour les étapes de cette section, attendez 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
global-ext-lb1   gke-l7-global-external-managed   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 global-ext-lb1
```
  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 Attached Routes est 1, ce qui indique que la route est associée.
3. Envoyez une requête à la passerelle :
```
curl http://GATEWAY_IP_ADDRESS/get \
    -H "Host: HOST_NAME"
```
  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 est le nom de la passerelle :
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses[0].value}"
```
  - HOST_NAME correspond au nom d'hôte défini dans la ressource HTTPRoute de la passerelle. Vous pouvez récupérer le HOST_NAME à l'aide de la commande suivante :
```
kubectl get HTTPRoute HTTPROUTE_NAME -n NAMESPACE
```
  For example:
```
curl http://34.54.193.72/get \
-H "Host: apigee-apim-operator-test.apigee.net"
```
  La réponse devrait ressembler à ceci :
```
  {
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "apigee-apim-operator-test.apigee.net",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://apigee-apim-operator-test.apigee.net/get"
  }
```

Étapes suivantes

Découvrez comment installer l'opérateur APIM.