Microservizio Rainbow Rumpus

1. Introduzione

Ultimo aggiornamento: 06/05/2021

Microservizio Rainbow Rumpus

Ti è mai capitato di partecipare a una battaglia a palle di neve in cui ti muovi e lanci palle di neve in modo giocoso contro gli altri? In caso contrario, prova a farlo un giorno. Ma ora, invece di rischiare di essere colpito fisicamente, puoi creare un piccolo servizio accessibile alla rete (un microservizio) che parteciperà a una battaglia epica contro altri microservizi, lanciando arcobaleni invece di palle di neve.

Ti starai chiedendo… Ma in che modo un microservizio "lancia" un arcobaleno ad altri microservizi? Un microservizio può ricevere richieste di rete (di solito tramite HTTP) e restituire risposte. Esiste un "gestore dell'arena" che invia al microservizio lo stato attuale dell'arena e il microservizio risponde con un comando che specifica cosa fare.

Naturalmente l'obiettivo è vincere, ma lungo il percorso imparerai a creare ed eseguire il deployment di microservizi su Google Cloud.

Come funziona

Creerai un microservizio con la tecnologia che preferisci (oppure scegli tra gli starter Go, Java, Kotlin, Scala, NodeJS o Python) e poi lo eseguirai il deployment su Google Cloud. Una volta eseguito il deployment, comunicaci l'URL del tuo microservizio e lo aggiungeremo all'arena.

L'arena contiene tutti i giocatori per una determinata battaglia. Il Rainbow Rumpus avrà le sue arene. Ogni giocatore rappresenta un microservizio che si muove e lancia arcobaleni contro gli altri giocatori.

Circa una volta al secondo, il nostro gestore dell'arena chiamerà il tuo microservizio, inviando lo stato attuale dell'arena (dove si trovano i giocatori) e il tuo microservizio risponderà con un comando su cosa fare. Nell'arena puoi andare avanti, girare a sinistra o a destra o lanciare un arcobaleno. Un arcobaleno si sposta fino a tre spazi nella direzione in cui è rivolto il giocatore. Se l'arcobaleno "colpisce" un altro giocatore, chi lo lancia ottiene un punto e il giocatore colpito ne perde uno. Le dimensioni dell'arena vengono regolate automaticamente in base al numero attuale di giocatori.

Ecco l'aspetto di un'arena passata:

20628e6bd442bd11.png

Esempio di arena della prima battaglia

Revolving Conflicts

Nell'arena è possibile che più giocatori tentino di eseguire azioni in conflitto. Ad esempio, due giocatori potrebbero provare a spostarsi nello stesso spazio. In caso di conflitto, vince il microservizio con il tempo di risposta più rapido.

Guardare la battaglia

Per vedere come sta andando il tuo microservizio nella battaglia, dai un'occhiata all'arena live.

API Battle

Per funzionare con il nostro gestore dell'arena, il tuo microservizio dovrà implementare un'API specifica per partecipare all'arena. L'arena manager invierà lo stato attuale dell'arena in un HTTP POST all'URL che ci fornisci, con la seguente struttura 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
    }
  }
}

La risposta HTTP deve avere il codice di stato 200 (OK) con un corpo della risposta contenente la tua prossima mossa, codificata come un singolo carattere maiuscolo:

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

E con questo è tutto! Vediamo come eseguire il deployment di un microservizio su Cloud Run, un servizio Google Cloud per l'esecuzione di microservizi e altre applicazioni.

2. Accedi a Google Cloud

Per poter eseguire il deployment del microservizio su Cloud Run, devi accedere a Google Cloud. Applicheremo un credito al tuo account e non dovrai inserire una carta di credito. In genere è meno problematico utilizzare un account personale (ad es. gmail.com) anziché un account G Suite, perché a volte gli amministratori G Suite impediscono ai propri utenti di utilizzare determinate funzionalità di Google Cloud. Inoltre, la console web che utilizzeremo dovrebbe funzionare perfettamente con Chrome o Firefox, ma potrebbe presentare problemi in Safari.

3. Deployment del microservizio

Puoi creare il tuo microservizio con qualsiasi tecnologia ed eseguirne il deployment ovunque, purché sia raggiungibile pubblicamente e conforme all'API Battle. Per semplificare le cose, ti aiuteremo a iniziare da un servizio di esempio e a eseguirne il deployment su Cloud Run.

Scegliere un campione con cui iniziare

Esistono numerosi esempi di microservizi di battaglia da cui puoi iniziare:

Kotlin e Spring Boot

Origine

Kotlin e Micronaut

