Como as solicitações são processadas

Este documento descreve como um aplicativo do App Engine recebe solicitações e envia respostas. Para mais detalhes, consulte a referência de cabeçalhos de solicitação.

Se seu aplicativo usar serviços, você poderá endereçar solicitações para um serviço específico ou uma versão específica desse serviço. Para mais informações sobre a capacidade de endereçamento do serviço, consulte Como as solicitações são encaminhadas.

Como processar solicitações

Seu aplicativo é responsável por iniciar um servidor da Web e processar as solicitações. Você pode usar qualquer biblioteca da Web disponível na linguagem de desenvolvimento que adotou.

O App Engine executa várias instâncias do aplicativo, e cada uma delas tem seu próprio servidor da Web para processar solicitações. Cada solicitação pode ser encaminhada para qualquer instância. Portanto, solicitações consecutivas do mesmo usuário não são necessariamente enviadas para a mesma instância. Uma instância pode processar várias solicitações simultaneamente. O número de instâncias pode ser ajustado automaticamente, à medida que o tráfego muda. Você também pode alterar o número de solicitações simultâneas que uma instância pode processar configurando o elemento max_concurrent_requests no arquivo app.yaml.

Veja a seguir um aplicativo Flask de arquivo único muito básico que responde a todas as solicitações de clientes da Web para o caminho raiz ('/') exibindo a mensagem "Hello, world!".

import logging

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    """Return a friendly HTTP greeting."""
    return 'Hello World!'

@app.errorhandler(500)
def server_error(e):
    logging.exception('An error occurred during a request.')
    return """
    An internal error occurred: <pre>{}</pre>
    See logs for full stacktrace.
    """.format(e), 500

if __name__ == '__main__':
    # This is used when running locally. Gunicorn is used to run the
    # application on Google App Engine. See entrypoint in app.yaml.
    app.run(host='127.0.0.1', port=8080, debug=True)

Cotas e limites

O Google App Engine aloca recursos para seu aplicativo automaticamente à medida que o tráfego aumenta. No entanto, isso é limitado pelas seguintes restrições:

  • O App Engine reserva a capacidade de dimensionamento automático para aplicativos com baixa latência que respondem a uma solicitação em menos de um segundo. Aplicativos com latência muito alta, como mais de um segundo por solicitação no caso de muitas solicitações, e alta capacidade requerem o suporte Silver, Gold ou Platinum. Os clientes com esse nível de suporte podem entrar em contato com nossos representantes para solicitar limites de capacidade mais altos.

  • Aplicativos que fazem muito uso da CPU podem gerar latência adicional a fim de compartilhar recursos de maneira eficiente com outros aplicativos nos mesmos servidores. Solicitações de arquivos estáticos estão isentas dos limites de latência.

Cada solicitação recebida para o aplicativo é contabilizada no limite de Solicitações. Os dados enviados em resposta a uma solicitação são contabilizados no limite de Largura de banda de saída (faturável).

Tanto as solicitações HTTP como as HTTPS (seguras) são contabilizadas nos limites de Solicitações, Largura de banda de entrada (faturável) e Largura de banda de saída (faturável). A página Detalhes da cota, no Console do GCP, também exibe os dados de Solicitações seguras, Largura de banda segura de entrada e Largura de banda segura de saída como valores separados para fins informativos. Apenas solicitações HTTPS são contabilizadas nesses valores. Para mais informações, consulte a página Cotas.

Os limites a seguir se aplicam especificamente ao uso de gerenciadores de solicitações:

Limites de solicitações

  • É permitido usar no máximo aproximadamente 15 KB nos cabeçalhos das solicitações.
  • O tamanho total da solicitação está limitado a aproximadamente 32 MB.
  • Todas as solicitações em HTTP/2 serão traduzidas para HTTP/1.1 quando encaminhadas para o servidor do aplicativo.
  • As conexões SSL são encerradas no balanceador de carga. O tráfego do balanceador de carga é enviado para a instância por meio de um canal criptografado e, em seguida, encaminhado para o servidor do aplicativo por HTTP. O cabeçalho X-Forwarded-Proto permite saber se a solicitação da origem era HTTP ou HTTPS.

Limites de respostas

  • As respostas são armazenadas em buffer por blocos de 64 K.
  • O tamanho da resposta é ilimitado.
  • O limite de tempo de resposta é de uma hora.

Pedidos HTTP não compatíveis

Os recursos a seguir não são compatíveis com o ambiente flexível do App Engine:

  • tráfego HTTP/2 para o serviço de back-end
  • WebSockets
  • solicitações HTTP que acessam as instâncias diretamente

Cabeçalhos de solicitação

Uma solicitação HTTP de entrada inclui os cabeçalhos HTTP enviados pelo cliente. Para fins de segurança, alguns cabeçalhos são limpos ou retificados por proxies intermediários antes de chegarem ao aplicativo.

Para ver mais informações, consulte a referência de cabeçalhos da solicitação.

Respostas a solicitações

O App Engine chama o script do gerenciador com um Request e espera o retorno do script. Todos os dados gravados no fluxo de saída padrão são enviados como a resposta HTTP.

Existem limites que se aplicam à resposta gerada e a resposta pode ser modificada antes de ser retornada ao cliente.

Como desativar o armazenamento em buffer

Por padrão, todas as respostas do App Engine são armazenadas em buffer em blocos de 64 K. Em alguns casos, pode ser útil desativar o armazenamento em buffer e transmitir os bytes diretamente para o cliente por streaming. Faça isso ao usar solicitações GET de suspensão ou eventos enviados pelo servidor (SSEs, na sigla em inglês). Para desativar o armazenamento em buffer, você pode definir o cabeçalho da resposta X-Accel-Buffering como no.

X-Accel-Buffering: no

Como forçar conexões HTTPS

Por razões de segurança, todos os aplicativos devem incentivar os clientes a se conectarem por meio de https. Você pode usar o cabeçalho Strict-Transport-Security para instruir o navegador a preferir https em vez de http para uma determinada página ou um domínio inteiro. Por exemplo:

Strict-Transport-Security: max-age=31536000; includeSubDomains

É possível usar a biblioteca flask-talisman, que processa a configuração de cabeçalhos de segurança HTTP.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentos do ambiente flexível do App Engine para Python