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 este início rápido, instale o SDK do Cloud e, em seguida, configure um projeto do GCP para o App Engine:

  1. Faça o download e instale o SDK do Cloud:

    Fazer o download do SDK

    Observação: se o SDK do Cloud já estiver instalado, atualize-o executando o seguinte comando:

    gcloud components update
    
  2. Crie o novo projeto:

    gcloud projects create [YOUR_PROJECT_NAME] --set-as-default
    

    Verifique se o projeto foi criado:

    gcloud projects describe [YOUR_PROJECT_NAME]
    

    Você vê detalhes do projeto parecidos com o seguinte:

    createTime: year-month-hour
    lifecycleState: ACTIVE
    name: project-name
    parent:
    id: '433637338589'
    type: organization
    projectId: project-name-id
    projectNumber: 499227785679
    
  3. Inicialize seu aplicativo do App Engine com o projeto e escolha a região dele:

    gcloud app create --project=[YOUR_PROJECT_NAME]
    

    Quando solicitado, selecione a região em que o aplicativo do App Engine será armazenado.

  4. Verifique se o faturamento está ativado no projeto. Uma conta de faturamento precisa estar vinculada ao projeto para que o aplicativo seja implantado no App Engine.

    Ativar faturamento

  5. Instale os seguintes pré-requisitos:

    • Execute o seguinte comando para instalar o componente do gcloud que inclui a extensão do App Engine para Python:

      gcloud components install app-engine-python
      
  6. Prepare o ambiente para o desenvolvimento do Python. É recomendável ter a versão mais recente do Python, pip, virtualenv e outras ferramentas instaladas no sistema. Para mais instruções, consulte o Guia de configuração do ambiente de desenvolvimento do Python.

Locais do App Engine

Como App Engine é regional, a infraestrutura de execução dos aplicativos está em uma determinada região e é gerenciada pelo Google para que esteja disponível de modo redundante em todas as zonas dessa região.

Os seus requisitos de latência, disponibilidade ou durabilidade são os principais fatores considerados para 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)
  • europe-west6 (Zurique)
  • asia-northeast1 (Tóquio)
  • asia-east2 (Hong Kong)
  • asia-south1 (Mumbai)
  • australia-southeast1 (Sydney)

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

Se já tiver criado um aplicativo do App Engine, execute o comando gcloud app describe ou abra o painel do App Engine no Console do GCP para visualizar a região. A região do aplicativo do App Engine está listada em http://[YOUR_PROJECT_ID].appspot.com.

Neste guia de início rápido, você verá a demonstração de um aplicativo simples em Python, gravado com o framework da Web Flask que pode ser implantado no App Engine. O Flask é usado nesta amostra, mas é possível usar qualquer framework da Web que atenda aos requisitos mencionados acima. Outros exemplos de frameworks são Django, Pyramid, Bottle e web.py.

Fazer o download do app Hello World

Criamos um aplicativo Hello World para Python simples. Com ele, você tem uma ideia geral de como ocorre a implantação de um aplicativo no Google Cloud Platform.

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

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

    Outra opção é fazer o download da amostra (em inglês) 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
    

Como executar o 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 fora do 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 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
  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

A mensagem Hello World do aplicativo de amostra é exibida na página. Na janela do 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, siga estas etapas:

  1. Implante o aplicativo Hello World executando o comando a seguir no diretório hello_world:

    gcloud app deploy

    Saiba mais sobre 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. Para ver uma lista de todas as sinalizações de comando, consulte a referência gcloud app deploy.

  2. Abra o navegador para ver o aplicativo em http://YOUR_PROJECT_ID.appspot.com.

    gcloud app browse
    em que YOUR_PROJECT_ID é o ID do projeto do GCP.

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 aplicativo em Python no ambiente flexível do App Engine.

Nas seções a seguir, veja as informações sobre limpeza e os links para as próximas etapas que você pode realizar.

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

Agora que você já implantou o Hello World, comece a explorar o próximo app de amostra: o Bookshelf. O app Bookshelf é um pouco mais complexo, mas ainda é um app da Web básico do Python no qual são usados vários recursos do Cloud Platform, por exemplo, armazenamento de dados, autenticação, geração de registros, Pub/Sub etc.

Iniciar o tutorial do app Bookshelf

Para mais informações sobre o ambiente flexível do App Engine, consulte Visão geral do App Engine.

Revisão do código do Hello World

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

main.py

O aplicativo Hello World é um aplicativo básico Flask de um arquivo.

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

O arquivo app.yaml descreve a configuração de implantação do aplicativo:

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 no arquivo app.yaml, que define env: flex determinando o uso do ambiente flexível no aplicativo.

O entrypoint informa ao App Engine como iniciar o app. Ele usa o gunicorn 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 do 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

requirements.txt e o gerenciador de pacotes em Python pip são usados para declarar e instalar as dependências do aplicativo. No caso do Hello World, são necessários o framework da Web Flask e o servidor WSGI Gunicorn.

Flask==1.0.2
gunicorn==19.9.0

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…