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

Mettre à jour les règles de gestion des API avec l'opérateur Apigee APIM pour Kubernetes

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

Consultez la documentation d' Apigee Edge.

À mesure que vos besoins de gestion des API évoluent, vous devrez peut-être ajouter de nouveaux services à votre cluster ou mettre à jour les routes et les options d'entrée existantes. Cette page explique comment mettre à jour votre cluster pour effectuer les tâches suivantes:

Ajoutez une passerelle et un routage HTTP.
Mettez à jour un produit d'API.
Créez un produit API.
Créez un ensemble d'opérations d'API.
Testez la nouvelle configuration de la passerelle.

Avant de commencer

Avant de commencer cette tâche, assurez-vous d'avoir suivi la procédure décrite dans la section Appliquer une stratégie avec l'opérateur APIM Apigee pour Kubernetes. Cette page suppose que vous avez configuré un cluster Google Kubernetes Engine (GKE), installé l'opérateur APIM Apigee pour Kubernetes, créé une passerelle Google Kubernetes Engine (GKE) et appliqué au moins une stratégie de gestion des API à la passerelle.

Rôles requis

Si vous avez attribué les rôles requis à votre compte de service comme décrit dans Installer l'opérateur APIM Apigee pour Kubernetes, aucun rôle ni autorisation IAM supplémentaires ne sont requis pour effectuer ces tâches.

Vous pouvez choisir d'autoriser des actions sur les ressources de votre cluster Google Kubernetes Engine à l'aide du mécanisme intégré de contrôle des accès basé sur les rôles (RBAC) dans Kubernetes. Pour en savoir plus, consultez la section Autoriser des actions dans les clusters à l'aide du contrôle des accès basé sur les rôles.

Ajouter une passerelle et un routage HTTP

Dans cette section, vous allez ajouter une passerelle et un HTTPRoute à votre cluster. Dans les guides de tâches précédents, les exemples de configurations utilisaient une passerelle GKE externe. Si plusieurs passerelles sont déployées dans la même région, elles doivent être du même type (externes ou internes). C'est pourquoi l'exemple de configuration de ce guide utilise également une passerelle externe.

L'opérateur APIM peut être utilisé avec des passerelles GKE internes ou externes, mais vous ne pouvez pas déployer les deux types de passerelles dans la même région.

Pour ajouter une passerelle et un HTTPRoute à votre cluster, procédez comme suit:

Configurez une nouvelle passerelle GKE externe. Pour en savoir plus et connaître la procédure à suivre, consultez Déployer une passerelle externe.
Créez un fichier nommé gateway2.yaml dans l'espace de noms apim.

Copiez le contenu suivant dans le nouveau fichier:

# gateway2.yaml
apiVersion: gateway.networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: global-ext-lb2
  spec: 
  gatewayClassName: gke-l7-global-external-managed
  listeners:
  - name: https
    protocol: HTTPS
    allowedRoutes:
      kinds:
      - kind: HTTPRoute
      namespaces:
        from: All
    port: 443
    tls:
      options:
        networking.gke.io/pre-shared-certs: apigee-lb-new-cert-sept

Ajoutez un HTTPRoute pour /post au même fichier, comme indiqué ci-dessous:

# http-route2.yaml
  apiVersion: gateway.networking.k8s.io/v1beta1
  kind: HTTPRoute
  metadata:
    name: http-bin-route-post
    namespace: http
  spec:
    parentRefs:
      - kind: Gateway
        name: global-ext-lb2
        namespace: default
    hostnames:
      - HOST_NAME_2
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/post"
      backendRefs:
      - name: httpbin
        kind: Service
        port: 80
        namespace: http

Appliquez la nouvelle passerelle et le nouveau routage HTTP:
```
kubectl apply -f gateway2.yaml
```

Vérifiez l'état de HTTPRoute à l'aide de la commande suivante :

kubectl -n http get HttpRoute

La sortie devrait ressembler à ce qui suit :

