Como emitir solicitações HTTP(S)

ID de região

O REGION_ID é um código abreviado que o Google atribui com base na região que você selecionou ao criar o aplicativo. O código não corresponde a um país ou estado, ainda que alguns IDs de região sejam semelhantes aos códigos de país e estado geralmente usados. Para apps criados após fevereiro de 2020, o REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criados antes dessa data, o ID da região é opcional no URL.

Saiba mais sobre IDs de região.

OK

Esta página descreve como emitir solicitações HTTP(S) do seu aplicativo App Engine.

Essa API é compatível com os ambientes de execução de primeira geração e pode ser usada ao fazer upgrade para os ambientes de execução de segunda geração correspondentes. Se você estiver atualizando para o ambiente de execução do Python 3 do App Engine, consulte o guia de migração para saber mais sobre as opções de migração para serviços incluídos legados.

Por padrão, o App Engine usa o serviço de busca de URL para emitir solicitações HTTP(S) de saída.

Para mais detalhes sobre os limites de tamanho de solicitação e quais cabeçalhos são enviados em uma solicitação de busca de URL, consulte Solicitações de saída.

Se você tiver configurado o acesso VPC sem servidor ou se usar a API Sockets, precisará interromper o processamento de solicitações da busca de URL. A busca de URL faz com que as solicitações para a rede VPC ou para a API Sockets falhem. Depois de desativar a busca de URL, a biblioteca Python padrão processará solicitações HTTP. Se você precisar dos recursos fornecidos pela busca de URL para solicitações específicas, poderá usar a biblioteca urlfetch diretamente para essas solicitações específicas.

Como emitir solicitações HTTP

Para emitir uma solicitação HTTP de saída, use o método urlfetch.fetch. Para melhorar a portabilidade de código, você também pode usar as bibliotecas padrão do Python urllib, urllib2 ou httplib para emitir solicitações HTTP. Quando você usa essas bibliotecas no App Engine, elas executam solicitações HTTP usando o serviço de busca de URL do App Engine. Você também pode usar a biblioteca requests de terceiros, desde que a configure para usar URLFetch.

urlfetch

Os snippets a seguir demonstram como executar uma solicitação HTTP GET básica usando urlfetch. Primeiro, importe a biblioteca urlfetch do SDK do App Engine:

from google.appengine.api import urlfetch

Em seguida, use urlfetch para executar a solicitação 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')

O snippet a seguir demonstra como executar uma solicitação mais avançada, enviando dados de um formulário da Web por meio de uma solicitação HTTP POST usando 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

Os snippets a seguir demonstram como executar uma solicitação HTTP GET básica usando urllib2. Primeiro, importe a biblioteca urllib2:

import urllib2

Em seguida, use urllib2 para executar a solicitação 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')

solicitações

Para usar as solicitações, você precisará instalar requests e requests-toolbelt usando as instruções de classificação.

Depois de instalado, use o módulo requests_toolbelt.adapters.appengine para configurar solicitações para usar 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()

Depois de configurado, use as solicitações normalmente:

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

Para mais informações sobre o suporte das solicitações ao Google App Engine, consulte a documentação de urllib3.contrib.appengine e requests_toolbelt.appengine

Como definir um tempo limite de solicitação

Você pode ajustar o prazo padrão usando a função urlfetch.set_default_fetch_deadline(). Essa função armazena o novo prazo padrão em uma variável de encadeamento local. Portanto, ela precisa ser configurada para cada solicitação, por exemplo, em um middleware personalizado.

Como desativar redirecionamentos

Importante: para melhorar a segurança do app, é recomendável desativar os redirecionamentos.

Se você estiver usando a busca de URL, o serviço subjacente de busca de URL seguirá até cinco redirecionamentos por padrão. Esses redirecionamentos podem encaminhar informações confidenciais, como cabeçalhos de autorização, para o destino redirecionado. Se o aplicativo não exigir redirecionamentos HTTP, é recomendável que você os desative.

Para instruir o serviço de busca de URL a não seguir redirecionamentos, defina o parâmetro follow_redirects do método fetch como False.

Como emitir solicitações HTTPS

Para emitir uma solicitação HTTPS, defina o parâmetro validate_certificate como true ao chamar o método urlfetch.fetch().

Como emitir uma solicitação assíncrona

As solicitações HTTP(S) são síncronas por padrão. Para emitir uma solicitação assíncrona, o aplicativo precisa:

1. Crie um novo objeto RPC usando urlfetch.create_rpc(). Esse objeto representa sua chamada assíncrona em chamadas de método subsequentes;
2. Chame urlfetch.make_fetch_call() para fazer a solicitação. Esse método usa o objeto RPC e o URL do destino da solicitação como parâmetros.
3. Chame o método get_result() do objeto RPC. Durante a solicitação, esse método retorna o objeto de resultado em caso de êxito e cria uma exceção em caso de erro.

Os snippets a seguir demonstram como fazer uma solicitação assíncrona básica a partir de um aplicativo em Python. Primeiro, importe a biblioteca urlfetch do SDK do App Engine:

from google.appengine.api import urlfetch

Em seguida, use urlfetch para fazer a solicitação assíncrona:

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')

Como definir um tempo limite de solicitação

Para definir um tempo limite para sua solicitação, defina o parâmetro deadline do método urlfetch.create_rpc() ao criar o objeto RPC.

Como usar uma função de retorno de chamada

É possível definir uma função de retorno de chamada para seu objeto de RPC. A função será chamada quando seu aplicativo chamar um método no objeto, como wait(), checksuccess() ou get_result(), que faz com que o objeto aguarde até que a solicitação seja concluída.

Para usar uma função de retorno de chamada ao lidar com o resultado da chamada de busca:

1. Crie uma função auxiliar para definir o escopo de callback.
2. Crie uma função de gerenciador para lidar com o resultado da chamada de busca.
3. Defina o atributo callback do objeto RPC para a função auxiliar.

O snippet a seguir demonstra como invocar uma função de retorno de chamada:

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')

Como emitir solicitações para outro aplicativo do App Engine

Ao emitir uma solicitação para outro aplicativo do App Engine, ele precisa declarar a identidade dele adicionando o cabeçalho X-Appengine-Inbound-Appid à solicitação. Se você instruir o serviço de busca de URL a não seguir redirecionamentos, o App Engine adicionará esse cabeçalho às solicitações automaticamente.

Consulte Como desativar redirecionamentos para orientação sobre como desativar redirecionamentos.

Observação: se você estiver fazendo solicitações para outro aplicativo do App Engine, use o nome de domínio REGION_ID.r.appspot.com dele em vez de um domínio personalizado para o aplicativo.

A seguir

Para saber mais sobre o serviço de busca de URL, como os cabeçalhos que são enviados em uma solicitação de busca de URL, consulte Solicitações de saída.