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

Ajouter des règles à la passerelle GKE

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

Consultez la documentation d' Apigee Edge.

Cette page explique comment ajouter des règles d'exécution Apigee et une règle d'injection de jeton à la passerelle Google Kubernetes Engine (GKE) avec l'opérateur APIM Apigee pour Kubernetes (version Preview). Google Ajouter un ensemble de règles disponibles à la passerelle vous permet d'étendre ses fonctionnalités au-delà de l'application des produits API pour inclure des règles de sécurité et d'entreprise supplémentaires.

L'opérateur APIM Apigee pour Kubernetes permet d'ajouter les stratégies suivantes à la passerelle:

Présentation

Dans les sections suivantes, nous allons voir comment effectuer les tâches suivantes :

Ajoutez des règles à la passerelle GKE.
Créez une règle de modèle pour appliquer l'utilisation des stratégies.
Mettez à jour le modèle Apigee pour inclure la règle du modèle .

Déployez la stratégie de la passerelle Apigee avec le modèle.
Vérifiez l'application des règles.

Avant de commencer

Pour modifier votre passerelle GKE avec l'ensemble complet de règles utilisées comme exemple dans ce guide, vous devez disposer d'un compte de service avec les rôles requis pour créer des jetons dans Apigee et déployer des proxys et des extensions. Si vous choisissez de ne pas créer de jetons Google , vous n'avez pas besoin d'ajouter les rôles supplémentaires à votre compte de service et vous pouvez passer à la section suivante.

Pour créer un compte de service disposant des autorisations requises, procédez comme suit :

Si vous avez créé un compte de service nommé apigee-apim-gsa dans le guide d'installation de l'opérateur APIM Apigee pour Kubernetes, vous pouvez ignorer cette étape et passer à la suivante. Sinon, créez le compte de service:
```
gcloud iam service-accounts create apigee-apim-gsa --project=${PROJECT_ID}
```

Attribuez au compte de service le rôle nécessaire pour créer des jetons:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role "roles/iam.serviceAccountTokenCreator"

Attribuez au compte de service apigee-apim-gsa le rôle nécessaire pour déployer des proxys et des extensions:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:apigee-apim-gsa@${PROJECT_ID}.iam.gserviceaccount.com" \
  --role "roles/iam.serviceAccountUser"

Modifier votre passerelle GKE avec des règles

Vous pouvez choisir de modifier votre passerelle GKE avec une ou plusieurs règles pour étendre ses fonctionnalités. Cet exemple de procédure d'application applique un fichier yaml à la passerelle qui inclut les spécifications de deux stratégies Apigee et une stratégie d'injection de jeton Google .

Chacune des règles appliquées à la passerelle à l'aide du fichier yaml suivant joue un rôle différent lors de l'évaluation des requêtes envoyées à la passerelle:

La règle SpikeArrest contrôle le débit de pointe des messages en définissant un débit maximal de requêtes autorisées sur une unité de temps. Dans cet exemple, la fréquence maximale est définie sur cinq par minute. Pour en savoir plus sur l'utilisation de la règle SpikeArrest pour atténuer les pics soudains de trafic, consultez la section Règle SpikeArrest.
La règle JavaScript vous permet d'ajouter du code JavaScript personnalisé aux requêtes de la passerelle. Dans cet exemple, la règle permet d'ajouter un en-tête personnalisé à la requête. Pour en savoir plus sur l'utilisation de la règle JavaScript pour ajouter du code personnalisé, consultez la page Règle JavaScript.
La règle d'injection de jeton Google permet d'injecter un jeton d'accès d'authentification Google dans les requêtes de la passerelle à l'aide de la règle AssignMessage. Apigee accepte l'utilisation de jetons Google OAuth ou de jetons OpenID Connect pour l'authentification auprès des services Google . Pour en savoir plus sur les jetons d'authentification, consultez la section Utiliser l'authentification Google.

Ajoutez les règles à la passerelle:

Créez un fichier nommé apigee-policies.yaml dans l'espace de noms apim.

