Implantar um exemplo de aplicativo de fluxos de trabalho transacionais em uma arquitetura de microsserviços no Google Cloud

---

Neste documento, descrevemos como implantar um aplicativo de exemplo usando Cloud Run, Pub/Sub, Fluxos de trabalho e Firestore no modo Datastore (Datastore). Ele é destinado a desenvolvedores de aplicativos que querem implementar fluxos de trabalho transacionais em um aplicativo baseado em microsserviços.

Este documento faz parte de uma série composta pelo seguinte:

• Fluxos de trabalho transacionais em uma arquitetura de microsserviços no Google Cloud: uma visão geral da arquitetura do aplicativo de fluxos de trabalho transacionais de exemplo que você implanta neste tutorial.
• Como implantar um exemplo de aplicativo de fluxos de trabalho transacionais em uma arquitetura de microsserviços no Google Cloud (este documento).

Neste aplicativo de exemplo implantado neste tutorial, os microsserviços são implementados para dois padrões de arquitetura:

• Uma saga baseada em coreografias
• Uma orquestração síncrona

O aplicativo contém um cliente da Web. É possível testar ambos os padrões na Google Cloud CLI e no cliente da Web.

Objetivos

• Implantar componentes do lado do servidor para a arquitetura de saga baseada em coreografia
• Implantar componentes do lado do servidor para a arquitetura de orquestração síncrona
• Testar os componentes do lado do servidor com o comando curl
• Implantar um aplicativo da Web e executar fluxos de trabalho por ele

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• Cloud Run
• Datastore
• Pub/Sub
• Fluxos de trabalho
• Cloud Scheduler
• Cloud Build
• Firebase

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

1. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

2. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

3. Ative as APIs Cloud Services, Cloud Run, Workflows, Cloud Build, and Cloud Scheduler.

   Ative as APIs

Clonar o código-fonte

Nesta seção, você vai definir o ID do projeto e clonar o código-fonte no Cloud Shell.

1. No Cloud Shell, defina o ID do projeto:

   PROJECT_ID=PROJECT_ID
   

   Substitua PROJECT_ID pelo ID do projeto do Cloud que você criou anteriormente.

2. Defina o ID do projeto:

   gcloud config set project $PROJECT_ID
   

3. Clonar o repositório do tutorial:

   cd $HOME
   git clone https://github.com/GoogleCloudPlatform/transactional-microservice-examples
   

Implantar componentes do lado do servidor para arquiteturas de saga baseadas em coreografia

Nesta seção, você vai implantar componentes do lado do servidor do aplicativo de exemplo. O aplicativo implementa arquiteturas de saga baseadas em coreografia, como microsserviços no Cloud Run, programações de publicação de eventos no Cloud Scheduler e tópicos do Pub/Sub.

Criar e implantar imagens de contêiner

1. No Cloud Shell, crie uma imagem de contêiner para o serviço Order chamada order-async e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-async
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-async
   gcloud run deploy order-service-async \
     --image gcr.io/$PROJECT_ID/order-service-async \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

2. Crie uma imagem de contêiner para o serviço Customer chamada customer-async e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/customer-async
   gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-async
   gcloud run deploy customer-service-async \
     --image gcr.io/$PROJECT_ID/customer-service-async \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

3. Crie uma imagem de contêiner para o serviço event-publisher e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/event-publisher
   gcloud builds submit --tag gcr.io/$PROJECT_ID/event-publisher
   gcloud run deploy event-publisher \
     --image gcr.io/$PROJECT_ID/event-publisher \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated \
     --set-env-vars "PROJECT_ID=$PROJECT_ID"
   

Criar um índice para o Datastore

Nesta seção, você criará um índice para o Datastore. Esse índice é usado pelo serviço event-publisher para selecionar os eventos que precisam ser publicados.

1. No console do Datastore no console do Google Cloud, selecione Modo do Datastore.

2. Clique em Escolha onde armazenar seus dados e selecione us-east1 como o local. Em seguida, clique em Criar banco de dados.

3. Crie um índice para o Datastore:

   cd $HOME/transactional-microservice-examples/services/event-publisher
   gcloud datastore indexes create index.yaml --quiet
   

4. No console do Google Cloud, no menu Datastore, selecione Índices e aguarde até que o status do índice mude Indexação para Exibição. Esse processo pode levar alguns minutos.

