Microservizio Rainbow Rumpus

1. Introduzione

Ultimo aggiornamento: 2021-05-06

Rimpus arcobaleno a microservizi

Hai mai partecipato a una battaglia a palle di neve in cui ti sposti e lanci scherzosamente palle di neve agli altri? Altrimenti, prova un giorno o l'altro! Ma ora, invece di rischiare di essere schiacciati fisicamente, puoi creare un piccolo servizio accessibile in rete (un microservizio) che prenderà parte a un'epica battaglia contro altri microservizi, lanciando arcobaleni invece di palle di neve.

Forse ti starai chiedendo... Ma come fa un microservizio "lancia" un arcobaleno ad altri microservizi? Un microservizio può ricevere richieste di rete (di solito tramite HTTP) e restituire risposte. C'è un "gestore dell'arena" che invierà al microservizio lo stato attuale dell'arena, dopodiché risponderà con un comando che specifica cosa fare.

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

Come funziona

Dovrai creare un microservizio con qualsiasi tecnologia tu voglia (o scegliere tra i comandi iniziali Go, Java, Kotlin, Scala, NodeJS o Python) e quindi eseguire il deployment del microservizio su Google Cloud. Una volta eseguito il deployment, dovrai comunicarci l'URL del microservizio e poi lo aggiungeremo all'arena.

L'arena contiene tutti i giocatori di una data battaglia. Il Rumpus arcobaleno avrà le proprie 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 microservizio, inviando l'attuale stato dell'arena (dove si trovano i giocatori) e il microservizio risponderà con un comando indicando cosa fare. Nell'arena puoi avanzare, girare a sinistra o destra o lanciare un arcobaleno. L'arcobaleno si sposterà fino a tre spazi nella direzione in cui il giocatore è rivolto. Se l'arcobaleno "colpisce" un altro giocatore, il lanciatore ottiene un punto e il giocatore vittima perde un punto. Le dimensioni dello stadio vengono adattate automaticamente in base al numero corrente di giocatori.

Ecco come si presenta un'arena del passato:

20628e6bd442bd11.png

arena di esempio Battle One

Conflitti rotanti

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 vedere come sta andando il tuo microservizio durante la battaglia, visita l'arena.

API Battle

Per collaborare con il nostro gestore dell'arena, il microservizio dovrà implementare un'API specifica per partecipare all'arena. Il gestore dell'arena invierà lo stato corrente dell'arena in un POST HTTP all'URL che ci hai fornito, 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 essere il codice di stato 200 (OK) con un corpo della risposta contenente la mossa successiva, codificato come un solo carattere maiuscolo di:

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

E con questo è tutto! Esaminiamo in dettaglio 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. Di solito è meno problematico utilizzare un account personale (ad es. gmail.com) invece di 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 al meglio con Chrome o Firefox, ma potrebbe presentare problemi in Safari.

3. Deployment del microservizio

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

Scegli il tuo Sample con cui iniziare

Puoi iniziare da diversi campioni di microservizi di battaglia:

Kotlin e Stivale a molla

Origine

Kotlin e Micronaut

Origine

Kotlin e Quarkus

Origine

Java e Stivale a molla

Origine

Java e Quarkus

Origine

Vai

Origine

Node.js e Espressa

Origine

Python e Fiaschetta

Origine

Dopo aver deciso con quale esempio iniziare, fai clic sul pulsante "Deploy on Cloud Run" pulsante qui sopra. Verrà avviato Cloud Shell (una console basata sul web in una macchina virtuale nel cloud) in cui l'origine verrà clonata e creata in un pacchetto di cui è possibile eseguire il deployment (un'immagine container Docker), che verrà poi caricato in Google Container Registry e sottoposto a deployment in Cloud Run.

Quando richiesto, specifica la regione us-central1.

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

d88e40430706a32b.png

Verifica che il microservizio funzioni