Copiez le contenu du fichier suivant dans le nouveau fichier que vous avez créé:

# apigee-policies.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: SpikeArrest
metadata:
  name: spike-arrest
  namespace: apim
spec:
  identifier:
    ref: request.header.name
  useEffectiveCount: true
  peakMessageRate:
    value: "5pm"
---
apiVersion: apim.googleapis.com/v1alpha1
kind: Javascript
metadata:
  name: js-add-headers
  namespace: apim
spec:
  timeLimit: 2000
  source: |
    var sum = 1+1;
    context.setVariable("request.header.first", 1);
    context.setVariable("request.header.second", 1);
    context.setVariable("request.header.sum", sum);
---
apiVersion: apim.googleapis.com/v1alpha1
kind: AssignMessage
metadata:
  name: google-token-policy
  namespace: apim
spec:
  setActions:
    - authentication:
        googleAccessToken:
          scopes:
            - 'https://www.googleapis.com/auth/cloud-platform'
  AssignTo:
    createNew: false
    type: request

Appliquez le fichier yaml à la passerelle à l'aide de la commande suivante:
```
kubectl -n apim apply -f apigee-policies.yaml
```

Créer un TemplateRule en tant que modèle SharedFlow

À cette étape, vous allez créer un TemplateRule pour appliquer les règles que vous avez ajoutées à la passerelle. Une règle de modèle est une règle pour SharedFlows créée par les administrateurs de l'organisation afin de s'assurer que seuls les règles approuvées sont appliquées au trafic de la passerelle par les développeurs de services. Une règle de modèle permet aux développeurs de comprendre quelles règles sont disponibles, quelles règles sont requises pour des cas d'utilisation spécifiques et quelles règles ne peuvent pas être utilisées par les développeurs de services.

Créer une règle de modèle

Créez une règle de modèle pour appliquer la règle AssignMessage:

Créez un fichier yaml nommé template-rule.yaml dans l'espace de noms apim.
Copiez le contenu du fichier suivant dans le nouveau fichier que vous avez créé:
```
# template-rule.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplateRule
metadata:
  name: template-rule
  namespace: apim
spec:
  allowList: [SpikeArrest, Javascript]
  requiredList: [AssignMessage]
  denyList: []
```
Dans cet exemple, la règle de modèle indique aux développeurs que la stratégie AssignMessage décrivant la stratégie d'injection de jeton Google est requise. Il indique également aux développeurs qu'ils peuvent utiliser les règles SpikeArrest et JavaScript dans leur gestion des API. Aucune règle n'est spécifiée dans la liste de refus.

Appliquer la règle du modèle

Appliquez la règle de modèle à l'aide de la commande suivante:

kubectl apply -f template-rule.yaml

Mettre à jour le modèle Apigee pour inclure les règles du modèle

Mettez à jour le modèle Apigee pour inclure la règle de modèle que vous avez créée dans la section précédente:

Créez un fichier yaml nommé new-admin-template.yaml dans l'espace de noms apim.

Copiez le contenu du fichier suivant dans le nouveau fichier que vous avez créé:

# new-admin-template.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplate
metadata:
  name: new-admin-template
  namespace: apim
spec:
  apimTemplateRule:
    group: apim.googleapis.com
    kind: ApimTemplateRule
    name: template-rule
    namespace: apim
  templates:
  - policies:
      - group: apim.googleapis.com
        kind: SpikeArrest
        name: spike-arrest
        namespace: apim
      - group: apim.googleapis.com
        kind: Javascript
        name: js-add-headers
        namespace: apim
      - group: apim.googleapis.com
        kind: AssignMessage
        name: google-token-policy
        namespace: apim

Appliquez le modèle mis à jour à l'aide de la commande suivante:
```
kubectl apply -f new-admin-template.yaml
```

Déployer la stratégie de la passerelle Apigee

