Diffuser des modèles de machine learning à l'aide d'Apigee Edge et d'AI Platform

Ce tutoriel vous explique comment configurer Apigee Edge avec AI Platform Prediction.

Pour diffuser des modèles de machine learning, la préparation des données et l'entraînement des modèles ne sont que deux des divers facteurs dont vous devez tenir compte. Vous devez également examiner les éléments suivants :

  • Diffuser les prédictions tout en gardant à l'esprit les performances, l'évolutivité et la disponibilité.
  • Restreindre l'accès aux fonctionnalités suivant le type d'utilisateur, par exemple un utilisateur interne de votre entreprise ou un utilisateur d'une organisation partenaire externe.
  • Appliquer des quotas et des règles d'utilisation à l'aide de clés API.
  • Gérer le cycle de vie des clés API, en particulier leur distribution et leur révocation.
  • Autoriser l'accès à vos API de ML via un processus d'approbation manuel ou automatisé.
  • Déployer de nouvelles versions des modèles de ML à mesure qu'ils sont mis à jour.

Google Cloud fournit des services gérés pour l'hébergement de modèles et la gestion d'API pour l'accès aux fonctionnalités de prédiction de vos modèles hébergés.

AI Platform est un service de machine learning évolutif géré disponible sur Google Cloud. En plus de l'entraînement basé sur l'infrastructure distribuée de Google, AI Platform propose des modèles d'hébergement pour diffuser des prédictions en ligne et par lot à grande échelle. L'infrastructure sous-jacente tire parti de l'équilibrage de charge mondial de Google pour fournir des prédictions à hautes performances aux utilisateurs, quelle que soit leur localisation géographique.

Pour les cas d'utilisation nécessitant une faible latence, la prédiction en ligne avec AI Platform permet de réaliser des prédictions avec vos modèles hébergés en exposant une API REST qui affiche les prédictions directement dans la réponse. L'infrastructure servant à héberger votre modèle s'adapte automatiquement à la demande, sans qu'il soit nécessaire de maintenir des configurations complexes ou de gérer le provisionnement d'infrastructures. AI Platform simplifie également le processus de mise à jour des modèles de prédiction en fournissant des fonctionnalités de gestion des versions pour les modèles.

Pour activer les fonctionnalités étendues de gestion des API pour votre service, vous pouvez utiliser la prédiction en ligne d'AI Platform conjointement avec Apigee Edge pour mettre en place les éléments suivants :

  • Stratégies de sécurité et de contrôle d'accès précises pour votre API
  • Données analytiques d'API pour comprendre son utilisation.
  • Limitation du débit d'API et application d'autres quotas.
  • Accès tiers à votre API grâce à des clés de développeur
  • Monétisation de votre API AI Platform hébergée dans la prédiction en ligne AI Platform
  • Transparence des changements de modèles par redirection des requêtes de prédiction à travers une façade d'API

Objectifs

  • Déployer des serveurs proxy d'API à l'aide d'Apigee Edge pour vos modèles hébergés sur AI Platform
  • Sécuriser l'accès à vos modèles hébergés à l'aide de clés API
  • Spécifier les processus d'approbation manuels et automatiques pour la distribution des clés API
  • Créer des produits d'API pour appliquer différentes règles d'utilisation, telles que des quotas horaires en fonction du type d'abonné

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Outre les composants facturables de Google Cloud, ce tutoriel utilise Apigee Edge.

Avant de commencer

Créer un projet Google Cloud

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activez l'API AI Platform.

    Activer l'API

Si le SDK Cloud n'est pas installé, utilisez Cloud Shell pour déployer l'application. Cloud Shell fournit un environnement d'interface système dans lequel le SDK Cloud est préinstallé. Le reste de ce tutoriel utilise Cloud Shell.

Créer un compte Apigee Edge

