Guia de início rápido para Python no ambiente flexível do App Engine

Neste guia de início rápido, você aprenderá a criar um pequeno aplicativo do App Engine que exibe uma mensagem curta.

Antes de começar

Antes de executar e implantar a amostra, siga estas etapas:

  1. Use o Console do GCP para criar um novo projeto do GCP e um aplicativo do App Engine. Depois, ative o faturamento:
    Acessar o App Engine

    Quando solicitado, selecione uma região para o aplicativo do App Engine e ative o faturamento.

  2. Instale os seguintes pré-requisitos localmente:
    1. Faça o download do git e instale-o.
    2. Prepare o ambiente para o desenvolvimento do Python.
    3. Faça o download e instale o Cloud SDK. Siga as instruções na página do Cloud SDK para inicializar e definir o código do seu projeto do GCP na ferramenta de linha de comando gcloud:
      Faça o download do SDK
  3. Se preferir, use o Google Cloud Shell. Ele vem com o Git e o Cloud SDK instalados, além de muitos outros recursos, como compatibilidade com linguagens e editores de código.

    Depois que o Google Cloud Shell for iniciado, prossiga com este tutorial e execute os comandos no Cloud Shell.

Locais do App Engine

O App Engine é regional. Isso significa que a infraestrutura que executa os aplicativos localiza-se em determinada região e é gerenciada pelo Google para estar disponível de forma redundante em todas as zonas dessa região.

Os requisitos de latência, disponibilidade ou durabilidade são os principais fatores considerados ao selecionar a região em que os aplicativos serão executados. Em geral, você escolhe a região mais próxima dos usuários do app. No entanto, pense também no local dos outros produtos e serviços do GCP utilizados pelo app. Se você usa os serviços em vários locais, a latência e o preço do app podem ser afetados.

O App Engine está disponível nas seguintes regiões:

  • northamerica-northeast1 (Montreal)
  • us-central (Iowa)
  • us-west2 (Los Angeles)
  • us-east1 (Carolina do Sul)
  • us-east4 (Virgínia do Norte)
  • southamerica-east1 (São Paulo)*
  • europe-west (Bélgica)
  • europe-west2 (Londres)
  • europe-west3 (Frankfurt)
  • asia-northeast1 (Tóquio)
  • asia-south1 (Mumbai)
  • australia-southeast1 (Sydney)

*Para clientes que usam a região de São Paulo, todos os SLAs de produtos regionais permanecerão em vigor. No entanto, funcionalidades de várias regiões e entre regiões que abrangem América do Norte e América do Sul podem sofrer uma redução temporária de disponibilidade ou desempenho.

Não é possível alterar a região de um app depois de defini-la.

Você poderá visualizar a região caso já tenha criado um aplicativo do App Engine. Basta executar o comando gcloud app describe ou abrir o painel do App Engine no Console do GCP. A região do aplicativo do App Engine está listada em http://[YOUR_PROJECT_ID].appspot.com.

Neste guia de início rápido, demonstramos um aplicativo simples do Python escrito com a biblioteca Flask da Web que pode ser implantada no App Engine. Embora aqui seja usada a biblioteca Flask, é possível usar qualquer biblioteca da Web que atenda às necessidades mencionadas acima. Outros exemplos de bibliotecas são Django, Pyramid, Bottle e web.py.

Download do aplicativo Hello World

Criamos um app Hello World simples para Python. Com ele, é possível ter uma noção rápida de como implantar um app no ambiente flexível do App Engine. Siga estas etapas em uma linha de comando para fazer o download de Hello World na sua máquina local.

Faça o download do app de amostra e acesse o diretório dele:

  1. Clone o repositório do app de amostra Hello World na máquina local:

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples
    

    Uma alternativa é fazer o download da amostra como um arquivo zip e extraí-lo.

  2. Acesse o diretório que contém o código de amostra:

    cd python-docs-samples/appengine/flexible/hello_world
    

Executar o aplicativo Hello World na máquina local

Para executar o aplicativo Hello World no seu computador:

Mac OS/Linux

  1. Crie um ambiente Python isolado em um diretório externo ao projeto e ative-o:
    virtualenv env
    source env/bin/activate
  2. Navegue até o diretório do projeto e instale as dependências:
    cd YOUR_PROJECT
    pip install  -r requirements.txt
  3. Execute o aplicativo:
    python main.py
  4. No navegador da Web, digite este endereço:
    http://localhost:8080

Windows

Se você instalou o Cloud SDK, 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 externo ao projeto e ative-o:
    python -m virtualenv env
    env\Scripts\activate
  5. Navegue até o diretório do projeto e instale as dependências:
    cd YOUR_PROJECT
    python -m pip install -r requirements.txt
  6. Execute o aplicativo:
    python main.py
  7. No navegador da Web, digite este endereço:
    http://localhost:8080