NAME             HOSTNAMES                                                  AGE
http-bin-route   ["my-hostname-2"]   12d

Vérifiez l'état de la passerelle à l'aide de la commande suivante:
```
kubectl get gateway global-ext-lb2
```
La sortie devrait ressembler à ce qui suit :
```
NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb2   gke-l7-global-external-managed   34.54.193.92   True         11d
```
Vérifiez que la colonne Address contient une adresse IP valide et que l'état de Programmed est True.
Décrivez la passerelle pour vous assurer que la route est associée:
```
kubectl describe gateway global-ext-lb2
```

La sortie devrait ressembler à ce qui suit :

...
Listeners:
  Attached Routes:  1
  Conditions:
    Last Transition Time:  2024-10-03T03:10:17Z
...

Vérifiez que la valeur Attached Routes est 1.

Envoyez une requête à la passerelle pour vérifier que la route fonctionne:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"
```
Où :
- GATEWAY_IP_ADDRESS correspond à l'adresse IP de la passerelle, comme indiqué dans la colonne Address de la réponse renvoyée à l'étape 7.
- HOST_NAME est le nom d'hôte défini dans le HTTPRoute de la passerelle.

La sortie devrait ressembler à ce qui suit :

  {
    "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": "https://apigee-apim-operator-test.apigee.net/post"
  }

Créez une règle d'extension APIM qui fait référence au routage HTTP de la nouvelle passerelle créée à l'étape précédente :
1. Créez un fichier nommé apim-policy2.yaml dans l'espace de noms apim.
2. Copiez le contenu suivant dans le nouveau fichier:
```
# apim-policy2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIMExtensionPolicy
metadata:
  name: global-ext-lb2-apim-policy-2
  namespace: apim
spec:
  location: global
  failOpen: false
  timeout: 1000ms
  targetRef: # identifies the Gateway where the extension should be installed
    name: global-ext-lb2 
    kind: Gateway
    namespace: default
```
3. Appliquez la nouvelle règle d'extension APIM:
```
kubectl apply -f apim-policy2.yaml
```
  Une fois le fichier appliqué, l'opérateur APIM crée des ressources réseau en arrière-plan.
4. Vérifiez l'état de la règle d'extension APIM:
```
kubectl -n apim get APIMExtensionPolicy
```
  La sortie devrait ressembler à ce qui suit :
```
NAME                           STATE        ERRORMESSAGE
global-ext-lb2-apim-policy-2   RUNNING  
```
  Vérifiez que la valeur STATE est RUNNING.
5. Attendez cinq minutes pour vous assurer que les modifications se propagent à toutes les instances de l'équilibreur de charge, puis exécutez la commande suivante pour vérifier qu'une requête envoyée à la nouvelle passerelle échoue:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOSTNAME"
```
  Où :
  - GATEWAY_IP_ADDRESS est l'adresse IP de la passerelle obtenue à une étape précédente.
  - HOST_NAME est le nom d'hôte défini dans le HTTPRoute de la passerelle.
  La requête doit échouer et renvoyer une réponse semblable à celle-ci:
```
{
  "fault": {
    "faultstring": "Raising fault. Fault name : RF-insufficient-request-raise-fault",
    "detail": {
      "errorcode": "steps.raisefault.RaiseFault"
    }
  }
}
```
  Cela signifie que l'extension de service vers Apigee est active et que la vérification de la clé API et du jeton d'accès est appliquée. Pour connaître la procédure à suivre pour créer une application de développement, obtenir une clé API et tester votre nouvelle passerelle avec la clé, consultez la section Tester l'extension de service Apigee.

Modifier un produit d'API

Modifiez un produit d'API existant pour référencer la nouvelle stratégie d'extension APIM:

Créez un fichier nommé api-product-2.yaml dans l'espace de noms apim.

Copiez le contenu suivant dans le nouveau fichier:

# api-product-2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIProduct
metadata:
  name: api-product-2
  namespace: apim