Suivez les étapes décrites dans la documentation Créer un compte Apigee Edge (en anglais). Apigee propose un compte d'essai gratuit permettant de tester la solution, que vous pouvez utiliser pour suivre les étapes de ce tutoriel.

Architecture de la solution

Dans ce tutoriel, vous déployez des modèles TensorFlow sur AI Platform et vous utilisez la prédiction en ligne pour les mettre à disposition pour la diffusion. Pour chaque modèle hébergé, vous déployez un proxy d'API sur Apigee Edge qui utilisera un compte de service pour authentifier les requêtes en provenance des applications clientes. Apigee Edge transmet ensuite les requêtes au service de prédiction en ligne d'AI Platform. Apigee Edge applique les règles de l'API telles que les quotas d'utilisation, la limitation de débit et la vérification des clés API. Le service peut également appliquer des variantes de règles, telles que des quotas variables par clé API, à l'aide des produits d'API que vous configurez. Le diagramme suivant illustre cette architecture.

Déploiement de modèles TensorFlow dans AI Platform et utilisation de la prédiction en ligne pour les mettre à disposition pour la diffusion

Le tableau suivant explique plus en détail les concepts utilisés dans le diagramme :

Concept Description
Application Une application appelle les prédictions sur votre modèle de machine learning à travers une API hébergée par Apigee Edge. La requête HTTP est adressée à un point de terminaison géré par un proxy d'API. Le proxy d'API dans Apigee Edge vérifie la clé API pour authentification et applique des niveaux d'accès et de fonctionnalités spécifiques tels que définis par le produit d'API associé à la clé API.
Proxy d'API Un proxy d'API transmet les requêtes d'un point de terminaison de proxy (exposé aux applications clientes) vers un point de terminaison cible. Le point de terminaison cible est le point de terminaison de votre modèle hébergé, qui est défini pour recevoir les requêtes de prédiction en ligne d'AI Platform.
Produit d'API Un produit d'API regroupe des ressources Apigee (telles que des proxy d'API) afin de proposer des niveaux d'accès et de fonctionnalités spécifiques aux développeurs d'applications clientes. Par exemple, le produit d'API peut imposer des limites d'accès, des méthodes d'approbation de clé API et des configurations alternatives pour les serveurs proxy d'API utilisés pour accéder aux prédictions en ligne sur les modèles hébergés.
Modèle hébergé Un modèle hébergé est un modèle de ML entraîné et déployé dans AI Platform. Pour demander des prédictions à partir de vos modèles hébergés, vous utilisez le service de prédiction en ligne ou de prédiction par lot d'AI Platform.

Au lieu d'exposer directement aux utilisateurs le modèle hébergé dans AI Platform, l'architecture de cette solution exploite Apigee Edge pour permettre aux utilisateurs externes d'appeler des modèles hébergés via un proxy d'API. Faire transiter les requêtes à travers un proxy via Apigee Edge permet d'appliquer différentes règles d'utilisation.
Ressources de modèles Dans ce tutoriel, pour déployer un modèle TensorFlow hébergé sur AI Platform, vous exportez votre modèle au format SavedModel de TensorFlow et vous stockez les ressources de modèle résultantes dans un bucket Cloud Storage. Le service de prédiction en ligne ou par lot d'AI Platform peut ensuite générer des prédictions sur le modèle.

Exemple de scénario

Dans ce tutoriel, vous utilisez Apigee Edge pour créer deux exemples de produits d'API pour un modèle hébergé simple (prédiction de revenus à partir de données de recensement) déployé dans AI Platform.

Le schéma suivant présente les deux exemples de produits d'API : un produit de Prédiction de revenu en version d'essai, avec des quotas d'utilisation limités, et un produit de Prédiction de revenu en version premium, doté de quotas élevés. Dans ce scénario d'exemple, vous enregistrez deux développeurs et applications pour tester l'API dans différentes conditions de restrictions appliquées par les deux produits d'API.

Deux exemples de produits d'API pour un modèle hébergé simple déployé dans AI Platform

Créer un compte de service Google Cloud

Apigee Edge nécessite un compte de service Google Cloud pour authentifier ses requêtes auprès du service de prédiction en ligne d'AI Platform.

GCLOUD

  1. Ouvrez Cloud Shell.

    Accéder à Cloud Shell

    Sauf indication contraire, vous utilisez Cloud Shell tout au long de ce tutoriel.

  2. Configurez une variable d'environnement pour stocker le nom de votre compte de service :

    SERVICE_ACCOUNT=income-prediction-api@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
    
  3. Créez un compte de service :

    gcloud iam service-accounts create \
        income-prediction-api \
        --display-name "Apigee service account"
    
  4. Créez une clé privée pour le compte de service :

    gcloud iam service-accounts keys create \
        --iam-account ${SERVICE_ACCOUNT} \
        ~/key.json
    

    Cette commande enregistre un fichier de clé privée dans ${HOME}/key.json. Gardez ce fichier bien en sécurité, vous en aurez besoin pour les prochaines étapes.

Console

  1. Dans Cloud Console, accédez à la page IAM et admin > Comptes de service de votre projet :

    Accéder à la page "Comptes de service"

  2. Cliquez sur Créer un compte de service, puis saisissez les détails du compte de service :

    1. Indiquez un nom de compte de service, tel que Income Prediction API.
    2. Indiquez un ID de compte de service, tel que income-prediction-api.
    3. Cliquez sur Créer.
  3. Sur la page Autoriser ce compte de service à accéder au projet (facultatif), laissez la liste déroulante Rôle vide et cliquez sur Continuer.

  4. Sur la page Accorder l'accès à ce compte de service à des utilisateurs (facultatif), faites défiler vers le bas et cliquez sur Créer une clé :

    1. Sélectionnez le type de clé JSON, qui est le type de clé par défaut.
    2. Cliquez sur Créer. Votre navigateur lance le téléchargement de votre fichier de clé privée. Gardez ce fichier bien en sécurité, car vous en aurez besoin pour les prochaines étapes.
    3. Cliquez sur OK.

Déployer le modèle de prédiction de revenu sur AI Platform

Ce tutoriel utilise un exemple de code existant pour entraîner un modèle de prédiction de revenus à partir de données de recensement. Pour plus de commodité, le dépôt du code de ce tutoriel sur GitHub inclut un modèle entraîné.

Réalisez les étapes suivantes pour déployer le modèle pré-entraîné de prédiction de revenu sur AI Platform :

  1. Ouvrez Cloud Shell.

    Accéder à Cloud Shell

  2. Dans Cloud Shell, définissez les variables d'environnement que vous utiliserez dans les commandes suivantes :

    GCS_MODEL_BUCKET=${GOOGLE_CLOUD_PROJECT}-ml-models
    MODEL_NAME=census
    MODEL_VERSION=v1
    MODEL_REGION=us-central1
    
  3. Clonez les fichiers du tutoriel depuis GitHub :

    cd ${HOME}
    
    git clone https://github.com/GoogleCloudPlatform/cloudml-apigee-serving.git
    
  4. Créez un bucket de stockage régional Cloud Storage pour stocker le modèle de prédiction :

    gsutil mb -c regional -l ${MODEL_REGION} \
        -p ${GOOGLE_CLOUD_PROJECT} gs://${GCS_MODEL_BUCKET}
    
  5. Extrayez et copiez le modèle dans Cloud Storage :

    cd ${HOME}/cloudml-apigee-serving/model
    
    tar zxvf census.tar.gz
    
    gsutil -m cp -rv census gs://${GCS_MODEL_BUCKET}
    
  6. Créez le modèle de prédiction dans AI Platform.

    gcloud ml-engine models create ${MODEL_NAME} \
         --regions ${MODEL_REGION}
    
  7. Créez une nouvelle version du modèle de prédiction :

    gcloud ml-engine versions create ${MODEL_VERSION} \
        --model ${MODEL_NAME} \
        --origin gs://${GCS_MODEL_BUCKET}/census \
        --runtime-version 1.6
    
  8. Obtenez des informations sur la nouvelle version à l'aide de la commande suivante :

    gcloud ml-engine versions describe ${MODEL_VERSION} \
        --model ${MODEL_NAME}
    

    La sortie doit ressembler à ce qui suit :

    deploymentUri: your_bucket_path
    framework: TENSORFLOW
    isDefault: true
    lastUseTime: '2018-05-07T04:41:22Z'
    name: projects/your_project/models/census/versions/v1
    pythonVersion: '2.7'
    runtimeVersion: '1.6'
    state: READY
    
  9. Avant de continuer, vérifiez que vous pouvez correctement exécuter des prédictions :

    gcloud ml-engine predict \
        --model ${MODEL_NAME} \
        --version ${MODEL_VERSION} \
        --json-instances ${HOME}/cmle-op-apigee-tutorial/model/test.json
    

    La sortie doit ressembler à ce qui suit. Cette sortie confirme que votre modèle hébergé est correctement déployé sur AI Platform et qu'il peut être appelé via le service de prédiction en ligne d'AI Platform.

    CLASS_IDS  CLASSES  LOGISTIC               LOGITS                PROBABILITIES
    [0]        [u'0']   [0.23072466254234314]  [-1.204223871231079]  [0.7692753076553345, 0.23072466254234314]
    

Déployer le proxy d'API sur Apigee Edge

Un proxy d'API permet aux clients d'appeler votre modèle hébergé via une API externe. Le proxy d'API effectue cette tâche en transmettant par proxy les requêtes des clients depuis une interface API externe hébergée par Apigee Edge vers l'API predict AI Platform pour votre modèle hébergé. L'interface met en œuvre un modèle de façade d'API qui protège les utilisateurs contre toute modification des points de terminaison cibles lors du déploiement de nouveaux modèles et de nouvelles versions de modèles. Pour plus d'informations, consultez la documentation sur les proxys d'API.

Dans une configuration de proxy d'API, vous utilisez des flux pour configurer les étapes de traitement exécutées dans votre requête et votre réponse d'API. Les étapes de traitement peuvent inclure des activités telles que la génération et la signature de jetons Web JSON (JWT), l'ajout d'en-têtes de requête et de réponse ou l'utilisation de fonctionnalités spécifiques d'Apigee Edge. Apigee Edge fournit un certain nombre de règles d'API intégrées pour assurer ces activités. Vous pouvez ajouter ces règles à vos flux d'API.

Apigee Edge propose plusieurs méthodes pour déployer des proxys d'API, parmi lesquelles une interface de gestion Web (connexion requise), des API de gestion et des outils de ligne de commande.

Pour ce tutoriel, vous allez utiliser apigeetool pour créer les ressources Apigee requises et déployer le proxy d'API.

  1. Ouvrez Cloud Shell.

    Accéder à Cloud Shell

  2. Dans Cloud Shell, configurez les variables d'environnement. Vous aurez besoin de ces variables ultérieurement. Remplacez [YOUR_APIGEE_USER_EMAIL], [YOUR_APIGEE_ORGANIZATION], [YOUR_APIGEE_ENVIRONMENT] et [YOUR_APIGEE_USER_PASSWORD] par vos propres valeurs.

    • Votre compte Apigee se voit automatiquement attribuer le rôle d'administrateur d'organisation et dispose d'un accès super-utilisateur à toutes les ressources de votre organisation Apigee. Vous pouvez en apprendre davantage sur les fonctions des différents rôles Apigee (en anglais).
    • Votre organisation Apigee est créée automatiquement. Vous pouvez trouver le nom de votre organisation dans l'interface de gestion Web d'Apigee, dans le coin supérieur gauche de la page affichant le nom de votre nom de compte.
    • Deux environnements Apigee nommés test et prod sont automatiquement créés. Vous pouvez utiliser l'un ou l'autre de ces environnements dans les étapes suivantes.

    1. Exportez les variables d'environnement requises par apigeetool :

      export APIGEE_USERNAME=[YOUR_APIGEE_USER_EMAIL]
      export APIGEE_ORGANIZATION=[YOUR_APIGEE_ORGANIZATION]
      
    2. Vous pouvez éventuellement exporter une variable d'environnement pour votre mot de passe Apigee :

      export APIGEE_PASSWORD=[YOUR_APIGEE_USER_PASSWORD]
      
    3. Configurez les autres variables d'environnement nécessaires pour travailler avec votre environnement Apigee :

      APIGEE_ENVIRONMENT=[YOUR_APIGEE_ENVIRONMENT]
      
    4. Laissez le nom de cache d'Apigee à sa valeur par défaut, "google" :

      APIGEE_CACHE=google
    5. Configurez les variables d'environnement correspondant au nom et à la version de votre modèle dans AI Platform. Ces variables doivent être identiques aux valeurs précédentes que vous avez utilisées pour déployer la version du modèle :

      MODEL_NAME=census
      MODEL_VERSION=v1
      
    6. Configurez une variable d'environnement pour le compte de service utilisé par Apigee pour appeler le service de prédiction en ligne d'AI Platform :

      SERVICE_ACCOUNT=income-prediction-api@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com
      
  3. Installez apigeetool, que vous utilisez pour créer des ressources Apigee et déployer le proxy d'API :

    npm install -g apigeetool
    
    alias apigeetool=$(npm config get prefix)/bin/apigeetool
    
  4. Récupérez la clé privée associée à votre compte de service dans le fichier d'identifiants JSON que vous avez enregistré précédemment :

    PRIVATE_KEY=`sed -rne 's/^.*\"private_key\": \"(.*)\",$/\1/p' <  ${HOME}/key.json`
    
  5. Créez un mapping clé-valeur (KVM, Key-Value Map) chiffré pour stocker de manière sécurisée le nom du compte de service et la clé privée dans Apigee Edge :

    apigeetool createkvmmap \
        -e ${APIGEE_ENVIRONMENT} \
        --encrypted \
        --mapName "secrets"
    
  6. Ajoutez le nom du compte de service à la carte KVM chiffrée :

    apigeetool addEntryToKVM \
        -e ${APIGEE_ENVIRONMENT} \
        --mapName "secrets" \
        --entryName "service-account" \
        --entryValue "${SERVICE_ACCOUNT}"
    
  7. Ajoutez la clé privée à la carte KVM chiffrée :

    apigeetool addEntryToKVM \
        -e ${APIGEE_ENVIRONMENT} \
        --mapName "secrets" \
        --entryName "private-key" \
        --entryValue "`echo -e ${PRIVATE_KEY}`"
    
  8. Mettez à jour le point de terminaison du proxy d'API vers votre modèle déployé dans AI Platform. Le proxy d'API transfère les requêtes à la méthode projects.predict pour votre modèle hébergé dans la prédiction en ligne d'AI Platform.

    sed -i \
        -e "s/\[project\]/${GOOGLE_CLOUD_PROJECT}/" \
        -e "s/\[model-name\]/${MODEL_NAME}/" \
        -e "s/\[model-version\]/${MODEL_VERSION}/" \
        ${HOME}/cmle-op-apigee-tutorial/apiproxy/targets/default.xml
    
  9. Créez un cache Apigee pour le stockage temporaire des jetons d'accès OAuth2 renvoyés par le serveur d'autorisation de Google :

    apigeetool createcache \
        -e ${APIGEE_ENVIRONMENT} \
        -z ${APIGEE_CACHE}
    
  10. Accordez des autorisations Identity and Access Management (IAM) pour permettre à votre compte de service de demander des prédictions sur votre modèle. Vous accordez ces autorisations en ajoutant la liaison de stratégie IAM pour le modèle census, comme suit :

    gcloud ml-engine models add-iam-policy-binding \
        ${MODEL_NAME} \
        --member=serviceAccount:${SERVICE_ACCOUNT} \
        --role=roles/ml.modelUser
    
  11. Déployez le proxy d'API :

    apigeetool deployproxy  \
        -e ${APIGEE_ENVIRONMENT} \
        -n income_prediction -d ${HOME}/cmle-op-apigee-tutorial
    

Créer des produits d'API pour distribuer vos API

Vous pouvez utiliser un produit d'API Apigee pour configurer des niveaux d'accès et de fonctionnalités spécifiques pour les développeurs. Par exemple, vous pouvez créer deux produits d'API pour refléter deux niveaux de service intitulés "Essai" et "Premium" pour vos modèles hébergés dans AI Platform. Chaque niveau se distingue par les quotas autorisés, les fonctionnalités accessibles et d'autres caractéristiques.

Dans cette section, vous allez créer deux produits d'API : Prédiction de revenu en version d'essai et Prédiction de revenu en version premium. Vous configurez les deux produits d'API pour utiliser le proxy d'API que vous avez déployé à l'étape précédente, mais vous appliquez des règles d'utilisation différentes, comme expliqué ici :

  • Le produit d'API Prédiction de revenu en version d'essai applique un quota d'utilisation quotidienne faible, mais permet aux développeurs d'obtenir des clés API par le biais d'un processus automatisé. Cette règle peut refléter un niveau de type "essai gratuit", grâce auquel vous proposez un accès simple à votre API avec des limites d'utilisation relativement faibles.

  • Le produit d'API Prédiction de revenu en version premium accorde un quota d'utilisation quotidienne plus élevé, mais impose aux développeurs de passer par un processus d'approbation manuel. Cette règle peut correspondre à un niveau payant pour votre API, qui propose un accès plus contrôlé et des limites d'utilisation élevées.

Pour créer les produits d'API, procédez comme suit.

  1. Créez le produit d'API Prédiction de revenu en version d'essai :

    apigeetool createProduct \
        --approvalType "auto" \
        --environments ${APIGEE_ENVIRONMENT} \
        --proxies income_prediction \
        --productName "income_prediction_trial" \
        --productDesc "Free trial API for income prediction." \
        --quota 10 \
        --quotaInterval 1 \
        --quotaTimeUnit "day"
    
  2. Créez le produit d'API Prédiction de revenu en version premium :

    apigeetool createProduct \
        --approvalType "manual" \
        --environments ${APIGEE_ENVIRONMENT} \
        --proxies income_prediction \
        --productName "income_prediction_premium" \
        --productDesc "Premium API for income prediction." \
        --quota 10000 \
        --quotaInterval 1 \
        --quotaTimeUnit "day"
    

Créer des profils de développeur

Les profils de développeur peuvent être créés par un administrateur Apigee Edge ou par des personnes utilisant un processus d'inscription en libre service.

  1. Créez un profil de développeur pour John :

    apigeetool createDeveloper \
        --email john@example.com \
        --firstName John \
        --lastName Citizen \
        --userName john@example.com
    
  2. Créez un deuxième profil de développeur pour Sally :

    apigeetool createDeveloper \
        --email sally@example.com \
        --firstName Sally \
        --lastName Resident \
        --userName sally@example.com
    

Enregistrer des applications de développement

Dans cette section, vous enregistrez manuellement des applications de développement pour chacun des profils de développeur.

Si chacune des commandes suivantes s'exécute avec succès, une réponse JSON est affichée dans le terminal. Pour chaque commande, notez la valeur de la propriété consumerKey, qui est la clé d'API générée pour l'application de développement.

  1. Enregistrez l'application de développement FooApp et associez-la à John pour une utilisation avec le produit d'API Prédiction de revenus en version d'essai. Cette commande utilise jq pour extraire la valeur de la propriété consumerKey de la réponse. Notez cette valeur.

    FOOAPP_API_KEY="$(apigeetool createApp \
        --apiProducts "income_prediction_trial" \
        --name "FooApp" \
        --email john@example.com \
        | jq -r '.credentials[0].consumerKey')"
    
  2. Enregistrez l'application de développement BarApp et associez-la à Sally pour une utilisation avec le produit d'API Prédiction de revenus en version premium. Notez la valeur consumerKey dans la sortie.

    BARAPP_API_KEY="$(apigeetool createApp \
        --apiProducts "income_prediction_premium" \
        --name "BarApp" \
        --email sally@example.com \
        | jq -r '.credentials[0].consumerKey')"
    

Tester le proxy d'API

Pour tester le proxy d'API, vous pouvez maintenant utiliser la clé API pour appeler l'API de prédiction de revenus.

  1. Testez la clé API (la valeur de la propriété consumerKey) pour l'application FooApp, qui est enregistrée auprès du développeur John.

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${FOOAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict
    

    Si le test réussit, la réponse ressemble à ce qui suit :

    {
        "predictions":[
            {
                "probabilities":[
                    0.7692753076553345,
                    0.23072466254234314
                ],
                "class_ids":[
                    0
                ],
                "classes":[
                    "0"
                ],
                "logits":[
                    -1.204223871231079
                ],
                "logistic":[
                    0.23072466254234314
                ]
            }
        ]
    }
    

    Exécutez la requête dix fois de plus pour épuiser le quota :

    for i in `seq 10`; do !! | jq '.' ; done
    

    Lorsque le quota est dépassé, Apigee Edge renvoie une erreur :

    {
        "fault":{
            "detail":{
                "errorcode": "policies.ratelimit.QuotaViolation"
            },
            "faultstring": "Rate limit quota violation. Quota limit exceeded. Identifier : \_default"
        }
    }
    

    La demande est rejetée si la clé API est supprimée de l'en-tête de la requête :

    {
        "fault":{
            "faultstring": "Failed to resolve API Key variable request.header.X-APIKEY",
            "detail":{
               "errorcode": "steps.oauth.v2.FailedToResolveAPIKey"
            }
        }
    }
    
  2. Testez la clé API (la valeur de la propriété consumerKey) pour l'application BarApp, qui est enregistrée auprès du développeur Sally.

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${BARAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict | jq '.'
    

    La sortie doit ressembler à ce qui suit, car le produit d'API correspondant à la clé API n'a pas encore été approuvé :

    {
        "fault": {
            "faultstring": "Invalid ApiKey for given resource",
            "detail": {
                "errorcode": "oauth.v2.InvalidApiKeyForGivenResource"
            }
        }
    }
    

Approuver et révoquer des produits d'API

À l'étape précédente, le proxy d'API a renvoyé une erreur lorsque nous avons utilisé la clé API pour l'application BarApp. En effet, le produit d'API correspondant n'a pas encore été approuvé pour une utilisation avec cette clé API.

Pour approuver le produit d'API à utiliser avec la clé API BarApp, vous pouvez utiliser l'API de gestion Apigee Edge. Vous pouvez également utiliser l'interface Web Apigee Edge pour approuver le produit d'API. Vous pouvez en apprendre davantage sur l'approbation ou la révocation manuelles de clés API à l'aide de l'interface Web (en anglais).

Effectuez les étapes suivantes dans Cloud Shell pour approuver le produit d'API à l'aide de l'API de gestion d'Apigee Edge.

  1. Configurez les variables d'environnement dont vous aurez besoin dans les commandes ultérieures :

    DEVELOPER_EMAIL=sally@example.com
    APP_NAME=BarApp
    API_PRODUCT=income_prediction_premium
    
  2. Appelez l'API de gestion d'Apigee Edge pour approuver l'utilisation du produit d'API avec la clé API :

    curl -s -X POST \
        -u "${APIGEE_USERNAME}" \
        --header "Content-Type: application/octet-stream" \
        "https://api.enterprise.apigee.com/v1/organizations/${APIGEE_ORGANIZATION}/developers/${DEVELOPER_EMAIL}/apps/${APP_NAME}/keys/${BARAPP_API_KEY}/apiproducts/${API_PRODUCT}?action=approve"
    
  3. Renvoyez la requête API en utilisant la même clé API :

    curl -s -X POST \
        -H "Content-Type: application/json" \
        -H "X-APIKEY: ${BARAPP_API_KEY}" \
        -d '{
            "instances": [{
                "age": 25,
                "workclass": "Private",
                "education": "Some-college",
                "education_num": 1,
                "marital_status": "Never-married",
                "occupation": "Other-service",
                "relationship": "Other-relative",
                "race": "Other",
                "gender": "Female",
                "capital_gain": 0,
                "capital_loss": 0,
                "hours_per_week": 40,
                "native_country": "United-States"}]
        }' \
        https://${APIGEE_ORGANIZATION}-${APIGEE_ENVIRONMENT}.apigee.net/ml/census/v1/predict | jq '.'
    

    La sortie doit ressembler à ce qui suit, car le produit d'API correspondant à la clé API est désormais approuvé :

    {
        "predictions":[
            {
                "probabilities":[
                    0.7692753076553345,
                    0.23072466254234314
                ],
                "class_ids":[
                    0
                ],
                "classes":[
                    "0"
                ],
                "logits":[
                    -1.204223871231079
                ],
                "logistic":[
                    0.23072466254234314
                ]
            }
        ]
    }
    

Activer l'enregistrement en libre-service au travers du portail des développeurs

Dans ce tutoriel, vous avez utilisé un compte d'administration Apigee pour créer des profils de développeur, des applications et des clés API.

Vous pouvez envisager d'activer l'enregistrement en libre-service pour votre produit d'API à l'aide d'un portail de services pour les développeurs. Ce portail permet aux utilisateurs d'enregistrer des profils et des applications de développement, ainsi que de générer des clés API via un processus en libre service. Si vous activez un portail en libre-service, les utilisateurs individuels peuvent accéder à votre API via un processus automatisé. En fonction de vos besoins dans le cadre de ce processus, vous pouvez configurer une approbation automatique de la clé API, ou continuer à spécifier une approbation manuelle.

Apigee Edge fournit un outil Web graphique permettant de créer votre portail des développeurs. Vous pouvez en apprendre davantage sur la création d'un portail des développeurs pour vos produits d'API (en anglais).

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud Platform, procédez comme suit :

  • Supprimez le projet.
  • Fermez votre compte d'essai Apigee Edge.
  • Arrêtez de répondre aux requêtes de proxy d'API.

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Fermer votre compte d'essai Apigee Edge

Votre compte d'essai Apigee Edge est automatiquement fermé à l'expiration de la période d'évaluation. Aucune action spécifique de votre part n'est requise pour supprimer votre compte d'essai.

Arrêter la diffusion des requêtes de proxy d'API

Pour cesser de diffuser les requêtes de proxy d'API, annulez le déploiement ou supprimez le proxy d'API. En outre, pour empêcher toute nouvelle inscription, supprimez les portails des développeurs que vous avez éventuellement créés.

  1. Dans Cloud Shell, annulez le déploiement du proxy d'API à l'aide de apigeetool :

    apigeetool undeploy \
        -u ${APIGEE_USERNAME} \
        -o ${APIGEE_ORGANIZATION} \
        -n income_prediction
        -e ${APIGEE_ENVIRONMENT} \
        -r 1 \
        -n income_prediction
    

    La sortie ressemble à ceci :

    "income_prediction" Revision 1
      undeployed
      environment = test
      base path = /
    

Étapes suivantes