Primeiros passos com o ambiente padrão do Python 2

Neste guia, você aprende a desenvolver e implantar aplicativos básicos do Python 2.7 executados no ambiente padrão do Google App Engine. Este guia é destinado a pessoas que não têm experiência com o Google App Engine e serviços relacionados, especialmente com uso do App Engine com a linguagem Python. Por esse motivo, para cada tarefa, você encontrará explicações mais detalhadas do que as que estão no Guia de início rápido.

Antes de começar

Antes de desenvolver um aplicativo:

  1. Crie um novo projeto ou recupere a ID de um projeto existente no Console do Google Cloud Platform:

    Acessar a página Projetos

  2. Instale e inicialize o SDK do Google Cloud.

Como criar um aplicativo básico

Este guia usa o framework Flask de aplicativos da Web devido à simplicidade, facilidade de uso e extensibilidade, mas os mesmos princípios são aplicados em qualquer framework que você queira usar. Neste guia, você aprende a:

  • Criar um formulário básico de comentários do usuário que exibirá o conteúdo enviado por ele nesse formulário, em um modelo HTML.
  • Criar um aplicativo básico que disponibilize arquivos estáticos, como CSS ou imagens.

Depois de configurar o ambiente de desenvolvimento, você pode escrever o código do aplicativo e implantá-lo no App Engine.

Estrutura básica de um projeto de aplicativo

Este guia usa a estrutura abaixo para o projeto flask-app:

Estrutura do projeto flask-app

  • app.yaml: defina as configurações do seu aplicativo do App Engine
  • main.py: escreva o conteúdo do aplicativo
  • static: diretório para armazenar arquivos estáticos
    • style.css: folha de estilo básica que formata a aparência dos arquivos de modelos
  • templates: diretório para todos os modelos HTML
    • form.html: modelo HTML para exibir seu formulário
    • submitted_form.html: modelo HTML para exibir o conteúdo de um formulário enviado

Como configurar bibliotecas para ativar o desenvolvimento

Neste tutorial, você aprende a colocar uma cópia da biblioteca Flask no diretório do seu aplicativo. Observe que, embora o ambiente de execução do Python 2.7 para App Engine tenha uma biblioteca Flask incorporada, ela é uma versão mais antiga e talvez não funcione com este tutorial.

Para configurar as bibliotecas necessárias:

  1. Crie um arquivo chamado appengine_config.py no diretório raiz do projeto. Ao implantar seu aplicativo, use esse arquivo para especificar o local em que o App Engine terá de procurar por bibliotecas de terceiros:

    from google.appengine.ext import vendor
    
    # Add any libraries installed in the "lib" folder.
    vendor.add('lib')
  2. Crie um arquivo chamado requirements.txt no diretório raiz do projeto:

    Flask==0.12.4
    Werkzeug<0.13.0,>=0.12.0
    
  3. Para executar este app no seu computador local, configure um ambiente de desenvolvimento Python, incluindo Python, pip e virtualenv. Para mais instruções, consulte Como configurar um ambiente de desenvolvimento do Python para o Google Cloud Platform.

  4. Instale as dependências usando virtualenv:

    Mac OS/Linux

    1. Crie um ambiente Python isolado em um diretório fora do projeto e ative-o:
      virtualenv env
      source env/bin/activate
      No final do tutorial, saia do virtualenv digitando deactivate.
    2. Navegue até o diretório do projeto e instale as dependências:
      cd YOUR_PROJECT
      pip install -t lib -r requirements.txt

    Windows

    Se você instalou o SDK do Cloud, já deve ter o Python 2.7 instalado, normalmente em C:\python27_x64\ (para sistemas de 64 bits). Use o PowerShell para executar seus pacotes Python.

    1. Localize a instalação do PowerShell.
    2. Clique com o botão direito do mouse no atalho do PowerShell e inicie-o como administrador.
    3. Tente executar o comando python. Se ele não for encontrado, adicione a pasta Python ao PATH do ambiente.
      $env:Path += ";C:\python27_x64\"
    4. Crie um ambiente Python isolado em um diretório fora do projeto e ative-o:
      python -m virtualenv env
      env\Scripts\activate
      No final do tutorial, saia do virtualenv digitando deactivate.
    5. Navegue até o diretório do projeto e instale as dependências:
      cd YOUR_PROJECT
      python -m pip install -t lib -r requirements.txt

    A sinalização -t lib copia as bibliotecas para uma pasta lib, transferida por upload para o App Engine durante a implantação. Para mais informações sobre como copiar bibliotecas de terceiros, veja Como utilizar o arquivo pip requirements.txt com as bibliotecas copiadas.

    A sinalização -r requirements.txt instrui o pip a fazer instalações a partir de um arquivo requirements.txt.

Como criar o arquivo app.yaml

Defina as configurações do aplicativo do App Engine no arquivo app.yaml criado manualmente ou como parte da criação do seu projeto de desenvolvimento. app.yaml é um arquivo de configuração que instrui o App Engine a executar o aplicativo e a associar URLs a arquivos estáticos e módulos Python.

