GSP843

Présentation

Les API sont utilisées par des développeurs d'applications, qui s'en servent dans le but d'offrir des expériences uniques à leurs utilisateurs. La plate-forme d'API Apigee de Google Cloud permet de publier des API et de les mettre à la disposition des développeurs.

Dans cet atelier, vous allez créer un proxy d'API Apigee qui impose une vérification de clé API pour restreindre l'accès à l'API.

Vous créerez des produits d'API pour fournir différents niveaux de service aux développeurs d'applications internes et externes. Ensuite, vous utiliserez une règle de quota pour limiter le nombre d'appels pour chaque application spécifique. Vous créerez également une règle CORS pour ajouter à l'API la fonctionnalité de Cross-Origin Resource Sharing, laquelle lui permet d'être appelée depuis des applications Web. Enfin, vous créerez un portail des développeurs et y publierez les produits d'API pour que les développeurs d'applications puissent s'en servir.

Points abordés

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Vérifier une clé API pour restreindre l'accès à une API et suivre l'utilisation de l'application
• Créer des produits d'API pour fournir différents niveaux d'accès à différents types de développeurs d'applications
• Utiliser la règle de quota pour limiter le nombre d'appels pour une application spécifique en fonction du produit d'API associé
• Ajouter la fonctionnalité CORS (Cross-Origin Resource Sharing) à une API pour autoriser les appels d'API multi-origines à partir d'applications Web
• Créer un portail des développeurs et y publier les produits d'API

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).

Remarque : Ouvrez une fenêtre de navigateur en mode incognito (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• Vous disposez d'un temps limité. N'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau "Détails concernant l'atelier", qui contient les éléments suivants :

   • Le bouton "Ouvrir la console Google Cloud"
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page "Se connecter" dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau "Détails concernant l'atelier".

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau "Détails concernant l'atelier".

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET : . Le résultat contient une ligne qui déclare l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

3. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Ouvrir la console Apigee

Pour ouvrir la console Apigee :

• Dans la console Google Cloud, dans le champ Rechercher, saisissez Apigee, puis cliquez sur Apigee API Management dans les résultats de recherche.

La console Apigee s'ouvre. La page de destination propose des liens rapides vers des emplacements couramment utilisés.

• Dans le menu de navigation (), à côté de Apigee, cliquez sur Ajouter aux favoris ().

Apigee est désormais ajouté en tant que favori au menu de navigation.

Tâche 1 : Mettre en place un proxy pour le service de backend à l'aide d'un proxy d'API Apigee

Dans cette tâche, vous allez créer un proxy d'API Apigee qui fait office de façade pour un service de backend. Ce proxy d'API utilisera un compte de service pour présenter des jetons d'identité OpenID Connect au service Cloud Run.

Un service de backend nommé simplebank-rest a déjà été créé et déployé sur Cloud Run.

Créer le proxy Apigee

1. Dans Cloud Shell, exécutez la commande suivante pour récupérer l'URL du service de backend :

gcloud run services describe simplebank-rest --platform managed --region {{{project_0.default_region |REGION}}} --format 'value(status.url)'

Enregistrez cette URL. Vous l'utiliserez lors de la création du proxy d'API.

1. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API).

2. Pour créer un proxy à l'aide de l'assistant de création de proxy, cliquez sur + Créer.

   Vous allez créer un proxy inverse pour votre service de backend.

3. Pour le modèle de proxy, sélectionnez General template > Reverse proxy (Most common) (Modèle général > Proxy inverse (le plus courant)).

   Remarque : N'utilisez pas l'option Reverse proxy (Most common) (Proxy inverse (le plus courant)) dans la section OpenAPI spec template (Modèle de spécification OpenAPI).

4. Saisissez les informations suivantes pour les détails du proxy :

   Propriété	Valeur
   Proxy name (Nom du proxy)	bank-v1
   Base path (Chemin de base)	/bank/v1
   Target (Existing API) (Cible (API existante))	URL du backend

   Remarque : Vérifiez que vous utilisez "/bank/v1" comme chemin de base, et non "/bank-v1".

   La cible doit être l'URL du backend, que vous avez récupérée précédemment au cours de cette tâche. Elle doit ressembler à ceci :

   https://simplebank-rest-mtdtzt7yzq-ue.a.run.app

5. Cliquez sur Next (Suivant).

6. Conservez les paramètres par défaut de la section Deploy (optional) (Déployer (facultatif)), puis cliquez sur Create (Créer).

Tâche 2 : Ajouter une règle VerifyAPIKey

Dans cette tâche, vous allez ajouter une règle VerifyAPIKey au proxy d'API. Toute requête qui ne fournit pas de clé API valide sera refusée.

Une règle VerifyAPIKey applique la vérification des clés API lors de l'exécution, afin de n'autoriser que les applications disposant de clés API approuvées à accéder à l'API. Cette règle assure que la clé API est valide, qu'elle n'a pas été révoquée et qu'elle est approuvée pour utiliser la ressource spécifique demandée.

Ajouter la règle VerifyAPIKey

1. Cliquez sur l'onglet Develop (Développer) :

2. Dans le menu de navigation du proxy, dans la section Proxy Endpoints (Points de terminaison du proxy), cliquez sur PreFlow.

   La règle VerifyAPIKey doit être placée très tôt dans le proxy d'API. Le PreFlow de requête dans le point de terminaison de proxy par défaut est le premier flux exécuté lorsqu'une requête parvient au proxy d'API.

3. Dans le volet Flow (Flux), cliquez sur le bouton + Add Policy Step (+ Ajouter une étape de règle) en haut à droite, au-dessus du flux de requête.

4. Sélectionnez Create new policy (Créer une règle), puis sous Select policy (Sélectionner une règle), dans la section Security (Sécurité), sélectionnez Verify API Key (Valider la clé API). Définissez ensuite Display Name (Nom à afficher) et Name (Nom) sur VAK-VerifyKey.

5. Cliquez sur Add (Ajouter).

6. Cliquez sur le nom VAK-VerifyKey.

   La configuration VerifyAPIKey s'affiche dans le volet Code sous Policies (Règles).

   L'élément APIKey indique où la clé API est fournie dans la requête.

7. Dans l'élément APIKey, remplacez request.queryparam.apikey par request.header.apikey.

   Une clé API est moins susceptible d'être consignée dans l'historique du navigateur lorsqu'elle est spécifiée dans un en-tête.

Modifier la cible pour envoyer un jeton d'identité OpenID Connect

Le service de backend est déployé pour exiger un accès authentifié. Vous ne pouvez donc pas appeler le service sans jeton d'identité OpenID Connect valide.

La section HTTPTargetConnection spécifie la cible de backend du service.

