Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Mikrodienst „Rainbow Rumpus“

1. Einführung

Zuletzt aktualisiert: 06.05.2021

Mikrodienst Rainbow Rumpus

Hast du schon mal eine Schneeballschlacht erlebt, bei der du dich bewegt und spielerisch Schneebälle auf andere geworfen hast? Wenn nicht, probieren Sie es doch einmal aus. Statt sich nun aber körperlich zu prügeln, können Sie einen kleinen, über das Netzwerk zugänglichen Dienst (einen Mikrodienst) entwickeln, der an einem epischen Kampf gegen andere Mikrodienste teilnimmt und Regenbögen anstelle von Schneebällen wirft.

Sie fragen sich vielleicht: Aber wie „wirft“ ein Mikrodienst einen Regenbogen auf andere Mikrodienste? Ein Mikrodienst kann Netzwerkanfragen (in der Regel über HTTP) empfangen und Antworten zurückgeben. Es gibt einen „Arena-Manager“, der Ihrem Mikrodienst den aktuellen Zustand der Arena sendet. Ihr Mikrodienst antwortet dann mit einem Befehl, der angibt, was zu tun ist.

Natürlich ist das Ziel, zu gewinnen, aber auf dem Weg dorthin lernen Sie, wie Sie Mikrodienste in Google Cloud erstellen und bereitstellen.

Funktionsweise

Sie erstellen einen Mikrodienst mit einer beliebigen Technologie (oder wählen aus den Startern für Go, Java, Kotlin, Scala, NodeJS oder Python) und stellen ihn dann in Google Cloud bereit. Sobald der Mikrodienst bereitgestellt wurde, teilen Sie uns die URL mit und wir fügen ihn der Arena hinzu.

Die Arena enthält alle Spieler für einen bestimmten Kampf. Das Rainbow Rumpus hat eigene Arenen. Jeder Spieler stellt einen Mikrodienst dar, der sich bewegt und Regenbögen auf die anderen Spieler wirft.

Etwa einmal pro Sekunde ruft unser Arenamanager Ihren Mikrodienst auf und sendet den aktuellen Arenazustand (wo sich die Spieler befinden). Ihr Mikrodienst antwortet mit einem Befehl, was zu tun ist. In der Arena können Sie sich vorwärts bewegen, nach links oder rechts drehen oder einen Regenbogen werfen. Ein Regenbogen bewegt sich bis zu drei Felder in die Richtung, in die der Spieler blickt. Wenn der Regenbogen einen anderen Spieler „trifft“, erhält der Werfer einen Punkt und der getroffene Spieler verliert einen Punkt. Die Größe der Arena wird automatisch an die aktuelle Anzahl der Spieler angepasst.

So sieht eine vergangene Arena aus:

Beispiel für eine Battle One-Arena

Wiederkehrende Konflikte

In der Arena kann es vorkommen, dass mehrere Spieler versuchen, widersprüchliche Aktionen auszuführen. Beispielsweise könnten zwei Spieler versuchen, sich auf dasselbe Feld zu bewegen. Im Falle eines Konflikts gewinnt der Microservice mit der schnellsten Reaktionszeit.

Battle ansehen

Hier geht es zur Live-Arena, wo Sie sehen können, wie sich Ihr Mikrodienst im Wettbewerb schlägt.

Battle API

Damit Ihr Mikrodienst mit unserem Arenamanager zusammenarbeiten kann, muss er eine bestimmte API implementieren, um an der Arena teilzunehmen. Der Arenamanager sendet den aktuellen Arenazustand in einem HTTP-POST an die von Ihnen angegebene URL mit der folgenden JSON-Struktur:

{
  "_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
    }
  }
}

Ihre HTTP-Antwort muss den Statuscode 200 (OK) haben und einen Antworttext enthalten, der Ihren nächsten Zug als einzelnen Großbuchstaben codiert:

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

Das ist keine Kunst! Wir sehen uns jetzt an, wie Sie einen Mikrodienst in Cloud Run bereitstellen, einem Google Cloud-Dienst zum Ausführen von Mikrodiensten und anderen Anwendungen.

