Mikroserwis Rainbow Rumpus

1. Wprowadzenie

Ostatnia aktualizacja: 2021-05-06

Mikroserwisy: tęczowy rozgardiasz

Czy zdarzyło Ci się kiedyś brać udział w bitwie na śnieżki, w której poruszasz się i rzucasz śnieżkami w inne osoby? Jeśli nie, wypróbuj ją kiedyś. Zamiast ryzykować fizyczne uderzenie, możesz teraz stworzyć małą usługę dostępną w sieci (mikroserwis), która weźmie udział w epickiej bitwie z innymi mikroserwisami, rzucając tęczami zamiast śnieżkami.

Może się zastanawiasz… Ale jak mikroserwis „rzuca” tęczę na inne mikroserwisy? Mikroserwis może odbierać żądania sieciowe (zwykle przez HTTP) i zwracać odpowiedzi. Istnieje „menedżer areny”, który wysyła do mikroserwisu bieżący stan areny, a mikroserwis odpowiada poleceniem określającym, co należy zrobić.

Oczywiście celem jest zwycięstwo, ale po drodze dowiesz się, jak tworzyć i wdrażać mikroserwisy w Google Cloud.

Jak to działa

Utworzysz mikroserwis w dowolnej technologii (możesz też wybrać jeden z projektów początkowych w Go, Javie, Kotlinie, Scali, NodeJS lub Pythonie), a następnie wdrożysz go w Google Cloud. Po wdrożeniu podaj nam adres URL mikroserwisu, a my dodamy go do areny.

Arena zawiera wszystkich graczy biorących udział w danej bitwie. Tęczowe rozróby będą miały własne areny. Każdy gracz reprezentuje mikrousługę, która porusza się i rzuca tęczami w innych graczy.

Menedżer areny będzie wywoływać Twój mikroserwis mniej więcej raz na sekundę, wysyłając bieżący stan areny (gdzie znajdują się gracze), a Twój mikroserwis będzie odpowiadać poleceniem, co należy zrobić. Na arenie możesz iść do przodu, skręcać w lewo lub w prawo albo rzucać tęczą. Tęcza może przemieścić się maksymalnie o 3 pola w kierunku, w którym jest zwrócony gracz. Jeśli tęcza „trafi” innego gracza, rzucający otrzymuje 1 punkt, a trafiony gracz traci 1 punkt. Rozmiar areny jest automatycznie dostosowywany do aktualnej liczby graczy.

Tak wyglądała arena w przeszłości:

20628e6bd442bd11.png

Przykładowa arena bitwy 1

Konflikty cykliczne

Na arenie może się zdarzyć, że kilku graczy będzie próbować wykonać sprzeczne działania. Na przykład dwóch graczy może próbować przesunąć się na to samo pole. W przypadku konfliktu wygrywa mikrousługa z najkrótszym czasem odpowiedzi.

Oglądanie bitwy

Aby zobaczyć, jak radzi sobie Twój mikroserwis, sprawdź arenę na żywo.

Battle API

Aby współpracować z naszym menedżerem areny, mikrousługa musi wdrożyć określony interfejs API, który umożliwi jej udział w arenie. Menedżer areny wyśle bieżący stan areny w żądaniu HTTP POST na podany przez Ciebie adres URL, używając tej struktury 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
    }
  }
}

Odpowiedź HTTP musi mieć kod stanu 200 (OK) i zawierać treść z kolejnym ruchem zakodowanym jako pojedynczy znak pisany wielką literą:

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

To już wszystko. Omówimy wdrażanie mikroserwisu w Cloud Run, usłudze Google Cloud do uruchamiania mikroserwisów i innych aplikacji.

2. Logowanie się w Google Cloud

Aby wdrożyć mikrousługę w Cloud Run, musisz zalogować się w Google Cloud. Dodamy środki do Twojego konta i nie będziesz musiał(-a) podawać danych karty kredytowej. Zwykle mniej problematyczne jest używanie konta osobistego (np. gmail.com) zamiast konta G Suite, ponieważ administratorzy G Suite czasami uniemożliwiają użytkownikom korzystanie z określonych funkcji Google Cloud. Konsola internetowa, której będziemy używać, powinna dobrze działać w Chrome i Firefoxie, ale może sprawiać problemy w Safari.

3. Wdrażanie mikroserwisu

Mikroserwis możesz utworzyć w dowolnej technologii i wdrożyć w dowolnym miejscu, o ile jest on publicznie dostępny i zgodny z interfejsem Battle API. Aby ułatwić Ci to zadanie, pomożemy Ci zacząć od przykładowej usługi i wdrożyć ją w Cloud Run.

Wybierz próbkę, od której chcesz zacząć

Możesz zacząć od wielu przykładowych mikrousług bitewnych:

Kotlin i Spring Boot

Źródło

Kotlin i Micronaut

Źródło

Kotlin i Quarkus

Źródło

Java i Spring Boot

Źródło

Java i Quarkus

Źródło

Go

Źródło

Node.js i Express

Źródło

Python i Flask

Źródło

