Configurer Cloud Endpoints gRPC pour Knative serving avec ESPv2

Cette page vous explique comment configurer Cloud Endpoints pour Knative serving. Endpoints utilise le proxy Extensible Service Proxy V2 (ESPv2) en guise de passerelle API. Pour assurer la gestion des API pour Knative serving, vous devez déployer le conteneur ESPv2 prédéfini sur Knative serving exécuté sur un cluster GKE.

Une fois la configuration finalisée, ESPv2 peut intercepter toutes les requêtes adressées à vos services avant de les appeler, afin d'effectuer les vérifications nécessaires, telles que l'authentification. Lorsque le service répond, ESPv2 rassemble et consigne les données de télémétrie.

Pour obtenir une présentation d'Endpoints, consultez les pages À propos d'Endpoints et Architecture Endpoints.

Liste de tâches

Tout au long du tutoriel, reportez-vous à la liste de tâches présentée ci-dessous. La finalisation du tutoriel suppose de réaliser l'intégralité de ces tâches.

  1. Créez un projet Google Cloud et, si vous n'avez pas déployé votre propre service Knative serving, déployez un exemple de service. Consultez la section Avant de commencer.

  2. Créez un cluster GKE avec le service Knative activé.

  3. Déployer un exemple de service de diffusion Knative gRPC

  4. Créez un document de configuration de l'API gRPC décrivant votre API Endpoints, puis configurez les routes vers votre service de diffusion Knative. Consultez la section Configurer Endpoints.

  5. Déployez le document de configuration de l'API gRPC pour créer un service géré. Consultez la section Déployer la configuration Endpoints.

  6. Créez une image ESPv2 pour Docker avec votre configuration de service Endpoints. Consultez la section Créer une nouvelle image ESPv2.

  7. Déployez la nouvelle image de service Knative ESPv2. Consultez la section Déployer l'image ESPv2 pour Cloud Run.

  8. Créez un mappage de domaine sur le service ESPv2 Knative serving.

  9. Testez votre configuration en envoyant une requête à l'API.

  10. Suivez l'activité de vos services. Consultez la section Suivre l'activité de l'API.

  11. Effectuez un nettoyage.

Coûts

Dans ce document, vous utilisez 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.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  6. Notez l'ID du projet, car vous en aurez besoin ultérieurement. Sur le reste de cette page, cet ID est appelé ESP_PROJECT_ID.
  7. Téléchargez et installez la gcloud CLI.

Configurer la ligne de commande gcloud

Pour configurer la gcloud CLI pour Knative serving for Anthos:

  1. Assurez-vous que la CLI gcloud est autorisée à accéder à vos données et services.

    1. Connectez-vous.

      gcloud auth login

    2. Dans le nouvel onglet de navigateur qui s'ouvre, choisissez un compte auquel a été attribué le rôle Éditeur ou Propriétaire dans le projet Google Cloud que vous avez créé pour déployer ESPv2 dans le service Knative.

  2. Mettez à jour les composants gcloud installés : 

    gcloud components update

  3. Définissez la plate-forme sur gke et définissez le paramètre de projet par défaut pour gcloud sur celui que vous venez de créer :

    gcloud config set run/platform gke 
gcloud config set project ESP_PROJECT_ID

    Remplacez ESP_PROJECT_ID par l'ID du projet que vous avez créé.

  4. Définissez la zone souhaitée pour le nouveau cluster. Vous pouvez utiliser n’importe quelle zone dans laquelle GKE est disponible, par exemple : 

    gcloud config set compute/zone ZONE

    Remplacez ZONE par votre zone. Par exemple, utilisez us-central1-a. Vous pouvez utiliser n'importe quelle zone compatible avec GKE.

  5. Activez les API suivantes pour le projet, qui sont nécessaires pour créer un cluster, ainsi qu'un conteneur et le publier dans Artifact Registry: 

    gcloud services enable container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

Créer un cluster GKE avec Knative serving activé

