Battle One – mikroserwisowe pole bitwy

1. Wprowadzenie

Ostatnia aktualizacja: 26.08.2020

Microservices Battle Arena

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 jednak ryzykować fizyczne uderzenie, możesz utworzyć małą usługę dostępną w sieci (mikroserwis), która weźmie udział w epickiej bitwie z innymi mikroserwisami. A ponieważ bitwa mikroserwisów odbędzie się na konferencji SpringOne, nasze mikroserwisy będą rzucać liśćmi zamiast śnieżkami.

Może się zastanawiasz… Ale jak mikroserwis „zgłasza” liść w 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 przy użyciu dowolnej technologii (lub wybierzesz jeden z projektów startowych w języku Java, Kotlin lub Scala), a następnie wdrożysz go w Google Cloud. Po wdrożeniu wypełnij formularz, aby podać adres URL mikrousługi. Następnie dodamy ją do areny.

Arena zawiera wszystkich graczy biorących udział w danej bitwie. Konferencja SpringOne będzie miała własną arenę. Każdy gracz reprezentuje mikrousługę, która porusza się i rzuca liśćmi 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ć liściem. Rzucony liść może przebyć maksymalnie 3 pola w kierunku, w którym jest zwrócony gracz. Jeśli liść „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:

Przykładowa arena bitwy 1

Konflikty cykliczne

Na arenie może się zdarzyć, że kilku graczy będzie próbowało wykonać sprzeczne działania. Na przykład 2 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 Twoim następnym 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 2 przykładowych mikrousług bitewnych:

Java i Spring Boot	Źródło	Wdróż w Cloud Run
Kotlin i Spring Boot	Źródło	Wdróż w Cloud Run

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

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 F, L, R lub T.

4. Prośba o dołączenie do Areny

Aby wziąć udział w tym wydarzeniu, musisz wysłać wiadomość na kanał Slack #3-sponsor-google-cloud, podając swoje imię i nazwisko, adres URL usługi Cloud Run i opcjonalnie nazwę użytkownika GitHub, która będzie używana jako awatar lub zdjęcie profilowe. Gdy zweryfikujemy informacje, Twój zawodnik pojawi się na arenie.

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=java-springboot
export SAMPLE=kotlin-springboot

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.

Cloud Shell z otwartym edytorem i przykładowym projektem

Po zapisaniu zmian uruchom aplikację w Cloud Shell:

cd cloudbowl-microservice-game/samples/$SAMPLE
./mvnw spring-boot:run

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).

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\
          --memory=512Mi\
          --allow-unauthenticated

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

6. Opracowywanie lokalne

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

[W Cloud Shell] Spakuj próbkę:

cd ~/cloudbowl-microservice-game/samples; zip -r cloudbowl-sample.zip $SAMPLE

[W Cloud Shell] Pobierz plik ZIP na komputer:

cloudshell download-file cloudbowl-sample.zip

[Na komputerze] Rozpakuj plik, a następnie wprowadź i przetestuj zmiany.
[Na komputerze] Zainstaluj gcloud CLI
[Na komputerze] Zaloguj się w Google Cloud:

gcloud auth login

[Na swoim komputerze] Ustaw zmienne środowiskowe PROJECT_ID i SAMPLE na te same wartości co w Cloud Shell.
[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

[Na komputerze] Wdróż nowy kontener:

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

7. Gratulacje

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

Kontynuuj naukę

Więcej laboratoriów kodu Spring

Dokumentacja

Dokumentacja Cloud Run

8. Najczęstsze pytania

Dlaczego mój mikroserwis nie wyświetla się na arenie?