Microsserviço arco-íris rumpus

1. Introdução

Última atualização:06/05/2021

Microsserviço Rainbow Rumpus

Você já participou de uma luta de bolas de neve em que se moveu e jogava bolas de neve em outras pessoas? Se não, tente algum dia! Mas agora, em vez de arriscar um golpe físico, é possível criar um pequeno serviço acessível pela rede (um microsserviço) que participará de uma batalha épica contra outros microsserviços, jogando arco-íris em vez de bolas de neve.

Talvez você esteja se perguntando... Mas como um microsserviço "gera" um arco-íris em outros microsserviços? Um microsserviço pode receber solicitações de rede (geralmente por HTTP) e retornar respostas. Há um "administrador da arena" que enviará ao microsserviço o estado atual da arena. Em seguida, o microsserviço responderá com um comando especificando o que fazer.

É claro que o objetivo é vencer, mas ao longo do curso você vai aprender a criar e implantar microsserviços no Google Cloud.

Como funciona

Você vai criar um microsserviço com qualquer tecnologia que quiser (ou escolher entre as ativações Go, Java, Kotlin, Scala, NodeJS ou Python) e implantá-lo no Google Cloud. Depois da implantação, informe o URL do microsserviço e o adicionaremos à arena.

A arena contém todos os jogadores de uma determinada batalha. A Rumpus arco-íris terá suas próprias arenas. Cada jogador representa um microsserviço que se move e lança arco-íris nos outros jogadores.

cerca de uma vez por segundo, o gerente da arena vai chamar seu microsserviço, enviando o estado atual da arena (onde estão os jogadores), e o microsserviço responderá com um comando sobre o que fazer. Na arena, você pode avançar, virar para a esquerda ou direita ou jogar um arco-íris. Um arco-íris viaja até três espaços na direção para o jogador. Se o arco-íris "acertar" para outro jogador, o arremessador ganha um ponto, e o que atingir o ponto perde um ponto. O tamanho da arena é ajustado automaticamente de acordo com o número atual de jogadores.

Esta é a aparência de uma arena antiga:

20628e6bd442bd11.png

Exemplo: arena Battle One

Conflitos rotativos

Na arena, é possível que vários jogadores tentem realizar ações conflitantes. Por exemplo, dois jogadores podem tentar se mover para o mesmo espaço. Em caso de conflito, vence o microsserviço com o menor tempo de resposta.

Assista à batalha

Para saber como o microsserviço está se saindo na batalha, confira a arena ao vivo.

API Battle

Para trabalhar com o gerente da arena, seu microsserviço vai precisar implementar uma API específica para participar da arena. O gerente da arena enviará o estado atual da arena em um HTTP POST para o URL fornecido com a seguinte estrutura JSON:

{
  "_links": {
    "self": {
      "href": "https://YOUR_SERVICE_URL"
    }
  },
  "arena": {
    "dims": [4,3], // width, height
    "state": {
      "https://A_PLAYERS_URL": {
        "x": 0, // zero-based x position, where 0 = left
        "y": 0, // zero-based y position, where 0 = top
        "direction": "N", // N = North, W = West, S = South, E = East
        "wasHit": false,
        "score": 0
      }
      ... // also you and the other players
    }
  }
}

Sua resposta HTTP precisa ter o código de status 200 (OK) e o corpo da resposta contendo o próximo movimento codificado como um único caractere maiúsculo:

F <- move Forward
R <- turn Right
L <- turn Left
T <- Throw

Isso é tudo! Vamos mostrar como implantar um microsserviço no Cloud Run, um serviço do Google Cloud para executar microsserviços e outros aplicativos.

2. Fazer login no Google Cloud

Para implantar o microsserviço no Cloud Run, você precisa fazer login no Google Cloud. Aplicaremos um crédito à sua conta e você não precisará inserir um cartão de crédito. Geralmente, é menos problemático usar uma conta pessoal (por exemplo, gmail.com) em vez de uma conta do G Suite porque às vezes os administradores do G Suite impedem que os usuários utilizem determinados recursos do Google Cloud. Além disso, o console da Web que vamos usar deve funcionar muito bem com o Chrome ou o Firefox, mas pode apresentar problemas no Safari.

3. Como implantar o microsserviço

É possível criar seu microsserviço com qualquer tecnologia e implantá-lo em qualquer lugar, desde que ele seja acessível publicamente e esteja em conformidade com a API Battle. Mas, para facilitar, vamos ajudar você a começar com um serviço de exemplo e implantá-lo no Cloud Run.

Escolha sua amostra para começar

É possível começar com vários exemplos de microsserviços de batalha:

Kotlin e Spring Boot (em inglês)

Origem

Kotlin e Micronaut

Origem

Kotlin e Quarkus (em inglês)

Origem

Java e Spring Boot (em inglês)

Origem

Java e Quarkus (em inglês)

Origem

Go

Origem

Node.js e Rápido

Origem

Python e Garrafa

Origem