Origine

Kotlin e Quarkus

Origine

Java e Spring Boot

Origine

Java e Quarkus

Origine

Go

Origine

Node.js ed Express

Origine

Python e Flask

Origine

Dopo aver deciso con quale esempio iniziare, fai clic sul pulsante "Esegui il deployment su Cloud Run" qui sopra. Verrà avviata Cloud Shell (una console basata sul web per una macchina virtuale nel cloud) in cui verrà clonato il codice sorgente, quindi verrà creato un pacchetto di cui è possibile eseguire il deployment (un'immagine container Docker), che verrà poi caricato in Google Container Registry e di cui verrà eseguito il deployment su Cloud Run.

Quando ti viene chiesto, specifica la regione us-central1.

Lo screenshot seguente mostra l'output di Cloud Shell per la creazione e il deployment di microservizi

d88e40430706a32b.png

Verificare che il microservizio funzioni

In Cloud Shell puoi inviare una richiesta al microservizio appena di cui è stato eseguito il deployment, sostituendo YOUR_SERVICE_URL con l'URL del servizio (che si trova in Cloud Shell dopo la riga "Your application is now live here"):

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

Dovresti visualizzare la stringa di risposta F, L, R o T.

4. Richiedere l'inclusione nell'arena

Per partecipare al Rainbow Rumpus, devi unirti a un'arena. Apri rainbowrumpus.dev e fai clic su Partecipa in un'arena in cui fornirai l'URL del microservizio.

5. Apportare e implementare le modifiche

Prima di poter apportare modifiche, devi configurare alcune informazioni in Cloud Shell sul progetto Google Cloud e sul campione che hai utilizzato. Innanzitutto, elenca i tuoi progetti Google Cloud:

gcloud projects list

Probabilmente hai un solo progetto. Copia PROJECT_ID dalla prima colonna e incollalo nel comando seguente (sostituendo YOUR_PROJECT_ID con l'ID progetto effettivo) per impostare una variabile di ambiente che utilizzeremo nei comandi successivi:

export PROJECT_ID=YOUR_PROJECT_ID

Ora imposta un'altra variabile di ambiente per l'esempio che hai utilizzato, in modo che nei comandi successivi possiamo specificare la directory e il nome del servizio corretti:

# 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

Ora puoi modificare l'origine del tuo microservizio da Cloud Shell. Per aprire l'editor web di Cloud Shell, esegui questo comando:

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

Verranno visualizzate ulteriori istruzioni per apportare le modifiche.

f910c9ef7b51c406.png

Cloud Shell con l'editor con il progetto di esempio aperto

Dopo aver salvato le modifiche, avvia l'applicazione in Cloud Shell utilizzando il comando del file README.md, ma prima assicurati di trovarti nella directory di esempio corretta in Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE

Una volta che l'applicazione è in esecuzione, apri una nuova scheda di Cloud Shell e testa il servizio utilizzando 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 è tutto pronto per il deployment delle modifiche, crea il progetto in Cloud Shell utilizzando il comando pack. Questo comando utilizza Buildpacks per rilevare il tipo di progetto, compilarlo e creare l'artefatto di cui è possibile eseguire il deployment (un'immagine container 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

Ora che l'immagine container è stata creata, utilizza il comando docker (in Cloud Shell) per eseguire il push dell'immagine container in Google Container Registry in modo che possa essere accessibile da Cloud Run:

docker push gcr.io/$PROJECT_ID/$SAMPLE

Ora esegui il deployment della nuova versione su Cloud Run:

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

Ora l'arena utilizzerà la nuova versione.

6. Sviluppo locale (facoltativo)

Puoi lavorare al tuo progetto localmente utilizzando il tuo IDE seguendo questi passaggi:

  1. [In Cloud Shell] Comprimi l'esempio:
# 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. [In Cloud Shell] Scarica il file ZIP sulla tua macchina:
cloudshell download-file cloudbowl-sample.zip
  1. [Sul tuo computer] Decomprimi il file, quindi apporta e testa le modifiche
  2. [Sulla tua macchina] Installa gcloud CLI
  3. [Sulla tua macchina] Accedi a Google Cloud:
gcloud auth login
  1. [Sulla tua macchina] Imposta le variabili di ambiente PROJECT_ID e SAMPLE sugli stessi valori di Cloud Shell.
  2. [Sulla tua macchina] Utilizza Cloud Build per creare il container (dalla directory principale del progetto):
gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID
  1. [Sulla tua macchina] Esegui il deployment del nuovo contenitore:
gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. Distribuzione continua

Configura SCM

Configura GitHub per collaborare con il tuo team al microservizio:

  1. Accedi a GitHub
  2. Creare un nuovo repository
  3. Se lavori sulla tua macchina locale, puoi utilizzare l'interfaccia a riga di comando (CLI) di git o l'applicazione GUI GitHub Desktop (Windows o Mac). Se utilizzi Cloud Shell, devi utilizzare la CLI git. Per ottenere il codice del microservizio su GitHub, segui le istruzioni dell'interfaccia a riga di comando o di GitHub Desktop.

Eseguire il push del codice con git CLI

  1. Segui le istruzioni per git su HTTPS con un token di accesso personale
  2. Scegli l'ambito "repo"
  3. Configura 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. Imposta le variabili di ambiente per l'organizzazione e il repository GitHub (https://github.com/ORG/REPO)
export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO
  1. Esegui il push del codice nel nuovo repository
# 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. Dopo aver apportato le modifiche, puoi eseguirne il commit e il push su GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Eseguire il push del codice con GitHub Desktop

  1. Scarica il codice seguendo le istruzioni del lab precedente "Sviluppa in locale".
  2. Installa GitHub Desktop, avvialo e accedi.
  3. Clona il repository appena creato

cf7f38c7c86a91cd.png

  1. Apri Esplora file e copia il progetto nel nuovo repository.
  2. Esegui il commit delle modifiche

5f3c1552e30ad7c5.png

  1. Pubblica il ramo principale su GitHub

Configura il deployment continuo di Cloud Run

Con la configurazione SCM su GitHub, ora puoi configurare la distribuzione continua in modo che ogni volta che vengono inviati nuovi commit al ramo main, Cloud Build crei ed esegua automaticamente il deployment delle modifiche. Puoi anche aggiungere l'integrazione continua, che esegue i test prima del deployment, ma questo passaggio è stato lasciato come esercizio perché gli esempi predefiniti non contengono test.

  1. Nella console Google Cloud, vai al tuo servizio Cloud Run.
  2. Fai clic sul pulsante "CONFIGURA DEPLOYMENT CONTINUO".
  3. Autenticati con GitHub e seleziona il repository del tuo microservizio

a3b5692f178869bc.png

  1. Seleziona il tuo repository GitHub e imposta il branch su: ^main$

338f1c00f33d2f65.png

  1. Imposta il tipo di build per utilizzare Buildpacks
  2. Fai clic su Salva per configurare il deployment continuo.

8. Osservabilità

Le cose si rompono. L'osservabilità ci consente di sapere quando si verifica e di diagnosticare il motivo. Le metriche ci mostrano i dati relativi alla salute e all'utilizzo del nostro servizio. I log mostrano le informazioni strumentate manualmente emesse dal nostro servizio. Gli avvisi ci consentono di ricevere una notifica quando si verifica un problema. Esploriamoli uno alla volta.

Metriche

  1. Trova il tuo servizio nell'elenco dei servizi Cloud Run.
  2. Fai clic sul nome del servizio per visitare la dashboard delle metriche.

8491b8ec6bc5b4db.png

  1. Fai clic sul menu ⋮ di una metrica, poi seleziona "Visualizza in Esplora metriche".
  2. Ora puoi modificare le metriche, i filtri, il raggruppamento e altre opzioni delle risorse. Ad esempio, puoi visualizzare le latenze medie dei servizi per tutti i servizi:

f0d666d8f4221d45.png

Log

L'output STDOUT dei servizi viene inviato al sistema Google Cloud Logging. Puoi accedere a una visualizzazione di base dei log dalla pagina di amministrazione del servizio Cloud Run, ad esempio:

40058a82c9299cff.png

Nei log di Cloud Run puoi filtrare per gravità e filtrare i log. Per una maggiore flessibilità, fai clic su: 186fdb0e6d39a6ca.png

Avvisi

  1. Crea un URL di controllo dell'integrità per il tuo servizio.
  2. Per Spring Boot, aggiungi la seguente dipendenza:
org.springframework.boot:spring-boot-starter-actuator
  1. Crea o aggiorna src/main/resources/application.properties e disattiva il controllo dello spazio su disco:
management.health.diskspace.enabled=false
  1. Crea un avviso di uptime, specificando il protocollo, il nome host e il percorso. Per Spring Boot, il percorso è: /actuator/health
  2. Testare l'avviso

6948d13b263bf573.png

  1. Crea l'avviso

9. Complimenti

Congratulazioni, hai creato e implementato correttamente un microservizio che può competere con altri microservizi. In bocca al lupo!

Documenti di riferimento