In Cloud Shell puoi inviare una richiesta al microservizio di cui hai appena eseguito il deployment, sostituendo YOUR_SERVICE_URL con l'URL del tuo servizio (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 vedere la stringa di risposta F, L, R o T.

4. Richiedi l'inclusione nell'arena

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

5. Crea e Esegui il deployment delle modifiche

Prima di poter apportare modifiche, devi configurare alcune informazioni in Cloud Shell sul progetto Google Cloud e sull'esempio che hai utilizzato. Per prima cosa, elenca i tuoi progetti Google Cloud:

gcloud projects list

Probabilmente hai un solo progetto. Copia il valore PROJECT_ID dalla prima colonna e incollalo nel comando seguente (sostituendo YOUR_PROJECT_ID con il tuo 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 potremo 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 microservizio da Cloud Shell. Per aprire l'editor basato sul 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 assicurati innanzitutto di trovarti nella directory di esempio corretta in Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE

Quando 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 eseguire il deployment delle modifiche, crea il tuo 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 al Container Registry di Google in modo che sia 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 tua nuova versione!

6. Sviluppo locale (facoltativo)

Per lavorare al tuo progetto localmente nel 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. [Sul computer] Decomprimi il file, quindi crea e testa le modifiche
  2. [Sul tuo computer] Installa gcloud CLI
  3. [Sul tuo computer] Accedi a Google Cloud:
gcloud auth login
  1. [Sulla macchina] Imposta le variabili di ambiente PROJECT_ID e SAMPLE sugli stessi valori di Cloud Shell.
  2. [Sulla macchina] Usa 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. [Sul tuo computer] Esegui il deployment del nuovo container:
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 poter collaborare con il tuo team sul microservizio:

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

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

  1. Segui git su https con le istruzioni per un token di accesso personale
  2. Scegli "repository" ambito
  3. Git di configurazione:
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 env 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 delle modifiche ed eseguirne il push su GitHub:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Esegui il push del codice con GitHub desktop

  1. Scarica il codice seguendo le istruzioni nella precedente sezione "Sviluppo locale" laboratorio
  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 di SCM su GitHub, ora puoi configurare la distribuzione continua in modo che, ogni volta che viene eseguito il push di nuovi commit al ramo main, Cloud Build crei e sottoporrà automaticamente le modifiche a deployment. Puoi anche aggiungere l'integrazione continua, che esegue i test prima del deployment, ma questo passaggio è stato lasciato come esercizio perché gli esempi pronti all'uso non contengono test.

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

a3b5692f178869bc.png

  1. Seleziona il tuo repository GitHub e imposta il ramo 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à

Si rompono le cose. L'osservabilità ci permette di sapere quando succede e di diagnosticare il motivo. Le metriche mostrano dati sull'integrità e sull'utilizzo del nostro servizio. I log mostrano le informazioni strumentate manualmente emesse dal nostro servizio. Gli avvisi ci permettono di essere avvisati quando si verifica un problema. Vediamoli più a fondo.

Metriche

  1. Individua il tuo servizio nell'elenco di servizi Cloud Run
  2. Fai clic sul nome del tuo servizio per visitare la relativa 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 delle risorse, i filtri, i raggruppamenti e altre opzioni. 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 del log di base dalla pagina dell'amministratore del servizio Cloud Run, ad esempio:

40058a82c9299cff.png

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

Avvisi

  1. Crea un URL per il 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 disabilita il controllo dello spazio su disco:
management.health.diskspace.enabled=false
  1. Crea un avviso di uptime specificando protocollo, nome host e percorso. Per l'avvio a molla il percorso è: /actuator/health
  2. Testa l'avviso

6948d13b263bf573.png

  1. Crea l'avviso

9. Complimenti

Complimenti, hai creato ed eseguito correttamente il deployment di un microservizio in grado di funzionare con altri microservizi. In bocca al lupo!

Documenti di riferimento