Depois de decidir com qual amostra começar, clique no botão "Implantar no Cloud Run" acima. Isso vai iniciar o Cloud Shell (um console baseado na Web para uma máquina virtual na nuvem), onde a origem será clonada e, em seguida, criada em um pacote implantável (uma imagem de contêiner do Docker), que é depois carregado para o Google Container Registry e implantado no Cloud Run.

Quando solicitado, especifique a região us-central1.

A captura de tela abaixo mostra a saída do Cloud Shell para criação e implantação de microsserviços

d88e40430706a32b.png

Verifique se o microsserviço funciona

No Cloud Shell, você pode fazer uma solicitação para o microsserviço recém-implantado, substituindo YOUR_SERVICE_URL pelo URL do serviço (que está no Cloud Shell depois da linha "Seu aplicativo agora está ativo aqui"):

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  https://YOUR_SERVICE_URL

A string de resposta de F, L, R ou T será exibida.

4. Solicitar inclusão na arena

Para entrar na Rumpus Arco-Íris, você precisa entrar em uma arena. Abra rainbowrumpus.dev e clique em "Join" em uma arena para fornecer o URL do microsserviço.

5. Marca e Implantar mudanças

Antes de fazer as alterações, você precisa configurar algumas informações no Cloud Shell sobre o projeto do GCP e o exemplo usado. Primeiro liste seus projetos do GCP:

gcloud projects list

Você provavelmente tem apenas um projeto. Copie o PROJECT_ID da primeira coluna e cole-o no comando a seguir (substituindo YOUR_PROJECT_ID pelo ID do projeto real) para definir uma variável de ambiente que será usada em comandos posteriores:

export PROJECT_ID=YOUR_PROJECT_ID

Agora defina outra variável de ambiente para a amostra que você usou. Assim, nos comandos posteriores, poderemos especificar o diretório correto e o nome do serviço:

# Copy and paste ONLY ONE of these
export SAMPLE=kotlin-micronaut
export SAMPLE=kotlin-quarkus
export SAMPLE=kotlin-springboot
export SAMPLE=java-quarkus
export SAMPLE=java-springboot
export SAMPLE=go
export SAMPLE=nodejs
export SAMPLE=python

Agora você pode editar a origem do seu microsserviço no Cloud Shell. Para abrir o editor baseado na Web do Cloud Shell, execute este comando:

cloudshell edit cloudbowl-microservice-game/samples/$SAMPLE/README.md

Você verá mais instruções para fazer alterações.

f910c9ef7b51c406.png

Cloud Shell com o editor com o projeto de amostra aberto

Depois de salvar as alterações, inicie o aplicativo no Cloud Shell usando o comando do arquivo README.md, mas primeiro verifique se você está no diretório de exemplo correto no Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE

Quando o aplicativo estiver em execução, abra uma nova guia do Cloud Shell e teste o serviço usando curl:

curl -d '{
  "_links": {
    "self": {
      "href": "https://foo.com"
    }
  },
  "arena": {
    "dims": [4,3],
    "state": {
      "https://foo.com": {
        "x": 0,
        "y": 0,
        "direction": "N",
        "wasHit": false,
        "score": 0
      }
    }
  }
}' -H "Content-Type: application/json" -X POST -w "\n" \
  http://localhost:8080

Quando estiver tudo pronto para implantar as mudanças, crie o projeto no Cloud Shell usando o comando pack. Esse comando usa Buildpacks para detectar o tipo de projeto, compilá-lo e criar o artefato implantável (uma imagem de contêiner do Docker).

# Make sure you are in a Cloud Shell tab where you set the PROJECT_ID
# and SAMPLE env vars. Otherwise, set them again.
pack build gcr.io/$PROJECT_ID/$SAMPLE \
  --path ~/cloudbowl-microservice-game/samples/$SAMPLE \
  --builder gcr.io/buildpacks/builder

Agora que a imagem do contêiner foi criada, use o comando docker (no Cloud Shell) para enviá-la ao Google Container Registry para que ela possa ser acessada pelo Cloud Run:

docker push gcr.io/$PROJECT_ID/$SAMPLE

Agora implante a nova versão no Cloud Run:

gcloud run deploy $SAMPLE \
          --project=$PROJECT_ID \
          --platform=managed \
          --region=us-central1 \
          --image=gcr.io/$PROJECT_ID/$SAMPLE \
          --allow-unauthenticated

Agora a arena usará sua nova versão.

6. Desenvolver localmente (opcional)

Para trabalhar no projeto localmente usando seu próprio ambiente de desenvolvimento integrado, siga estas etapas:

  1. [No Cloud Shell] Compacte a amostra:
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples
zip -r cloudbowl-sample.zip $SAMPLE
  1. [No Cloud Shell] Faça o download do arquivo ZIP para sua máquina:
cloudshell download-file cloudbowl-sample.zip
  1. [Na sua máquina] Descompacte o arquivo, depois crie & testar as alterações
  2. [Na sua máquina] Instale a gcloud CLI
  3. [Na sua máquina] Faça login no Google Cloud:
gcloud auth login
  1. [Na sua máquina] Defina as variáveis de ambiente PROJECT_ID e SAMPLE com os mesmos valores do Cloud Shell.
  2. [Na sua máquina] Use o Cloud Build para criar o contêiner (do diretório raiz do projeto):
gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID
  1. [Na sua máquina] Implante o novo contêiner:
gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. Entrega contínua

Configurar o SCM

Configure o GitHub para colaborar com sua equipe no microsserviço:

  1. Fazer login no GitHub
  2. Criar um novo repositório
  3. Se você estiver trabalhando na sua máquina local, use a interface de linha de comando (CLI) git ou o aplicativo de GUI do GitHub para computador (Windows ou Mac). Se você estiver usando o Cloud Shell, precisará usar a CLI do git. Para conseguir o código do seu microsserviço no GitHub, siga as instruções da CLI ou do GitHub Desktop.

Enviar o código por push com a CLI do git

  1. Siga as instruções de git por HTTPS com um token de acesso pessoal.
  2. Escolha "repositório" escopo
  3. Configure o git:
git config --global credential.helper \
  'cache --timeout=172800'
git config --global push.default current
git config --global user.email "YOUR@EMAIL"
git config --global user.name "YOUR NAME"
  1. Definir variáveis de ambiente para a organização e o repositório do GitHub (https://github.com/ORG/REPO)
export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO
  1. Envie seu código para o novo repositório
# Make sure the SAMPLE env var is still set. If not, re-set it.
cd ~/cloudbowl-microservice-game/samples/$SAMPLE
git init
git add .
git commit -m init
git remote add origin https://github.com/$GITHUB_ORG/$GITHUB_REPO.git
git branch -M main

# This will now ask for your GitHub username & password
# for the password use the personal access token
git push -u origin main
  1. Depois de fazer qualquer mudança, você pode confirmar e enviá-la por push para o GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Enviar o código com o GitHub para computador

  1. Faça o download do código seguindo as instruções da seção anterior "Desenvolver localmente" laboratório
  2. Instale o GitHub Desktop, inicie-o e faça login
  3. Clonar seu repositório recém-criado

cf7f38c7c86a91cd.png

  1. Abra o explorador de arquivos e copie seu projeto para o novo repositório.
  2. Confirme suas alterações

5f3c1552e30ad7c5.png

  1. Publicar a ramificação principal no GitHub

Configurar a implantação contínua do Cloud Run

Com a configuração do SCM no GitHub, agora é possível configurar a entrega contínua para que, sempre que novas confirmações forem enviadas para a ramificação main, o Cloud Build crie e implante as alterações automaticamente. Também é possível adicionar a integração contínua, que executa os testes antes da implantação. No entanto, essa etapa foi deixada como um exercício para você, já que as amostras prontas para uso não contêm testes.

  1. No console do Cloud, acesse seu serviço do Cloud Run
  2. Clique em "CONFIGURAR IMPLANTAÇÃO CONTÍNUA" botão
  3. Autentique com o GitHub e selecione o repositório do seu microsserviço

a3b5692f178869bc.png

  1. Selecione seu repositório do GitHub e defina a ramificação como: ^main$

338f1c00f33d2f65.png

  1. Definir o tipo de build para usar Buildpacks
  2. Clique em "Salvar" para configurar a implantação contínua.

8. Observabilidade

As coisas quebram. A observabilidade nos permite saber quando isso acontece e diagnosticar o motivo. As métricas nos mostram dados sobre a integridade e o uso do nosso serviço. Os registros mostram as informações instrumentadas manualmente emitidas pelo serviço. Os alertas nos permitem ser notificados quando algo dá errado. Vamos explorar cada um deles mais detalhadamente.

Métricas

  1. Encontre seu serviço na lista de serviços do Cloud Run.
  2. Clique no nome do seu serviço para acessar o painel de métricas dele.

8491b8ec6bc5b4db.png

  1. Clique no menu ⋮ de uma métrica e selecione "Ver no Metrics Explorer"
  2. Agora é possível alterar as métricas, os filtros, o agrupamento e outras opções dos recursos. Por exemplo, é possível visualizar as latências médias de serviço para todos os serviços:

f0d666d8f4221d45.png

Registros

A saída STDOUT dos serviços é enviada ao sistema do Google Cloud Logging. É possível acessar uma visualização básica de registros na página do administrador do serviço do Cloud Run, como:

40058a82c9299cff.png

Nos registros do Cloud Run, é possível filtrar por gravidade e filtrar os registros. Para ter mais flexibilidade, clique em: 186fdb0e6d39a6ca.png

Alertas

  1. Crie um URL de verificação de integridade para seu serviço.
  2. Para o Spring Boot, basta adicionar a seguinte dependência:
org.springframework.boot:spring-boot-starter-actuator
  1. Crie ou atualize src/main/resources/application.properties e desative a verificação de espaço em disco:
management.health.diskspace.enabled=false
  1. Crie um alerta de tempo de atividade especificando seu protocolo, nome do host e caminho. Para o Spring Boot, o caminho é: /actuator/health
  2. Testar o alerta

6948d13b263bf573.png

  1. Criar o alerta

9. Parabéns

Parabéns, você criou e implantou com sucesso um microsserviço que pode ser usado para lidar com outros microsserviços. Boa sorte!

Documentos de referência