GSP023

Informações gerais

Neste laboratório, você vai aprender a implantar um aplicativo da Web Python Flask no ambiente flexível do App Engine. Com o aplicativo de exemplo, o usuário pode fazer upload da foto do rosto de alguém e descobrir se a pessoa está feliz. O aplicativo usa as APIs do Google Cloud para o Vision, o Storage e o Datastore.

Sobre o App Engine

Os aplicativos do Google App Engine são fáceis de criar, manter e escalonar de acordo com as alterações necessárias no tráfego e no armazenamento de dados. Com o App Engine, você não precisa se preocupar com a manutenção dos servidores. Basta fazer upload do seu aplicativo.

Os aplicativos do App Engine têm escalonamento automático com base em tráfego de entrada, balanceamento de carga, microsserviços, autorização, bancos de dados SQL e NoSQL, divisão de tráfego, geração de registros, pesquisa, controle de versões, implantações, reversões e verificações de segurança. Tudo isso tem compatibilidade nativa e é altamente personalizável.

O ambiente flexível do App Engine oferece suporte a várias linguagens de programação, como Java, Python, PHP, Node.js, Ruby e Go. O ambiente padrão do App Engine é mais uma opção para determinadas linguagens, incluindo Python. Com esses dois ambientes, os usuários contam com a maior flexibilidade possível quanto ao comportamento dos aplicativos, já que cada ambiente tem pontos fortes específicos. Confira mais informações em Como escolher um ambiente do App Engine.

O que você vai aprender

• Como implantar um aplicativo da Web simples no ambiente flexível do App Engine
• Como acessar bibliotecas de cliente do Google Cloud para o Vision, o Storage e o Datastore
• Como usar o Cloud Shell

Pré-requisitos

• Familiaridade com Python
• Conhecer os editores de texto padrão do Linux, como vim, emacs ou nano.
• Ter uma fotografia com um rosto

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1. Acessar o exemplo de código

1. No Cloud Shell, execute o comando a seguir para clonar o repositório do GitHub:

gcloud storage cp -r gs://spls/gsp023/flex_and_vision/.

2. Altere o diretório para flex_and_vision:

cd flex_and_vision

Tarefa 2. Autenticar as solicitações de API

As APIs Datastore, Storage e Vision são ativadas para você automaticamente neste laboratório. Para fazer solicitações às APIs, você precisará ter credenciais da conta de serviço. É possível gerar credenciais no seu projeto usando o gcloud no Cloud Shell. O ID do projeto pode ser encontrado na guia em que você começou o laboratório.

1. Configure uma variável de ambiente para o ID do projeto:

export PROJECT_ID=$(gcloud config get-value project)

2. Crie uma conta de serviço para acessar as APIs do Google Cloud quando testar localmente:

gcloud iam service-accounts create qwiklab \ --display-name "My Qwiklab Service Account"

3. Dê as permissões adequadas à nova conta de serviço:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \ --member serviceAccount:qwiklab@${PROJECT_ID}.iam.gserviceaccount.com \ --role roles/owner

4. Após criar a conta de serviço, crie uma chave de conta de serviço:

gcloud iam service-accounts keys create ~/key.json \ --iam-account qwiklab@${PROJECT_ID}.iam.gserviceaccount.com

Esse comando gera uma chave de conta de serviço armazenada em um arquivo JSON chamado key.json no seu diretório principal.

5. Usando o caminho absoluto da chave gerada, defina uma variável de ambiente para a chave de conta de serviço:

export GOOGLE_APPLICATION_CREDENTIALS="/home/${USER}/key.json"

Saiba mais sobre como autenticar a API Vision em Quickstart: Setup the Vision API Guide.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Autentique as solicitações de API

Tarefa 3. Como testar o aplicativo localmente

Como iniciar seu ambiente virtual e instalar dependências

1. Crie um ambiente Python 3 isolado denominado env com o virtualenv:

virtualenv -p python3 env

2. Entre no novo virtualenv, chamado env:

source env/bin/activate

3. Use pip para instalar as dependências do seu projeto pelo arquivo requirements.txt:

pip install -r requirements.txt

O arquivo requirements.txt é uma lista de dependências de pacote necessárias para o projeto. O comando acima fez o download de todas essas dependências listadas para o virtualenv.

Como criar um app do App Engine

1. Primeiro, crie uma variável de ambiente com a região atribuída a você:

AE_REGION={{{project_0.startup_script.app_region|REGION}}}

2. Em seguida, crie uma instância do App Engine usando:

gcloud app create --region=$AE_REGION

Como criar um bucket de armazenamento

