Como usar o servidor de desenvolvimento local

É possível usar o servidor de desenvolvimento local para simular a execução do aplicativo do App Engine na produção, bem como usá-lo para acessar serviços em pacote do App Engine.

O ambiente simulado aplica algumas restrições de sandbox, como funções de sistema restrito e importações de módulo do Python 2, mas não outras, como intervalos de solicitação ou cotas.

O servidor de desenvolvimento local também simula os serviços fornecidos pelas bibliotecas no SDK do App Engine, incluindo Datastore, Memcache e filas de tarefas, por meio da execução local das respectivas tarefas. Quando o aplicativo está sendo executado no servidor de desenvolvimento, ainda é possível fazer chamadas de API remotas para a infraestrutura de produção usando os endpoints HTTP das APIs do Google.

Antes de começar

Como o Python 2.7 chegou ao fim do suporte, não é mais possível usar a versão mais recente de dev_appserver.py para executar localmente seus aplicativos. Para fazer o download de uma versão arquivada de devapp_server.py, siga estas etapas:

1. No arquivo, faça o download da pasta compactada que contém o servidor dev_appserver.py para ambientes de execução que atingiram o fim do suporte.

2. Extraia o conteúdo do diretório para o sistema de arquivos local, como o diretório /home. É possível encontrar dev_appserver.py no diretório google_appengine/.

Configurar o servidor de desenvolvimento local

Para executar a ferramenta do servidor de desenvolvimento local, configure o seguinte:

1. Verifique se você instalou um intérprete do Python 2 da versão 2.7.12 ou posterior.

2. Defina a variável de ambiente DEVAPPSERVER_ROOT no shell como o caminho do interpretador do Python 2.

Executar o servidor de desenvolvimento local

Observação: a ferramenta dev_appserver não é compatível com o desenvolvimento de aplicativos Python 3 no Windows.

Depois de configurar o servidor de desenvolvimento local e criar o arquivo de configuração app.yaml para seu app, use o comando dev_appserver.py para executar seu aplicativo localmente.

Para iniciar o servidor de desenvolvimento local:

1. No diretório que contém o arquivo de configuração app.yaml, execute o comando dev_appserver.py.

   Especifique o caminho do diretório para seu aplicativo, por exemplo:

        python2 [DEVAPPSERVER_ROOT]/google_appengine/dev_appserver.py [PATH_TO_YOUR_APP]
   

   Se preferir, informe o arquivo de configuração de um serviço específico, por exemplo:

        python2 [DEVAPPSERVER_ROOT]/google_appengine/dev_appserver.py app.yaml
   

   Para alterar a porta, inclua a opção --port:

        python2 [DEVAPPSERVER_ROOT]/google_appengine/dev_appserver.py --port=9999 [PATH_TO_YOUR_APP]
   

   Substitua [DEVAPPSERVER_ROOT] pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.

   Saiba mais sobre as opções do comando dev_appserver.py em Opções do servidor de desenvolvimento local.

2. O servidor de desenvolvimento local já está sendo executado e detectando solicitações. Acesse http://localhost:8080/ no seu navegador da Web para ver o aplicativo em ação.

   Caso tenha especificado uma porta personalizada com a opção --port, lembre-se de abrir essa porta no navegador.

Para parar o servidor local pela linha de comando, pressione:

• macOS ou Linux: Control+C
• Windows: Control+Break

Especificar IDs de aplicativo

Para acessar o ID do aplicativo no servidor local, por exemplo, para falsificar um endereço de e-mail, use a função get_application_id(). Para receber o nome do host do aplicativo em execução, use a função get_default_version_hostname().

Como detectar o ambiente de execução do aplicativo

Para determinar se o código está em execução na produção ou no servidor de desenvolvimento local, verifique a variável de ambiente SERVER_SOFTWARE:

if os.getenv('SERVER_SOFTWARE', '').startswith('Google App Engine/'):
  # Production
else:
  # Local development server

Como usar o Datastore local

Observação: estamos migrando o ambiente de desenvolvimento local para usar o emulador do Cloud Datastore. Para mais informações sobre essa alteração, consulte o guia de migração.

O servidor de desenvolvimento local simula o armazenamento de dados do App Engine usando um arquivo local que persiste entre invocações do servidor local.

Para mais informações sobre índices e index.yaml, consulte as páginas Índices do Datastore e Configuração do índice do Datastore.

Navegar pelo Datastore local

Se seu aplicativo tiver gravado dados no seu Datastore local usando o servidor de desenvolvimento local, você pode navegar nele pelo console de desenvolvimento local.

Para navegar no Datastore local:

1. Inicie o servidor de desenvolvimento.

2. Acesse o Leitor do Datastore no console de desenvolvimento local. O URL é http://localhost:8000/datastore.

3. Veja o conteúdo do Datastore local.

Especificar a política de alocação de códigos

Para o App Engine de produção, defina o Datastore para gerar automaticamente códigos da entidade.

Embora as políticas de atribuição automática de IDs para o servidor de produção sejam completamente diferentes das usadas pelo servidor de desenvolvimento, é possível configurar a política de alocação automática de IDs para o servidor local.

Para especificar a política de atribuição automática de IDs, use a opção --auto_id_policy:

python2 DEVAPPSERVER_ROOT/google_appengine/dev_appserver.py --auto_id_policy=sequential

Substitua:

• DEVAPPSERVER_ROOT pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.

• --auto_id_policy por um destes procedimentos:

  • scattered scattered (padrão): os IDs são atribuídos com base em uma sequência não repetitiva de números inteiros distribuídos de maneira quase uniforme.
  • sequential: os IDs são atribuídos da sequência de números inteiros consecutivos.

