Émettre des requêtes HTTP(S)

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

App Engine passe par le service URL Fetch 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.

É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 standard urllib, urllib2 ou httplib Python pour envoyer 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 utiliser URLFetch.

urlfetch

Les extraits de code suivants expliquent comment exécuter 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 des données à partir 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 expliquent comment exécuter 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 les requêtes, vous devez installer les options requests et requests-toolbelt à l'aide des instructions de vendoring.

Une fois installées, utilisez le module requests_toolbelt.adapters.appengine pour configurer les requêtes d'utilisation de URLFetch :

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 plus d'informations sur la prise en charge des requêtes pour Google App Engine, consultez la documentation de urllib3.contrib.appengine et requests_toolbelt.appengine.

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

Vous pouvez ajuster la date limite 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é.

É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 nouvel 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 URL Fetch de ne pas suivre les redirections, App Engine ajoutera automatiquement cet en-tête aux requêtes.

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

Étape suivante

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

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python 2