1. Dans le menu de navigation du proxy, dans la section Target Endpoints (Points de terminaison cibles), cliquez sur PreFlow.

2. Recherchez le code suivant (votre URL sera différente) :

   <HTTPTargetConnection> <URL>https://simplebank-rest-zce6j3rjwq-uw.a.run.app</URL> </HTTPTargetConnection>

Remarque : Si la section "HTTPTargetConnection" n'apparaît pas, assurez-vous d'avoir cliqué sur "PreFlow" dans la section "Target Endpoints" (Points de terminaison cibles), et non dans la section "Proxy Endpoints" (Points de terminaison du proxy).

3. Sous l'URL, ajoutez une section Authentication qui ressemble à ceci :

<Authentication> <GoogleIDToken> <Audience>AUDIENCE</Audience> </GoogleIDToken> </Authentication>

4. Remplacez AUDIENCE par la valeur d'URL déjà présente dans la section HTTPTargetConnection. Votre code doit maintenant ressembler à ceci, excepté que votre URL spécifique apparaît dans les éléments "URL" et "Audience" :

<TargetEndpoint name="default"> <PreFlow name="PreFlow"> <Request/> <Response/> </PreFlow> <Flows/> <PostFlow name="PostFlow"> <Request/> <Response/> </PostFlow> <HTTPTargetConnection> <URL>https://simplebank-rest-zce6j3rjwq-uw.a.run.app</URL> <Authentication> <GoogleIDToken> <Audience>https://simplebank-rest-zce6j3rjwq-uw.a.run.app</Audience> </GoogleIDToken> </Authentication> </HTTPTargetConnection> </TargetEndpoint>

5. Cliquez sur Save (Enregistrer).

Vérifier que l'instance d'exécution est disponible

1. Dans Cloud Shell, collez et exécutez cet ensemble de commandes :

   export INSTANCE_NAME=eval-instance; export ENV_NAME=eval; if [ -z "${GOOGLE_CLOUD_PROJECT}" ]; then echo "Error: GOOGLE_CLOUD_PROJECT environment variable is not set. Please set it to your project ID."; else export PREV_INSTANCE_STATE=; echo "waiting for runtime instance ${INSTANCE_NAME} to be active"; while : ; do export INSTANCE_STATE=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${GOOGLE_CLOUD_PROJECT}/instances/${INSTANCE_NAME}" | jq "select(.state != null) | .state" --raw-output); [[ "${INSTANCE_STATE}" == "${PREV_INSTANCE_STATE}" ]] || (echo; echo "INSTANCE_STATE=${INSTANCE_STATE}"); export PREV_INSTANCE_STATE=${INSTANCE_STATE}; [[ "${INSTANCE_STATE}" != "ACTIVE" ]] || break; echo -n "."; sleep 5; done; echo; echo "instance created, waiting for environment ${ENV_NAME} to be attached to instance"; while : ; do export ATTACHMENT_DONE=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${GOOGLE_CLOUD_PROJECT}/instances/${INSTANCE_NAME}/attachments" | jq "select(.attachments != null) | .attachments[] | select(.environment == \"${ENV_NAME}\" or (.environment | endswith(\"/${ENV_NAME}\"))) | .environment" --raw-output); [[ -n "${ATTACHMENT_DONE}" ]] && break; echo -n "."; sleep 5; done; echo; echo "${ENV_NAME} environment attached"; echo "***ORG IS READY TO USE***"; fi

   Cette série de commandes utilise l'API Apigee pour déterminer quand l'instance d'exécution Apigee a été créée et quand l'environnement "eval" a été associé.

2. Attendez que l'instance soit prête.

   Lorsque le texte ***ORG IS READY TO USE*** s'affiche, l'instance est prête. Il se peut que l'organisation Apigee ait été créée avant le début de l'atelier. Dans ce cas, vous n'aurez pas à attendre la création de l'instance.

   Pendant que vous patientez, vous pouvez en apprendre davantage sur les produits d'API, le CORS (Cross-Origin Resource Sharing) et les portails des développeurs.

Déployer le proxy d'API

1. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.

2. Cliquez sur Deploy (Déployer).

3. Pour Environment (Environnement), sélectionnez eval.

4. Pour Service account (Compte de service), spécifiez l'adresse e-mail du compte de service :

   apigee-internal-access@{{{ project_0.project_id | PROJECT }}}.iam.gserviceaccount.com

5. Cliquez sur Deploy (Déployer), puis sur Confirm (Confirmer).

6. Attendez que l'état du déploiement eval indique que le proxy a été déployé.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer le proxy Apigee et ajouter la règle VerifyAPIKey

Tester le proxy d'API

L'environnement "eval" de l'organisation Apigee peut être appelé à l'aide du nom d'hôte eval.example.com. L'entrée DNS de ce nom d'hôte a été créée dans votre projet et est résolue sur l'adresse IP de l'instance d'exécution Apigee. Cette entrée DNS a été créée dans une zone privée, ce qui signifie qu'elle n'est visible que sur le réseau interne.

Cloud Shell ne réside pas sur le réseau interne. Par conséquent, les commandes Cloud Shell ne peuvent pas résoudre cette entrée DNS. Une machine virtuelle (VM) de votre organisation peut accéder au DNS de la zone privée. Une VM nommée apigeex-test-vm a été créée automatiquement. Vous pouvez l'utiliser pour appeler le proxy d'API.

1. Dans Cloud Shell, ouvrez une connexion SSH vers votre VM de test :

   TEST_VM_ZONE=$(gcloud compute instances list --filter="name=('apigeex-test-vm')" --format "value(zone)") gcloud compute ssh apigeex-test-vm --zone=${TEST_VM_ZONE} --force-key-file-overwrite

2. Si vous êtes invité à donner votre autorisation, cliquez sur Autoriser.

3. Pour chaque question posée dans Cloud Shell, cliquez sur Entrée ou Retour pour spécifier la valeur par défaut.

   L'identité avec laquelle vous êtes connecté est propriétaire du projet. La connexion SSH à cette machine est donc autorisée.

   Votre session Cloud Shell s'exécute désormais dans la VM.

4. Appelez le proxy d'API bank-v1 déployé dans l'environnement eval :

   curl -i -k -X GET "https://eval.example.com/bank/v1/customers"

   L'option -k indique à curl d'ignorer la vérification du certificat TLS. L'environnement d'exécution Apigee de cet atelier utilise un certificat autosigné au lieu d'un certificat créé par une autorité de certification (CA) de confiance.

   Remarque : Vous ne devez pas utiliser l'option -k pour contourner la vérification des certificats dans les cas d'utilisation de production.

   Cette API tente de récupérer une liste de clients. Vous devriez maintenant voir une réponse 401 Unauthorized (non autorisé) semblable à celle-ci :

   HTTP/2 401 content-type: application/json x-request-id: 01e8da87-dc8c-4428-9cdf-8bea84e98860 content-length: 146 date: Tue, 07 Dec 2021 22:54:37 GMT via: 1.1 google {"fault":{"faultstring":"Failed to resolve API Key variable request.header.apikey","detail":{"errorcode":"steps.oauth.v2.FailedToResolveAPIKey"}}}

   Cette réponse indique que le proxy d'API a bloqué l'accès au service de backend du fait que la clé API n'a pas été fournie.