Criar uma conta de serviço para invocar microsserviços no Cloud Run

• No Cloud Shell, crie a conta de serviço cloud-run-invoker :

  SERVICE_ACCOUNT_NAME="cloud-run-invoker"
  SERVICE_ACCOUNT_EMAIL=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
  gcloud iam service-accounts create $SERVICE_ACCOUNT_NAME \
    --display-name "Cloud Run Invoker"
  

  Você vai usar essa conta de serviço posteriormente neste tutorial para invocar as APIs REST para os microsserviços executados no Cloud Run.

Definir uma programação para chamar o serviço de editor de eventos

Nesta seção, você definirá uma programação para invocar o editor de eventos chamado event-publisher em intervalos de um minuto.

1. No Cloud Shell, atribua o papel run.invoker ao serviço event publisher.

   SERVICE_NAME="event-publisher"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

2. Defina uma programação para chamar o serviço Event publisher chamado event-publisher em intervalos de um minuto usando a conta de serviço cloud-run-invoker:

   SERVICE_NAME="event-publisher"
   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)"
     --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/event/publish"
   gcloud scheduler jobs create http event-publisher-scheduler \
     --schedule='* * * * *' \
     --http-method=GET \
     --uri=$SERVICE_URL \
     --oidc-service-account-email=$SERVICE_ACCOUNT_EMAIL \
     --oidc-token-audience=$SERVICE_URL \
     --location=us-central1
   

Criar tópicos Pub/Sub

• No Cloud Shell, crie os seguintes tópicos do Pub/Sub:

  gcloud pubsub topics create order-service-event
  gcloud pubsub topics create customer-service-event
  

O tópico order-service-event é usado pelo serviço Order e pelo serviço event-publisher para publicar eventos do serviço Order. O tópico customer-service-event é usado para publicar eventos do serviço Customer.

Definir um tópico para enviar notificações de eventos para microsserviços

Nesta seção, você definirá o tópico push-subscription para entregar mensagens em tópicos do Pub/Sub para microsserviços.

1. No Cloud Shell, atribua o papel iam.serviceAccountTokenCreator à conta de serviço do Pub/Sub do projeto:

   PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format "value(projectNumber)")
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member=serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-pubsub.iam.gserviceaccount.com \
     --role=roles/iam.serviceAccountTokenCreator
   

   Esse comando permite que a conta de serviço crie um token de acesso para invocar microsserviços no Cloud Run.

2. Atribua o papel run.invoker ao serviço customer-service-async:

   SERVICE_NAME="customer-service-async"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

3. Crie um tópico push-subscription:

   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/customer/pubsub"
   gcloud pubsub subscriptions create push-order-to-customer \
     --topic order-service-event \
     --push-endpoint=$SERVICE_URL \
     --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL
   

   Este tópico entrega mensagens no tópico order-service-event para o serviço Customer usando a conta de serviço cloud-run-invoker.

4. Atribua o papel run.invoker ao serviço order-service-async:

   SERVICE_NAME="order-service-async"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   

5. Crie um tópico push-subscription:

   SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   SERVICE_URL="${SERVICE_URL}/api/v1/order/pubsub"
   gcloud pubsub subscriptions create push-customer-to-order \
     --topic customer-service-event \
     --push-endpoint=$SERVICE_URL \
     --push-auth-service-account=$SERVICE_ACCOUNT_EMAIL
   

   O tópico push-subscription entrega mensagens no tópico customer-service-event para o serviço Order usando a conta de serviço cloud-run-invoker.

Implantar componentes do lado do servidor para uma arquitetura de orquestração síncrona

Nesta seção, você vai implantar os componentes do lado do servidor para o aplicativo de exemplo. Esses componentes implementam uma arquitetura de orquestração síncrona no Cloud Run, bem como um fluxo de trabalho executado com fluxos de trabalho.

Criar e implantar imagens de contêiner

Nesta seção, você criará imagens de contêiner para microsserviços e as implantará no Cloud Run.

1. No Cloud Shell, crie uma imagem de contêiner para o serviço Order chamada order-sync e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-sync
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-service-sync
   gcloud run deploy order-service-sync \
     --image gcr.io/$PROJECT_ID/order-service-sync \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

