Premiers pas avec le processeur d'extension Apigee

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

Consultez la documentation d' Apigee Edge.

Cette page explique comment configurer le processeur d'extension Apigee pour activer l'application des règles d'API pour le trafic d'API à l'aide d'un équilibreur de charge compatible avec les extensions de service.

Pour en savoir plus sur les cas d'utilisation suggérés et les avantages de l'utilisation du processeur d'extension Apigee pour la gestion des API, consultez la section Présentation du processeur d'extension Apigee.

Le processeur d'extension Apigee est une extension de trafic (un type d'extension de service) qui vous permet d'utiliser Cloud Load Balancing pour envoyer des accroches du chemin de traitement des données de l'équilibreur de charge d'application au processeur d'extension Apigee. Une fois l'équilibreur de charge et l'extension de trafic configurés, le trafic de l'API est traité par l'équilibreur de charge. Les règles du processeur d'extension Apigee sont appliquées au trafic de l'API à l'aide des accroches d'extension de trafic.

Les sections suivantes vous guident dans les étapes nécessaires à la configuration des éléments clés du processeur d'extension Apigee:

  • Configurez un équilibreur de charge pour un service de backend.
  • Configurez le processeur d'extension Apigee.
  • Configurez l'extension de trafic.
  • Utiliser des règles avec l'outil de traitement des extensions

    • Avant de commencer

    Avant de commencer à configurer le processeur d'extension Apigee, assurez-vous d'avoir effectué les tâches suivantes:

    1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

    2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

      Go to project selector

    3. Make sure that billing is enabled for your Google Cloud project.

    4. Enable the Apigee, Compute Engine, and Network Services APIs.

      Enable the APIs

      5.

    5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

      Go to project selector

    6. Make sure that billing is enabled for your Google Cloud project.

    7. Enable the Apigee, Compute Engine, and Network Services APIs.

      Enable the APIs

      8.

    8. Installez Google Cloud CLI.

      Une fois la Google Cloud CLI installée, exécutez la commande gcloud components update pour obtenir les derniers composants gcloud.

    9. Provisionnez une instance Apigee à l'aide de la version 1-15-0-apigee-2 ou ultérieure, si ce n'est pas déjà fait.

      Vous pouvez afficher les versions d'instance sur la page Détails de l'instance de l'interface utilisateur d'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 le processeur d'extension avec une organisation Apigee avec abonnement ou paiement à l'usage. Si vous ne savez pas si vous utilisez une organisation Apigee avec abonnement ou en paiement à l'usage, contactez l'administrateur de votre organisation Apigee. Pour en savoir plus sur le provisionnement d'instances Apigee payantes, consultez la section Avant de commencer.

    10. Vérifiez que vous avez activé un VPC et un sous-réseau dans l'instance Apigee que vous prévoyez d'utiliser. Accédez à la page Réseaux VPC dans la console : Google Cloud

      Accéder aux réseaux VPC

    Rôles requis

    Pour obtenir les autorisations nécessaires pour installer le processeur d'extension Apigee, demandez à votre administrateur de vous accorder les rôles IAM suivants dans l'organisation:

    Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

    Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

    Définir des variables d'environnement

    Dans le projet Google Cloud qui contient votre instance Apigee, utilisez la commande suivante pour définir des variables d'environnement: 

    export PROJECT_ID=PROJECT_ID
