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

ID da região

O REGION_ID é um código abreviado que o Google atribui com base na região que você selecionou ao criar o aplicativo. O código não corresponde a um país ou estado, ainda que alguns IDs de região sejam semelhantes aos códigos de país e estado geralmente usados. A inclusão de REGION_ID.r em URLs do App Engine é opcional para aplicativos atuais. Em breve, será necessária para todos os aplicativos novos.

Para garantir uma transição tranquila, estamos atualizando o App Engine gradativamente para usar IDs de região. Se ainda não tivermos atualizado seu projeto do Google Cloud, você não verá um ID da região para o app. Como o ID é opcional para os apps atuais, não é necessário atualizar os URLs ou fazer outras alterações quando o ID da região está disponível para eles.

Saiba mais sobre IDs de região.

OK

Python |Java |Node.js |Go |Ruby |PHP |.NET

Neste guia de início rápido, você aprenderá a criar um pequeno app 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 configure um projeto do Cloud 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
   

   Substitua [YOUR_PROJECT_ID] por uma string de caracteres que identifique seu projeto de maneira exclusiva. Por exemplo, my-project-24.

   A sinalização --set-as-default define o novo projeto como o padrão usado por gcloud.

   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.

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

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:

   • Faça o download do Git e instale-o.

• 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 relacionadas instaladas em seu 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á em uma determinada região que é gerenciada pelo Google para estar 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 aplicativos. Geralmente, é possível selecionar a região mais próxima dos usuários do aplicativo, mas considere os locais em que o App Engine está disponível, bem como os locais dos outros produtos e serviços do Google Cloud usados pelo app. O uso de serviços em vários locais pode afetar a latência e o preço do aplicativo.

Observação: dois locais, chamados europe-west e us-central nos comandos do App Engine e no Console do Google Cloud, são chamados europe-west1 e us-central1, respectivamente, em todos os outros lugares da documentação do Google.

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

Se você já criou um aplicativo do App Engine, será possível ver a região dele com um dos seguintes procedimentos:

• Execute o comando gcloud app describe.

• Abra o Painel do App Engine no Console do Cloud. A região aparece perto do topo da página.

OK

Neste guia de início rápido, você verá a demonstração de um app 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 app Hello World simples para Python. Assim, é possível ter uma ideia de como implantar um app no Google Cloud.

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 app Hello World no seu computador:

Mac OS/Linux

Observação: estas instruções descrevem como configurar um ambiente virtual no Python 3. Para apps do Python 2, use virtualenv (link em inglês) para configurar um ambiente virtual.

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

   Observação: se estiver usando o Cloud Shell, na barra de ferramentas, clique em Visualização da Web e selecione Visualização na porta 8080 em vez disso.

Windows

Observação: estas instruções descrevem como configurar um ambiente virtual no Python 3. Para apps do Python 2, use virtualenv (link em inglês) para configurar um ambiente virtual.

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 app 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 app Hello World no ambiente flexível do App Engine:

1. Implemente 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 ID exclusivo da versão do seu aplicativo. 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 de projeto alternativo do Cloud para o que você inicializou 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, consulte a referência do gcloud app deploy.

   OK

2. Inicie o navegador para visualizar o aplicativo em https://PROJECT_ID.REGION_ID.r.appspot.com

   gcloud app browse

   em que PROJECT_ID representa o ID do projeto do Google Cloud.

Nesse momento, a página que exibe a mensagem "Hello World" é enviada por um servidor da Web executado em uma instância do App Engine.

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

Se você encontrar erros na implantação do app, verifique as dicas de solução de problemas.

Veja as seções a seguir para informações sobre limpeza e links das próximas etapas.

Limpar

Exclua o projeto do Google Cloud para não ser cobrado pelos recursos usados nele.

Cuidado: excluir um projeto tem os seguintes efeitos:
• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.
1. No Console do Cloud, acesse a página Gerenciar recursos:

   Acessar "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 Google Cloud. Você já tem o SDK do Cloud instalado, que oferece as ferramentas para interagir com produtos como Cloud SQL, Cloud Storage, 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.

• Uma visão geral do App Engine
• Como as solicitações são roteadas
• Como as solicitações são tratadas
• Como as instâncias são gerenciadas

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 app Hello World é um app básico Flask de um arquivo.

appengine/flexible/hello_world/main.py

Ver no GitHub

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 app:

appengine/flexible/hello_world/app.yaml

Ver no GitHub

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

Neste caso, app.yaml especifica o ambiente de execução usado pelo app e configura o env: flex, que determina o uso do ambiente flexível.

O entrypoint informa ao App Engine como iniciar o app. Este app usa gunicorn para disponibilizar o app Python como uma alternativa ao servidor de desenvolvimento do Flask (usado na execução local). A variável $PORT é definida pelo App Engine quando inicia o app. Para mais informações sobre entrypoint, consulte Inicialização do app.

Observação: essa é a maneira mais simples de executar o gunicorn. Porém, esta abordagem executa o app com um único worker de bloqueio, o que significa que todas as solicitações HTTP são processadas em série, incluindo verificações de integridade. Na prática, o resultado é o app deixar de responder em caso de solicitações lentas. Para mais detalhes sobre como configurar o gunicorn para produção, consulte Configurações recomendadas do gunicorn

Além disso, na seção opcional runtime_config, a python_version é definida como Python 3. Se python_version não for especificado, o Python 2 será usado por padrão. Também é possível especificar python_version: 2 explicitamente.

• Para mais informações sobre como o ambiente de execução do Python funciona, consulte Ambiente de execução do Python.

• Para aprender a projetar seu app para aproveitar mais as versões e os serviços, consulte Visão geral do App Engine.

• Para mais detalhes sobre as configurações do App Engine, consulte Como configurar um app com o arquivo app.yaml.

requirements.txt

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

appengine/flexible/hello_world/requirements.txt

Ver no GitHub

Flask==1.1.2
gunicorn==20.0.4

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