2. Crie uma imagem de contêiner para o serviço Customer chamada customer-sync e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/customer-sync
   gcloud builds submit --tag gcr.io/$PROJECT_ID/customer-service-sync
   gcloud run deploy customer-service-sync \
     --image gcr.io/$PROJECT_ID/customer-service-sync \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated
   

3. Crie uma imagem de contêiner para o serviço de processador Order chamada order-processor e implante-a no Cloud Run:

   cd $HOME/transactional-microservice-examples/services/order-processor
   gcloud builds submit --tag gcr.io/$PROJECT_ID/order-processor-service
   gcloud run deploy order-processor-service \
     --image gcr.io/$PROJECT_ID/order-processor-service \
     --platform=managed --region=us-central1 \
     --no-allow-unauthenticated \
     --set-env-vars "PROJECT_ID=$PROJECT_ID"
   

Criar uma conta de serviço para invocar microsserviços no Cloud Run

Nesta seção, você reutiliza a conta de serviço cloud-run-invoker criada em Criar uma conta de serviço para invocar microsserviços no Cloud Run.

Implantar um fluxo de trabalho para processar um pedido

1. No Cloud Shell, atribua os papéis run.invoker e run.viewer à conta de serviço cloud-run-invoker do serviço order-service-sync.

   SERVICE_NAME="order-service-sync"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.viewer \
     --platform=managed --region=us-central1
   

2. Atribua os papéis run.invoker e run.viewer à conta de serviço cloud-run-invoker para o serviço customer-service-sync:

   SERVICE_NAME="customer-service-sync"
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.invoker \
     --platform=managed --region=us-central1
   gcloud run services add-iam-policy-binding $SERVICE_NAME \
     --member=serviceAccount:$SERVICE_ACCOUNT_EMAIL \
     --role=roles/run.viewer \
     --platform=managed --region=us-central1
   

3. Use a conta de serviço cloud-run-invoker para implantar um fluxo de trabalho:

   SERVICE_NAME="order-service-sync"
   ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   
   SERVICE_NAME="customer-service-sync"
   CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
     --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
   
   cd $HOME/transactional-microservice-examples/services/order-processor
   cp order_workflow.yaml.template order_workflow.yaml
   sed -i "s#ORDER-SERVICE-URL#${ORDER_SERVICE_URL}#" order_workflow.yaml
   sed -i "s#CUSTOMER-SERVICE-URL#${CUSTOMER_SERVICE_URL}#" order_workflow.yaml
   
   gcloud beta workflows deploy order_workflow \
     --source=order_workflow.yaml \
     --service-account=$SERVICE_ACCOUNT_EMAIL
   

Testar componentes de arquitetura de saga baseados em coreografia

Nesta seção, você testará os componentes implantados na arquitetura de saga baseada em coreografia usando o comando curl.

• No Cloud Shell, defina variáveis de ambiente que apontem para os URLs dos endpoints da API dos microsserviços customer-service-async e order-service-async:

  SERVICE_NAME="customer-service-async"
  CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-service-async"
  ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  

Criar uma entrada do cliente

• No Cloud Shell, crie um ID de cliente chamado customer01 enviando uma solicitação de API para o serviço Customer chamado customer-service-async:

  curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"customer_id":"customer01", "limit":10000}' \
    -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .
  

  O resultado será assim:

  {
    "credit": 0,
    "customer_id": "customer01",
    "limit": 10000
  }
  

Enviar um pedido

Nesta seção, você vai enviar um pedido e acionar uma atribuição de ID de pedido para ele.

1. No Cloud Shell, envie um pedido enviando uma solicitação de API para o serviço Order chamado order-service-async:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer01", "number":10}' \
     -s ${ORDER_SERVICE_URL}/api/v1/order/create | jq .
   

   Nesse caso, você ordena 10 itens especificando: "number": 10

   O resultado será assim:

   {
     "customer_id": "customer01",
     "number": 10,
     "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
     "status": "pending"
   }
   

   A sinalização "order_id" na saída mostra o ID exclusivo do pedido, atribuído a ele. Copie esse ID, porque ele será usado na próxima etapa.

2. Defina o ID do pedido em uma variável de ambiente:

   ORDER_ID=ORDER_ID
   

   Substitua ORDER_ID pela sinalização "order_id" que você copiou na etapa anterior.

