Microsserviço arco-íris rumpus

1. Introdução

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

Microsserviço Rainbow Rumpus

Já participou de uma guerra de bolas de neve em que você se move e joga bolas de neve em outras pessoas? Se não, tente um dia! Mas agora, em vez de correr o risco de levar um tapa, você pode criar um serviço pequeno e acessível pela rede (um microsserviço) que vai participar de uma batalha épica contra outros microsserviços, jogando arco-íris em vez de bolas de neve.

Você deve estar se perguntando... Mas como um microsserviço "joga" um arco-íris em outros microsserviços? Um microsserviço pode receber solicitações de rede (geralmente por HTTP) e retornar respostas. Há um "gerenciador de arena" que envia ao microsserviço o estado atual da arena. Em seguida, o microsserviço responde com um comando especificando o que fazer.

O objetivo é vencer, mas ao longo do caminho você vai aprender a criar e implantar microsserviços no Google Cloud.

Como funciona

Você vai criar um microsserviço com a tecnologia que quiser (ou escolher entre os iniciadores Go, Java, Kotlin, Scala, NodeJS ou Python) e implantar o microsserviço no Google Cloud. Depois da implantação, informe o URL do microsserviço para que ele seja adicionado à arena.

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

Aproximadamente uma vez por segundo, nosso gerenciador de arena vai chamar seu microsserviço, enviando o estado atual da arena (onde os jogadores estão), e seu microsserviço vai responder com um comando para o que fazer. Na arena, você pode avançar, virar à esquerda ou à direita ou lançar um arco-íris. Um arco-íris vai viajar até três espaços na direção em que o jogador está olhando. Se o arco-íris "atingir" outro jogador, o lançador ganha um ponto e o jogador atingido perde um ponto. O tamanho da arena é ajustado automaticamente para o número atual de jogadores.

Confira a aparência de uma arena anterior:

20628e6bd442bd11.png

Exemplo de arena da Batalha 1

Conflitos recorrentes

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, o microsserviço com o tempo de resposta mais rápido vence.

Assistir a batalha

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

API Battle

Para trabalhar com nosso gerenciador de arena, seu microsserviço precisa implementar uma API específica para participar da arena. O gerente da arena vai enviar o estado atual da arena em um HTTP POST para o URL que você fornecer, 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) com um corpo contendo sua próxima jogada, codificada como um único caractere maiúsculo de:

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

Isso é tudo! Vamos 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, faça login no Google Cloud. Vamos aplicar um crédito à sua conta, e você não precisará inserir um cartão de crédito. Normalmente, é 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 usem determinados recursos do Google Cloud. Além disso, o console da Web que vamos usar funciona bem com o Chrome ou o Firefox, mas pode ter problemas no Safari.

3. Como implantar seu microsserviço

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

Escolha uma amostra para começar

Há vários exemplos de microsserviços de batalha para começar:

Kotlin e Spring Boot

Origem

Kotlin e Micronaut

Origem

Kotlin e Quarkus

Origem

Java e Spring Boot

Origem

Java e Quarkus

Origem

Go

Origem

Node.js e Express

Origem

Python e Flask

Origem

Depois de decidir qual amostra usar, 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), em que a origem será clonada e criada em um pacote implantável (uma imagem de contêiner do Docker), que será enviado 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 a criação e implantação de microsserviços

d88e40430706a32b.png

Verificar se o microsserviço funciona

No Cloud Shell, faça uma solicitação ao microsserviço recém-implantado, substituindo YOUR_SERVICE_URL pelo URL do serviço (que está no Cloud Shell após a linha "Seu aplicativo 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

Você vai ver a string de resposta de F, L, R ou T.

4. Pedir inclusão na Arena

Para participar do Rainbow Rumpus, você precisa entrar em uma arena. Abra rainbowrumpus.dev e clique em "Participar" em uma arena onde você vai fornecer o URL do microsserviço.

5. Fazer e implantar mudanças

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

gcloud projects list

Você provavelmente tem apenas um projeto. Copie o PROJECT_ID da primeira coluna e cole 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 usada. Assim, em comandos posteriores, podemos especificar o diretório e o nome do serviço corretos:

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

Em seguida, você vai encontrar mais instruções para fazer mudanças.

f910c9ef7b51c406.png

Cloud Shell com o editor e o projeto de exemplo aberto

Depois de salvar as mudanças, inicie o aplicativo no Cloud Shell usando o comando do arquivo README.md. Primeiro, confira se você está no diretório de amostra correto no Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE

Depois que 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 enviar a imagem ao Container Registry e permitir que ela seja 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 vai usar sua nova versão.

6. Desenvolver localmente (opcional)

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

  1. [No Cloud Shell] Compacte o exemplo:
# 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 e faça e teste as mudanças
  2. [Na sua máquina] Instale a CLI gcloud
  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 (no 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) do git ou o aplicativo GUI do GitHub Desktop (Windows ou Mac). Se você estiver usando o Cloud Shell, use a CLI do Git. Para colocar o código do seu microsserviço no GitHub, siga as instruções da CLI ou do GitHub Desktop.

Enviar o código com a CLI git

  1. Siga as instruções do Git por HTTPS com um token de acesso pessoal.
  2. Escolha o escopo "repo".
  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 o 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 as mudanças, crie uma confirmação e envie as alterações 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 Desktop

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

cf7f38c7c86a91cd.png

  1. Abra o explorador de arquivos e copie seu projeto para o novo repositório.
  2. Confirmar as mudanças

5f3c1552e30ad7c5.png

  1. Publicar sua ramificação principal no GitHub

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

Com o SCM configurado no GitHub, agora é possível configurar a entrega contínua para que, sempre que novos commits forem enviados por push para a ramificação main, o Cloud Build crie e implante automaticamente as mudanças. Você também pode 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 no botão "CONFIGURAR IMPLANTAÇÃO CONTÍNUA".
  3. Autentique com o GitHub e selecione o repositório do 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 mostram dados sobre a integridade e o uso do nosso serviço. Os registros mostram as informações instrumentadas manualmente emitidas pelo nosso serviço. Os alertas permitem que sejamos notificados quando algo dá errado. Vamos analisar cada uma delas.

Métricas

  1. Encontre seu serviço na lista de serviços do Cloud Run.
  2. Clique no nome do 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 você pode mudar métricas de recursos, filtros, agrupamentos e outras opções. Por exemplo, é possível ver as latências médias de serviço de todos os serviços:

f0d666d8f4221d45.png

Registros

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

40058a82c9299cff.png

Nos registros do Cloud Run, é possível filtrar por gravidade e filtrar os registros. Para 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 o 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 de host e caminho. No caso do 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 um microsserviço que pode lutar com outros microsserviços. Boa sorte!

Documentos de referência