Para criar o arquivo app.yaml:

  1. Crie um arquivo chamado app.yaml no diretório raiz do seu projeto.
  2. Adicione as seguintes linhas ao arquivo:

    runtime: python27
    api_version: 1
    threadsafe: true
    
    libraries:
    - name: ssl
      version: latest
    
    handlers:
    - url: /static
      static_dir: static
    - url: /.*
      script: main.app
    

Para mais informações de referência sobre o arquivo app.yaml, consulte esta página.

Como criar um gerenciador de solicitações para o aplicativo Flask

Quando o App Engine recebe uma solicitação da Web para o aplicativo, ele chama o script do gerenciador que corresponde ao URL, conforme descrito no arquivo de configuração app.yaml do aplicativo. O ambiente de execução do Python 2.7 é compatível com o padrão WSGI. O WSGI é o preferido e alguns recursos do Python 2.7 não funcionam sem ele. A configuração dos gerenciadores de script do aplicativo determina se uma solicitação é gerenciada usando o WSGI.

O servidor determina qual objeto de aplicativo Python chamar, comparando o URL da solicitação com os padrões de URL no arquivo de configuração do aplicativo. Em seguida, o objeto do aplicativo é chamado usando os argumentos, conforme definido no padrão WSGI. O objeto do aplicativo executa ações apropriadas à solicitação. Em seguida, prepara uma resposta e a retorna como uma lista de strings.

Os gerenciadores de solicitações abaixo recebem as informações enviadas no formulário do arquivo /templates/form.html e colocam essas informações no arquivo de modelo /templates/submitted_form.html:

  1. Crie um novo arquivo chamado main.py no diretório raiz do seu aplicativo.

  2. Importe o framework e as interfaces do Flask que você quer usar:

    from flask import Flask, render_template, request
  3. Adicione esta linha para criar uma instância da classe Flask e atribuí-la a uma variável chamada app:

    app = Flask(__name__)
  4. Crie um gerenciador de solicitações que exiba um formulário usando o modelo form.html:

    @app.route('/form')
    def form():
        return render_template('form.html')

    Quando o usuário navega até o diretório /form/ no aplicativo, é exibido o modelo form.html criado por você.

  5. Crie um gerenciador de solicitações que processe as informações do formulário enviado:

    @app.route('/submitted', methods=['POST'])
    def submitted_form():
        name = request.form['name']
        email = request.form['email']
        site = request.form['site_url']
        comments = request.form['comments']
    

    O aplicativo armazena as informações do formulário nas variáveis criadas aqui. Essas variáveis permitirão que você publique os dados do formulário no modelo submitted_form.html a ser criado por você.

Saiba mais sobre os primeiros passos com o Flask no guia de início rápido do Flask.

É possível ampliar facilmente a funcionalidade deste formulário. Por exemplo, é possível usar a API Mail, o Mailgun, o Mailjet ou o SendGrid para enviar comentários dos usuários para você ou outras pessoas.

Como configurar modelos do Jinja2

Como a manutenção do HTML incorporado ao código é difícil, use um sistema de modelos e armazene o HTML em um arquivo separado que use uma sintaxe especial para especificar o local de exibição dos dados retornados de um aplicativo. Use o mecanismo de modelos que preferir e o agrupe-o com o código do aplicativo. Para sua conveniência, o App Engine inclui os mecanismos de modelos Django e Jinja2 (links em inglês).

  1. Adicione a linha abaixo ao final da função submitted_form():

    return render_template(
        'submitted_form.html',
        name=name,
        email=email,
        site=site,
        comments=comments)

    Essa linha usa a interface render_template() para renderizar o modelo submitted_form.html com informações do formulário enviado.

  2. Crie os modelos form.html e submitted_form.html:

    1. Crie uma nova pasta chamada templates no seu diretório raiz:

      mkdir templates
      
    2. Crie form.html no diretório templates do projeto:

      <html>
        <head>
          <title>Submit a form</title>
         <link rel="stylesheet" type="text/css" href="/static/style.css">
        </head>
        <body>
          <div id="container">
            <div class="pagetitle">
              <h1>Submit a form</h1>
            </div>
            <div id="main">
              <form method="post" action="{{ url_for('submitted_form') }}">
                <label for="name">Name:</label>
                <input type="text" name="name"><br />
                <label for="email">Email address:</label>
                <input type="email" name="email"><br />
                <label for="site_url">Website URL:</label>
                <input type="url" name="site_url"><br />
                <label for="comments">Comments:</label>
                <textarea name="comments"></textarea><br />
                <input type="submit">
              </form>
            </div>
          </div>
        </body>
      </html>
      
    3. Crie submitted_form.html no diretório templates do projeto:

      <html>
       <head>
         <title>Submitted form</title>
         <link rel="stylesheet" type="text/css" href="/static/style.css">
       </head>
       <body>
         <div id="container">
           <div class="pagetitle">
             <h1>Form submitted</h1>
           </div>
           <div id="main">
             <p>Thanks for your submission, {{name}}!</p>
             <p>Here's a review of the information that you sent:</p>
             <p>
                <strong>Name</strong>: {{name}} <br>
                <strong>Email</strong>: {{email}} <br>
                <strong>Website URL</strong>: {{site}} <br>
                <strong>Comments</strong>: {{comments}}
             </p>
           </div>
         </div>
       </body>
      </html>
      