Observação: o aplicativo não pode fazer suposições sobre a sequência de IDs automáticos atribuídos na produção.

Limpar o armazenamento de dados local

Para limpar o armazenamento de dados local de um aplicativo, invoque o servidor de desenvolvimento local da seguinte forma:

python2 DEVAPPSERVER_ROOT/google_appengine/dev_appserver.py --clear_datastore=yes app.yaml

Substitua DEVAPPSERVER_ROOT pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.

Alterar o local do Datastore

Para alterar o local usado para o arquivo de armazenamento de dados, use a opção --datastore_path:

python2 DEVAPPSERVER_ROOT/google_appengine/dev_appserver.py --datastore_path=/tmp/myapp_datastore app.yaml

Substitua DEVAPPSERVER_ROOT pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.

Usar o serviço Usuários

O App Engine fornece um Serviço usuários para simplificar a autenticação e autorização para seu aplicativo. O servidor de desenvolvimento local simula o comportamento das Contas do Google com suas próprias páginas de login e logout. Durante a execução no servidor de desenvolvimento local, as funções users.create_login_url e users.create_logout_url retornam URLs para /_ah/login e /_ah/logout no servidor local.

Usar o E-mail

O servidor de desenvolvimento local pode enviar e-mails para chamadas do serviço de e-mail do App Engine usando um servidor SMTP ou uma instalação local do Sendmail.

Como usar SMTP

Para ativar o suporte a e-mail com um servidor SMTP, invoque dev_appserver.py da seguinte maneira:

   python2 [DEVAPPSERVER_ROOT]/google_appengine/dev_appserver.py --smtp_host=smtp.example.com --smtp_port=25 \
    --smtp_user=ajohnson --smtp_password=k1tt3ns [PATH_TO_YOUR_APP]

Substitua:

• [DEVAPPSERVER_ROOT] pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.
• As opções --smtp_host, --smtp_port, --smtp_user e --smtp_password com seus próprios valores de configuração.

Como usar o Sendmail

Para ativar o suporte a e-mail com o Sendmail, invoque dev_appserver.py desta forma:

   python2 [DEVAPPSERVER_ROOT]/google_appengine/dev_appserver.py --enable_sendmail=yes [PATH_TO_YOUR_APP]

Substitua [DEVAPPSERVER_ROOT] pelo caminho para a pasta em que você extrai a versão arquivada de devapp_server.py.

O servidor local usará o comando sendmail para enviar mensagens de e-mail com a configuração padrão da instalação.

Observação: se você não invocar dev_appserver.py com o SMTP ou Sendmail, conforme descrito, as tentativas de enviar e-mails do aplicativo não terão efeito, mas a tentativa será exibida como bem-sucedida no aplicativo.

Usar a busca de URL

Quando o aplicativo usa a API de busca de URL para fazer uma solicitação HTTP, o servidor de desenvolvimento local efetua a solicitação diretamente do seu computador. O comportamento de busca de URL no servidor local pode ser diferente do App Engine de produção se você usar um servidor proxy para acessar sites.

Usar o console interativo

O console interativo permite que desenvolvedores inseriram um código Python arbitrário em um formulário da Web e o executem dentro do ambiente do aplicativo. Isso fornece o mesmo acesso ao ambiente e aos serviços do aplicativo que um arquivo .py dentro do próprio aplicativo.

Importante: se você especificar o argumento --host ao iniciar o servidor local em vez de usar o endereço padrão, o console interativo será desativado para impedir que alguém execute remotamente um código Python arbitrário no seu computador. É possível ignorar isso e reativar o console interativo iniciando o servidor de desenvolvimento usando o argumento --enable_console.

Para usar o console interativo:

1. Inicie o servidor de desenvolvimento.

2. Acesse o console interativo no console de desenvolvimento local. (O URL é http://localhost:8000/console.)

3. Insira na área de texto o código Python que quiser e envie o formulário para executá-lo. Por exemplo, o código a seguir adicionará uma entidade do Datastore chamada Greeting com o texto Hello:

     from google.appengine.ext import ndb
     class Greeting(ndb.Model):
       content = ndb.TextProperty()
   
     e = Greeting(content="Hello")
     e.put()
   

Depurar com o depurador Python

Para usar o depurador do Python (pdb):

1. Adicione a linha a seguir ao código:

   import pdb; pdb.set_trace();
   

   O dev_appserver será interrompido nesse momento e cairá no REPL pdb (loop de leitura-avaliação), permitindo que você depure o código a partir da linha de comando.

2. Se o aplicativo fizer várias solicitações simultâneas que invoquem pdb.set_trace(), várias sessões de depuração serão iniciadas ao mesmo tempo e cada uma enviará saída para STDOUT. Para evitar isso, serialize suas solicitações desativando o suporte de várias linhas de execução e vários processamentos a dev_appserver, da seguinte maneira:

   1. Desative as várias linhas de execução para:

      • todos os serviços que usam a sinalização --threadsafe_override=false;
      • um serviço que usa a sinalização --threadsafe_override=<SERVICENAME>:false;
      • vários serviços que usam a sinalização --threadsafe_override=<SERVICE1NAME>:false,<SERVICE2NAME>:false.

   2. Desative multiprocessamento para:

      • todos os serviços que usam a sinalização --max_module_instances=1;
      • um serviço que usa a sinalização --max_module_instances=<SERVICENAME>:1;
      • vários serviços que usam a sinalização --max_module_instances=<SERVICE1NAME>:1,<SERVICE2NAME>:1.