Émettre des requêtes HTTP(S)

ID de la région

Le REGION_ID est un code abrégé que Google attribue en fonction de la région que vous sélectionnez lors de la création de votre application. Le code ne correspond pas à un pays ou une province, même si certains ID de région peuvent ressembler aux codes de pays et de province couramment utilisés. Pour les applications créées après février 2020, REGION_ID.r est inclus dans les URL App Engine. Pour les applications existantes créées avant cette date, l'ID de région est facultatif dans l'URL.

En savoir plus sur les ID de région

OK

Cette page explique comment envoyer des requêtes HTTP(S) à partir de l'application App Engine.

Cette API est compatible avec les environnements d'exécution de première génération et peut être utilisée lors de la mise à niveau vers des environnements d'exécution de deuxième génération correspondants. Si vous effectuez une mise à jour vers l'environnement d'exécution Python 3 d'App Engine, consultez le guide de migration pour en savoir plus sur les options de migration des anciens services groupés.

Par défaut, App Engine utilise le service de récupération d'URL pour émettre des requêtes HTTP(S) sortantes.

Pour en savoir plus sur les limites de taille des requêtes et les en-têtes envoyés dans une requête de récupération d'URL, consultez la page Requêtes sortantes.

Si vous avez configuré l'accès au VPC sans serveur ou que vous utilisez l'API Sockets, vous devez empêcher le service de récupération d'URL de traiter les requêtes. Ce service provoque l'échec des requêtes adressées à votre réseau VPC ou à l'API Sockets. Une fois le service de récupération d'URL désactivé, la bibliothèque standard Python traite les requêtes HTTP. Si vous devez exploiter les fonctionnalités fournies par le service de récupération d'URL pour des requêtes spécifiques, vous pouvez utiliser la bibliothèque urlfetch directement pour ces requêtes.

Émettre une requête HTTP

Vous pouvez émettre une requête HTTP sortante à l'aide de la méthode urlfetch.fetch. Pour améliorer la portabilité du code, vous pouvez également utiliser les bibliothèques standards Python urllib, urllib2 ou httplib pour émettre des requêtes HTTP. Ces bibliothèques exécutent des requêtes HTTP à l'aide du service URL Fetch d'App Engine lorsque vous les utilisez dans App Engine Vous pouvez également utiliser la bibliothèque requests tierce tant que vous la configurez pour exploiter le service de récupération d'URL.

urlfetch

Les extraits de code suivants montrent comment effectuer une requête GET HTTP de base à l'aide de urlfetch. Commencez par importer la bibliothèque urlfetch à partir du SDK App Engine :

from google.appengine.api import urlfetch

Utilisez ensuite urlfetch pour exécuter la requête GET :

url = 'http://www.google.com/humans.txt'
try:
    result = urlfetch.fetch(url)
    if result.status_code == 200:
        self.response.write(result.content)
    else:
        self.response.status_code = result.status_code
except urlfetch.Error:
    logging.exception('Caught exception fetching url')

L'extrait de code suivant montre comment exécuter une requête plus avancée en soumettant les données d'un formulaire Web via une requête POST HTTP à l'aide de urlfetch :

try:
    form_data = urllib.urlencode(UrlPostHandler.form_fields)
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    result = urlfetch.fetch(
        url='http://localhost:8080/submit_form',
        payload=form_data,
        method=urlfetch.POST,
        headers=headers)
    self.response.write(result.content)
except urlfetch.Error:
    logging.exception('Caught exception fetching url')

urllib2

Les extraits de code suivants montrent comment effectuer une requête GET HTTP de base à l'aide de urllib2. Commencez par importer la bibliothèque urllib2 :

import urllib2

Utilisez ensuite urllib2 pour exécuter la requête GET :

url = 'http://www.google.com/humans.txt'
try:
    result = urllib2.urlopen(url)
    self.response.write(result.read())
except urllib2.URLError:
    logging.exception('Caught exception fetching url')

requêtes

Pour utiliser des requêtes, vous devez installer les outils requests et requests-toolbelt à l'aide des instructions de vendoring.

Une fois ces outils installés, utilisez le module requests_toolbelt.adapters.appengine pour configurer les requêtes permettant d'utiliser le service de récupération d'URL :

import requests
import requests_toolbelt.adapters.appengine

# Use the App Engine Requests adapter. This makes sure that Requests uses
# URLFetch.
requests_toolbelt.adapters.appengine.monkeypatch()

Une fois configurées, vous pouvez utiliser les requêtes normalement :

url = 'http://www.google.com/humans.txt'
response = requests.get(url)
response.raise_for_status()
return response.text

Pour en savoir plus sur la compatibilité des requêtes avec Google App Engine, consultez la documentation sur urllib3.contrib.appengine et requests_toolbelt.appengine

Définir un délai d'inactivité de requête