2. In Google Cloud anmelden

Damit Sie Ihren Mikrodienst in Cloud Run bereitstellen können, müssen Sie sich in Google Cloud anmelden. Wir schreiben Ihrem Konto ein Guthaben gut und Sie müssen keine Kreditkarte eingeben. Es ist in der Regel weniger problematisch, ein privates Konto (z.B. gmail.com) anstelle eines G Suite-Kontos zu verwenden, da G Suite-Administratoren ihre Nutzer manchmal daran hindern, bestimmte Google Cloud-Funktionen zu verwenden. Außerdem sollte die Webkonsole, die wir verwenden, in Chrome oder Firefox gut funktionieren, in Safari kann es jedoch zu Problemen kommen.

3. Mikrodienst bereitstellen

Sie können Ihren Mikrodienst mit jeder beliebigen Technologie erstellen und überall bereitstellen, solange er öffentlich erreichbar ist und der Battle API entspricht. Um Ihnen den Einstieg zu erleichtern, helfen wir Ihnen, mit einem Beispieldienst zu beginnen und ihn in Cloud Run bereitzustellen.

Wählen Sie eine Probe aus, mit der Sie beginnen möchten

Es gibt zahlreiche Beispiele für Battle-Mikrodienste, die Sie als Ausgangspunkt verwenden können:

Kotlin und Spring Boot	Quelle
Kotlin und Micronaut	Quelle
Kotlin und Quarkus	Quelle
Java und Spring Boot	Quelle
Java und Quarkus	Quelle
Ok	Quelle
Node.js und Express	Quelle
Python und Flask	Quelle

Nachdem Sie sich für ein Beispiel entschieden haben, klicken Sie oben auf die Schaltfläche „In Cloud Run bereitstellen“. Dadurch wird Cloud Shell gestartet, eine webbasierte Konsole für eine virtuelle Maschine in der Cloud. Dort wird die Quelle geklont und dann in ein bereitstellbares Paket (ein Docker-Container-Image) umgewandelt, das in Google Container Registry hochgeladen und dann in Cloud Run bereitgestellt wird.

Geben Sie auf Aufforderung die Region us-central1 an.

Der Screenshot unten zeigt die Cloud Shell-Ausgabe für das Erstellen und Bereitstellen von Mikrodiensten.

Funktionsweise des Mikrodienstes prüfen

In Cloud Shell können Sie eine Anfrage an den neu bereitgestellten Microservice senden. Ersetzen Sie dazu YOUR_SERVICE_URL durch die URL für Ihren Dienst (die in Cloud Shell nach der Zeile „Your application is now live here“ angezeigt wird):

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

Sie sollten den Antwortstring F, L, R oder T sehen.

4. Aufnahme in die Arena beantragen

Um am Rainbow Rumpus teilzunehmen, musst du einer Arena beitreten. Öffnen Sie rainbowrumpus.dev und klicken Sie auf „Join“ (Beitreten) in einer Arena, in der Sie die URL Ihres Mikrodienstes angeben.

5. Änderungen vornehmen und bereitstellen

Bevor Sie Änderungen vornehmen können, müssen Sie in Cloud Shell einige Informationen zum GCP-Projekt und zum verwendeten Beispiel einrichten. Listen Sie zuerst Ihre GCP-Projekte auf:

gcloud projects list

Sie haben wahrscheinlich nur ein Projekt. Kopieren Sie die PROJECT_ID aus der ersten Spalte und fügen Sie sie in den folgenden Befehl ein. Ersetzen Sie dabei YOUR_PROJECT_ID durch Ihre tatsächliche Projekt-ID, um eine Umgebungsvariable festzulegen, die wir in späteren Befehlen verwenden werden:

export PROJECT_ID=YOUR_PROJECT_ID

Legen Sie nun eine weitere Umgebungsvariable für das verwendete Beispiel fest, damit wir in späteren Befehlen das richtige Verzeichnis und den richtigen Dienstnamen angeben können:

