Emitir pedidos HTTPS

ID da região

O REGION_ID é um código abreviado que a Google atribui com base na região que seleciona quando cria a sua app. O código não corresponde a um país ou uma província, embora alguns IDs de regiões possam parecer semelhantes aos códigos de países e províncias usados com frequência. Para apps criadas após fevereiro de 2020, REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criadas antes desta data, o ID da região é opcional no URL.

Saiba mais acerca dos IDs de regiões.

Esta página descreve como emitir pedidos HTTP(S) a partir da sua app do App Engine usando o serviço URL Fetch para runtimes de segunda geração.

Antes de seguir as instruções nesta página, recomendamos que use soluções idiomáticas para emitir pedidos HTTP(S) antes de usar o serviço URL Fetch. O principal exemplo de utilização da obtenção de URLs é quando quer emitir pedidos HTTP(S) para outra app do App Engine e afirmar a identidade da sua app nesse pedido.

Para ver detalhes sobre os limites de tamanho dos pedidos e os cabeçalhos enviados num pedido de obtenção de URL, consulte o artigo Pedidos de saída.

Emitir um pedido HTTP

Para usar o serviço de obtenção de URL para emitir pedidos HTTP(S) de saída, chame a biblioteca urlfetch.

Para emitir um pedido HTTP de saída, use qualquer uma das seguintes bibliotecas:

  • Para melhorar a portabilidade do código, use a biblioteca padrão do Python urllib.request para emitir pedidos HTTP.
  • Use uma biblioteca de terceiros, como requests.

  • Chame explicitamente a biblioteca urlfetch e use o método urlfetch.fetch.

urllib.request

Importe a biblioteca do urllib.request:

import urllib.request

Em seguida, use urllib.request para fazer o pedido 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

Os fragmentos seguintes demonstram como fazer um pedido HTTP GET básico usando urlfetch. Primeiro, importe a biblioteca urlfetch do SDK do App Engine:

from google.appengine.api import urlfetch

Use urlfetch para fazer o pedido 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 fragmento seguinte demonstra como fazer um pedido mais avançado, enviando dados de um formulário Web através de um pedido 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')

Defina um limite de tempo do pedido

Ajuste o prazo predefinido através da função urlfetch.set_default_fetch_deadline(). Esta função armazena o novo prazo predefinido numa variável local do segmento, pelo que tem de ser definida para cada pedido, por exemplo, num middleware personalizado.

Desative os redirecionamentos

Se estiver a usar a obtenção de URLs, o serviço de obtenção de URLs subjacente segue até cinco redirecionamentos por predefinição. Estes redirecionamentos podem encaminhar informações confidenciais, como cabeçalhos de autorização, para o destino redirecionado. Se a sua app não requerer redirecionamentos HTTP, recomendamos que os desative.

Para indicar ao serviço de obtenção de URLs que não siga os redirecionamentos, defina o parâmetro follow_redirects do método fetch como False.

Emitir um pedido HTTPS

Por predefinição, o serviço URL Fetch subjacente valida o certificado do anfitrião que contacta e rejeita pedidos se o certificado não corresponder. Não precisa de proteger explicitamente o seu pedido.

Emita um pedido assíncrono

Os pedidos HTTP(S) são síncronos por predefinição. Para emitir um pedido assíncrono, a sua aplicação tem de:

  1. Crie um novo objeto RPC com urlfetch.create_rpc(). Este objeto representa a sua chamada assíncrona em chamadas de método subsequentes.
  2. Ligue para urlfetch.make_fetch_call() para fazer o pedido. Este método usa o objeto RPC e o URL do destino do pedido como parâmetros.
  3. Chame o método get_result() do objeto RPC. Este método devolve o objeto de resultado se o pedido for bem-sucedido e gera uma exceção se ocorrer um erro durante o pedido.

Os fragmentos seguintes demonstram como fazer um pedido assíncrono básico a partir de uma aplicação Python. Primeiro, importe a biblioteca urlfetch do SDK do App Engine:

from google.appengine.api import urlfetch

Em seguida, use urlfetch para fazer o pedido assíncrono:

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

Defina um limite de tempo do pedido

Para definir um limite de tempo para o seu pedido, defina o parâmetro deadline do método quando criar o objeto RPC.urlfetch.create_rpc()

Use uma função de chamada de retorno

Pode definir uma função de retorno de chamada para o seu objeto RPC. A função é chamada quando a sua aplicação chama um método no objeto, como wait(), checksuccess() ou get_result(), que faz com que o objeto aguarde a conclusão do pedido.

Para usar uma função de chamada de retorno para processar o resultado da sua chamada de obtenção:

  1. Crie uma função auxiliar para definir o âmbito da função de retorno de chamada.
  2. Crie uma função de controlador para processar o resultado da sua chamada de obtenção.
  3. Defina o atributo callback do objeto RPC para a função auxiliar.

O fragmento seguinte demonstra como invocar uma função de chamada de retorno:

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

Emitir um pedido para outra app do App Engine

Quando usa a obtenção de URLs para emitir um pedido a outra app do App Engine, a sua app pode afirmar a respetiva identidade adicionando o cabeçalho X-Appengine-Inbound-Appid ao pedido.

Se instruir o serviço URL Fetch para não seguir redirecionamentos, o App Engine adiciona este cabeçalho aos pedidos automaticamente. Consulte o artigo Desativar redirecionamentos para obter orientações sobre como desativar redirecionamentos.

O que se segue?

Saiba mais sobre o serviço de obtenção de URL, como os cabeçalhos que são enviados num pedido de obtenção de URL em Pedidos de saída.