Vous pouvez ajuster le délai par défaut à l'aide de la fonction urlfetch.set_default_fetch_deadline(). Cette fonction stocke la nouvelle date limite par défaut sur une variable "thread" locale. Elle doit donc être définie pour chaque requête, par exemple dans un middleware personnalisé.

Désactiver les redirections

Important : Pour améliorer la sécurité de votre application, nous vous recommandons de désactiver les redirections.

Si vous utilisez la récupération d'URL, le service de récupération d'URL sous-jacent suit jusqu'à cinq redirections par défaut. Ces redirections peuvent transférer des informations sensibles, telles que des en-têtes d'autorisation, vers la destination de redirection. Si votre application ne nécessite pas de redirections HTTP, il est recommandé de les désactiver.

Pour indiquer au service de récupération d'URL de ne pas suivre les redirections, définissez le paramètre follow_redirects de la méthode fetch sur False.

Émettre une requête HTTPS

Pour émettre une requête HTTPS, définissez le paramètre validate_certificate sur true en appelant la méthode urlfetch.fetch().

Émettre une requête asynchrone

Les requêtes HTTP(S) sont synchrones par défaut. Pour émettre une demande asynchrone, l'application doit :

1. créer un objet RPC à l'aide de urlfetch.create_rpc(). Cet objet représente l'appel asynchrone dans les appels de méthode suivants.
2. appeler urlfetch.make_fetch_call() pour effectuer la requête. Cette méthode utilise l'objet RPC et l'URL de la cible de la requête comme paramètres.
3. appeler la méthode get_result() de l'objet RPC. Cette méthode renvoie l'objet du résultat si la requête aboutit, et génère une exception si une erreur s'est produite lors de la requête.

Les extraits de code suivants montrent comment effectuer une requête asynchrone de base à partir d'une application Python. Commencez par importer la bibliothèque urlfetch à partir du SDK App Engine :

from google.appengine.api import urlfetch

Utilisez ensuite urlfetch pour effectuer la requête asynchrone :

rpc = urlfetch.create_rpc()
urlfetch.make_fetch_call(rpc, 'http://www.google.com/')

# ... do other things ...
try:
    result = rpc.get_result()
    if result.status_code == 200:
        text = result.content
        self.response.write(text)
    else:
        self.response.status_int = result.status_code
        self.response.write('URL returned status code {}'.format(
            result.status_code))
except urlfetch.DownloadError:
    self.response.status_int = 500
    self.response.write('Error fetching URL')

Définir un délai d'inactivité de requête

Pour définir un délai d'inactivité pour la requête, configurez le paramètre deadline de la méthode urlfetch.create_rpc() lors de la création de l'objet RPC.

Utiliser une fonction de rappel

Vous pouvez définir une fonction de rappel pour l'objet RPC. La fonction est appelée lorsque l'application appelle une méthode sur l'objet (par exemple, wait(), checksuccess() ou get_result()). L'objet doit ainsi attendre que la requête soit exécutée.

Pour utiliser une fonction de rappel afin de gérer le résultat de l'appel de récupération :

1. Créez une fonction d'assistance pour définir la portée du rappel.
2. Créez une fonction de gestionnaire pour gérer le résultat de l'appel de récupération.
3. Définissez l'attribut callback de l'objet RPC sur la fonction d'assistance.

L'extrait de code suivant montre comment appeler une fonction de rappel :

def handle_result(rpc):
    result = rpc.get_result()
    self.response.write(result.content)
    logging.info('Handling RPC in callback: result {}'.format(result))

urls = ['http://www.google.com',
        'http://www.github.com',
        'http://www.travis-ci.org']
rpcs = []
for url in urls:
    rpc = urlfetch.create_rpc()
    rpc.callback = functools.partial(handle_result, rpc)
    urlfetch.make_fetch_call(rpc, url)
    rpcs.append(rpc)

# ... do other things ...

# Finish all RPCs, and let callbacks process the results.

for rpc in rpcs:
    rpc.wait()

logging.info('Done waiting for RPCs')

Envoyer une requête à une autre application App Engine

Lors de l'envoi d'une requête à une autre application App Engine, celle-ci doit affirmer son identité en ajoutant l'en-tête X-Appengine-Inbound-Appid à la requête. Si vous indiquez au service de récupération d'URL de ne pas suivre les redirections, App Engine ajoutera automatiquement cet en-tête aux requêtes.

Consultez Désactiver les redirections pour des conseils sur la désactivation des redirections.

Remarque : Si vous envoyez des requêtes à une autre application App Engine, utilisez le nom de domaine REGION_ID.r.appspot.com plutôt qu'un domaine personnalisé pour l'application.

Étape suivante

Pour en savoir plus sur le service de récupération d'URL, y compris sur les en-têtes envoyés dans une requête de récupération d'URL, consultez la page Requêtes sortantes.