5. Saisissez la commande exit pour quitter la session SSH et revenir à Cloud Shell.

Tâche 3 : Ajouter des produits d'API et une application

Dans cette tâche, vous allez ajouter des produits d'API qui fourniront différents niveaux d'accès à votre API. Vous créerez ensuite deux applications et leur associerez des produits d'API distincts, ce qui leur donnera un accès différent.

Créer le premier produit d'API

Le premier produit d'API offre un accès complet au service.

1. Dans le menu de navigation Apigee, sélectionnez Distribution > API Products (Distribution > Produits d'API).

2. Pour créer un produit d'API, cliquez sur +CREATE (+ CRÉER).

3. Dans le volet Product details (Informations sur le produit), spécifiez les éléments suivants :

   Propriété	Valeur
   Name (Nom)	bank-fullaccess
   Display Name (Nom à afficher)	bank (full access)
   Description (Description)	autorise l'accès complet à l'API bank
   Environment (Environnement)	sélectionnez eval
   Access (Accès)	sélectionnez Public

   Laissez l'option Automatically approve access requests (Approuver automatiquement les demandes d'accès) sélectionnée.

4. Dans la section Operations (Opérations), cliquez sur +Add an Operation (+ Ajouter une opération).

   Les opérations permettent de spécifier quelles sont les requêtes autorisées dans les proxys d'API pour une application associée au produit d'API.

   Remarque : Assurez-vous que le bouton se trouve dans la section "Operations" (Opérations) et non dans la section "GraphQL Operations" (Opérations GraphQL).

