Wdrażanie w Kubernetes Engine aplikacji Spring Boot w Javie w Google Kubernetes Engine

Kubernetes to projekt open source, który może działać w wielu różnych środowiskach, od laptopów po klastry wielowęzłowe o wysokiej dostępności, od chmur publicznych po wdrożenia lokalne i od maszyn wirtualnych po sprzęt fizyczny.

W tym ćwiczeniu z programowania wdrożysz prostą aplikację internetową Spring Boot w Javie w Kubernetes w GKE. Celem jest uruchomienie aplikacji internetowej jako replikowanej aplikacji w Kubernetes. Kod opracowany na komputerze przekształcisz w obraz kontenera Dockera i uruchomisz go w GKE.

Będziesz używać GKE, w pełni zarządzanej usługi Kubernetes w Google Cloud, dzięki czemu możesz skupić się na korzystaniu z Kubernetes, a nie na konfigurowaniu infrastruktury bazowej.

Jeśli chcesz uruchomić Kubernetes na komputerze lokalnym, np. na laptopie deweloperskim, zapoznaj się z Minikube, które oferuje prostą konfigurację klastra Kubernetes z 1 węzłem na potrzeby programowania i testowania. Jeśli chcesz, możesz skorzystać z Minikube, aby przejść przez laboratorium.

W tym ćwiczeniu z programowania użyjemy przykładowego kodu z przewodnika Tworzenie aplikacji za pomocą Spring Boot.

Wymagania wstępne

• Znajomość języka programowania Java i narzędzi
• Znajomość standardowych edytorów tekstu systemu Linux, takich jak Vim, Emacs i nano

Co musisz zrobić

• spakować prostą aplikację Java jako kontener Dockera,
• Utwórz klaster Kubernetes w GKE.
• Wdróż aplikację w Javie w Kubernetes w GKE.
• skalować usługę i wdrażać uaktualnienie,
• Dostęp do panelu, internetowego interfejsu Kubernetes.

Czego potrzebujesz

• projekt Google Cloud,
• przeglądarka, np. Google Chrome;

Samodzielne konfigurowanie środowiska

1. Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. (Jeśli nie masz jeszcze konta Gmail lub G Suite, musisz je utworzyć).

Uwaga: możesz łatwo uzyskać dostęp do konsoli Cloud, zapamiętując jej adres URL: console.cloud.google.com.

Zapamiętaj identyfikator projektu, czyli unikalną nazwę we wszystkich projektach Google Cloud (podana powyżej nazwa jest już zajęta i nie będzie działać w Twoim przypadku). W dalszej części tego laboratorium będzie on nazywany PROJECT_ID.

Uwaga: jeśli używasz konta Gmail, możesz pozostawić domyślną lokalizację ustawioną na Brak organizacji. Jeśli używasz konta G Suite, wybierz lokalizację odpowiednią dla Twojej organizacji.

2. Następnie musisz włączyć płatności w Cloud Console, aby móc korzystać z zasobów Google Cloud.

Wykonanie tego samouczka nie powinno kosztować więcej niż kilka dolarów, ale może okazać się droższe, jeśli zdecydujesz się wykorzystać więcej zasobów lub pozostawisz je uruchomione.

Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Aktywowanie Cloud Shell

1. W konsoli Cloud kliknij Aktywuj Cloud Shell .

Jeśli nigdy wcześniej nie uruchamiałeś(-aś) Cloud Shell, zobaczysz ekran pośredni (poniżej linii podziału) z opisem tego środowiska. W takim przypadku kliknij Dalej (i nie zobaczysz już tego ekranu). Ekran jednorazowy wygląda tak:

Udostępnienie Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Większość, jeśli nie wszystkie, zadań w tym laboratorium możesz wykonać za pomocą przeglądarki lub Chromebooka.

Po połączeniu z Cloud Shell zobaczysz, że jesteś już uwierzytelniony, a projekt jest już ustawiony na Twój identyfikator projektu.

2. Aby potwierdzić, że masz autoryzację, uruchom w Cloud Shell to polecenie:

gcloud auth list

Wynik polecenia

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Uwaga: narzędzie wiersza poleceń gcloud to zaawansowane i ujednolicone narzędzie wiersza poleceń w Google Cloud. Jest ono już zainstalowane w Cloud Shell. Zauważysz, że obsługuje on uzupełnianie za pomocą klawisza Tab. Więcej informacji znajdziesz w omówieniu narzędzia wiersza poleceń gcloud.

gcloud config list project

Wynik polecenia

[core]
project = <PROJECT_ID>

Jeśli nie, możesz ustawić go za pomocą tego polecenia:

gcloud config set project <PROJECT_ID>

Wynik polecenia

Updated property [core/project].