Pour créer un cluster et l'activer pour Knative serving sur Google Cloud:

  1. Créez un cluster à l'aide de la commande suivante : 

    gcloud container clusters create CLUSTER_NAME \ 
  --addons=HttpLoadBalancing,CloudRun \ 
  --machine-type=n1-standard-4 \ 
  --num-nodes=3

    Remplacez CLUSTER_NAME par le nom souhaité pour votre cluster.

    Bien que ces instructions ne permettent pas à l'autoscaling de cluster de redimensionner les clusters à la demande, le service Knative sur Google Cloud effectue automatiquement le scaling des instances du cluster.

  2. Patientez pendant la création du cluster. Un résultat semblable aux lignes suivantes doit s'afficher au cours du processus : 

    Creating cluster CLUSTER_NAME...done. 
Created [https://container.googleapis.com/v1/projects/ESP_PROJECT_ID/zones/ZONE/clusters/CLUSTER_NAME].

    La colonne NODE_VERSION du résultat affiche également la version du cluster. Par exemple, 1.15.11-gke.1 ou 1.14.10-gke.27. Notez la version du cluster afin de l'utiliser ultérieurement dans ce document.

  3. Définissez les valeurs par défaut de gcloud pour utiliser votre nouveau cluster et son emplacement, afin d'éviter d'avoir à les spécifier lorsque vous utilisez la gcloud CLI: 

    gcloud config set run/cluster CLUSTER_NAME
gcloud config set run/cluster_location ZONE

  4. Utilisez la commande suivante pour afficher les détails du nouveau cluster :

    gcloud container clusters describe CLUSTER_NAME

  5. Utilisez la commande suivante pour récupérer les identifiants de votre cluster :

    gcloud container clusters get-credentials CLUSTER_NAME

Déployer un exemple de service Cloud Run gRPC

Pour déployer l'exemple de conteneur Cloud Run pour Anthos "grpc-bookstore" sur le cluster que vous venez de créer, procédez comme suit :

  1. Suivez les étapes figurant sur la page gRPC Python Quick Start pour installer gRPC et les outils gRPC.

  2. Cet exemple de serveur gRPC contient une image Docker préconfigurée pour le "service grpc-bookstore" Python : gcr.io/endpointsv2/python-grpc-bookstore-server:2. Utilisez la commande suivante pour déployer "grpc-bookstore" sur votre cluster :

    gcloud run deploy GRPC_SERVICE \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
  --platform=gke \
 --connectivity=internal \
  --use-http2

    Notez que vous devez spécifier ce service en tant que service interne afin qu'il ne soit pas accessible de l'extérieur.

    Remplacez GRPC_SERVICE par le nom souhaité pour votre service. Exemple :

    gcloud run deploy grpc-bookstore \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2 \
  --platform=gke \
  --connectivity=internal \
  --use-http2

    Lorsque vous avez terminé, le message suivant s'affiche :

    Service [grpc-bookstore] revision [grpc-bookstore-00001-nuk] has been deployed and is serving 100 percent of traffic at http://grpc-bookstore.default.svc.cluster.local

    Lorsque vous créez un service interne, GKE crée un nom DNS (grpc-bookstore.default.svc.cluster.local dans cet exemple) qui ne peut être résolu que pour les requêtes provenant du cluster lui-même, et non pour les requêtes externes. Vous ne pouvez pas accéder à ce DNS en externe depuis le cluster. Pour en savoir plus, consultez la page Services Cloud Run.

  3. Pour vérifier que votre service fonctionne correctement, déployez un pod avec la même image Docker sur votre cluster. L'image contient le code client gRPC de "grpc-bookstore" que vous pouvez utiliser pour tester le service interne.

    1. Utilisez la commande kubectl suivante pour déployer un pod sur le même cluster que celui que vous avez déployé ci-dessus :

      kubectl run grpc --generator=run-pod/v1 \
  --image=gcr.io/endpointsv2/python-grpc-bookstore-server:2

      Cette image contient le script bookstore_client.py que vous pouvez utiliser pour effectuer des requêtes client à partir du cluster.

      Remarque : Pour les versions plus récentes de kubectl, la commande peut émettre l'avertissement suivant :

      Flag --generator has been deprecated, has no effect and will be removed in the future".

      Vous pouvez ignorer cet avertissement.

    2. Récupérez le nom du pod "grpc-bookstore" créé sur votre cluster lorsque vous avez déployé l'image Docker à l'étape précédente :

      kubectl get pods

      Le résultat doit s'afficher au format suivant :

      NAME   READY    STATUS    RESTARTS   AGE
grpc   1/1      Running   0          23h

      Où grp est le nom du pod "grpc-bookstore". Assurez-vous que la valeur Status (État) du pod est Running (En cours d'exécution) avant de continuer.

    3. Utilisez la commande suivante pour envoyer une requête client au service "grpc-bookstore" :

      kubectl exec grpc -ti -- python3 bookstore_client.py \
  --host grpc-bookstore.default.svc.cluster.local --port=80

      Cette commande exécute le script bookstore_client.py en interne sur le cluster pour envoyer une requête gRPC au service "grpc-bookstore" sur le nom d'hôte grpc-bookstore.default.svc.cluster.local.

      Si tout fonctionne correctement, une réponse doit s'afficher sous la forme :

      ListShelves: shelves {
  id: 1
  theme: "Fiction"
}
shelves {
  id: 2
  theme: "Fantasy"
}

Configurer Endpoints

Vous devez disposer d'une spécification de l'API gRPC décrivant la surface de votre service de backend ainsi que les conditions requises pour l'authentification.

À propos de la définition du champ de nom des spécifications de l'API gRPC

Dans le champ name des spécifications de l'API gRPC, vous devez spécifier le nom du service Endpoints utilisé pour accéder à votre service Cloud Run pour Anthos. Le nom du service Endpoints se présente sous la forme d'un nom de domaine :

API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

Étant donné que le nom du service Endpoints correspond à un nom de domaine, il doit respecter les règles suivantes :

  • Il ne doit contenir que des lettres minuscules, des chiffres, des points ou des tirets.
  • Il ne doit pas commencer par un tiret.
  • Il ne doit pas contenir de trait de soulignement.

Exemple :

grpc-boostore-api.endpoints.ESP_PROJECT_ID.cloud.goog

Créer les spécifications de l'API gRPC

L'exemple bookstore-grpc contient les fichiers que vous devez copier localement, puis configurer.

  1. Créez un répertoire pour les spécifications de l'API gRPC, tel que my-anthos-grpc. Accédez ensuite à ce répertoire à l'aide de la commande cd.

  2. Clonez le dépôt git dans lequel le code client gRPC est hébergé dans votre nouveau répertoire :

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

  3. Modifiez votre répertoire de travail :

    cd python-docs-samples/endpoints/bookstore-grpc/

    Notez que ce répertoire contient le fichier bookstore.proto. Ce fichier définit l'API du service Bookstore.

  4. Créez un fichier descripteur protobuf autonome à partir de votre fichier de service .proto :

    1. Créez le répertoire generated_pb2 dans votre répertoire de travail.

    2. Créez le fichier descripteur api_descriptor.pb à l'aide du compilateur de tampons de protocole protoc. Exécutez la commande suivante dans le répertoire contenant bookstore.proto :

      python3 -m grpc_tools.protoc \
--include_imports \
--include_source_info \
--proto_path=. \
--descriptor_set_out=api_descriptor.pb \
--python_out=generated_pb2 \
--grpc_python_out=generated_pb2 \
bookstore.proto

    Dans la commande ci-dessus, --proto_path est défini sur le répertoire de travail actuel. Dans votre environnement de compilation gRPC, si vous utilisez un autre répertoire pour les fichiers d'entrée .proto, modifiez --proto_path pour que le compilateur recherche le répertoire dans lequel vous avez enregistré votre fichier bookstore.proto.

  5. Modifiez le fichier api_config_anthos.yaml dans votre répertoire de travail actuel (le répertoire contenant bookstore.proto) pour y ajouter les contenus suivants :

    type: google.api.Service
config_version: 3
#
# Name of the service configuration.
#
name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
#
# API title to appear in the user interface (Google Cloud console).
#
title: Bookstore gRPC API In Cloud Run Anthors
apis:
- name: endpoints.examples.bookstore.Bookstore
#
# Create a DNS record to map your service name to IP address
#
endpoints:
  - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
    target: IP_ADDRESS
#
# Specify the backend address to route to
#
backend:
  rules:
    - selector: "*"
      address: grpc://GRPC_SERVICE.default.svc.cluster.local
      disable_auth: true
#
# API usage restrictions.
#
usage:
  rules:
  # ListShelves methods can be called without an API Key.
  - selector: endpoints.examples.bookstore.Bookstore.ListShelves
    allow_unregistered_calls: true

    La mise en retrait est importante pour le format YAML.

  6. Dans le champ name, spécifiez le nom de domaine de l'API Endpoints utilisé pour accéder à votre service Cloud Run pour Anthos, au format suivant :

    API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

    Exemple :

    grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

  7. La section endpoints enregistre une entrée DNS pour votre service Endpoints sur le domaine cloud.goog, sous la forme :

    endpoints:
  - name: API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog
    target: IP_ADDRESS

    IP_ADDRESS est l'adresse IP du service istio-ingress pour votre cluster. Pour déterminer cette adresse IP, procédez comme suit :

    1. Accédez à la page "Google Kubernetes Engine" dans Cloud Console :

      Accéder à Google Kubernetes Engine

    2. Cliquez sur Services et entrées dans le panneau de navigation de gauche pour afficher la liste des services.

    3. Si la version de votre cluster est 1.15.3-gke.19 ou supérieure, 1.14.3-gke.12 ou supérieure, ou 1.13.10-gke.8 ou supérieure, faites défiler la page jusqu'au service istio-ingress. Pour toutes les autres versions de cluster, faites défiler la page jusqu'au service istio-ingressgateway.

    4. Copiez l'adresse IP externe affichée à côté de l'équilibreur de charge, sans le paramètre "port", le cas échéant. Par exemple, si l'adresse IP est XX.XXX.XX.XXX:15020, omettez :15020. Ignorez les autres adresses IP répertoriées.

  8. Le champ address de la section backend spécifie le nom DNS interne du service Cloud Run "grpc-bookstore" avec le schéma proto grpc:// et désactive l'authentification auprès de ce service :

    address: grpc://GRPC_SERVICE.default.svc.cluster.local
disable_auth: true

    Exemple :

    address: grpc://grpc-bookstore.default.svc.cluster.local
disable_auth: true

    Cela est nécessaire, car l'appel d'ESPv2 vers le service Cloud Run pour Anthos est effectué en tant qu'appel interne à partir du cluster. Par conséquent, l'authentification n'est pas nécessaire.

  9. Notez la valeur de la propriété title dans le fichier api_config_authos.yaml :

    title: Bookstore gRPC API In Cloud Run Anthos

    La valeur de la propriété title devient le nom du service Endpoints après le déploiement de la configuration.

  10. Enregistrez votre document API gRPC.

Pour en savoir plus sur les champs du document OpenAPI requis par Endpoints, consultez la page Configurer Endpoints.

Déployer la configuration Endpoints

Pour déployer la configuration Endpoints, exécutez la commande gcloud endpoints services deploy. Celle-ci crée un service géré à l'aide de Service Management.

Pour déployer la configuration Endpoints :

  1. Assurez-vous que vous vous trouvez dans le répertoire contenant votre document gRPC.

  2. Téléchargez la configuration et créez un service géré. 

    gcloud endpoints services deploy api_descriptor.pb api_config_anthos.yaml \ 
  --project ESP_PROJECT_ID

    Vous créez ainsi un service Endpoints avec le nom spécifié dans le champ name du fichier api_config_anthos.yaml. Le service Endpoints est configuré conformément à votre document OpenAPI.

    Lors de la création et de la configuration du service, Service Management envoie des informations au terminal. Une fois le déploiement terminé, un message semblable au suivant s'affiche : 

    Service Configuration [CONFIG_ID] uploaded for service [API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog]

    CONFIG_ID correspond à l'ID unique de configuration du service Endpoints créé par le déploiement. Exemple : 

    Service Configuration [2019-02-01r0] uploaded for service [grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog]

    L'ID de configuration du service se compose d'un horodatage suivi d'un numéro de révision. Si vous déployez à nouveau api_config_anthos.yaml le même jour, le numéro de révision est incrémenté dans l'ID de configuration de service. Vous pouvez afficher la configuration du service et l'historique de déploiement sur la page Endpoints > Services de la console Google Cloud.

    Si vous recevez un message d'erreur, consultez la page Résoudre des problèmes de déploiement de la configuration Endpoints.

Vérifier les services requis

Endpoints et ESP requièrent au minimum l'activation des services Google suivants :
Nom Titre
servicemanagement.googleapis.com API Service Management
servicecontrol.googleapis.com API Service Control
endpoints.googleapis.com Google Cloud Endpoints

Dans la plupart des cas, la commande gcloud endpoints services deploy permet d'activer ces services requis. Toutefois, bien que la commande gcloud ait abouti, elle n'active pas les services requis dans les cas suivants :

  • Vous avez utilisé une application tierce telle que Terraform et vous n'incluez pas ces services.

  • Vous avez déployé la configuration Endpoints dans un projet Google Cloud existant dans lequel ces services étaient explicitement désactivés.

Utilisez la commande suivante pour vérifier que les services nécessaires sont activés :

gcloud services list

Si les services requis ne sont pas répertoriés, activez-les :

gcloud services enable servicemanagement.googleapis.com
gcloud services enable servicecontrol.googleapis.com
gcloud services enable endpoints.googleapis.com

Activez également votre service Endpoints :

gcloud services enable ENDPOINTS_SERVICE_NAME

Pour déterminer la valeur de ENDPOINTS_SERVICE_NAME, vous pouvez effectuer l'une des opérations suivantes :

  • Après avoir déployé la configuration Endpoints, accédez à la page Endpoints de Cloud Console. La liste des valeurs ENDPOINTS_SERVICE_NAME possibles s'affiche dans la colonne Nom du service.

  • Pour OpenAPI, ENDPOINTS_SERVICE_NAME correspond à ce que vous avez spécifié dans le champ host de votre spécification OpenAPI. Pour gRPC, ENDPOINTS_SERVICE_NAME correspond à ce que vous avez spécifié dans le champ name de votre configuration Endpoints gRPC.

Pour en savoir plus sur les commandes gcloud, consultez la page Services gcloud.

Créer une image de service Knative ESPv2

Créez la configuration du service Endpoints dans une nouvelle image ESPv2 pour Docker. Après avoir créé cette image, vous pouvez la déployer sur votre cluster.

Pour créer la configuration de service dans une nouvelle image ESPv2 pour Docker, procédez comme suit :

  1. Téléchargez ce script sur la machine locale où la gcloud CLI est installée, puis exécutez-le comme suit :

    chmod +x gcloud_build_image 
./gcloud_build_image -s API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog \ 
-c CONFIG_ID -p ESP_PROJECT_ID

    Le script utilise la commande gcloud pour télécharger la configuration de service, la compiler dans une nouvelle image ESPv2, puis importer la nouvelle image dans le registre de conteneurs de votre projet. Le script utilise automatiquement la dernière version d'ESPv2, désignée par ESP_VERSION dans le nom de l'image de sortie. L'image de sortie est importée dans l'emplacement suivant :

    gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:ESP_VERSION-API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID

Déployer l'image ESPv2 Knative serving

Déployez l'image du service ESPv2 Knative serving sur votre cluster:

  1. Déployez le service ESPv2 Knative serving avec la nouvelle image: 

    gcloud run deploy ESP_V2_SERVICE_NAME \ 
  --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \ 
  --platform gke \
  --use-http2 \
  --project=ESP_PROJECT_ID

    Pour ESP_PROJECT_ID, indiquez le nom que vous souhaitez utiliser pour le service ESPv2. Dans cet exemple, définissez la valeur de ESP_V2_SERVICE_NAME sur espv2.

  2. Si vous souhaitez configurer Endpoints afin d'utiliser d'autres options de démarrage d'ESPv2, telles que l'activation de CORS, vous pouvez transmettre les arguments dans la variable d'environnement ESPv2_ARGS :

    gcloud run deploy ESP_V2_SERVICE_NAME \
  --image="gcr.io/ESP_PROJECT_ID/endpoints-runtime-serverless:API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog-CONFIG_ID" \ 
  --set-env-vars=ESPv2_ARGS=--cors_preset=basic \ 
  --platform gke --use-http2 \
  --project ESP_PROJECT_ID

    Pour en savoir plus et obtenir des exemples de définition de la variable d'environnement ESPv2_ARGS, y compris la liste des options disponibles et des informations sur la manière de spécifier plusieurs options, reportez-vous à la page sur les options d'Extensible Service Proxy V2.

Créer un mappage de domaine vers le service ESPv2 Knative serving

Pour pouvoir omettre l'en-tête host lorsque vous effectuez une requête, ajoutez un mappage de domaine au service ESPv2 :

  1. Accédez à Cloud Run

  2. Sélectionnez Gérer les domaines personnalisés.

  3. Sélectionnez Ajouter un mappage.

  4. Dans la liste déroulante, sélectionnez Ajouter un mappage de domaine pour le service.

  5. Dans le champ Sélectionner un service vers lequel mapper du pop-up Ajouter un mappage, sélectionnez votre service ESPv2.

  6. Dans le champ Saisir un nom de domaine, spécifiez le nom de domaine que vous souhaitez utiliser pour accéder à votre service de diffusion Knative via Endpoints. Par exemple, spécifiez : 

    API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog

    Où API_NAME est le nom de votre API Endpoints. Pour cet exemple, vous pouvez utiliser "hello-api" : 

    grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog

  7. Cliquez sur Continuer. Un résumé du mappage s'affiche.

  8. Sélectionnez OK pour enregistrer le mappage.

Envoyer des requêtes à l'API

Pour envoyer des requêtes à l'exemple d'API, vous pouvez utiliser un exemple de client gRPC écrit en Python.

  1. Assurez-vous que vous vous trouvez dans le répertoire contenant vos documents gRPC, tels que api_config_anthos.yaml.

  2. Installez les dépendances :

    pip3 install virtualenv
virtualenv env
source env/bin/activate
pip3 install -r requirements.txt

  3. Envoyez une requête à l'exemple d'API :

    python3 bookstore_client.py --host API_NAME.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

    Exemple :

    python3 bookstore_client.py --host grpc-bookstore-api.endpoints.ESP_PROJECT_ID.cloud.goog --port 80

    Si tout fonctionne correctement, une réponse doit s'afficher sous la forme :

    ListShelves: shelves {
  id: 1
  theme: "Fiction"
}
shelves {
  id: 2
  theme: "Fantasy"
}

Si vous ne recevez pas de réponse positive, consultez la page Dépanner des erreurs de réponse.

Vous venez de déployer et de tester une API dans Endpoints.

Configurer l'API Endpoints pour utiliser HTTPS

La compatibilité avec TLS automatique est désactivée par défaut pour Knative serving sur Google Cloud. Par conséquent, dans cet exemple, lorsque vous accédez à votre API Endpoints via ESPv2, vous effectuez l'appel via HTTP.

Vous pouvez configurer ESPv2 afin d'accepter les requêtes via HTTPS. Notez que vous configurez la compatibilité HTTPS sur ESPv2 (le service externe) et non sur "hello", le service de backend interne.

Pour assurer la compatibilité du protocole HTTPS avec ESPv2, vous devez :

  1. être propriétaire d'un domaine. Si vous n'en avez pas, vous pouvez en obtenir un auprès de Google ou d'un autre fournisseur de domaine ;

  2. créer un mappage de domaine pour votre service ESPv2 et avoir mis à jour votre enregistrement DNS en suivant les instructions de la page sur le mappage de domaines.

    Si vous avez obtenu votre domaine auprès de Google Domains, utilisez-le comme serveur DNS. Sinon, utilisez Cloud DNS ou un serveur DNS de votre choix. L'utilisation d'un domaine à partir de Google Domains est l'option la plus simple ;

  3. dans les spécifications OpenAPI Endpoints :

    1. définir le champ name de sorte qu'il fasse référence à votre domaine plutôt qu'à *.cloud.goog ;

    2. supprimer la balise endpoints et ses deux propriétés enfants.

Pour obtenir des instructions complètes et un tutoriel, consultez la page Activer des certificats HTTPS et TLS automatiques.

Suivre l'activité de l'API

  1. Afficher les graphiques d'activité de votre API sur le point de terminaison > Service de la console Google Cloud.

    Afficher les graphiques d'activité Endpoints

    Il peut s'écouler quelques instants avant que la requête ne soit reflétée dans les graphiques.

  2. Consultez les journaux de requêtes de votre API sur la page de l'explorateur de journaux.

    Afficher les journaux de requête Endpoints

Créer un portail développeur pour l'API

Vous pouvez utiliser le portail Cloud Endpoints pour créer un portail des développeurs, c'est-à-dire un site Web qui vous permet d'interagir avec l'exemple d'API. Pour en savoir plus, consultez la page Présentation du portail Cloud Endpoints.

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud, procédez comme suit :

Pour plus d'informations sur l'arrêt des services utilisés par ce tutoriel, consultez la page Supprimer une API et des instances d'API.

Étapes suivantes