export ORG_NAME=$PROJECT_ID
export REGION=REGION
export INSTANCE=INSTANCE
export VPC_NETWORK_NAME=VPC_NETWORK_NAME
export SUBNET=SUBNET

    Où :

    • PROJECT_ID est l'ID du projet associé à votre instance Apigee.
    • REGION est la région Google Cloud de votre instance Apigee.
    • INSTANCE est le nom de votre instance Apigee.
    • VPC_NETWORK_NAME correspond au nom du réseau VPC de votre Google Cloud projet que vous souhaitez utiliser pour le processeur d'extension Apigee.
    • SUBNET correspond au nom du sous-réseau de votre Google Cloud projet que vous souhaitez utiliser pour le processeur d'extension Apigee.

    Pour vérifier que les variables d'environnement sont correctement définies, exécutez la commande suivante et examinez la sortie: 

    echo $PROJECT_ID $ORG_NAME $REGION $INSTANCE $VPC_NETWORK_NAME $SUBNET

    Configurer un jeton d'authentification

    Pour configurer un jeton d'authentification, exécutez la commande suivante: 

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

    Configurer un équilibreur de charge pour un service de backend

    Les sections suivantes décrivent les étapes requises pour configurer un équilibreur de charge d'application externe global pour un service de backend, en utilisant httpbin.org comme exemple:

    1. Créez un équilibreur de charge d'application externe global.
    2. Créez un groupe de points de terminaison du réseau (NEG).
    3. Créez un service backend.
    4. Créez un mappage d'URL.
    5. Créez un proxy cible.
    6. Créez une règle de transfert globale.

    Créer un équilibreur de charge d'application externe global

    Pour créer l'équilibreur de charge :

    1. Définissez la configuration gcloud pour utiliser votre projet actuel: 
      gcloud config set project PROJECT_ID

      Où PROJECT_ID correspond à l'ID du projet associé à votre instance Apigee.

    2. Créez une adresse IP statique globale: 
      gcloud compute addresses create IP_ADDRESS --ip-version=IPV4 --global

      où IP_ADDRESS est le nom de l'adresse IP que vous souhaitez créer. Le nom doit correspondre à l'expression régulière (?:a-z?).

    3. Obtenez l'adresse IP et enregistrez-la en tant que variable d'environnement: 
      IP=$(gcloud compute addresses describe IP_ADDRESS --format="get(address)" --global)

      où IP_ADDRESS correspond au nom de l'adresse IP que vous avez créée à l'étape précédente.

    4. Créez un certificat TLS pour nip.io, un service tiers qui fournit des enregistrements DNS génériques pour les adresses IP: 
      gcloud compute ssl-certificates create SSL_CERT_NAME \
  --domains="nip.io"

      où SSL_CERT_NAME correspond au nom du certificat que vous souhaitez créer.

    Créer un groupe de points de terminaison du réseau (NEG)

    Pour créer le groupe de points de terminaison du réseau (NEG) de votre équilibreur de charge:

    1. Créez un NEG: 
      gcloud compute network-endpoint-groups create NEG_NAME \
  --network-endpoint-type=INTERNET_FQDN_PORT \
  --default-port=443 \
  --global

      Où NEG_NAME est le nom du groupe de points de terminaison par NEG que vous souhaitez créer.

    2. Ajoutez le point de terminaison de httpbin.org au NEG: 
      gcloud compute network-endpoint-groups update NEG_NAME \
  --add-endpoint=fqdn=httpbin.org,port=443 \
  --global

      où NEG_NAME est le nom du NEG que vous avez créé à l'étape précédente.

    Créer un service de backend

    Pour créer le service de backend exposé par l'équilibreur de charge:

    1. Créez le service de backend : 
      gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --global

      où BACKEND_SERVICE_NAME est le nom du service de backend que vous souhaitez créer.

    2. Ajoutez le NEG au backend: 
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --global-network-endpoint-group \
  --global

      Où :

      • BACKEND_SERVICE_NAME est le nom du service backend que vous avez créé à l'étape précédente.
      • NEG_NAME correspond au nom de l'entité de négociation que vous avez créée à l'étape précédente.

    Créer un mappage d'URL

    Pour créer un mappage d'URL entre l'équilibreur de charge et le service backend, utilisez la commande suivante: 

    gcloud compute url-maps create URL_MAP_NAME \
  --default-service BACKEND_SERVICE_NAME \
  --global

    Où :

    • URL_MAP_NAME correspond au nom du mappage d'URL que vous souhaitez créer.
    • BACKEND_SERVICE_NAME est le nom du service backend que vous avez créé à une étape précédente.

    Créer un proxy cible

    Pour créer un proxy cible pour l'équilibreur de charge, exécutez la commande suivante: 

    gcloud compute target-https-proxies create TARGET_PROXY_NAME \
  --global \
  --ssl-certificates SSL_CERT_NAME \
  --global-ssl-certificates \
  --url-map URL_MAP_NAME \
  --global-url-map

    Où :

    • TARGET_PROXY_NAME est le nom du proxy cible que vous souhaitez créer.
    • URL_MAP_NAME est le nom du mappage d'URL que vous avez créé à l'étape précédente.
    • SSL_CERT_NAME correspond au nom du certificat SSL que vous avez créé pour nip.io à l'étape précédente.

    Créer une règle de transfert globale

    Pour créer une règle de transfert globale pour l'équilibreur de charge, utilisez la commande suivante: 

    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=IP_ADDRESS \
  --target-https-proxy=TARGET_PROXY_NAME \
  --ports=443 \
  --global

    Où :

    • FORWARDING_RULE_NAME est le nom de la règle de transfert que vous souhaitez créer.
    • IP_ADDRESS correspond au nom de l'adresse IP du point de terminaison NEG que vous avez créé à l'étape précédente.
    • TARGET_PROXY_NAME correspond au nom du proxy cible que vous avez créé à une étape précédente.

    Configurer le processeur d'extension Apigee

    Les sections suivantes décrivent les étapes requises pour configurer le processeur d'extension Apigee:

    1. Créez un environnement Apigee.
    2. Créez le proxy du processeur d'extension.

    Créer un environnement Apigee

    1. Créez un environnement Apigee à l'aide de la commande suivante: 
      curl -i -X POST -H  "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/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 que vous créez. Le nom doit contenir entre 2 et 32 caractères, qui peuvent être des lettres minuscules, des chiffres ou des traits d'union. Le nom doit commencer par une lettre et ne peut pas se terminer par un trait d'union. Le nom doit être différent de tout autre nom d'environnement dans votre organisation.

      Vérifiez que l'environnement est créé: 

      curl -i -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/environments"

      La liste des environnements doit inclure celui que vous venez de créer.

    2. Associez le nouvel environnement à votre instance Apigee: 
      curl -i -X POST -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances/$INSTANCE/attachments" -H "Content-Type:application/json" -d \
    '{
        "environment": "ENV_NAME"
        }'

      où ENV_NAME est le nom de l'environnement que vous avez créé à l'étape précédente.

      Cette opération peut prendre jusqu'à 10 minutes.

    3. Créez le groupe d'environnements Apigee: 
      curl -H "Authorization: Bearer $TOKEN" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups" -H "Content-Type:application/json" -d \
    '{
        "name": "ENV_GROUP_NAME",
        "hostnames": ["ENV_GROUP_HOSTNAME"]
        }'

      Où :

      • ENV_GROUP_NAME est le nom du groupe d'environnements que vous créez.
      • ENV_GROUP_HOSTNAME est le nom d'hôte du groupe d'environnements que vous créez. Le nom d'hôte doit être un nom de domaine complet (FQDN).
    4. Associez le nouvel environnement au nouveau groupe d'environnements: 
      curl -H "Authorization: Bearer $TOKEN" -X POST\
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups/ENV_GROUP_NAME/attachments" -H "content-type:application/json" -d \
        '{
            "name": "ENV_GROUP_NAME",
            "environment": "ENV_NAME"
        }'

      Où :

      • ENV_GROUP_NAME est le nom du groupe d'environnements que vous créez.
      • ENV_NAME est le nom de l'environnement que vous avez créé à une étape précédente.

    Créer le proxy du processeur d'extension

    Pour créer un proxy d'API sans cible Apigee à utiliser avec l'équilibreur de charge du processeur d'extension:

    1. Suivez les étapes décrites dans Créer un proxy d'API pour créer un proxy sans cible avec les spécifications suivantes :
      • Modèle de proxy: sélectionnez Aucune cible.
      • Nom du proxy: saisissez un nom de proxy.
      • Chemin de base: définissez le chemin de base de votre choix. Le chemin d'accès ne sera pas utilisé.

      La spécification XML du proxy doit se présenter comme suit: 

      <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<APIProxy revision="1" name="extproc-sample">
    <DisplayName/>
    <Description/>
    <CreatedAt>1739581781912</CreatedAt>
    <LastModifiedAt>1739582447868</LastModifiedAt>
    <BasePaths>/</BasePaths>
    <Policies></Policies>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
    </ProxyEndpoints>