1. Primeiro, defina a variável de ambiente CLOUD_STORAGE_BUCKET com o mesmo nome do seu PROJECT_ID. Para facilitar, recomendamos dar ao bucket o mesmo nome do PROJECT_ID:

export CLOUD_STORAGE_BUCKET=${PROJECT_ID}

2. Agora, execute o comando a seguir para criar um bucket com o mesmo nome do PROJECT_ID:

gsutil mb gs://${PROJECT_ID}

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Crie um app do App Engine e um bucket de armazenamento

Como executar o aplicativo

1. Execute o seguinte comando para iniciar o aplicativo:

python main.py

2. Quando o aplicativo for iniciado, clique no ícone de Visualização da Web na barra de ferramentas do Cloud Shell e selecione Visualizar na porta 8080.

Uma guia será aberta no navegador, conectando você ao servidor que acabou de iniciar. Aparecerá algo parecido com:

Agora vai ficar interessante!

3. Clique no botão Escolher arquivo, encontre no seu computador uma imagem com o rosto de alguém e clique em Enviar.

Quando o upload da foto for concluído, aparecerá algo assim:

Observação: quando tiver terminado de testar seu aplicativo localmente, pressione CTRL+C no Cloud Shell para desligar o servidor da Web local.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Execute o aplicativo

Tarefa 4. Como explorar o código

Layout do exemplo de código

O exemplo tem o seguinte layout:

templates/ homepage.html /* HTML template that uses Jinja2 */ app.yaml /* App Engine application configuration file */ main.py /* Python Flask web application */ requirements.txt /* List of dependencies for the project */

main.py

Esse arquivo Python é um aplicativo Flask da Web. Com o aplicativo, os usuários podem enviar fotos (preferencialmente de rostos), que são armazenadas no Cloud Storage e analisadas com o recurso de detecção facial da API Cloud Vision. Informações importantes sobre cada uma das fotos são armazenadas no Datastore, o banco de dados NoSQL do Google Cloud. Essas informações são acessadas nesse local toda vez que um usuário acessa o site.

Esse aplicativo usa as bibliotecas de cliente do Google Cloud para o Storage, o Datastore e o Vision. Essas bibliotecas de cliente tornam fácil o acesso às APIs do Cloud com o uso das suas linguagens preferidas de programação.

Agora analisaremos alguns snippets importantes do código.

A seção de importações, na parte de cima, é onde importamos os diversos pacotes de que precisamos para nosso código. É assim que importamos as bibliotecas de cliente do Google Cloud para o Datastore, o Storage e o Vision:

from google.cloud import datastore from google.cloud import storage from google.cloud import vision

Código que direciona o que acontece quando um usuário visita o URL raiz do site

Este é o código para o que acontece quando um usuário acessa o URL raiz do site. Um objeto do cliente do Datastore é criado e é usado para acessar a biblioteca de cliente do Datastore. É executada uma consulta no Datastore por entidades do tipo Faces. Por fim, o modelo HTML é renderizado, transmitindo image_entities que extraímos do Datastore como uma variável.

@app.route('/') def homepage(): # Create a Cloud Datastore client. datastore_client = datastore.Client() # Use the Cloud Datastore client to fetch information from Datastore about # each photo. query = datastore_client.query(kind='Faces') image_entities = list(query.fetch()) # Return a Jinja2 HTML template and pass in image_entities as a parameter. return render_template('homepage.html', image_entities=image_entities)

Agora veremos como as entidades são salvas no Datastore. O Datastore é solução de banco de dados NoSQL do Google Cloud. Os dados são armazenados em objetos denominados entidades. A cada entidade é atribuída uma chave de identificação exclusiva, que pode ser criada usando um tipo e uma string de nome da chave. Um tipo é um bucket organizacional para determinar o tipo da entidade. Por exemplo, podemos configurar tipos para Fotos, Pessoas e Animais.

Cada entidade pode ter diversas propriedades definidas pelo desenvolvedor. Elas podem ter valores de diversos tipos, incluindo: números inteiros, flutuantes, strings, datas ou dados binários:

# Create a Cloud Datastore client. datastore_client = datastore.Client() # Fetch the current date / time. current_datetime = datetime.now() # The kind for the new entity. kind = 'Faces' # The name/ID for the new entity. name = blob.name # Create the Cloud Datastore key for the new entity. key = datastore_client.key(kind, name) # Construct the new entity using the key. Set dictionary values for entity # keys blob_name, storage_public_url, timestamp, and joy. entity = datastore.Entity(key) entity['blob_name'] = blob.name entity['image_public_url'] = blob.public_url entity['timestamp'] = current_datetime entity['joy'] = face_joy # Save the new entity to Datastore. datastore_client.put(entity)

