Microsserviço arco-íris rumpus

Microsserviço Rainbow Rumpus

Sobre este codelab

subjectÚltimo mai. 12, 2021 atualizado
account_circleEscrito por James Ward

1. Introdução

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

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.

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 "administrador de arena" que envia o estado atual da arena ao microsserviço, que 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 qualquer tecnologia que quiser (ou escolher entre os starters Go, Java, Kotlin, Scala, NodeJS ou Python) e, em seguida, implantar o microsserviço no Google Cloud. Depois do lançamento, você vai informar o URL do microsserviço e vamos adicioná-lo à 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.

A cada segundo, o gerenciador de arena chama seu microsserviço, enviando o estado atual da arena (onde os jogadores estão), e o microsserviço responde com um comando sobre o que fazer. Na arena, você pode avançar, virar para a esquerda ou direita ou lançar 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 de arena de Batalha Um

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, vence o microsserviço com o menor tempo de resposta.

Assistir a batalha

Para saber como o 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 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 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 seu 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

Você pode 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. No entanto, para facilitar, vamos ajudar você a começar com um serviço de amostra 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

Origem

Kotlin e Micronauta

Origem

Kotlin e Quarkus (em inglês)

Origem

Java e Spring Boot

Origem

Java e Quarkus

Origem

Go

Origem

Node.js e Express

Origem

Python e Garrafa

Origem

Depois de decidir qual exemplo 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 depois integrada a 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 criação e implantação de microsserviços

d88e40430706a32b.png

Verificar se o microsserviço funciona

No Cloud Shell, é possível 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 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 encontrar a string de resposta F, L, R ou T.

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 alterações, é necessário 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

Provavelmente você só tem 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 o exemplo que você usou para que possamos especificar o diretório e o nome do serviço corretos em comandos posteriores:

# 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 enviar a imagem do contêiner 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 vai 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 a máquina:
cloudshell download-file cloudbowl-sample.zip
  1. [Na sua máquina] Descompactar o arquivo e fazer e testar as mudanças
  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 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 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 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 usando as instruções do laboratório anterior "Desenvolver localmente".
  2. Instalar o GitHub Desktop, abrir e fazer login
  3. Clone o repositório recém-criado

cf7f38c7c86a91cd.png

  1. Abra o File Explorer e copie o 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 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 permitem que você seja notificado quando algo der errado. Vamos analisar cada um deles em mais detalhes.

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 é possível mudar as métricas de recursos, os filtros, o agrupamento e outras opções. Por exemplo, é possível acessar as latências médias de serviço para todos os serviços:

f0d666d8f4221d45.png

Registros

A saída STDOUT dos serviços é enviada para o sistema do Google Cloud Logging. É possível acessar uma visualização de registro básica na página de 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 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 esta 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 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 um microsserviço que pode competir com outros microsserviços. Boa sorte!

Documentos de referência

bug_report Informar um erro