Para saber mais sobre o uso de modelos com Flask e Jinja2, consulte a documentação oficial do Flask.

Como disponibilizar arquivos estáticos

A disponibilização de arquivos estáticos é mais eficiente para alguns conteúdos, como imagens, CSS ou animações em Flash, que não são gerados dinamicamente quando uma página é solicitada.

Crie um arquivo CSS e um gerenciador para ele:

  1. Crie uma nova pasta chamada static no seu diretório raiz:

    mkdir static
    
  2. Crie o arquivo style.css que modificará a aparência dos arquivos de modelo que você acabou de criar. Crie o arquivo na pasta static do seu projeto e adicione o seguinte estilo:

    .pagetitle {
        color: #800080;
    }
    
  3. O arquivo app.yaml criado anteriormente especifica os diretórios static que contêm arquivos estáticos:

    handlers:
    - url: /static
      static_dir: static
    - url: /.*
      script: main.app

    A seção handlers define dois gerenciadores para URLs. Quando o App Engine recebe uma solicitação para um URL que começa com /static, ele associa o restante do caminho aos arquivos no diretório static e, caso seja encontrado um arquivo apropriado, retorna o conteúdo do arquivo ao cliente.

Para mais informações sobre o mapeamento de URLs e outras opções que podem ser especificadas em app.yaml, consulte a referência do app.yaml.

Testar o aplicativo

Teste o aplicativo com o servidor de desenvolvimento local dev_appserver.py, incluído no SDK.

  1. No diretório raiz em que está localizado o arquivo de configuração app.yaml do aplicativo, inicie o servidor de desenvolvimento local com o seguinte comando:

    dev_appserver.py app.yaml
    

    O servidor de desenvolvimento local agora está sendo executado e recebendo as solicitações na porta 8080.

    Ocorreu algum erro?

    1. Acesse http://localhost:8080/form no navegador da Web para ver o app.

Executar o servidor de desenvolvimento local (dev_appserver.py)

Para executar o servidor de desenvolvimento local, execute dev_appserver.py especificando o caminho completo do diretório ou adicione dev_appserver.py à variável de ambiente PATH:

  • Se você instalou o SDK original do App Engine, a ferramenta está localizada em:

    [PATH_TO_APP_ENGINE_SDK]/dev_appserver.py
    
  • Se você instalou o SDK do Google Cloud, a ferramenta está localizada em:

    [PATH_TO_CLOUD_SDK]/google-cloud-sdk/bin/dev_appserver.py
    

    Dica: para adicionar as ferramentas do SDK do Google Cloud à variável de ambiente PATH e ativar a conclusão do comando no shell, execute:

    [PATH_TO_CLOUD_SDK]/google-cloud-sdk/install.sh
    

Para mais informações sobre como executar o servidor de desenvolvimento local, incluindo como alterar o número da porta, consulte a referência Servidor de desenvolvimento local.

Fazer uma alteração

É possível deixar o servidor de desenvolvimento em execução enquanto você desenvolve o aplicativo. Esse servidor observa as alterações nos arquivos de origem e as atualiza, se necessário.

  1. Faça o teste agora: deixe o servidor de desenvolvimento em execução e edite templates/form.html alterando o texto Submit a form nas tags <h1> para outra coisa.
  2. Atualize o endereço http://localhost:8080/form para ver os resultados.

Como implantar o aplicativo

Para fazer o upload do aplicativo, execute o comando abaixo no diretório raiz do seu projeto no local em que está o arquivo app.yaml:

gcloud app deploy

Sinalizações opcionais:

  • Inclua a sinalização --project para especificar uma ID do projeto no Console do GCP como alternativa àquela definida como padrão na ferramenta gcloud. Exemplo: --project [YOUR_PROJECT_ID]
  • Inclua a sinalização -v para especificar uma ID da versão. Caso contrário, será gerada uma automaticamente. Exemplo: -v [YOUR_VERSION_ID]

Para saber mais sobre como implantar seu aplicativo a partir da linha de comando, veja Como implantar um aplicativo Python.

Como ver o aplicativo

Abra o navegador e veja seu aplicativo em http://[YOUR_PROJECT_ID].appspot.com/form.

Suporte

Caso encontre problemas durante o desenvolvimento do aplicativo, busque a ajuda do suporte técnico e das comunidades de desenvolvedores.

A seguir

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

Enviar comentários sobre…

Ambiente padrão do App Engine para Python 2