# 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

Jetzt können Sie den Quellcode für Ihren Mikrodienst in Cloud Shell bearbeiten. Führen Sie den folgenden Befehl aus, um den webbasierten Cloud Shell-Editor zu öffnen:

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

Sie sehen dann weitere Anleitungen zum Vornehmen von Änderungen.

Cloud Shell mit dem Editor und dem geöffneten Beispielprojekt

Nachdem Sie die Änderungen gespeichert haben, starten Sie die Anwendung in Cloud Shell mit dem Befehl aus der Datei README.md. Achten Sie aber zuerst darauf, dass Sie sich in Cloud Shell im richtigen Beispielverzeichnis befinden:

cd cloudbowl-microservice-game/samples/$SAMPLE

Sobald die Anwendung ausgeführt wird, öffnen Sie einen neuen Cloud Shell-Tab und testen Sie den Dienst mit 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

Wenn Sie bereit sind, Ihre Änderungen bereitzustellen, erstellen Sie Ihr Projekt in Cloud Shell mit dem Befehl pack. Mit diesem Befehl werden Buildpacks verwendet, um den Projekttyp zu erkennen, das Projekt zu kompilieren und das bereitstellbare Artefakt (ein Docker-Container-Image) zu erstellen.

# 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

Nachdem Ihr Container-Image erstellt wurde, können Sie es mit dem Docker-Befehl (in Cloud Shell) in die Google Container Registry übertragen, damit Cloud Run darauf zugreifen kann:

docker push gcr.io/$PROJECT_ID/$SAMPLE

Stellen Sie die neue Version jetzt in Cloud Run bereit:

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

Jetzt wird in der Arena Ihre neue Version verwendet.

6. Lokal entwickeln (optional)

So können Sie lokal mit Ihrer eigenen IDE an Ihrem Projekt arbeiten:

[In Cloud Shell] Zip the sample:

# 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

[In Cloud Shell] Laden Sie die ZIP-Datei auf Ihren Computer herunter:

cloudshell download-file cloudbowl-sample.zip

[Auf Ihrem Computer] Datei entpacken und Änderungen vornehmen und testen
[Auf Ihrem Computer] gcloud CLI installieren
[Auf Ihrem Computer] In Google Cloud anmelden:

gcloud auth login

[Auf Ihrem Computer] Legen Sie die Umgebungsvariablen PROJECT_ID und SAMPLE auf dieselben Werte wie in Cloud Shell fest.
[Auf Ihrem Computer] Verwenden Sie Cloud Build, um den Container zu erstellen (aus dem Stammverzeichnis des Projekts):

gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID

[Auf Ihrem Computer] Stellen Sie den neuen Container bereit:

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

7. Continuous Delivery

SCM einrichten

Richten Sie GitHub ein, damit Sie mit Ihrem Team an Ihrem Microservice zusammenarbeiten können:

Bei GitHub anmelden
Neues Repository erstellen
Wenn Sie auf Ihrem lokalen Computer arbeiten, können Sie entweder die Git-Befehlszeilenschnittstelle (CLI) oder die GitHub Desktop-GUI-Anwendung (Windows oder Mac) verwenden. Wenn Sie Cloud Shell verwenden, müssen Sie die git-Befehlszeile verwenden. Wenn Sie den Code Ihres Microservice auf GitHub abrufen möchten, folgen Sie der Anleitung für die CLI oder GitHub Desktop.

Code mit der Git-Befehlszeile übertragen

Folgen Sie der Anleitung für Git über HTTPS mit einem persönlichen Zugriffstoken.
Wählen Sie den Bereich „repo“ aus.
Git einrichten:

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"