5. Renseignez les champs suivants :

   Name (Nom)	Valeur
   Source (Source)	sélectionnez le proxy d'API bank-v1
   Path (Chemin)	/**
   Methods (Méthodes)	sélectionnez GET, PATCH, POST, PUT et DELETE

   L'expression de chemin d'accès "/**" indique que n'importe quel suffixe de chemin d'accès, quelle que soit sa profondeur, correspond pour l'opération.

   Dans un environnement de production, vous pouvez choisir d'ajouter chaque opération autorisée séparément, plutôt que d'utiliser cette expression de chemin avec caractère générique.

6. Cliquez sur Save (Enregistrer) pour enregistrer l'opération.

7. Dans la section Custom Attributes (Attributs personnalisés) du produit d'API, cliquez sur +Add Custom Attribute (+ Ajouter un attribut personnalisé).

   Vous pouvez utiliser des attributs personnalisés pour associer au proxy les données auxquelles vous souhaitez accéder afin de contrôler l'accès.

   Dans ce cas, comme il s'agit du produit d'API à accès complet pour votre API Retail, vous allez créer un attribut personnalisé qui indique que l'application appelant l'API doit bénéficier d'un accès complet.

8. Renseignez les champs suivants :

   Propriété	Valeur
   Name (Nom)	full-access
   Value (valeur)	yes

9. Cliquez sur OK pour enregistrer l'attribut personnalisé.

10. Pour enregistrer le produit d'API, cliquez sur Save (Enregistrer) en haut de la page.

11. Revenez à la page Distribution > API Products (Distribution > Produits d'API). Le produit d'API est affiché à l'écran.

Cliquez sur Vérifier ma progression pour valider l'objectif. Ajouter des produits d'API et une application

Créer un produit d'API fournissant un accès limité

Le deuxième produit d'API fournira un accès en lecture seule au service.

1. Pour créer un produit d'API, cliquez sur +CREATE (+ CRÉER).

2. Dans le volet Product details (Informations sur le produit), spécifiez les éléments suivants :

   Propriété	Valeur
   Name (Nom)	bank-readonly
   Display Name (Nom à afficher)	bank (read-only)
   Description (Description)	permet un accès en lecture seule à l'API bank
   Environment (Environnement)	sélectionnez eval
   Access (Accès)	sélectionnez Public

   Laissez l'option Automatically approve access requests (Approuver automatiquement les demandes d'accès) sélectionnée.

3. Dans la section Operations (Opérations), cliquez sur +Add an Operation (+ Ajouter une opération).

   Remarque : Assurez-vous que le bouton se trouve dans la section "Operations" (Opérations) et non dans la section "GraphQL Operations" (Opérations GraphQL).

4. Renseignez les champs suivants :

   Propriété	Valeur
   Source (Source)	sélectionnez le proxy d'API bank-v1
   Path (Chemin)	/**
   Methods (Méthodes)	sélectionnez GET

5. Cliquez sur Save (Enregistrer) pour enregistrer l'opération.

6. Pour enregistrer le produit d'API, cliquez sur Save (Enregistrer) en haut de la page.

7. Revenez à la page Distribution > API Products (Distribution > Produits d'API). Le produit d'API est affiché à l'écran.

Créer un développeur d'applications

Avant de créer une application, vous devez créer un développeur d'applications.

Remarque : Les développeurs d'applications sont généralement créés à l'aide d'un portail des développeurs. Vous créerez celui-ci plus tard dans l'atelier. Pour l'instant, vous allez utiliser la console Apigee.

1. Dans le menu de navigation Apigee, cliquez sur Distribution > Developers (Distribution > Développeurs).

2. Pour créer un développeur d'applications, cliquez sur +CREATE (+ CRÉER).

3. Renseignez les champs suivants :

   Propriété	Valeur
   First Name (Prénom)	Joe
   Last Name (Nom)	Developer (Développeur)
   Email (E-mail)	joe@example.com
   Username (Nom d'utilisateur)	joe

4. Cliquez sur ADD (AJOUTER) pour créer le développeur d'applications.

Créer une application avec un accès en lecture seule

1. Dans le menu de navigation Apigee, cliquez sur Distribution > Apps (Distribution > Applications).

2. Pour créer une application, cliquez sur +CREATE (+ CRÉER).

3. Dans le volet App details (Informations sur l'application), spécifiez les éléments suivants :

   Propriété	Valeur
   Name (Nom)	readonly-app
   Developer (Développeur)	sélectionnez Joe Developer

4. Dans le volet Credentials (Identifiants), cliquez sur + ADD CREDENTIAL (+ AJOUTER UN IDENTIFIANT), puis sur + ADD PRODUCTS (+ AJOUTER DES PRODUITS). Sélectionnez bank (read-only), puis cliquez sur Add (Ajouter).

   Sous "Product" (Produit), cochez la case à côté de bank (read-only), puis cliquez sur APPROVE (APPROUVER).

5. Cliquez sur Create (Créer) pour créer l'application.

   La clé et le secret de l'application sont désormais configurés.

6. Dans le menu de navigation Apigee, cliquez sur Distribution > Apps > readonly-app (Distribution > Applications > readonly-app).

7. Sous "Credentials" (Identifiants), cliquez sur Show (Afficher) à côté de Key (Clé).

   Il s'agit de la clé API qui sera utilisée pour appeler l'API. Vous pourriez copier la clé, mais les étapes suivantes utilisent un appel curl vers l'API Apigee pour la récupérer.

Créer une application avec un accès complet

1. Dans le menu de navigation de gauche, cliquez sur Distribution > Apps (Distribution > Applications).

2. Pour créer une application, cliquez sur +CREATE (+ CRÉER).

3. Dans le volet App details (Informations sur l'application), spécifiez les éléments suivants :

   Propriété	Valeur
   Name (Nom)	fullaccess-app
   Developer (Développeur)	sélectionnez Joe Developer

4. Dans le volet Credentials (Identifiants), cliquez sur + ADD CREDENTIAL (+ AJOUTER UN IDENTIFIANT), puis sur + ADD PRODUCTS (+ AJOUTER DES PRODUITS). Sélectionnez bank (full access), puis cliquez sur Add (Ajouter).

   Sous "Product" (Produit), cochez la case à côté de bank (full-access), puis cliquez sur APPROVE (APPROUVER).

5. Cliquez sur Create (Créer) pour créer l'application.

6. Dans le menu de navigation Apigee, cliquez sur Distribution > Apps > fullaccess-app (Distribution > Applications > fullaccess-app).

7. Sous "Credentials" (Identifiants), cliquez sur Show (Afficher) à côté de Key (Clé).

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un produit d'API fournissant un accès limité

Tester avec la clé API

1. Dans Cloud Shell, ouvrez une connexion SSH vers votre VM de test :

   TEST_VM_ZONE=$(gcloud compute instances list --filter="name=('apigeex-test-vm')" --format "value(zone)") gcloud compute ssh apigeex-test-vm --zone=${TEST_VM_ZONE} --force-key-file-overwrite

2. Si vous êtes invité à donner votre autorisation, cliquez sur Autoriser.

   Votre session Cloud Shell s'exécute désormais dans la VM.

3. Pour obtenir la clé API de l'application en lecture seule, exécutez les commandes suivantes :

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null) echo "PROJECT_ID=${PROJECT_ID}" export API_KEY=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${PROJECT_ID}/developers/joe@example.com/apps/readonly-app" | jq ".credentials[0].consumerKey" --raw-output) echo "API_KEY=${API_KEY}"

   La première commande lit la configuration gcloud pour obtenir le projet actuel. La seconde récupère la clé API à l'aide de l'API Apigee. La requête est autorisée, car vous envoyez un jeton d'accès qui dispose des autorisations de l'utilisateur connecté.

4. Appelez le proxy d'API bank-v1 déployé dans l'environnement eval en utilisant une clé API falsifiée :

   curl -i -k -X GET -H "apikey: ABC123" "https://eval.example.com/bank/v1/customers"

   La réponse est 401 Unauthorized (non autorisé), avec une erreur indiquant que la clé API n'est pas valide.

5. Appelez le proxy d'API bank-v1 déployé dans l'environnement eval, cette fois en utilisant la clé API réelle :

   curl -i -k -X GET -H "apikey: ${API_KEY}" "https://eval.example.com/bank/v1/customers"

   La requête est autorisée et la réponse contient une liste de clients.

6. Effectuez un autre appel au proxy d'API bank-v1 déployé dans l'environnement eval, en utilisant à nouveau la clé API réelle :

   curl -i -k -X POST -H "apikey: ${API_KEY}" -H "Content-Type: application/json" "https://eval.example.com/bank/v1/customers" -d '{"firstName": "Julia", "lastName": "Dancey", "email": "julia@example.org"}'

   Cette fois, la réponse est 401 Unauthorized (non autorisé), avec une erreur indiquant que la clé API n'est pas valide pour la ressource concernée. La requête a été refusée, car la clé API fournie est associée au produit d'API en lecture seule, qui n'autorise pas les requêtes POST.

7. Saisissez exit pour quitter la session SSH de la machine virtuelle.

Tâche 4 : Appliquer un quota

Dans cette tâche, vous allez ajouter une règle de quota qui limitera le nombre de requêtes autorisées par application sur une période spécifique. La règle de quota utilisera une configuration de quota spécifiée dans les produits d'API.

Ajouter la règle de quota

2. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.

3. Cliquez sur l'onglet Develop (Développer) :

4. Dans le menu de navigation du proxy, dans la section Proxy Endpoints (Points de terminaison du proxy), cliquez sur PreFlow.

   La règle de quota vérifie que le quota d'une application spécifique n'a pas été dépassé. Si la limite est atteinte, la règle de quota génère une erreur et la requête est abandonnée. Si la limite n'est pas atteinte, le nombre de requêtes autorisées diminue.

   La règle de quota détermine l'application appelante en fonction d'une variable renseignée par la règle VerifyAPIKey. Par conséquent, la règle de quota doit être placée après la règle VerifyAPIKey.

5. Dans le volet Flow (Flux), cliquez sur le bouton + Add Policy Step (+ Ajouter une étape de règle) en haut à droite, au-dessus du flux de requête.

6. Sélectionnez Create new policy (Créer une règle), puis sous Select policy (Sélectionner une règle), dans la section Traffic Management (Gestion du trafic), sélectionnez Quota. Définissez ensuite Display Name (Nom à afficher) et Name (Nom) sur Q-EnforceQuota.

7. Cliquez sur Add (Ajouter).

8. Cliquez sur le nom Q-EnforceQuota.

   La configuration Quota s'affiche dans le volet Code.

9. Modifiez la configuration de quota comme suit :

   <Quota continueOnError="false" enabled="true" name="Q-EnforceQuota" type="calendar"> <Identifier ref="client_id"/> <UseQuotaConfigInAPIProduct stepName="VAK-VerifyKey"> <DefaultConfig> <Allow>2</Allow> <Interval>1</Interval> <TimeUnit>hour</TimeUnit> </DefaultConfig> </UseQuotaConfigInAPIProduct> <Distributed>true</Distributed> <Synchronous>true</Synchronous> <StartTime>2021-01-01 00:00:00</StartTime> </Quota>

   Vous utiliserez le produit d'API pour spécifier le nombre d'appels autorisé. La propriété stepName de l'élément UseQuotaConfigInAPIProduct spécifie l'étape qui déterminera le produit d'API.

   En cas de validation d'une clé API ou d'un jeton OAuth, cet élément peut être lié à une application qui est associée à un produit d'API. À l'aide de ces paramètres de règle, l'étape de VerifyAPIKey appelée VAK-VerifyKey détermine le produit d'API. La règle VerifyAPIKey doit s'exécuter avant la règle Q-EnforceQuota.

   Les valeurs de configuration par défaut spécifiées dans la règle de quota indiquent un maximum de 2 requêtes (Allow) par intervalle de 1 (interval) mois (TimeUnit). Les valeurs par défaut ne seront utilisées que si les valeurs ne sont pas disponibles, ce qui ne doit se produire que quand les paramètres de quota ne sont pas définis pour le produit d'API associé à la clé API.

10. Cliquez sur Save (Enregistrer). Si vous recevez une notification indiquant que le proxy a été enregistré en tant que nouvelle révision, cliquez sur SAVE AS NEW REVISION (ENREGISTRER EN TANT QUE NOUVELLE RÉVISION).

11. Cliquez sur Déployer.

12. Pour Service account (Compte de service), spécifiez l'adresse e-mail du compte de service :

    apigee-internal-access@{{{ project_0.project_id | PROJECT }}}.iam.gserviceaccount.com

13. Cliquez sur Deploy (Déployer), puis sur Confirm (Confirmer).

14. Cliquez sur l'onglet Overview (Vue d'ensemble) et attendez que l'état du déploiement eval indique que le proxy a été déployé.

Ajouter une configuration de quota pour le produit d'API à accès complet

1. Dans le menu de navigation Apigee, sélectionnez Distribution > API Products (Distribution > Produits d'API), puis cliquez sur bank (full access).
2. Cliquez sur Edit (Modifier).
3. Sur la ligne "bank-v1" de la section Operations (Opérations), cliquez sur l'icône de menu Actions (), puis sélectionnez Edit (Modifier).
4. Définissez le quota de l'opération sur 5 requests every 1 minute (5 requêtes par minute), puis cliquez sur Save (Enregistrer) pour enregistrer l'opération.

Remarque : Veillez à bien modifier le quota configuré dans l'opération.

5. Cliquez sur Save (Enregistrer) pour enregistrer le produit d'API.

Cliquez sur Vérifier ma progression pour valider l'objectif. Appliquer un quota

Démarrer une session de débogage

Debug est un outil permettant de dépanner et de surveiller les proxys d'API exécutés sur Apigee. Vous pouvez l'utiliser pour examiner les détails de chaque étape lors d'un appel d'API.

1. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.

2. Cliquez sur l'onglet Debug (Débogage).

3. Cliquez sur Start a debug session (Démarrer une session de débogage).

4. Dans le menu déroulant Environment (Environnement) du volet Start a debug session (Démarrer une session de débogage), sélectionnez eval.

5. Cliquez sur Start (Démarrer).

   Il peut s'écouler un court laps de temps avant que la session de débogage ne commence à capturer les requêtes.

Remarque : Si des messages d'erreur s'affichent dans des encadrés rouges en haut de l'écran, avec des descriptions telles que "Error fetching debug transactions" (Erreur lors de la récupération des transactions de débogage) ou "List debug session transaction error" (Erreur de transaction List Debug Session), il est possible que votre session de débogage fonctionne tout de même toujours correctement.

Vous allez envoyer des requêtes API, puis examiner la session de débogage.

Tester le quota

1. Dans Cloud Shell, ouvrez une connexion SSH vers votre VM de test :

   TEST_VM_ZONE=$(gcloud compute instances list --filter="name=('apigeex-test-vm')" --format "value(zone)") gcloud compute ssh apigeex-test-vm --zone=${TEST_VM_ZONE} --force-key-file-overwrite

2. Si vous êtes invité à donner votre autorisation, cliquez sur Autoriser.

Votre session Cloud Shell s'exécute désormais dans la VM.

3. Pour obtenir les deux clés API, exécutez les commandes suivantes :

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null) echo "PROJECT_ID=${PROJECT_ID}" export API_KEY_READONLY=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${PROJECT_ID}/developers/joe@example.com/apps/readonly-app" | jq ".credentials[0].consumerKey" --raw-output) echo "API_KEY_READONLY=${API_KEY_READONLY}" export API_KEY_FULL=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${PROJECT_ID}/developers/joe@example.com/apps/fullaccess-app" | jq ".credentials[0].consumerKey" --raw-output) echo "API_KEY_FULL=${API_KEY_FULL}"

4. Envoyez cette requête à plusieurs reprises jusqu'à ce que vous obteniez un échec de quota :

   curl -i -k -X GET -H "apikey: ${API_KEY_READONLY}" "https://eval.example.com/bank/v1/customers" Remarque : Pour répéter rapidement une commande dans Cloud Shell ou une session SSH, cliquez sur la flèche vers le haut, puis appuyez sur RETOUR ou ENTRÉE.

   La violation de quota sera présentée comme suit :

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

5. Revenez à l'onglet de l'interface utilisateur Apigee.

   Vous devriez voir quelques requêtes 200 et une requête 429.

   Cliquez sur une requête 200. La carte des transactions affiche une icône "usine" sur la droite, ce qui indique que le backend a été appelé.

6. Dans le volet "Debug session" (Session de débogage), cliquez sur la flèche vers la gauche (<) en haut à gauche.

7. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.

8. Cliquez sur l'onglet Debug (Débogage).

9. Cliquez sur Start Debug Session (Démarrer la session de débogage) pour démarrer une session de débogage.

10. Revenez à la session SSH, puis envoyez cette requête à plusieurs reprises en utilisant la clé API à accès complet, jusqu'à ce que vous obteniez un échec de quota :

    date; curl -i -k -X GET -H "apikey: ${API_KEY_FULL}" "https://eval.example.com/bank/v1/customers"

    Cette fois, vous devriez pouvoir envoyer au moins cinq requêtes avant de recevoir une réponse de refus 429. Le quota pour le produit d'API à accès complet est de cinq requêtes par minute. Le quota est réinitialisé lorsque la partie "secondes" de l'heure est remise à zéro. La commande ci-dessus affiche l'heure avant d'appeler l'API. Vous devriez donc pouvoir voir l'heure approximative à laquelle le quota est réinitialisé.

11. Saisissez exit pour quitter la session SSH de la machine virtuelle.

12. Revenez à l'onglet de l'interface utilisateur Apigee.

    Si vous sélectionnez une requête et cliquez sur l'icône de quota, vous pouvez voir que les variables de quota VAK-VerifyKey indiquent désormais cinq requêtes par minute.

Tâche 5 : Ajouter CORS au proxy d'API

Dans cette tâche, vous allez ajouter CORS (Cross-Origin Resource Sharing) au proxy bank-v1.

CORS est un protocole qui utilise des en-têtes HTTP pour indiquer aux navigateurs s'il est sûr d'accéder à des ressources restreintes à partir d'un domaine distinct. Par défaut, les requêtes interdomaines sont interdites par la règle de sécurité same-origin policy (SOP) (règle de même origine). La règle SOP protège les utilisateurs de navigateurs contre le partage involontaire d'informations de session avec des acteurs malveillants.

Cette règle implique qu'une page Web diffusée depuis www.example.com ne peut pas, par défaut, appeler des API sur api.example.com, car le nom d'hôte est différent. CORS peut être utilisé pour autoriser ce type d'accès multi-origines.

Vous aurez besoin de CORS dans l'API "bank" pour le portail des développeurs. Un portail des développeurs Apigee possède un nom de domaine *.apigee.io, et l'API est accessible via un autre domaine. Pour qu'il soit possible d'appeler l'API à partir de la documentation, vous devez ajouter des en-têtes CORS à toutes les réponses de l'API, y compris les réponses d'erreur.

CORS utilise également des requêtes préliminaires, que le navigateur envoie à l'aide du verbe OPTIONS pour déterminer si l'appel suivant sera autorisé.

La règle CORS peut gérer toutes les fonctionnalités CORS.

Pour en savoir plus, consultez la documentation Apigee sur CORS.

Ajouter la règle CORS

1. Dans le menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.

2. Cliquez sur l'onglet Develop (Développer) :

3. Dans le menu de navigation du proxy, dans la section Proxy Endpoints (Points de terminaison du proxy), cliquez sur PreFlow.

4. Dans le volet Flow (Flux), cliquez sur le bouton + Add Policy Step (+ Ajouter une étape de règle) en haut à droite, au-dessus du flux de requête.

5. Sélectionnez Create new policy (Créer une règle), puis sous Select policy (Sélectionner une règle), dans la section Security (Sécurité), sélectionnez CORS. Définissez ensuite Display Name (Nom à afficher) et Name (Nom) sur CORS.

6. Cliquez sur Add (Ajouter).

   La configuration de la règle CORS s'affiche sous le volet "Flow" (Flux).

   AllowOrigins recense les origines autorisées. La configuration par défaut autorise n'importe quelle origine, car elle définit l'origine autorisée comme étant égale à celle transmise dans la requête. Dans un cas d'utilisation en production typique, vous pouvez n'autoriser que les requêtes provenant de noms d'hôte spécifiques.

   AllowMethods spécifie les méthodes qui doivent être autorisées pour l'API.

   AllowHeaders liste les en-têtes qui peuvent être transmis dans la requête.

   ExposeHeaders spécifie les en-têtes de la réponse qui doivent être autorisés lorsqu'ils sont appelés avec une origine. Si vous utilisez la valeur par défaut *, aucun en-tête de réponse ne sera supprimé de la réponse.

   MaxAge spécifie la durée (en secondes) pendant laquelle une réponse de requête préliminaire peut être mise en cache par un navigateur.

   AllowCredentials indique si les en-têtes Authorization, les certificats client TLS ou les cookies peuvent être envoyés dans la requête.

   GeneratePreflightResponse indique si les requêtes préliminaires utilisant la méthode OPTIONS seront traitées.

7. Cliquez sur le nom CORS.

8. Remplacez la configuration AllowHeaders par :

   <AllowHeaders>origin, x-requested-with, accept, content-type, apikey</AllowHeaders>

   Votre API utilise l'en-tête apikey pour spécifier une clé API. Vous devez donc l'ajouter pour pouvoir l'appeler depuis un navigateur.

9. Remplacez la valeur MaxAge par -1.

   Cela désactivera la mise en cache de la réponse de requête préliminaire par le navigateur, de sorte que vous verrez toujours la requête préliminaire. Dans un cas d'utilisation en production, vous autorisez généralement la mise en cache de la réponse pour éviter d'effectuer deux appels par requête.

10. Dans le menu de navigation du proxy, dans la section Proxy Endpoints (Points de terminaison du proxy), cliquez sur PreFlow.

    La règle CORS a été ajoutée automatiquement à la fin du flux. Toutefois, aucune clé API ne devrait être requise pour les requêtes préliminaires.

11. Déplacez la règle CORS avant la règle VAK-VerifyKey en modifiant la configuration PreFlow. Remplacez :

    <PreFlow name="PreFlow"> <Request> <Step> <Name>VAK-VerifyKey</Name> </Step> <Step> <Name>Q-EnforceQuota</Name> </Step> <Step> <Name>CORS</Name> </Step> </Request> <Response/> </PreFlow>

    par :

    <PreFlow name="PreFlow"> <Request> <Step> <Name>CORS</Name> </Step> <Step> <Name>VAK-VerifyKey</Name> </Step> <Step> <Name>Q-EnforceQuota</Name> </Step> </Request> <Response/> </PreFlow>

12. Cliquez sur Save (Enregistrer). Si vous recevez une notification indiquant que le proxy a été enregistré en tant que nouvelle révision, cliquez sur SAVE AS NEW REVISION (ENREGISTRER EN TANT QUE NOUVELLE RÉVISION).

13. Cliquez sur Deploy (Déployer).

14. Pour Service account (Compte de service), spécifiez l'adresse e-mail du compte de service :

    apigee-internal-access@{{{ project_0.project_id | PROJECT }}}.iam.gserviceaccount.com

15. Cliquez sur Deploy (Déployer), puis sur Confirm (Confirmer).

16. Cliquez sur l'onglet Overview (Vue d'ensemble) et attendez que l'état du déploiement eval indique que le proxy a été déployé.

Cliquez sur Vérifier ma progression pour valider l'objectif. Ajouter CORS au proxy d'API

Démarrer une session de débogage

1. Cliquez sur l'onglet Debug (Débogage).

2. Cliquez sur Start a debug session (Démarrer une session de débogage).

3. Dans le menu déroulant Environment (Environnement) du volet Start a debug session (Démarrer une session de débogage), sélectionnez eval.

4. Cliquez sur Start (Démarrer).

   Il peut s'écouler un court laps de temps avant que la session de débogage ne commence à capturer les requêtes.

Tester la fonctionnalité CORS

1. Dans Cloud Shell, ouvrez une connexion SSH vers votre VM de test :

   TEST_VM_ZONE=$(gcloud compute instances list --filter="name=('apigeex-test-vm')" --format "value(zone)") gcloud compute ssh apigeex-test-vm --zone=${TEST_VM_ZONE} --force-key-file-overwrite

2. Si vous êtes invité à donner votre autorisation, cliquez sur Autoriser.

   Votre session Cloud Shell s'exécute désormais dans la VM.

3. Pour obtenir une clé API, exécutez les commandes suivantes :

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null) echo "PROJECT_ID=${PROJECT_ID}" export API_KEY=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${PROJECT_ID}/developers/joe@example.com/apps/fullaccess-app" | jq ".credentials[0].consumerKey" --raw-output) echo "API_KEY=${API_KEY}"

4. Envoyez une requête pour récupérer la liste des clients :

   curl -i -k -X GET -H "apikey: ${API_KEY}" "https://eval.example.com/bank/v1/customers"

   Comme il n'y a pas d'origine, la fonctionnalité CORS est ignorée. Vérifiez que l'en-tête Access-Control-Allow-Origin n'est pas renvoyé.

5. Envoyez une autre requête, mais incluez l'en-tête Origin cette fois-ci. Cette commande teste une requête CORS normale :

   curl -i -k -X GET -H "Origin: https://www.example.com" -H "apikey: ${API_KEY}" "https://eval.example.com/bank/v1/customers"

   Les en-têtes access-control-* sont renvoyés, car l'origine a été fournie.

6. Envoyez une requête préliminaire :

   curl -i -k -X OPTIONS -H "Origin: https://www.example.com" -H "Access-Control-Request-Method: POST" -H "Access-Control-Request-Headers: Content-Type,apikey" "https://eval.example.com/bank/v1/customers"

   La règle CORS définit les en-têtes de requête préliminaire dans la réponse et empêche la requête de progresser jusqu'au backend.

   Si vous revenez à l'UI Apigee et que vous examinez l'appel OPTIONS dans l'outil Debug, vous pouvez voir que la règle CORS a empêché l'appel de passer au service de backend.

7. Saisissez exit pour quitter la session SSH de la machine virtuelle.

Tâche 6 : Télécharger et modifier une spécification OpenAPI

Dans cette tâche, vous allez télécharger et modifier une spécification OpenAPI qui définit l'interface de votre proxy d'API.

La spécification OpenAPI sera utilisée lors de la publication de votre proxy d'API sur votre portail des développeurs.

Télécharger et modifier la spécification OpenAPI

1. Dans Cloud Shell, exécutez la commande suivante afin de télécharger la spécification OpenAPI pour votre proxy d'API :

   curl https://storage.googleapis.com/spls/shared/firestore-simplebank-data/dev-portal/simplebank-spec.yaml?$(date +%s) --output ~/simplebank-spec.yaml

   Avec cette commande curl, vous téléchargez un fichier nommé simplebank-spec.yaml et stockez celui-ci dans un fichier portant le même nom dans le répertoire d'accueil.

Remarque : "?$(date +%s)" ajoute à l'URL un paramètre de requête qui est une représentation sous forme de chaîne de la date et de l'heure actuelles. Cette variable dynamique modifie l'URL et force curl à récupérer la dernière version d'un fichier, même si une version précédente est présente dans le cache.

2. Dans Cloud Shell, cliquez sur Ouvrir l'éditeur, puis sur Ouvrir dans une nouvelle fenêtre si nécessaire.

   

3. Dans l'éditeur, sélectionnez le fichier simplebank-spec.yaml.

   Cette spécification OpenAPI décrit l'interface du proxy d'API que vous avez créé au cours de cet atelier. Elle sera utilisée pour fournir une documentation en ligne dans le portail des développeurs.

   Le portail des développeurs accède au proxy Apigee depuis le réseau externe. Le nom d'hôte que vous avez utilisé, eval.example.com, n'est disponible que sur le réseau interne.

   Un équilibreur de charge a été provisionné pour fournir un accès externe au proxy d'API. L'accès externe utilise un nom d'hôte fourni par nip.io, qui est un fournisseur DNS générique.

   Le nom d'hôte externe ressemblera à ceci :

   eval.60.70.80.90.nip.io

   Ce nom d'hôte a déjà été spécifié comme nom d'hôte correspondant pour le groupe d'environnements eval-group.

4. Dans Cloud Shell, utilisez cette commande pour récupérer les paramètres eval-group :

   curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${GOOGLE_CLOUD_PROJECT}/envgroups/eval-group"

   Le tableau hostnames contient deux noms d'hôte : l'un sans adresse IP (eval.example.com) et l'autre avec une adresse IP (semblable à eval.60.70.80.90.nip.io). Vous utiliserez le nom d'hôte avec l'adresse IP dans la spécification OpenAPI.

5. Dans l'éditeur, à la ligne 10, remplacez le nom d'hôte :

   eval.<IPADDR>.nip.io

   Une fois que vous avez remplacé le nom d'hôte dans l'URL du serveur, la ligne 10 devrait ressembler à ceci :

   - url: "https://eval.60.70.80.90.nip.io/bank/v1"

6. Cliquez sur Fichier > Enregistrer.

7. Effectuez un clic droit sur simplebank-spec.yaml > Télécharger.

   Cela vous permet de télécharger le fichier sur votre ordinateur local. Vous utiliserez la spécification mise à jour avec le portail des développeurs.

Tâche 7 : Créer un portail des développeurs et y publier une API

Dans cette tâche, vous allez créer un portail des développeurs intégré, puis y publier votre API.

Créer un portail des développeurs intégré

1. Dans le menu de navigation Apigee, sélectionnez Distribution > Portals (Distribution > Portails), puis cliquez sur + CREATE (+ CRÉER).

2. Saisissez bank comme nom, puis cliquez sur Create (Créer).

   Après environ une minute, la page de présentation du portail devrait s'ouvrir.

3. Si le message "Enroll in beta for team and audience management features" (Inscrivez-vous à la version bêta pour bénéficier des fonctionnalités de gestion des équipes et des audiences) s'affiche, cliquez sur Enroll (S'inscrire).

Publier votre API sur le portail

1. Dans le menu de navigation Apigee, sélectionnez Distribution > Portals (Distribution > Portails), puis cliquez sur bank.

2. Cliquez sur + API.

3. Sélectionnez bank (full access) comme produit d'API.

4. Personnalisez les détails de l'API :

   Propriété	Valeur
   Published (listed in the catalog) (Publié (figure dans le catalogue))	sélectionné
   Display title (Titre à afficher)	SimpleBank
   Display description (Description à afficher)	API SimpleBank v1
   API visibility (Visibilité de l'API)	sélectionnez "Public (visible to anyone)" (Public (visible par tout le monde))

   Published (Publiée) rend l'API visible sur le portail, et Public (Public) permet aux API d'être visibles même si l'utilisateur n'est pas connecté au portail.

5. Cliquez sur Select (Sélectionner) dans Display image (Image à afficher), puis sur URL.

6. Définissez l'URL de l'image sur :

   https://storage.googleapis.com/spls/shared/firestore-simplebank-data/dev-portal/piggy-bank.png

   Vous devriez voir l'image d'une tirelire en cliquant sur PREVIEW (PRÉVISUALISER).

7. Cliquez sur Select (Sélectionner).

8. Dans la section API documentation (Documentation de l'API), sélectionnez OpenAPI document (Document OpenAPI).

9. Cliquez sur Select (Sélectionner) dans Select File (Sélectionner un fichier).

10. Cliquez sur Browse (Parcourir) et sélectionnez le fichier de spécification OpenAPI que vous avez téléchargé depuis Cloud Shell (simplebank-spec.yaml).

11. Cliquez sur Select (Sélectionner).

12. Cliquez sur Save (Enregistrer).

13. Pour ouvrir le portail des développeurs dans un nouvel onglet, cliquez sur VIEW LIVE PORTAL (AFFICHER LE PORTAIL EN LIGNE) en haut à droite.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un portail des développeurs et y publier une API

Démarrer une session de débogage

1. Revenez au menu de navigation Apigee, sélectionnez Proxy development > API Proxies (Développement de proxys > Proxys d'API), puis cliquez sur bank-v1.
2. Cliquez sur l'onglet Debug (Débogage).
3. Dans le menu déroulant Environment (Environnement) du volet Start a debug session (Démarrer une session de débogage), sélectionnez eval.
4. Cliquez sur Start (Démarrer).

Tester l'API à l'aide du portail des développeurs

1. Dans Cloud Shell, exécutez la commande suivante pour obtenir la clé API à accès complet :

   export PROJECT_ID=$(gcloud config list --format 'value(core.project)' 2>/dev/null) echo "PROJECT_ID=${PROJECT_ID}" export API_KEY=$(curl -s -H "Authorization: Bearer $(gcloud auth print-access-token)" -X GET "https://apigee.googleapis.com/v1/organizations/${PROJECT_ID}/developers/joe@example.com/apps/fullaccess-app" | jq ".credentials[0].consumerKey" --raw-output) echo "API_KEY=${API_KEY}"

   Copiez la clé API dans le presse-papiers.

2. Revenez à l'onglet "Live Portal" (Portail en ligne), puis cliquez sur APIs (API).

3. Cliquez sur la tirelire.

   L'API SimpleBank s'affiche.

4. Cliquez sur Authorize (Autoriser).

5. Collez la clé API dans le champ Key (Clé).

6. Cliquez sur Authorize (Autoriser), puis sur OK.

   La clé API sera désormais envoyée avec chaque requête.

7. Dans le menu de gauche, cliquez sur /customers POST.

8. Spécifiez le corps de requête suivant :

   { "email": "mina@example.com", "lastName": "Yu", "firstName": "Mina" }

9. Cliquez sur Execute (Exécuter).

   Une réponse 200 OK indique que le client a été créé.

10. Dans le menu de gauche, cliquez sur /customers GET.

11. Cliquez sur Execute (Exécuter).

    Le client que vous venez de créer est renvoyé avec les autres clients présents dans la base de données.

    Si vous revenez à l'UI Apigee et à la session Debug, vous pouvez voir qu'une requête (préliminaire) OPTIONS a été automatiquement envoyée par le navigateur avant l'envoi des deux commandes. Une requête préliminaire est requise avant la commande GET, car le navigateur ne sait pas si l'en-tête apikey doit être autorisé.

Tâche 8 : Créer un développeur d'applications dans le portail (facultatif)

Dans cette tâche, vous allez utiliser le portail des développeurs pour créer un développeur d'applications.

Remarque : Pour cette tâche, vous devez saisir votre adresse e-mail afin de recevoir un e-mail d'inscription. L'e-mail contient un lien sur lequel il faut cliquer pour que le compte enregistré puisse se connecter au portail des développeurs. L'adresse e-mail ne sera pas utilisée à d'autres fins et sera effacée lorsque le projet Google Cloud sera automatiquement supprimé.

Enregistrer un développeur d'applications dans le portail des développeurs

1. Revenez au Live Portal (Portail en ligne), puis cliquez sur Sign In (Se connecter).

2. Cliquez sur Create an account (Créer un compte).

3. Saisissez un prénom, un nom, une adresse e-mail et un mot de passe.

   Vous devrez utiliser le mot de passe pour vous connecter au portail des développeurs. Veillez donc à en choisir un facile à mémoriser.

4. Cochez la case indiquant que vous acceptez les conditions d'utilisation.

   La page des conditions d'utilisation doit être spécifiée par l'organisation qui fournit les API aux développeurs d'applications.

5. Cliquez sur Create Account (Créer le compte).

   Un e-mail est envoyé à votre adresse électronique. Il inclut un lien sur lequel vous devez cliquer pour autoriser l'utilisateur du compte à se connecter.

6. Cliquez sur le lien envoyé par e-mail.

   Un onglet de navigateur s'ouvre sur le portail des développeurs.

7. Cliquez sur Sign In (Se connecter).

8. Saisissez l'adresse e-mail et le mot de passe, puis cliquez sur Sign In (Se connecter).

Créer une application pour le développeur d'applications

1. Cliquez sur l'adresse e-mail en haut à droite, puis sur Apps (Applications).

2. Cliquez sur + New App (+ Nouvelle application).

3. Indiquez MyApp comme App Name (Nom de l'application).

4. Dans la section "API", cliquez sur Enable (Activer) pour SimpleBank.

5. Cliquez sur Save (Enregistrer).

   L'application est enregistrée et la clé API s'affiche. Cette clé API peut être utilisée dans le portail des développeurs. Pour afficher le développeur et l'application, revenez à l'UI Apigee, puis accédez à Publish > Developers (Publier > Développeurs) et Publish > Apps (Publier > Applications), respectivement.

Félicitations !

Dans cet atelier, vous avez utilisé la validation des clés API pour restreindre l'accès à l'API. Vous avez créé des produits d'API pour fournir différents niveaux de service aux développeurs d'applications internes et externes. Vous avez utilisé une règle de quota pour limiter le nombre d'appels pour chaque application et ajouté une règle CORS pour prendre en charge le Cross-Origin Resource Sharing dans l'API. Vous avez créé un portail des développeurs et y avez publié les produits d'API pour que les développeurs d'applications puissent les utiliser.

Étapes suivantes et informations supplémentaires

• Produits d'API
• CORS (Cross-Origin Resource Sharing)
• Portails des développeurs

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 5 août 2025

Dernier test de l'atelier : 5 août 2025

Copyright 2026 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.