À cette étape, vous allez appliquer un nouveau fichier à votre passerelle qui inclut les spécifications d'un ApigeeGatewayPolicy. Cette règle permet de déployer le modèle Apigee sur la passerelle.

Déployez la stratégie de la passerelle Apigee:

Créez un fichier yaml nommé apigee-gateway-policy-withSA.yaml dans l'espace de noms apim.

Copiez le contenu du fichier suivant dans le nouveau fichier que vous avez créé:

# apigee-gateway-policy-withSA.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApigeeGatewayPolicy
metadata:
  name: apim-template-injection
  namespace: apim
spec:
  serviceAccount: apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  ref:
    group: apim.googleapis.com
    kind: ApimTemplate
    name: new-admin-template
    namespace: apim
  targetRef:
    group: apim.googleapis.com
    kind: APIMExtensionPolicy
    name: global-ext-lb1-apim-policy
    namespace: apim

Appliquez la règle :

kubectl apply -f apigee-gateway-policy-withSA.yaml

Vérifiez l'état de déploiement de la nouvelle règle de passerelle:
```
kubectl -n apim get ApigeeGatewayPolicy
```
Une fois déployée, la règle STATUS doit afficher CREATED.

Une fois la nouvelle règle de passerelle déployée, attendez deux minutes avant d'envoyer une requête à la passerelle pour permettre à la règle de se propager au cluster.

Valider l'application des règles

Pour vérifier que les règles de la passerelle Apigee fonctionnent comme prévu, envoyez des requêtes à la passerelle comme décrit dans les sections suivantes.

Vérifier l'application de la règle AssignMessage

Pour vérifier que le jeton {company_name} est injecté dans la requête à l'aide de la stratégie AssignMessage, envoyez une requête à la passerelle à l'aide de la commande suivante:

curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"

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:
```
kubectl get gateway GATEWAY_NAME
```
HOST_NAME est le nom de l'hôte.
API_KEY correspond à la valeur de la clé API.

Une réponse réussie doit inclure un en-tête Authorization avec le jeton porteur généré, semblable à ce qui suit:

{
  "args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Authorization": "Bearer ya29.c.c0ASRK0Gbw03y9cfvxL11DxaRYBQUU18SmUP4Vu63OckHI5cX7wJ4DmGMG2vbDDS69HXJHqMj-lak4tcqOsJGmE65crn2gNuJLanXidwM8", 
    "First": "1.0", 
    "Host": "apigee-apim-operator-test.apigee.net", 
    "Second": "1.0", 
    "Sum": "2", 
    "User-Agent": "curl/8.7.1", 
    "X-Api-Key": "McYcHGR3PTSGLXExvKADwQ1JJeCjgPDUvAakCl0rJKCFaX0Y", 
    "X-Cloud-Trace-Context": "0fd3dadc2a3c328fa968d5f5f1434c29/18300783092696918345"
  }, 
  "origin": "34.54.108.129", 
  "url": "apigee-apim-operator-test.apigee.net/get"
}

Vérifier l'application de la règle SpikeArrest

Vous pouvez tester l'application de la règle SpikeArrest en envoyant une requête à la passerelle dix fois en une minute.

Vous pouvez exécuter le script suivant pour générer les requêtes:

#!/bin/sh
for i in $(seq 1 11); do
    curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"
    sleep 1
done

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 est le nom d'hôte défini dans le HTTPRoute de la passerelle.
API_KEY est la valeur de la clé API obtenue dans Configuration des tests.

La réponse ressemble à ceci:

"fault":{"faultstring":"Spike arrest violation. Allowed rate : MessageRate{capacity=5, period=Minutes}","detail":{"errorcode":"policies.ratelimit.SpikeArrestViolation"}}}

Résoudre les problèmes

Si vous rencontrez des problèmes lors de l'ajout de règles à la passerelle GKE, consultez Résoudre les problèmes liés à l'opérateur APIM pour trouver des solutions aux erreurs courantes.

Étape suivante

En savoir plus sur la règle SpikeArrest
En savoir plus sur la règle JavaScript