Gdy zdecydujesz, od którego przykładu chcesz zacząć, kliknij powyżej przycisk „Wdróż w Cloud Run”. Spowoduje to uruchomienie Cloud Shell (konsoli internetowej na maszynie wirtualnej w chmurze), w której zostanie sklonowane źródło, a następnie skompilowane w pakiet do wdrożenia (obraz kontenera Dockera), który zostanie przesłany do Google Container Registry, a następnie wdrożony w Cloud Run.

Gdy pojawi się prośba, podaj region us-central1.

Na zrzucie ekranu poniżej widać dane wyjściowe Cloud Shell dotyczące kompilacji i wdrażania mikroserwisu

d88e40430706a32b.png

Sprawdzanie działania mikroserwisu

W Cloud Shell możesz wysłać żądanie do nowo wdrożonej mikroserwisu, zastępując YOUR_SERVICE_URL adresem URL usługi (który znajduje się w Cloud Shell po wierszu „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

Powinien pojawić się ciąg znaków odpowiedzi F, L, R lub T.

4. Prośba o uwzględnienie w Arenie

Aby dołączyć do Rainbow Rumpus, musisz wejść na arenę. Otwórz rainbowrumpus.dev i kliknij „Dołącz” w arenie, w której podasz adres URL mikrousługi.

5. Wprowadzanie i wdrażanie zmian

Zanim wprowadzisz zmiany, musisz skonfigurować w Cloud Shell informacje o projekcie GCP i użytej próbce. Najpierw wyświetl listę projektów GCP:

gcloud projects list

Prawdopodobnie masz tylko 1 projekt. Skopiuj PROJECT_ID z pierwszej kolumny i wklej go do tego polecenia (zastępując YOUR_PROJECT_ID identyfikatorem projektu), aby ustawić zmienną środowiskową, której będziemy używać w późniejszych poleceniach:

export PROJECT_ID=YOUR_PROJECT_ID

Teraz ustaw kolejną zmienną środowiskową dla użytego przykładu, aby w późniejszych poleceniach można było określić prawidłowy katalog i nazwę usługi:

# 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

Teraz możesz edytować źródło mikrousługi w Cloud Shell. Aby otworzyć edytor internetowy Cloud Shell, uruchom to polecenie:

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

Następnie zobaczysz dalsze instrukcje dotyczące wprowadzania zmian.

f910c9ef7b51c406.png

Cloud Shell z otwartym edytorem i przykładowym projektem

Po zapisaniu zmian uruchom aplikację w Cloud Shell za pomocą polecenia z pliku README.md. Najpierw jednak upewnij się, że w Cloud Shell znajdujesz się w odpowiednim katalogu z próbkami:

cd cloudbowl-microservice-game/samples/$SAMPLE

Gdy aplikacja będzie działać, otwórz nową kartę Cloud Shell i przetestuj usługę za pomocą polecenia 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

Gdy zechcesz wdrożyć zmiany, skompiluj projekt w Cloud Shell za pomocą polecenia pack. To polecenie używa pakietów Buildpacks do wykrywania typu projektu, kompilowania go i tworzenia artefaktu do wdrożenia (obrazu kontenera Dockera).

# 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

Po utworzeniu obrazu kontenera użyj polecenia docker (w Cloud Shell), aby przenieść obraz kontenera do Google Container Registry, tak aby można było uzyskać do niego dostęp z Cloud Run:

docker push gcr.io/$PROJECT_ID/$SAMPLE

Teraz wdróż nową wersję w Cloud Run:

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

Teraz arena będzie używać nowej wersji.

6. Opracowywanie lokalne (opcjonalnie)

Aby pracować nad projektem lokalnie w swoim środowisku IDE, wykonaj te czynności:

  1. [W Cloud Shell] Spakuj próbkę:
# 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. [W Cloud Shell] Pobierz plik ZIP na komputer:
cloudshell download-file cloudbowl-sample.zip
  1. [Na komputerze] Rozpakuj plik, a następnie wprowadź i przetestuj zmiany.
  2. [Na komputerze] Zainstaluj gcloud CLI
  3. [Na komputerze] Zaloguj się w Google Cloud:
gcloud auth login
  1. [Na swoim komputerze] Ustaw zmienne środowiskowe PROJECT_ID i SAMPLE na te same wartości co w Cloud Shell.
  2. [Na komputerze] Użyj Cloud Build, aby utworzyć kontener (z głównego katalogu projektu):
gcloud alpha builds submit . \
  --pack=image=gcr.io/$PROJECT_ID/$SAMPLE \
  --project=$PROJECT_ID
  1. [Na komputerze] Wdróż nowy kontener:
gcloud run deploy $SAMPLE \
  --project=$PROJECT_ID \
  --platform=managed \
  --region=us-central1 \
  --image=gcr.io/$PROJECT_ID/$SAMPLE \
  --allow-unauthenticated

7. Tryb ciągłego dostarczania

Konfigurowanie SCM

Skonfiguruj GitHub, aby móc współpracować z zespołem nad mikrousługą:

  1. Zaloguj się w GitHubie
  2. Tworzenie nowego repozytorium
  3. Jeśli pracujesz na komputerze lokalnym, możesz użyć interfejsu wiersza poleceń Git lub aplikacji GitHub Desktop GUI (Windows lub Mac). Jeśli używasz Cloud Shell, musisz użyć interfejsu git CLI. Aby uzyskać kod mikroserwisu w GitHubie, postępuj zgodnie z instrukcjami dotyczącymi interfejsu wiersza poleceń lub GitHub Desktop.

Przesyłanie kodu za pomocą interfejsu wiersza poleceń Git

  1. Postępuj zgodnie z instrukcjami dotyczącymi używania Gita przez HTTPS z osobistym tokenem dostępu.
  2. Wybierz zakres „repo”.
  3. Skonfiguruj 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. Ustaw zmienne środowiskowe dla organizacji i repozytorium GitHub (https://github.com/ORG/REPO).
export GITHUB_ORG=YOUR_GITHUB_ORG
export GITHUB_REPO=YOUR_GITHUB_REPO
  1. Wypchnij kod do nowego repozytorium
# 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. Po wprowadzeniu zmian możesz je zatwierdzić i przesłać do GitHuba:
git add .
git status
git diff --staged
git commit -am "my changes"
git push

Przenoszenie kodu za pomocą aplikacji GitHub Desktop

  1. Pobierz kod, postępując zgodnie z instrukcjami z poprzedniego modułu „Tworzenie aplikacji lokalnie”.
  2. Zainstaluj GitHub Desktop, uruchom go i zaloguj się.
  3. Klonowanie nowo utworzonego repozytorium

cf7f38c7c86a91cd.png

  1. Otwórz eksplorator plików i skopiuj projekt do nowego repozytorium.
  2. Zatwierdzanie zmian

5f3c1552e30ad7c5.png

  1. Opublikuj gałąź główną w GitHubie

Konfigurowanie ciągłego wdrażania Cloud Run

Po skonfigurowaniu systemu SCM w GitHubie możesz skonfigurować ciągłe dostarczanie, aby za każdym razem, gdy nowe zatwierdzenia są przenoszone do gałęzi main, Cloud Build automatycznie kompilował i wdrażał zmiany. Możesz też dodać tryb ciągłej integracji, który uruchamia testy przed wdrożeniem, ale ten krok został pominięty, ponieważ gotowe przykłady nie zawierają żadnych testów.

  1. W konsoli Cloud otwórz usługę Cloud Run.
  2. Kliknij przycisk „SKONFIGURUJ CIĄGŁE WDRAŻANIE”.
  3. Uwierzytelnianie w GitHub i wybieranie repozytorium mikrousługi

a3b5692f178869bc.png

  1. Wybierz repozytorium GitHub i ustaw gałąź na: ^main$

338f1c00f33d2f65.png

  1. Ustaw typ kompilacji na „Użyj pakietów kompilacji”
  2. Aby skonfigurować ciągłe wdrażanie, kliknij Zapisz.

8. Dostrzegalność

Rzeczy się psują. Obserwacja pozwala nam wykrywać takie sytuacje i diagnozować ich przyczyny. Dane pokazują nam informacje o stanie i sposobie korzystania z naszej usługi. Logi zawierają informacje o usłudze, które zostały dodane ręcznie. Alerty pozwalają nam otrzymywać powiadomienia, gdy coś pójdzie nie tak. Przyjrzyjmy się bliżej każdemu z tych typów.

Dane

  1. Znajdź usługę na liście usług Cloud Run.
  2. Kliknij nazwę usługi, aby przejść do panelu wskaźników.

8491b8ec6bc5b4db.png

  1. Kliknij menu ⋮ danych, a potem wybierz „Wyświetl w narzędziu Metrics Explorer”.
  2. Możesz teraz zmieniać dane zasobów, filtry, grupowanie i inne opcje. Możesz na przykład wyświetlić średnie opóźnienia usług dla wszystkich usług:

f0d666d8f4221d45.png

Logi

Dane wyjściowe STDOUT z usług są wysyłane do systemu Google Cloud Logging. Podstawowy widok logów możesz otworzyć na stronie administracyjnej usługi Cloud Run, np.:

40058a82c9299cff.png

W logach Cloud Run możesz filtrować logi według poziomu ważności. Aby uzyskać większą elastyczność, kliknij: 186fdb0e6d39a6ca.png

Alerty

  1. Utwórz adres URL testu stanu usługi.
  2. W przypadku Spring Boot wystarczy dodać tę zależność:
org.springframework.boot:spring-boot-starter-actuator
  1. Utwórz lub zaktualizuj plik src/main/resources/application.properties i wyłącz sprawdzanie miejsca na dysku:
management.health.diskspace.enabled=false
  1. Utwórz alert dotyczący dostępności, podając protokół, nazwę hosta i ścieżkę. W przypadku Spring Boot ścieżka to: /actuator/health
  2. Testowanie alertu

6948d13b263bf573.png

  1. Tworzenie alertu

9. Gratulacje

Gratulacje, udało Ci się utworzyć i wdrożyć mikroserwis, który może walczyć z innymi mikroserwisami. Powodzenia!

Dokumentacja