Umgebungsvariablen für die GitHub-Organisation und das Repository festlegen (https://github.com/ORG/REPO)

export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO

Code per Push in das neue Repository übertragen

# 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

Nachdem Sie Änderungen vorgenommen haben, können Sie sie per Commit und Push an GitHub übertragen:

git add .
git status
git diff --staged
git commit -am "my changes"
git push

Code mit GitHub Desktop übertragen

Laden Sie Ihren Code gemäß der Anleitung aus dem vorherigen Lab „Lokal entwickeln“ herunter.
GitHub Desktop installieren, starten und anmelden
Neu erstelltes Repository klonen

Öffnen Sie den Datei-Explorer und kopieren Sie Ihr Projekt in das neue Repository.
Änderungen per Commit durchführen

Hauptzweig auf GitHub veröffentlichen

Kontinuierliche Bereitstellung für Cloud Run einrichten

Nachdem Sie Ihr SCM in GitHub eingerichtet haben, können Sie Continuous Delivery einrichten. Jedes Mal, wenn neue Commits in den main-Branch übertragen werden, erstellt und stellt Cloud Build die Änderungen automatisch bereit. Sie können auch Continuous Integration hinzufügen, um Ihre Tests vor der Bereitstellung auszuführen. Dieser Schritt wurde jedoch als Übung für Sie ausgelassen, da die sofort einsatzbereiten Beispiele keine Tests enthalten.

Rufen Sie in der Cloud Console Ihren Cloud Run-Dienst auf.
Klicken Sie auf die Schaltfläche „KONTINUIERLICHE BEREITSTELLUNG EINRICHTEN“.
Mit GitHub authentifizieren und das Repository Ihres Microservice auswählen

Wählen Sie Ihr GitHub-Repository aus und legen Sie den Zweig auf ^main$ fest.

Build-Typ für die Verwendung von Buildpacks festlegen
Klicken Sie auf „Speichern“, um die kontinuierliche Bereitstellung einzurichten.

8. Beobachtbarkeit

Es geht etwas kaputt. Dank Observability können wir feststellen, wann das passiert, und die Ursache diagnostizieren. Messwerte liefern uns Daten zur Funktionsfähigkeit und Nutzung unseres Dienstes. In den Logs sehen wir die manuell instrumentierten Informationen, die von unserem Dienst ausgegeben werden. Mithilfe von Benachrichtigungen werden wir informiert, wenn etwas schiefgeht. Sehen wir uns die einzelnen Punkte genauer an.

Messwerte

Suchen Sie Ihren Dienst in der Liste der Cloud Run-Dienste.
Klicken Sie auf den Namen Ihres Dienstes, um das Messwert-Dashboard aufzurufen.

Klicken Sie auf das Dreipunkt-Menü eines Messwerts und wählen Sie „Im Metrics Explorer ansehen“ aus.
Sie können jetzt Ressourcenmesswerte, Filter, Gruppierungen und andere Optionen ändern. Sie können beispielsweise die durchschnittlichen Dienstlatenzen für alle Dienste ansehen:

Logs

Die STDOUT-Ausgabe von Diensten wird an das Google Cloud Logging-System gesendet. Sie können über die Admin-Seite des Cloud Run-Dienstes auf eine einfache Logansicht zugreifen, z. B.:

In den Cloud Run-Logs können Sie nach Schweregrad filtern und die Logs filtern. Für mehr Flexibilität klicken Sie auf:

Benachrichtigungen

Erstellen Sie eine Healthcheck-URL für Ihren Dienst.
Fügen Sie für Spring Boot einfach die folgende Abhängigkeit hinzu:

org.springframework.boot:spring-boot-starter-actuator

Erstellen oder aktualisieren Sie die src/main/resources/application.properties und deaktivieren Sie die Überprüfung des Speicherplatzes:

management.health.diskspace.enabled=false

Erstellen Sie eine Verfügbarkeitswarnung und geben Sie das Protokoll, den Hostnamen und den Pfad an. In Spring Boot lautet der Pfad: /actuator/health
Benachrichtigung testen

Benachrichtigung erstellen

9. Glückwunsch

Herzlichen Glückwunsch! Sie haben erfolgreich einen Mikrodienst erstellt und bereitgestellt, der sich mit anderen Mikrodiensten messen kann. Viel Erfolg!

Referenzdokumente

Cloud Run-Dokumentation