Você verá a mensagem Hello World do aplicativo de amostra na página.

Na janela de terminal, pressione Ctrl+C para sair do servidor da Web.

Implantar e executar o Hello World no App Engine

Para implantar o aplicativo Hello World no ambiente flexível do App Engine:

  1. Execute o seguinte comando no diretório hello_world:
    gcloud app deploy
    Saiba mais sobre as sinalizações opcionais.

    Sinalizações comuns do comando gcloud

    • Inclua a sinalização --version para especificar um código exclusivo da versão do seu app. Quando a sinalização não é incluída, o código é gerado automaticamente. Exemplo: --version [YOUR_VERSION_ID]
    • Inclua a sinalização --project para especificar um código do projeto do GCP como alternativa ao código definido como padrão na ferramenta gcloud. Exemplo: --project [YOUR_PROJECT_ID]

    Exemplo:

    gcloud app deploy --version pre-prod-5 --project my-sample-app

    Para aprender a implantar o app pela linha de comando, consulte Como testar e implantar o app. Consulte a referência gcloud app deploy para uma lista de todas as sinalizações de comando.

  2. Inicie o navegador e execute o comando abaixo para visualizar o aplicativo em http://YOUR_PROJECT_ID.appspot.com:
    gcloud app browse
Nesse momento, a página que exibe a mensagem “Hello World” é enviada por um servidor da Web em execução em uma instância do App Engine.

Parabéns! Você implantou seu primeiro app do Python no ambiente flexível do App Engine.

Consulte as seções a seguir para informações sobre limpeza e links para as próximas etapas que você pode executar.

Limpeza

Exclua seu projeto do GCP para não ser cobrado pelos recursos usados nele.

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Próximas etapas

Conheça a plataforma inteira

Agora que você já sabe como é desenvolver e implantar aplicativos no App Engine, você pode expandir seus horizontes e conhecer o restante do Google Cloud Platform. Você já instalou o Google Cloud SDK, que fornece as ferramentas necessárias para interagir com outros produtos, como o Google Cloud SQL, o Google Cloud Storage, o Google Cloud Datastore e muito mais.

Para ver instruções passo a passo sobre como criar um aplicativo que use toda a plataforma, não apenas o App Engine, confira nosso guia de início rápido sobre a criação de um app Bookshelf.

Saiba mais sobre o ambiente flexível do App Engine

Aqui vão alguns tópicos para você continuar aprendendo sobre o App Engine.

Revisão do código do app Hello World

Hello World é o app mais simples possível do App Engine. Nele, há apenas um serviço, uma versão e todo o código é armazenado no diretório raiz. Nesta seção, são descritos em detalhes cada arquivo do app.

main.py

O Hello World é um app de um arquivo único básico da biblioteca Flask.

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)

app.yaml

A configuração de implantação de um aplicativo é descrita no arquivo app.yaml:

runtime: python
env: flex
entrypoint: gunicorn -b :$PORT main:app

runtime_config:
  python_version: 3

# This sample incurs costs to run on the App Engine flexible environment.
# The settings below are to reduce costs during testing and are not appropriate
# for production use. For more information, see:
# https://cloud.google.com/appengine/docs/flexible/python/configuring-your-app-with-app-yaml
manual_scaling:
  instances: 1
resources:
  cpu: 1
  memory_gb: 0.5
  disk_size_gb: 10

O ambiente de execução usado pelo aplicativo é especificado em app.yaml. Ele também contém a instrução env: flex, que determina o uso do ambiente flexível no aplicativo.

O entrypoint informa ao App Engine como iniciar o app. O gunicorn é usado por esse aplicativo para disponibilizar o aplicativo em Python. A variável $PORT é definida pelo App Engine quando o app é iniciado. Para mais informações sobre entrypoint, consulte Inicialização de aplicativo.

Além disso, a seção opcional runtime_config define python_version para usar o Python 3. Se o valor de python_version não for especificada, o Python 2 será usado por padrão. Também é possível especificar python_version: 2 explicitamente.

requirements.txt

O requirements.txt e o gerenciador de pacote Python pip são usados para declarar e instalar as dependências do aplicativo. Para o Hello World, são necessários o Flask, uma biblioteca da Web, e o Gunicorn, um servidor WSGI.

Flask==0.12.2
gunicorn==19.7.1

As bibliotecas que serão instaladas tanto localmente quanto durante a implantação no App Engine são definidas no arquivo requirements.txt.

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

Enviar comentários sobre…

Documentos do ambiente flexível do App Engine para Python