Po uruchomieniu Cloud Shell możesz użyć wiersza poleceń, aby sklonować przykładowy kod źródłowy w katalogu głównym.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

1. Aplikację Spring Boot możesz uruchomić normalnie za pomocą wtyczki Spring Boot.

$ ./mvnw -DskipTests spring-boot:run

2. Po uruchomieniu aplikacji kliknij Podgląd w przeglądarce na pasku narzędzi Cloud Shell i wybierz Podejrzyj na porcie 8080.

W przeglądarce otworzy się karta, która połączy się z uruchomionym serwerem.

Następnie musisz przygotować aplikację do uruchomienia w klastrze Kubernetes. Pierwszym krokiem jest zdefiniowanie kontenera i jego zawartości.

1. Utwórz plik JAR do wdrożenia aplikacji.

$ ./mvnw -DskipTests package

2. Włącz Container Registry, aby przechowywać utworzony obraz kontenera.

$ gcloud services enable containerregistry.googleapis.com

3. Użyj Jib, aby utworzyć obraz kontenera i przenieść go do Container Registry.

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Jeśli wszystko przebiegnie pomyślnie, obraz kontenera powinien być widoczny w konsoli po wybraniu Container Registry > Obrazy. Masz teraz dostępny obraz Dockera w całym projekcie, do którego Kubernetes może uzyskać dostęp i którym może zarządzać. Zobaczysz to za kilka minut.

Uwaga: w przypadku rejestru użyto domeny ogólnej (gcr.io), ale możesz też dokładniej określić, której strefy i którego zasobnika chcesz użyć. Więcej informacji znajdziesz w dokumentacji Container Registry.

5. Po zakończeniu tego procesu (pobieranie i wyodrębnianie wszystkich plików zajmie trochę czasu) możesz przetestować obraz lokalnie za pomocą tego polecenia, które uruchomi kontener Dockera jako demona na porcie 8080 z nowo utworzonego obrazu kontenera:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

6. Ponownie skorzystaj z funkcji podglądu w przeglądarce Cloud Shell.

7. W nowej karcie powinna się otworzyć strona domyślna. Gdy upewnisz się, że aplikacja działa lokalnie w kontenerze Docker, możesz zatrzymać działający kontener, naciskając Control+C.

Możesz już utworzyć klaster GKE. Klaster składa się z serwera Kubernetes API zarządzanego przez Google i zestawu węzłów roboczych. Węzły robocze to maszyny wirtualne Compute Engine.

1. Najpierw upewnij się, że włączone są powiązane funkcje interfejsu API.

$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully

2. Utwórz klaster z 2 węzłami n1-standard-1 (wykonanie tego kroku może potrwać kilka minut).

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Na koniec powinien pojawić się utworzony klaster.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Uwaga: klaster możesz też utworzyć w konsoli Cloud. Aby to zrobić, kliknij Menu nawigacyjne > Kubernetes Engine> Klastry> Utwórz klaster. Klaster możesz utworzyć w innej strefie, ale zalecamy, aby znajdował się w tym samym regionie co zasobnik pamięci masowej używany przez Container Registry.

Powinien być teraz dostępny w pełni funkcjonalny klaster Kubernetes obsługiwany przez GKE.

Czas wdrożyć skonteneryzowaną aplikację w klastrze Kubernetes. Od tej pory będziesz używać wiersza poleceń kubectl (skonfigurowanego już w środowisku Cloud Shell). Pozostała część tego samouczka wymaga, aby wersja klienta i serwera Kubernetes była co najmniej 1.2. kubectl version wyświetli aktualną wersję polecenia.

1. Wdrożenie Kubernetes może tworzyć wiele instancji aplikacji, zarządzać nimi i je skalować za pomocą utworzonego przez Ciebie obrazu kontenera. Wdróż jedną instancję aplikacji w Kubernetes za pomocą polecenia kubectl run.

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

2. Aby wyświetlić utworzone wdrożenie, uruchom to polecenie:

$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. Aby wyświetlić instancje aplikacji utworzone przez wdrożenie, uruchom to polecenie:

$ kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

W tym momencie kontener powinien działać pod kontrolą Kubernetes, ale nadal musisz udostępnić go do użytku publicznego.

Domyślnie pod jest dostępny tylko przez wewnętrzny adres IP w klastrze. Aby kontener hello-java był dostępny spoza wirtualnej sieci Kubernetes, musisz udostępnić poda jako usługę Kubernetes.