spec:
  name: api-product-2
  approvalType: auto
  description: Http bin GET calls
  displayName: api-product-2
EnforcementRefs:
  - name: global-ext-lb1-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  - name: global-ext-lb2-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  attributes:
  - name: access
    value: private

Appliquez le nouveau fichier de produit d'API:
```
kubectl apply -f api-product-2.yaml
```
L'application des modifications dans l'ensemble du cluster prendra environ trois minutes.

Dans cet exemple, la section EnforcementRefs du produit d'API api-product-2 est mise à jour pour faire référence à la fois à global-ext-lb1-apim-policy et à global-ext-lb2-apim-policy, comme indiqué dans les parties en surbrillance de yaml.

Créer un produit API

Créez un produit API:

Créez un fichier nommé api-product-2.yaml dans l'espace de noms apim.

Copiez le contenu suivant dans le nouveau fichier:

# api-product-2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIProduct
metadata:
  name: api-product-2
  namespace: apim
spec:
  name: api-product-2
  approvalType: auto
  description: Http bin GET calls
  displayName: api-product-2
  enforcementRefs:
  - name: global-ext-lb2-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  attributes:
  - name: access
    value: private

Appliquez le nouveau fichier de produit d'API:
```
kubectl apply -f api-product-2.yaml
```
L'application des modifications dans l'ensemble du cluster prendra environ trois minutes.

Dans cet exemple, la section EnforcementRefs du nouveau produit d'API api-product-2 est créée pour référencer global-ext-lb2-apim-policy, comme indiqué dans les parties en surbrillance de yaml.

Créer un ensemble d'opérations d'API

Créez un ensemble d'opérations d'API:

Créez un fichier nommé item-set-post.yaml dans l'espace de noms apim.

Copiez le contenu suivant dans le nouveau fichier:

# item-set-post.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIOperationSet
metadata:
  name: item-set-post
  namespace: apim
spec:
  apiProductRefs:
    - name: api-product-1
      kind: APIProduct
      group: apim.googleapis.com
      namespace: apim
  quota:
    limit: 1
    interval: 1
    timeUnit: minute
  restOperations:
    - name: PostItems
      path: "/post"
      methods:
      - POST

Appliquez le nouveau fichier de l'ensemble d'opérations de l'API:
```
kubectl apply -f item-set-post.yaml
```
L'application des modifications dans l'ensemble du cluster prendra environ trois minutes.

Dans cet exemple, la valeur restOperations du nouvel ensemble d'opérations d'API item-set-post est créée pour faire référence au chemin /post, comme indiqué dans les parties en surbrillance du fichier.

Tester la nouvelle configuration de la passerelle

Pour tester la nouvelle configuration de la passerelle, envoyez la requête suivante au nouveau chemin /post:

curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"

Où :

GATEWAY_IP_ADDRESS est l'adresse IP de la passerelle obtenue à une étape précédente.
HOST_NAME est le nom d'hôte défini dans le HTTPRoute de la passerelle.

La requête doit aboutir et renvoyer une réponse semblable à celle-ci:

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "apigee-apim-operator-test.apigee.net",
    "User-Agent": "curl/8.7.1",
    "X-Api-Key": "f0N6sXXXclGXXXe0oP5XXXdA20PjgrP2x8xXXh7z4XXXKiYt",
    "X-Cloud-Trace-Context": "bb3a768787099bda628781188bfb318b/15554891713516675739"
  },
  "origin": "34.54.193.72",
  "url": "https://34.54.193.72/post"
}

Résoudre les problèmes

Si vous rencontrez des problèmes lors de la mise à jour et de l'extension des règles de gestion des API utilisées avec l'opérateur APIM, consultez la section Dépannage de l'opérateur APIM pour trouver des solutions aux erreurs courantes.

Étape suivante

Découvrez comment désinstaller l'opérateur APIM Apigee pour Kubernetes.
Découvrez les options de déploiement des passerelles.