Verificar o status de um pedido

Nesta seção, você vai ver como o status de um pedido vai mudar.

1. No Cloud Shell, veja o status do pedido enviando uma solicitação de API para o serviço Order chamado order-service-async:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d "{\"customer_id\":\"customer01\", \"order_id\":\"$ORDER_ID\"}" \
     -s ${ORDER_SERVICE_URL}/api/v1/order/get | jq .
   

   A saída será assim:

   {
     "customer_id": "customer01",
     "number": 10,
     "order_id": "720d1305-b6fd-4f57-aaf4-fd2ca5bdfe1e",
     "status": "pending"
   }
   

   A sinalização "status" na saída mostra o status do pedido. Se o processo transacional ainda estiver em execução, o status será "pending". Nesse caso, aguarde alguns minutos e verifique o status novamente executando o mesmo comando. Quando o processo transacional for concluído, o status será exibido como "accepted".

2. Veja as informações do cliente no ID do cliente customer01:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer01"}' \
     -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
   

   A saída será assim:

   {
     "credit": 1000,
     "customer_id": "customer01",
     "limit": 10000
   }
   

   A sinalização "credit" mostra o uso atual de crédito do cliente. Ela aumenta em 1.000 porque a lógica de negócios para essa transação é aumentar o crédito em 100 para um item.

   É possível repetir o processo de pedido repetindo as etapas em Enviar um pedido. Se você ordenar 100 itens especificando "number": 100, o status final do pedido será "rejected" porque o uso do crédito ultrapassa o limite.

Testar componentes de arquitetura de orquestração síncrona

Nesta seção, você testará os componentes implantados da arquitetura de orquestração síncrona usando o comando curl.

• No Cloud Shell, defina as variáveis de ambiente que apontam para os URLs dos endpoints de API dos microsserviços customer-service-sync, order-service-sync e order-processor-service:

  SERVICE_NAME="customer-service-sync"
  CUSTOMER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-service-sync"
  ORDER_SERVICE_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  
  SERVICE_NAME="order-processor-service"
  ORDER_PROCESSOR_URL=$(gcloud run services list --platform managed \
    --format="table[no-heading](URL)" --filter="SERVICE:${SERVICE_NAME}")
  

Criar uma entrada do cliente

• No Cloud Shell, envie uma solicitação de API ao serviço Customer, chamada customer-service-sync, para criar um ID de cliente chamado customer02:

  curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    -H "Content-Type: application/json" \
    -d '{"customer_id":"customer02", "limit":10000}' \
    -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/limit | jq .
  

  A saída será assim:

  {
    "credit": 0,
    "customer_id": "customer02",
    "limit": 10000
  }
  

Enviar um pedido

Nesta seção, você vai enviar um pedido e conferir o resultado.

1. No Cloud Shell, envie um pedido enviando uma solicitação de API para o serviço order-processor-service do Order:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer02", "number":10}' \
     -s ${ORDER_PROCESSOR_URL}/api/v1/order/process | jq .
   

   Nesse caso, você ordena 10 itens especificando "number": 10.

   O resultado será assim:

   {
     "customer_id": "customer02",
     "number": 10,
     "order_id": "fb6d5087-dd99-4d5a-84c2-0e381016b9d3",
     "status": "accepted"
   }
   

   Como o fluxo de trabalho transacional é realizado de maneira síncrona, o cliente vê o resultado imediatamente. Nesse caso, o status final é este: "accepted"

2. Veja as informações do cliente com o ID customer02:

   curl -X POST -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
     -H "Content-Type: application/json" \
     -d '{"customer_id":"customer02"}' \
     -s ${CUSTOMER_SERVICE_URL}/api/v1/customer/get | jq .
   

   O resultado será assim:

   {
     "credit": 1000,
     "customer_id": "customer02",
     "limit": 10000
   }
   

   O uso do crédito pelo cliente aumenta em 1.000. Para repetir o processo de pedido, repita essas etapas. Se você ordenar 100 itens especificando o valor "number": 100, o cliente receberá imediatamente o resultado "rejected" porque o uso do crédito ultrapassa o limite.

Opcional: implantar um aplicativo da Web