Assim como o Datastore, as bibliotecas de cliente do Vision e do Storage podem ser acessadas de modo programático. Você pode abrir o arquivo main.py usando o vim, o emacs ou o nano para explorar todo o código de exemplo.

homepage.html

O framework da Web para o Flask aproveita o Jinja2 como mecanismo do modelo. Isso nos permite transmitir variáveis e expressões de main.py em homepage.html que são substituídas por valores quando a página é renderizada.

Saiba mais sobre Jinja2 em Documentação de designer de modelos.

Esse modelo Jinja2 HTML exibe um formulário para os usuários enviarem fotos ao banco de dados. O modelo também exibe cada uma das imagens enviadas anteriormente com o nome do arquivo e a data e a hora do upload. Além disso, ele mostra a probabilidade de a pessoa que teve o rosto detectado pela API Vision estar feliz.

<h1>Google Cloud Platform - Face Detection Sample</h1> <p>This Python Flask application demonstrates App Engine Flexible, Google Cloud Storage, Datastore, and the Cloud Vision API.</p> <br> <html> <body> <form action="upload_photo" method="POST" enctype="multipart/form-data"> Upload File: <input type="file" name="file"><br> <input type="submit" name="submit" value="Submit"> </form> {% for image_entity in image_entities %} <img src="{{image_entity['image_public_url']}}" width=200 height=200> <p>{{image_entity['blob_name']}} was uploaded {{image_entity['timestamp']}}.</p> <p>Joy Likelihood for Face: {{image_entity['joy']}}</p> {% endfor %} </body> </html>

Tarefa 5: Como implantar o app no ambiente flexível do App Engine

O ambiente flexível do App Engine usa um arquivo denominado app.yaml para descrever a configuração de implantação do aplicativo. Se o arquivo estiver faltando, o App Engine tentará deduzir essa configuração. No entanto, convém incluir esse arquivo.

1. A seguir, você fará alterações no app.yaml usando um editor de sua preferência vim, nano ou emacs. Vamos usar o editor nano:

nano app.yaml

2. Com o app.yaml aberto, substitua <your-cloud-storage-bucket> pelo nome do bucket do Cloud Storage. Se você esqueceu o nome do seu bucket do Cloud Storage, copie o ID do projeto do painel de detalhes do laboratório.

A seção env_variables define variáveis de ambiente que serão usadas no main.py quando o aplicativo estiver implantado.

3. Depois, configure o app para usar escalonamento manual adicionando isto no final do arquivo:

manual_scaling: instances: 1

4. Por fim, altere python_version de 3 para 3.7 para implantar o App Engine.

Seu arquivo deve ser semelhante a este:

runtime: python env: flex entrypoint: gunicorn -b :$PORT main:app runtime_config: python_version: 3.7 env_variables: CLOUD_STORAGE_BUCKET: <your-cloud-storage-bucket> manual_scaling: instances: 1

Esta é a configuração básica necessária para implantar um aplicativo do ambiente flexível do App Engine para Python 3. Saiba mais sobre como configurar o App Engine em Como configurar um app com o guia app.yaml.

5. Salve e feche o arquivo em nano:

• Pressione CTRL+X.
• No prompt, digite Y e pressione ENTER.

6. Atualize o tempo limite do Cloud Build:

gcloud config set app/cloud_build_timeout 1000

7. Implante o app no App Engine usando o gcloud:

gcloud app deploy

Quando aparecer Do you want to continue (Y/n), digite Y e pressione ENTER.

Confira no Cloud Shell o processo de criação do aplicativo. Isso pode levar até 10 minutos. O ambiente flexível do App Engine está provisionando automaticamente uma máquina virtual do Compute Engine para você em segundo plano e, depois, vai instalar o aplicativo e iniciá-lo.

8. Depois que o aplicativo for implantado, abra-o no navegador da Web com o seguinte URL:

https://<PROJECT_ID>.appspot.com Observação: se você esquecer o PROJECT_ID, execute gcloud config list project no Cloud Shell.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Implante o app

Parabéns!

Parabéns! Neste laboratório, você aprendeu a criar e implantar um aplicativo da Web em Python no ambiente flexível do App Engine.

Próximas etapas/Saiba mais

• Python no Google Cloud
• Documentação do ambiente flexível do App Engine para Python
• Documentação para bibliotecas de cliente do Python: Datastore, Storage e Vision
• Saiba mais sobre as bibliotecas de clientes
• Mais exemplos de código de Python
• Saiba mais sobre o Flask.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 13 de outubro de 2023

Laboratório testado em 13 de outubro de 2023

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.