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 guia de 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 comando a seguir:

    gcloud components update
    
  2. Crie um novo projeto:

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

    Verifique se o projeto foi criado:

    gcloud projects describe [YOUR_PROJECT_ID]
    

    Você verá 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:

    gcloud app create --project=[YOUR_PROJECT_ID]
    

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

  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

    A implantação de ambiente flexível gerará custos enquanto estiver ativa. Limpe o projeto quando terminar para evitar custos contínuos.

  5. Instale os pré-requisitos a seguir:

    • 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 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

O App Engine é regional, isso significa que a infraestrutura que executa os aplicativos está localizada em uma região específica e é gerenciada pelo Google para ficar disponível de modo redundante em todas as zonas dessa região.

Atender aos requisitos de latência, disponibilidade ou durabilidade são os principais fatores para selecionar a região de execução dos seus aplicativos. Em geral, você escolhe a região mais próxima dos usuários do aplicativo. No entanto, pense também no local dos outros produtos e serviços do GCP utilizados pelo aplicativo. O uso de serviços em vários locais pode afetar a latência e o preço do seu aplicativo.

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

  • northamerica-northeast1 (Montreal)
  • us-central (Iowa)
  • us-west2 (Los Angeles)
  • us-east1 (Carolina do Sul)
  • us-east4 (Norte da Virgínia)
  • southamerica-east1 (São Paulo)
  • europe-west (Bélgica)
  • europe-west2 (Londres)
  • europe-west3 (Frankfurt)
  • europe-west6 (Zurique)
  • asia-northeast1 (Tóquio)
  • asia-northeast2 (Osaka)
  • 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 framework são Django, Pyramid, Bottle e web.py (links em inglês).

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:
    python3 -m venv 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

Use o PowerShell para executar os 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. Crie um ambiente Python isolado em um diretório fora do projeto e ative-o:
    python -m venv env
    env\Scripts\activate
  4. Navegue até o diretório do projeto e instale as dependências:
    cd YOUR_PROJECT
    pip install -r requirements.txt
  5. Execute o aplicativo:
    python main.py
  6. 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 gcloud

    • Inclua a sinalização --version para especificar um ID exclusivo da versão do seu app. Quando a sinalização não é incluída, o ID é gerado automaticamente. Exemplo: --version [YOUR_VERSION_ID]
    • Inclua a sinalização --project para especificar um ID do projeto do GCP como alternativa ao ID 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 uma lista de todas as sinalizações de comando, acesse a referência de gcloud app deploy (link em inglês).

  2. Inicie o navegador para visualizar o aplicativo em http://YOUR_PROJECT_ID.appspot.com

    gcloud app browse
    em que YOUR_PROJECT_ID representa 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 Gerenciar recursos.

    Acessar a página Gerenciar recursos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

Conheça a plataforma inteira

Agora que você sabe como é desenvolver e implantar aplicativos do App Engine, explore o restante do GCP. Você já tem instalado o SDK do Cloud, que fornece as ferramentas de interação com produtos como o Cloud SQL, o Cloud Storage, o Cloud Firestore e muito mais.

Para ver um passo a passo sobre como criar um aplicativo que usa toda a plataforma, em vez de somente o App Engine, confira nosso guia de início rápido sobre a criação do app Bookshelf.

Saiba mais sobre o ambiente flexível do App Engine

Listamos alguns tópicos para você continuar aprendendo sobre o App Engine.

Revisão do código do Hello World

O 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 contém a instrução 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 (link em inglês) para exibir 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

O requirements.txt e o gerenciador de pacote Python pip são usados para declarar e instalar as dependências do aplicativo (link em inglês). No caso do Hello World, são necessários a biblioteca da Web Flask e o servidor WSGI Gunicorn (link em inglês).

Flask==1.1.1
gunicorn==19.9.0

O requirements.txt define as bibliotecas que serão instaladas localmente e durante a implantação no App Engine.

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

Enviar comentários sobre…

Documentos do ambiente flexível do App Engine para Python