Nesta seção, como uma extensão opcional do tutorial, você implantará um aplicativo da Web de exemplo que executa o fluxo de trabalho transacional em cima dos microsserviços implantados na seção anterior. Use o Firebase Hosting para implantar um aplicativo da Web que interage com microsserviços de back-end em execução no Cloud Run.

O Firebase Hosting tem integração com o Cloud Run, que permite hospedar serviços de aplicativos da Web e microsserviços de back-end no mesmo domínio. Em outros tipos de implantação, é possível ter problemas de Compartilhamento de recursos entre origens (CORS, na sigla em inglês). Para mais informações, consulte Como autenticar usuários finais.

A integração com o Firebase Hosting faz o seguinte:

• Hospeda recursos estáticos para o aplicativo da Web.
• Redireciona o acesso às APIs para os seguintes serviços de back-end no Cloud Run:
  • /customer-service-sync/* a customer-service-sync
  • De /customer-service-async/* para customer-service-async
  • De /order-service-sync/* para order-service-sync
  • De /order-service-async/* para order-service-async
  • /order-processor-service/* a order-processor-service
• Retorna recursos estáticos do aplicativo da Web.

Configurar o Firebase

Nesta seção, você configurará o Firebase para hospedar o aplicativo da Web no Firebase Hosting.

1. No Cloud Shell, atualize o Node.js para a versão mais recente do LTS para usar a CLI do Firebase:

   nvm install lts/gallium
   

2. Adicionar recursos do Firebase ao projeto do Google Cloud

   firebase projects:addfirebase $PROJECT_ID
   

3. Adicione um alias de projeto padrão para a CLI do Firebase:

   jq -n --arg project_id $PROJECT_ID \
     '{"projects": {"default":$project_id}}' > \
     $HOME/transactional-microservice-examples/frontend/.firebaserc
   

Implantar o aplicativo da Web

Nesta seção, você vai implantar o aplicativo da Web no Firebase Hosting.

1. No Cloud Shell, crie o aplicativo de front-end da Web:

   cd $HOME/transactional-microservice-examples/frontend
   yarn install && yarn build
   

2. Implante o aplicativo da Web no Firebase Hosting:

   firebase deploy
   

Usar o aplicativo da Web

• Digite no navegador o URL de hospedagem que você copiou na seção anterior. Você verá a página inicial do aplicativo da Web.

Inicializar o aplicativo da Web com um token de identidade

Nesta seção, você inicializa o aplicativo da Web com seu token de identidade e segue para a página Shopping.

1. No Cloud Shell, salve o token de identidade:

   gcloud auth print-identity-token
   

2. Copie a saída do comando anterior e cole-a na caixa de texto.

3. Clique em Proceed. Você será redirecionado para a página Shopping se o token de identidade for válido.

Adicionar itens a um carrinho

• No aplicativo da Web, clique em Adicionar ao carrinho para adicionar itens a um carrinho.

Verificar itens em um carrinho

• No aplicativo da Web, clique no ícone de carrinho na barra de navegação para acessar a página Checkout. Há itens no carrinho.

Enviar um pedido usando o serviço assíncrono

1. No aplicativo da Web, clique no ícone de carrinho de compras na barra de navegação para acessar a página Checkout.
2. Clique em Enviar pedido (assíncrono). Você será redirecionado para a página Histórico de pedidos se o pedido for enviado.

Enviar um pedido usando o serviço síncrono

1. No aplicativo da Web, clique no ícone de carrinho de compras na barra de navegação para acessar a página Checkout.
2. Clique em Enviar pedido (Sincronizar). Você será redirecionado para a página Histórico de pedidos se o pedido for enviado.

Verificar o histórico de pedidos

• No aplicativo da Web, clique em Pedidos na barra de navegação para acessar a página Histórico de pedidos.

Atualizar o status de um pedido incompleto

1. No aplicativo da Web, clique em Pedidos na barra de navegação para acessar a página Histórico de pedidos.
2. Clique no ícone de atualização de um pedido individual. O ícone só será exibido se o pedido for processado de maneira assíncrona e o status for pending.

Verificar o orçamento atual de um cliente

• No aplicativo da Web, clique no nome do cliente (customer-number) na barra de navegação para acessar a página do perfil dele.

Redefinir o estado no aplicativo da Web

• No navegador, atualize o aplicativo da Web. Estados como itens no carrinho, histórico de pedidos e informações do cliente são redefinidos, e você é redirecionado para a página inicial.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos 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.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google 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.

Excluir recursos individuais

Nesta seção, você excluirá os recursos individuais usados neste tutorial.

Desativar o Firebase Hosting

• No Cloud Shell, execute o seguinte comando para interromper a veiculação do tráfego do Firebase Hosting:

   firebase hosting:disable -f
  

Excluir serviços no Cloud Run

• No Cloud Shell, exclua serviços no Cloud Run:

  gcloud run services delete order-service-async \
    --platform=managed --region=us-central1 --quiet
  
  gcloud run services delete customer-service-async \
    --platform=managed --region=us-central1 --quiet
  
  gcloud run services delete order-service-sync \
    --platform=managed --region=us-central1 --quiet
  
  gcloud run services delete customer-service-sync \
    --platform=managed --region=us-central1 --quiet
  
  gcloud run services delete order-processor-service \
    --platform=managed --region=us-central1 --quiet
  
  gcloud run services delete event-publisher \
    --platform=managed --region=us-central1 --quiet
  

Excluir imagens de contêiner usadas pelo Cloud Run

• No Cloud Shell, exclua as imagens de contêiner criadas para este tutorial:

  gcloud container images delete \
    gcr.io/$PROJECT_ID/order-service-async --force-delete-tags --quiet
  gcloud container images delete \
    gcr.io/$PROJECT_ID/customer-service-async --force-delete-tags --quiet
  gcloud container images delete \
    gcr.io/$PROJECT_ID/event-publisher --force-delete-tags --quiet
  gcloud container images delete \
    gcr.io/$PROJECT_ID/order-service-sync --force-delete-tags --quiet
  gcloud container images delete \
    gcr.io/$PROJECT_ID/customer-service-sync --force-delete-tags --quiet
  gcloud container images delete \
    gcr.io/$PROJECT_ID/order-processor-service --force-delete-tags --quiet
  

Excluir o fluxo de trabalho

• No Cloud Shell, exclua o fluxo de trabalho:

  gcloud beta workflows delete order_workflow --quiet
  

Excluir assinaturas e tópicos do Pub/Sub

1. No Cloud Shell, exclua as assinaturas do Pub/Sub:

   gcloud pubsub subscriptions delete push-customer-to-order --quiet
   gcloud pubsub subscriptions delete push-order-to-customer --quiet
   

2. Excluir os tópicos do Pub/Sub:

   gcloud pubsub topics delete order-service-event --quiet
   gcloud pubsub topics delete customer-service-event --quiet
   

Excluir registros do Datastore

1. No console do Cloud, no menu do Datastore, abra Entidades.
2. Verifique todas as entidades no campo Customer.
3. Clique em Excluir e em Confirmar para remover entidades permanentemente.
4. Repita as etapas 2 e 3 deste procedimento para os seguintes campos:
   1. Event
   2. Order
   3. ProcessedEvent

Excluir o job no Cloud Scheduler

• No Cloud Shell, exclua o job em execução no Cloud Scheduler:

  gcloud scheduler jobs delete event-publisher-scheduler --quiet \
    --location=us-central1
  

Excluir a conta de serviço

• No Cloud Shell, exclua a conta de serviço :

  gcloud iam service-accounts delete $SERVICE_ACCOUNT_EMAIL --quiet
  

Excluir recursos do tutorial

• No Cloud Shell, exclua os recursos usados para este tutorial:

  cd $HOME
  rm -rf transactional-microservice-examples
  

A seguir

• Leia a série a seguir para saber mais sobre como projetar, criar e implantar microsserviços:
  • Introdução a microsserviços
  • Como refatorar um monolítico em microsserviços
  • Comunicação entre serviços em uma configuração de microsserviços
  • Rastreamento distribuído em um aplicativo de microsserviços
• Leia sobre os benefícios e desafios dos monolíticos e de microsserviços
• Saiba como definir limites de serviço e refatorar monolíticos.
• Veja como distribuir transações entre microsserviços
• Saiba como configurar o rastreamento distribuído em um ambiente poliglota
• Leia sobre como implementar malhas de serviço em uma arquitetura de microsserviços
• Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.