1. W Cloud Shell możesz udostępnić poda publicznemu internetowi za pomocą polecenia kubectl expose w połączeniu z flagą --type=LoadBalancer. Flaga jest wymagana do utworzenia adresu IP dostępnego z zewnątrz.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Flaga użyta w poleceniu określa, że będziesz używać systemu równoważenia obciążenia udostępnianego przez infrastrukturę bazową. Pamiętaj, że bezpośrednio udostępniasz wdrożenie, a nie poda. Spowoduje to, że usługa będzie równoważyć obciążenie ruchem we wszystkich podach zarządzanych przez wdrożenie (w tym przypadku tylko w jednym podzie, ale później dodasz więcej replik).

Master Kubernetes tworzy system równoważenia obciążenia oraz powiązane z nim reguły przekierowania Compute Engine, pule docelowe i reguły zapory, aby usługa była w pełni dostępna spoza Google Cloud.

2. Aby znaleźć publicznie dostępny adres IP usługi, po prostu wyślij żądanie kubectl, aby wyświetlić listę wszystkich usług klastra.

$ kubectl get services
NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
Hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Uwaga: ikona EXTERNAL-IP może stać się dostępna i widoczna po kilku minutach. Jeśli brakuje ikony EXTERNAL-IP, poczekaj kilka minut i spróbuj ponownie.

3. Zwróć uwagę, że w przypadku Twojej usługi są wymienione 2 adresy IP, które obsługują port 8080. Jeden z nich to wewnętrzny adres IP, który jest widoczny tylko w Twojej sieci Virtual Private Cloud. Drugi to zewnętrzny adres IP z równoważeniem obciążenia. W tym przykładzie zewnętrzny adres IP to aaa.bbb.ccc.ddd. Usługa powinna być teraz dostępna pod adresem http://<EXTERNAL_IP>:8080.

Jedną z najważniejszych funkcji Kubernetes jest łatwość skalowania aplikacji. Załóżmy, że nagle potrzebujesz większej mocy obliczeniowej dla swojej aplikacji. Wystarczy, że powiesz kontrolerowi replikacji, aby zarządzał nową liczbą replik instancji aplikacji.

$ kubectl scale deployment hello-java --replicas=3
deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Zwróć uwagę na podejście deklaratywne. Zamiast uruchamiać lub zatrzymywać nowe instancje, deklarujesz, ile instancji powinno działać przez cały czas. Pętle uzgadniania Kubernetes po prostu sprawdzają, czy rzeczywistość jest zgodna z Twoimi żądaniami, i w razie potrzeby podejmują odpowiednie działania.

W pewnym momencie aplikacja wdrożona w środowisku produkcyjnym będzie wymagać poprawek lub dodatkowych funkcji. Kubernetes może pomóc Ci wdrożyć nową wersję w środowisku produkcyjnym bez wpływu na użytkowników.

1. W menu Cloud Shell kliknij Uruchom edytor , aby otworzyć edytor kodu.
2. Przejdź do src/main/java/hello/HelloController.java i zaktualizuj wartość odpowiedzi.

package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {    
    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Użyj Jib, aby utworzyć i przesłać nową wersję obrazu kontenera.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Uwaga: tworzenie i przesyłanie zaktualizowanego obrazu powinno być znacznie szybsze, ponieważ w pełni wykorzystujesz pamięć podręczną.

Kubernetes może teraz bezproblemowo zaktualizować kontroler replikacji do nowej wersji aplikacji.

4. Aby zmienić etykietę obrazu działającego kontenera, musisz edytować istniejące hello-java wdrożenie i zmienić obraz z gcr.io/PROJECT_ID/hello-java:v1 na gcr.io/PROJECT_ID/hello-java:v2.

5. Za pomocą polecenia kubectl set image możesz poprosić Kubernetes o wdrożenie nowej wersji aplikacji w całym klastrze, po jednej instancji naraz, za pomocą aktualizacji stopniowej.

$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Uwaga: w tym czasie użytkownicy usług mogą doświadczać przerw w działaniu, ale jest to spowodowane brakiem skonfigurowanej kontroli stanu. Jest to nieco bardziej zaawansowana konfiguracja, która wykracza poza zakres tego laboratorium.

6. Sprawdź ponownie adres http://EXTERNAL_IP:8080, aby upewnić się, że zwraca on nową odpowiedź.

Ups! Czy w nowej wersji aplikacji wystąpił błąd? Być może nowa wersja zawiera błąd i musisz szybko przywrócić poprzednią. Dzięki Kubernetes możesz łatwo przywrócić poprzedni stan. Cofnij wdrożenie aplikacji, wykonując to polecenie:

$ kubectl rollout undo deployment/hello-java

Dowiedzieliśmy się, jak utworzyć i wdrożyć nową aplikację internetową opartą na Javie w Kubernetes w GKE.

Więcej informacji

• Java w Google Cloud
• Przykłady kodu w Javie
• Kubernetes w GKE – od podstaw do zaawansowanych funkcji