Cette page a été traduite par l'API Cloud Translation.

É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

Cette page explique comment envoyer des requêtes HTTP(S) depuis votre application App Engine à l'aide du service de récupération d'URL pour les environnements d'exécution de deuxième génération.

Avant de suivre les instructions de cette page, nous vous recommandons d'utiliser des solutions idiomatiques de langage pour émettre des requêtes HTTP(S) avant d'utiliser le service de récupération d'URL. Le principal cas d'utilisation de la récupération d'URL est lorsque vous souhaitez envoyer des requêtes HTTP(S) à une autre application App Engine et revendiquer l'identité de votre application sur cette requête.

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

Pour émettre des requêtes HTTP(S) sortantes à l'aide du service de récupération d'URL, vous devez explicitement appeler la bibliothèque urlfetch.

Pour émettre une requête HTTP sortante, vous pouvez utiliser l'une des bibliothèques suivantes :

Pour améliorer la portabilité du code, utilisez la bibliothèque standard Python urllib.request pour émettre des requêtes HTTP.
Utilisez une bibliothèque tierce, telle que requests.
Appelez explicitement la bibliothèque urlfetch et utilisez la méthode urlfetch.fetch.

urllib.request

Importez la bibliothèque urllib.request :

import urllib.request

Utilisez ensuite urllib.request pour exécuter la requête GET :

url = 'http://www.google.com/humans.txt'
try:
    result = urllib.request.urlopen(url)
    self.response.write(result.read())
except urllib.error.URLError:
    logging.exception('Caught exception fetching 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')

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

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 :

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.
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.
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 :

Créez une fonction d'assistance pour définir la portée du rappel.
Créez une fonction de gestionnaire pour gérer le résultat de l'appel de récupération.
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

Lorsque vous utilisez URL Fetch pour envoyer une requête à une autre application App Engine, votre application peut 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.

Étapes suivantes

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.