</APIProxy>
    2. Suivez la procédure décrite dans Déployer un proxy d'API pour déployer le proxy dans l'environnement que vous avez créé précédemment.

    Configurer l'extension de trafic

    Cette section explique comment configurer l'extension de service de trafic pour votre processeur d'extension en procédant comme suit:

    1. Créez un groupe de points de terminaison du réseau Private Service Connect Apigee.
    2. Créez une extension de service d'équilibrage de charge.
    3. Envoyez une requête à l'équilibreur de charge.

    Créer un groupe de points de terminaison du réseau Private Service Connect Apigee

    Dans cette section, vous allez créer un groupe de points de terminaison du réseau (NEG) Private Service Connect (PSC) Apigee qui permet de vous connecter à votre instance Apigee. Pour en savoir plus sur le PSC, consultez la section Modèles de réseau Southbound.

    Pour créer un NEG PSC Apigee:

    1. Obtenez le rattachement de service PSC Apigee: 
      PSC_ATTACHMENT=$(curl -s -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances" \
    | jq -r '.instances[] | select(.name = "'$INSTANCE'") | .serviceAttachment' \
    )

      Pour afficher le rattachement de service: 

      echo $PSC_ATTACHMENT

      La réponse doit se présenter comme suit: 

      projects/apigee-psc-autopush/regions/us-west1/serviceAttachments/apigee-us-west1-1234567890-psc-service-attachment

    2. Créez le NEG PSC dans la même région que votre instance Apigee: 
      gcloud compute network-endpoint-groups create apigee-neg-$REGION \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=$PSC_ATTACHMENT \
  --region=$REGION \
  --network=$VPC_NETWORK_NAME \
  --subnet=$SUBNET

      La réponse doit se présenter comme suit: 

      projects/ab123456cd78ef910g-tp/regions/asia-northeast1/serviceAttachments/apigee-asia-northeast1-abcd

    3. Créez un service de backend HTTP/2 pointant vers le NEG du PSC, s'il n'en existe pas déjà un: 
      gcloud compute backend-services create PSC_NEG_BACKEND_SERVICE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP2 \
  --global

      où PSC_NEG_BACKEND_SERVICE est le nom du service de backend que vous souhaitez créer.

    4. Ajoutez le service de backend NEG PSC: 
      gcloud compute backend-services add-backend PSC_NEG_BACKEND_SERVICE \
  --network-endpoint-group=apigee-neg-$REGION \
  --network-endpoint-group-region=$REGION \
  --global

      PSC_NEG_BACKEND_SERVICE correspond au nom du service de backend que vous avez créé à l'étape précédente.

    5. Activez la journalisation pour le service de backend: 
      gcloud compute backend-services update PSC_NEG_BACKEND_SERVICE \
  --global \
  --enable-logging \
  --logging-sample-rate=1.0

      PSC_NEG_BACKEND_SERVICE correspond au nom du service de backend que vous avez créé à l'étape précédente.

    Créer une extension de service d'équilibreur de charge

    Pour créer une extension de service d'équilibreur de charge:

    1. Créez un fichier nommé global-xlb-httpbin-apim-policy.yaml avec le contenu suivant : 
      # global-xlb-httpbin-apim-policy.yaml
name: global-xlb-httpbin-apim-policy
metadata:
    apigee-extension-processor: EXT_PROC_NAME # Must match the name of the API proxy created in an earlier step.
forwardingRules:
- https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/forwardingRules/FORWARDING_RULE_NAME
loadBalancingScheme: EXTERNAL_MANAGED
extensionChains:
- name: "httpbin-apigee-extension-chain"
    matchCondition:
      celExpression: 'true'
    extensions:
    - name: 'httpbin-apigee-extension'
      authority: ENV_GROUP_HOSTNAME # The domain name used for the environment group.
      service: https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/backendServices/PSC_NEG_BACKEND_SERVICE
      failOpen: false
      timeout: 1s
      supportedEvents:
      - REQUEST_HEADERS
      - RESPONSE_HEADERS

      Où :

      • EXT_PROC_NAME Ce nom doit correspondre au nom du proxy d'API que vous avez créé à une étape précédente.
      • FORWARDING_RULE_NAME correspond au nom de la règle de transfert que vous avez créée à une étape précédente.
      • ENV_GROUP_HOSTNAME est le nom de domaine utilisé pour le groupe d'environnements.
      • PSC_NEG_BACKEND_SERVICE est le nom du service de backend que vous avez créé à une étape précédente.
    2. Appliquez l'extension de service à la règle de transfert de l'équilibreur de charge: 
      gcloud service-extensions lb-traffic-extensions import global-xlb-httpbin-apim-policy \
  --source=global-xlb-httpbin-apim-policy.yaml \
  --location=global

      Cette opération peut prendre quelques minutes. Pour vérifier l'état de l'opération, exécutez la commande suivante: 

      gcloud service-extensions lb-traffic-extensions describe global-xlb-httpbin-apim-policy --location global

      La réponse doit ressembler à celle-ci et afficher la règle de transfert et le service backend: 

      createTime: '2025-03-22T00:29:16.056719825Z'
extensionChains:
- extensions:
  - authority: extension-processor-test.hybrid.e2e.apigeeks.net
    name: httpbin-apigee-extension
    service: https://www.googleapis.com/compute/v1/projects/123456789012/global/backendServices/ep-test-psc-neg-bes
    supportedEvents:
    - REQUEST_HEADERS
    - RESPONSE_HEADERS
    timeout: 1s
  matchCondition:
    celExpression: 'true'
  name: httpbin-apigee-extension-chain
forwardingRules:
- https://www.googleapis.com/compute/v1/projects/123456789012/global/forwardingRules/ep-test-fw-rule
loadBalancingScheme: EXTERNAL_MANAGED
metadata:
  apigee-extension-processor: ep-test-proxy
name: projects/extension-processor-test/locations/global/lbTrafficExtensions/global-xlb-httpbin-apim-policy
updateTime: '2025-03-22T00:29:31.183275055Z'

    Envoyer une requête à l'équilibreur de charge

    Pour tester la configuration de l'équilibreur de charge et du processeur d'extension, envoyez une requête à l'équilibreur de charge: 

    curl "https://LB_DOMAIN_NAME/get"

    où LB_DOMAIN_NAME est le nom de domaine que vous avez utilisé pour l'équilibreur de charge et le certificat SSL. Si vous avez utilisé nip.io, le nom de domaine ressemblera à IP_ADDRESS.nip.io.

    La réponse doit se présenter comme suit: 

    {"status": 200,
  {
    "args": {},
    "headers": {
      ...
    },
    "origin": "173.93.50.108",
    "url": "https://httpbin.org/get"
  }
}

    Utiliser des règles avec le processeur d'extension

    Cette section explique comment utiliser des règles avec le processeur d'extension.

    Dans cet exemple, une règle VerifyAPIkey et AssignMessage sont configurées pour le processeur d'extension. Ces règles permettent de valider les clés API incluses dans les requêtes envoyées à Apigee et d'injecter un jeton Googledans les en-têtes de requête pour les appels à un service backend. Ce scénario est utile pour les fournisseurs d'API qui utilisent le processeur d'extension Apigee pour autoriser et authentifier les requêtes envoyées à leurs services Apigee, et injecter de manière transparente les jetons d'authentificationGoogle requis pour un service backend tel que Vertex AI.

    Ajouter la règle VerifyAPIKey pour la validation des clés API

    Les sections suivantes décrivent comment utiliser la règle VerifyAPIKey pour valider les clés API pour les appels à votre service backend à l'aide du processeur d'extension:

    1. Associez la règle VerifyAPIKey au processeur d'extension.
    2. Créez un produit API.
    3. Créez une application de développement et des identifiants d'application.
    4. Envoyez une requête à l'équilibreur de charge à l'aide de la clé API.

    Associer la règle VerifyAPIKey au proxy

    Pour associer une règle VerifyAPIKey au proxy du processeur d'extension:

    1. Dans l'interface utilisateur d'Apigee dans la console Cloud, accédez à l'onglet Develop (Développer) et sélectionnez le proxy du processeur d'extension que vous avez créé à une étape précédente.
    2. Dans la section Règles, cliquez sur + Ajouter une règle.
    3. Dans le volet Ajouter une règle, sélectionnez VerifyAPIKey dans la liste des règles.
    4. Dans le volet VerifyAPIKey (Valider la clé API), remplissez les champs obligatoires des sections Policy name (Nom de la règle) et Display name (Nom à afficher) à l'aide des valeurs suivantes :
      • Nom de la règle: saisissez un nom de règle. Exemple :VA-verify-api-key
      • Nom à afficher: saisissez le nom de la règle à utiliser dans l'interface utilisateur. Exemple :VA-verify-api-key
    5. Cliquez sur Créer.

      La spécification XML de la règle VerifyAPIKey incluse dans le proxy du processeur d'extension doit ressembler à ceci: 

        <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <VerifyAPIKey continueOnError="false" enabled="true" name="VA-verify-api-key">
    <DisplayName>VA-verify-api-key</DisplayName>
    <Properties/>
    <APIKey ref="request.queryparam.x-api-key"/>
  </VerifyAPIKey>
    6. Déployez la nouvelle révision du proxy.

    Créer un produit d'API

    Pour créer un produit API et configurer l'ensemble d'opérations d'API pour votre service:

    1. Suivez la procédure décrite dans la section Créer un produit d'API pour créer un produit d'API pour votre service. Vous pouvez configurer les détails du produit du produit API comme vous le souhaitez.
    2. Suivez la procédure décrite dans Opérations pour ajouter une opération d'API définie sur le produit d'API, conformément aux spécifications suivantes :
      • Source: sélectionnez Proxy d'API, puis le proxy que vous avez créé à une étape précédente.
      • Opération: configurez les chemins et les méthodes suivants :
        • Chemin: /get avec méthode: GET
        • Chemin: /PROXY_NAME avec méthode: GET

          PROXY_NAME est le nom du proxy que vous avez créé à une étape précédente.

    Créer une application de développeur et des identifiants d'application

    Pour créer une application de développeur et des identifiants d'application pour le nouveau produit d'API:

    1. Accédez à la page Gestion des API Apigee dans la console Google Cloud :

      Gestion des API Apigee

    2. Créez un développeur :
      1. Sélectionnez Distribution > Développeurs.
      2. Sur la page Développeurs, cliquez sur + Créer.
      3. Sur la page Ajouter un développeur, renseignez les champs obligatoires avec les valeurs de votre choix.
      4. Cliquez sur Ajouter.
    3. Créez une application :
      1. Sélectionnez Distribution> Applications.
      2. Sur la page Applications, cliquez sur + Créer.
      3. Sur la page Create App (Créer une application), remplissez les champs obligatoires de la section App Details (Détails de l'application) à l'aide des valeurs suivantes :
        • Nom de l'application: saisissez un nom pour l'application (par exemple, ext-proc-app).
        • Développeur: sélectionnez le développeur que vous avez créé à l'étape précédente ou un autre développeur dans la liste.
      4. Dans la section Identifiants de l'application, cliquez sur + Ajouter un identifiant.
      5. Dans la section Identifiants, sélectionnez Never (Jamais) dans la liste déroulante Expiration.
      6. Dans la section Produits, cliquez sur + Ajouter des produits pour afficher le volet Ajouter des produits.
      7. Sélectionnez le produit d'API que vous avez créé à l'étape précédente.
      8. Cliquez sur OK.
      9. Cliquez sur Ajouter pour fermer le volet Ajouter des produits.
      10. Cliquez sur Créer.
    4. Sur la page App Details (Détails de l'application), dans la section Credential (Identifiants), cliquez sur  pour afficher la valeur de la Clé.

      Copiez la valeur Key. Vous utiliserez cette clé pour effectuer des appels d'API vers votre service à une étape ultérieure.

    5. Sur la page App Details (Détails de l'application), dans la section Credential (Identifiants), cliquez sur  pour afficher la valeur du secret de l'application.

    Envoyer une requête à l'équilibreur de charge à l'aide de la clé API

    Pour tester la validation de la clé API, envoyez une requête à l'équilibreur de charge à l'aide de la clé API: 

    curl "https://LB_DOMAIN_NAME/get"

    où LB_DOMAIN_NAME est le nom de domaine que vous avez utilisé pour l'équilibreur de charge et le certificat SSL.

    La réponse doit échouer sans clé API.

    Envoyez une autre requête à l'équilibreur de charge en utilisant la clé API dans la requête: 

    curl "https://LB_DOMAIN_NAME/get?key=API_KEY"

    Où :

    • LB_DOMAIN_NAME est le nom de domaine que vous avez utilisé pour l'équilibreur de charge et le certificat SSL.
    • API_KEY est la clé API des identifiants de l'application de développement révélés à une étape précédente.

    La réponse doit indiquer que l'autorisation du point de terminaison a réussi. Cela indique que le processeur d'extension a validé la clé API et que la requête peut désormais être traitée par le proxy Apigee.

    Ajouter la règle AssignMessage pour l' Google authentification

    Si vous souhaitez utiliser votre processeur d'extension pour gérer les API d'un service authentifié par Google, vous pouvez injecter un jeton d'accès Google ou un jeton d'ID Google dans les requêtes envoyées au service backend à l'aide de la règle AssignMessage.

    Les sections suivantes décrivent comment utiliser la stratégie AssignMessage pour injecter un jeton d'authentification Google dans les requêtes envoyées au service backend à l'aide du processeur d'extension:

    1. Associez la règle AssignMessage au proxy.
    2. Envoyez une requête à l'équilibreur de charge pour tester l'injection de jeton.

    Associer la règle AssignMessage au proxy

    Pour ajouter la règle AssignMessage à votre proxy:

    1. Dans l'interface utilisateur d'Apigee dans la console Cloud, accédez à l'onglet Développer, puis sélectionnez le proxy que vous avez créé à l'étape précédente.
    2. Dans la section Règles, cliquez sur + Ajouter une règle.
    3. Dans le volet Ajouter une règle, sélectionnez Attribuer un message dans la liste des règles.
    4. Dans le volet Assigner un message, remplissez les champs obligatoires des sections Nom de la règle et Nom à afficher à l'aide des valeurs suivantes :
      • Nom de la règle: saisissez un nom de règle. Exemple :AM-auth
      • Nom à afficher: saisissez un nom de stratégie à afficher dans l'interface utilisateur. Exemple :AM-auth
    5. Cliquez sur Créer.
    6. Sous l'élément <Set>, ajoutez les éléments enfants suivants: 
      <Set>
    <Authentication>
    <HeaderName>Authorization</HeaderName>
    <GoogleAccessToken>
        <Scopes>
        <Scope>https://www.googleapis.com/auth/cloud-platform</Scope>
        </Scopes>
    </GoogleAccessToken>
    </Authentication>
</Set>
    7. Cliquez sur Enregistrer.
    8. Déployez la nouvelle version à l'aide d'un Google compte de service.

    Le compte de service permet de générer des jetons d'accès Google et de les injecter dans l'en-tête de la requête pour les appels d'API aux services backend Google .

    Envoyer une requête à l'équilibreur de charge pour tester l'injection de jeton

    Pour vérifier que l'injection de jeton fonctionne, envoyez une requête à l'équilibreur de charge: 

    curl "https://LB_DOMAIN_NAME/get"

    où LB_DOMAIN_NAME est le nom de domaine que vous avez utilisé pour l'équilibreur de charge et le certificat SSL.

    La réponse doit se présenter comme suit: 

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

    La réponse doit indiquer que l'injection du jeton d'authentification Google dans l'en-tête de la requête a réussi.

    Une fois la règle AssignMessage appliquée, la requête réussie du client (contenant la clé API) à Apigee dans l'exemple de scénario est modifiée pour inclure un jeton d'authentification Google dans l'en-tête de la requête, comme l'exige le service backend authentifié par Google.