Microservizio Rainbow Rumpus

1. Introduzione

Ultimo aggiornamento: 06/05/2021

Microservizio Rainbow Rumpus

Hai mai partecipato a una battaglia di palle di neve in cui ti muovi e lanci palle di neve agli altri? In caso contrario, provaci un giorno. Ora, invece di rischiare di ricevere una sberla, puoi creare un piccolo servizio accessibile tramite rete (un microservizio) che prenderà parte a una battaglia epica contro altri microservizi, lanciando arcobaleni anziché palle di neve.

Potresti chiederti… Ma come fa un microservizio a "lanciare" 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 corrente dell'arena, che risponde con un comando che specifica cosa fare.

Ovviamente l'obiettivo è vincere, ma lungo il percorso imparerai a creare e implementare microservizi su Google Cloud.

Come funziona

Dovrai creare un microservizio con la tecnologia che preferisci (o scegliere tra i comandi iniziali Go, Java, Kotlin, Scala, NodeJS o Python) ed eseguirlo su Google Cloud. Una volta eseguito il deployment, dovrai comunicarci l'URL del tuo microservizio, che aggiungeremo all'arena.

L'arena contiene tutti i giocatori di una determinata battaglia. Rainbow Rumpus avrà le sue arene. Ogni giocatore rappresenta un microservizio che si muove e lancia arcobaleni agli 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 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 percorrerà fino a tre caselle nella direzione in cui si trova 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 di giocatori attuali.

Ecco l'aspetto di un'arena passata:

20628e6bd442bd11.png

Esempio di arena Battle One

Conflitti ricorrenti

Nell'arena è possibile che più giocatori provino a 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 scoprire il rendimento del tuo microservizio nella battaglia, visita l'arena in tempo reale.

API Battle

Per poter lavorare con il nostro arena manager, il tuo microservizio dovrà implementare un'API specifica per partecipare all'arena. Il gestore dell'arena invierà lo stato attuale dell'arena in un POST HTTP 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 mossa successiva, codificata come un singolo carattere maiuscolo tra:

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 tuo 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 di 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 avere problemi in Safari.

3. Eseguire il deployment del microservizio

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

Scegli il tuo Sample per 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

Vai

Origine

Node.js ed Express

Origine

Python e Flask

Origine

Dopo aver deciso con quale sample iniziare, fai clic sul pulsante "Esegui il deployment in Cloud Run" qui sopra. Verrà avviato Cloud Shell (una console web per una macchina virtuale nel cloud) in cui verrà clonato il codice sorgente, poi verrà creato un pacchetto di deployment (un'immagine del container Docker), che verrà caricato in Google Container Registry e poi 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 compilazione e il deployment dei microservizi

d88e40430706a32b.png

Verificare il funzionamento del microservizio

In Cloud Shell puoi inviare una richiesta al microservizio appena disegnato, sostituendo YOUR_SERVICE_URL con l'URL del servizio (che si trova in Cloud Shell dopo la riga "La tua applicazione è ora disponibile qui"):

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 vedere 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, fai clic su Partecipa in un'arena in cui fornirai l'URL del tuo microservizio.

5. Apporta e esegui il deployment delle modifiche

Prima di poter apportare modifiche, devi configurare alcune informazioni in Cloud Shell sul progetto Google Cloud e sul Sample utilizzato. Per prima cosa 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 PROJECT_ID con il tuo ID progetto effettivo) per impostare una variabile di ambiente che utilizzeremo nei comandi successivi:YOUR_PROJECT_ID

export PROJECT_ID=YOUR_PROJECT_ID

Ora imposta un'altra variabile di ambiente per il sample che hai utilizzato in modo da poter specificare la directory e il nome del servizio corretti nei comandi successivi:

# 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 il codice sorgente del tuo microservizio da Cloud Shell. Per aprire l'editor basato su web di Cloud Shell, esegui questo comando:

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

Verranno visualizzate ulteriori istruzioni per apportare modifiche.

f910c9ef7b51c406.png

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

Dopo aver salvato le modifiche, avvia l'applicazione in Cloud Shell utilizzando il comando del file README.md, ma assicurati prima di essere 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 Buildpack per rilevare il tipo di progetto, compilarlo e creare l'elemento 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 del contenitore è stata creata, utilizza il comando docker (in Cloud Shell) per eseguirne il push in Google Container Registry in modo che Cloud Run possa accedervi:

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)

Per lavorare al progetto localmente utilizzando il tuo IDE, segui 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. [Sulla tua macchina] Decomprimere il file, apportare e testare 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 contenitore (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 in modo da poter 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 di GitHub Desktop (Windows o Mac). Se utilizzi Cloud Shell, dovrai utilizzare la CLI git. Per ottenere il codice del tuo microservizio su GitHub, segui le istruzioni per la CLI o GitHub Desktop.

Eseguire push del codice con l'interfaccia a riga di comando git

  1. Segui le istruzioni per utilizzare 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 eseguire il commit e il push delle modifiche 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 "Sviluppare localmente"
  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 del sistema di controllo dei flussi di lavoro su GitHub, ora puoi configurare la distribuzione continua in modo che ogni volta che vengono eseguiti push di nuovi commit nel ramo main, Cloud Build esegui automaticamente la compilazione e il deployment delle modifiche. Puoi anche aggiungere l'integrazione continua che esegue i test prima del deployment, ma questo passaggio è stato lasciato come esercizio per te poiché i sample out-of-the-box non contengono test.

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

a3b5692f178869bc.png

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

338f1c00f33d2f65.png

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

8. Osservabilità

Le cose si rompono. L'osservabilità ci consente di sapere quando si verificano questi problemi e di diagnosticarne il motivo. Le metriche ci mostrano dati sullo stato e sull'utilizzo del nostro servizio. I log mostrano le informazioni sottoposte a ispezione manuale emesse dal nostro servizio. Gli avvisi ci consentono di ricevere una notifica quando si verifica un problema. Esploriamoli nel dettaglio.

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, quindi 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 log di base dalla pagina di amministrazione del servizio Cloud Run, ad esempio:

40058a82c9299cff.png

Nei log di Cloud Run puoi filtrare in base alla gravità. 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 semplicemente 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. Verificare l'avviso

6948d13b263bf573.png

  1. Crea l'avviso

9. Complimenti

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

Documenti di riferimento