Wdrażanie aplikacji Java Spring rozruchu w Kubernetes w Google Kubernetes Engine

Wdrażanie aplikacji Java Spring rozruchu w Kubernetes w Google Kubernetes Engine

Informacje o tym ćwiczeniu (w Codelabs)

subjectOstatnia aktualizacja: kwi 22, 2020
account_circleDokument stworzony przez pracownika Google

1. Zanim zaczniesz

Kubernetes to projekt typu open source, który może działać w wielu różnych środowiskach, takich jak laptopy, klastry wielu węzłów o wysokiej dostępności, wdrożenia w chmurze publicznej, wdrożenia lokalne oraz maszyny wirtualne (VM) i Bare Metal.

W ramach tego ćwiczenia wdrożysz prostą aplikację internetową Spring Run Java w Kubernetes w GKE, której celem jest uruchomienie aplikacji jako zreplikowanej aplikacji w Kubernetes. Przerobisz kod utworzony na komputerze, przekształcisz go w obraz kontenera Dockera, a następnie uruchomisz obraz w GKE.

W pełni zarządzanej usługi Kubernetes w Google Cloud będziesz używać GKE, dzięki czemu możesz skupić się na korzystaniu z Kubernetes, zamiast konfigurować podstawową infrastrukturę.

Jeśli chcesz uruchomić Kubernetes na komputerze lokalnym, na przykład na laptopie do rozwoju, zapoznaj się z narzędziem Minikube, które oferuje prostą konfigurację klastra Kubernetes z pojedynczym węzłem do celów programistycznych i testowych. Jeśli chcesz, możesz skorzystać z Minikube.

W ćwiczeniach z programowania użyjesz przykładowego kodu z przewodnika dotyczącego tworzenia aplikacji przy użyciu wiosennego rozruchu.

Wymagania wstępne

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

Co chcesz zrobić

  • Pakowanie prostej aplikacji Java jako kontenera Dockera.
  • Utwórz klaster Kubernetes w GKE.
  • Wdróż swoją aplikację Java w Kubernetes w GKE.
  • Skaluj usługę i przeprowadź uaktualnienie.
  • Dostęp do internetowego interfejsu Kubernetes.

Czego potrzebujesz

2. Konfiguracja i wymagania

Konfiguracja środowiska we własnym tempie

  1. Zaloguj się w Cloud Console i utwórz nowy projekt lub ponownie wykorzystaj istniejący. Jeśli nie masz jeszcze konta Gmail lub G Suite, musisz je utworzyć.

Zapamiętaj identyfikator projektu, unikalną nazwę we wszystkich projektach Google Cloud (powyższa nazwa została już użyta i nie będzie działać). W ćwiczeniach nazywamy je później PROJECT_ID.

  1. Aby móc używać zasobów Google Cloud, musisz najpierw włączyć płatności w Cloud Console.

Ćwiczenia z programowania nie powinny kosztować więcej niż kilka dolarów, ale mogą być większe, jeśli zdecydujesz się wykorzystać więcej zasobów lub pozostawisz to uruchomione.

Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnej wersji próbnej 300 USD.

Aktywowanie Cloud Shell

  1. W Cloud Console kliknij Aktywuj Cloud Shell .

Jeśli nie korzystasz jeszcze z Cloud Shell, wyświetli się pośredni ekran (w części strony widocznej po przewinięciu), na którym widać, co to jest. Jeśli tak jest, kliknij Dalej (tj. nie zobaczysz tego ponownie). Tak wygląda jednorazowy ekran:

Udostępnienie usługi Cloud Shell i połączenie się z nią powinno zająć kilka minut.

Ta maszyna wirtualna jest wyposażona we wszystkie potrzebne narzędzia dla programistów. Oferuje trwały katalog domowy o pojemności 5 GB oraz działa w Google Cloud, co znacznie zwiększa wydajność sieci i uwierzytelnianie. Znaczna część (lub nawet całość) zadań z tego ćwiczenia z programowania można wykonać w przeglądarce lub na Chromebooku.

Po połączeniu z Cloud Shell powinno być widoczne, że projekt jest już uwierzytelniony, a projekt jest już ustawiony na jego identyfikator.

  1. Uruchom następujące polecenie w Cloud Shell, aby potwierdzić, że jesteś uwierzytelniony:
gcloud auth list

Polecenie wyjściowe

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

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

Polecenie wyjściowe

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

Polecenie wyjściowe

Updated property [core/project].

3. Pobierz kod źródłowy

Po uruchomieniu Cloud Shell możesz użyć wiersza poleceń, aby skopiować 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

4. Uruchom aplikację lokalnie

  1. Możesz uruchomić aplikację Spring Run przy użyciu wtyczki.
$ ./mvnw -DskipTests spring-boot:run
  1. Po uruchomieniu aplikacji kliknij Podgląd w przeglądarce na pasku narzędzi Cloud Shell i wybierz Podgląd na porcie 8080.

W przeglądarce otworzy się karta z uruchomionym serwerem.

5. Pakowanie aplikacji Java jako kontenera Dockera

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

  1. Utwórz plik JAR do wdrożenia w aplikacji.
$ ./mvnw -DskipTests package
  1. Włącz Container Registry, aby przechowywać utworzony kontener.
$ gcloud services enable containerregistry.googleapis.com
  1. Użyj Jib, aby utworzyć obraz kontenera i przekazać go do Container Registry.
$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1
  1. Jeśli wszystko się zgadza, możesz zobaczyć obraz kontenera na konsoli, klikając Container Registry > Images. Masz teraz dostępny obraz Dockera dla całego projektu, do którego dostęp będzie miał dostęp przez Kubernetes. Za kilka minut będzie on dostępny.
  1. Po zakończeniu (pobieranie i wyodrębnianie wszystkich danych zajmie trochę czasu) możesz przetestować obraz lokalnie, używając polecenia, które uruchomi kontener Dockera jako demona na porcie 8080 nowo utworzonego obrazu kontenera:
$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1
  1. Znowu skorzystaj z funkcji podglądu w Cloud Shell.

  1. Powinna wyświetlić się strona domyślna w nowej karcie. Gdy upewnisz się, że aplikacja działa lokalnie w kontenerze Dockera, możesz zatrzymać aktywny kontener, naciskając Control+C.

6. Utwórz klaster

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

  1. Najpierw sprawdź, czy powiązane funkcje interfejsu API są włączone.
$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully
  1. Utwórz klaster z 2 węzłami n1-standard-1 (zajmie to tylko kilka minut).
$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

W końcu klaster powinien być utworzony.

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

Masz już w pełni działający klaster Kubernetes obsługiwany przez GKE.

Czas wdrożyć aplikację konteneryzowaną w klastrze Kubernetes. Od teraz będziesz używać wiersza poleceń kubectl (jest już skonfigurowany w środowisku Cloud Shell). Reszta ćwiczeń z programowania wymaga, aby klient Kubernetes i wersja serwera miały co najmniej 1.2. kubectl version pokazuje bieżącą wersję polecenia.

7. Wdrażanie aplikacji w Kubernetes

  1. Wdrożenie Kubernetes pozwala tworzyć i zarządzać wieloma instancjami aplikacji oraz nimi zarządzać przy użyciu utworzonego przez Ciebie obrazu kontenera. Wdróż 1 instancję aplikacji w Kubernetes za pomocą polecenia kubectl run.
$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1
  1. Aby wyświetlić utworzone wdrożenie, uruchom następujące polecenie:
$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s
  1. 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

Na tym etapie kontener powinien być kontrolowany przez Kubernetes, ale nadal musisz mieć do niego dostęp z zewnątrz.

8. Zezwalaj na ruch z zewnątrz

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

  1. W Cloud Shell możesz udostępnić poda publicznie w internecie, używając 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żywana w poleceniu określa, że używany będzie system równoważenia obciążenia udostępniony przez infrastrukturę bazową. Pamiętaj, że musisz ujawnić wdrożenie bezpośrednio, nie poda. Spowoduje to, że wynikowa usługa będzie równoważyć obciążenie ruchu we wszystkich podach zarządzanych przez wdrożenie (w tym przypadku tylko jeden pod, ale później dodasz więcej replik).

Kubernetes Master tworzy system równoważenia obciążenia oraz powiązane reguły przekierowania Compute Engine, pule docelowe i reguły zapory sieciowej, aby zapewnić pełny dostęp do usługi spoza Google Cloud.

  1. Aby znaleźć publicznie dostępny adres IP usługi, poproś kubectl o podanie 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
  1. Twoja usługa ma 2 adresy IP. Obsługiwany jest w nich port 8080. 1 to wewnętrzny adres IP, który jest widoczny tylko w prywatnej chmurze wirtualnej. Drugi to zewnętrzny adres IP ze zrównoważonym obciążeniem. W tym przykładzie zewnętrzny adres IP to aaa.bbb.ccc.ddd. Teraz powinno być możliwe nawiązanie połączenia z usługą przez wskazanie w przeglądarce adresu http://<EXTERNAL_IP>:8080.

9. Skaluj swoją usługę

Jedną z zaawansowanych funkcji Kubernetes jest łatwość skalowania aplikacji. Załóżmy, że nagle potrzebujesz więcej miejsca na aplikację. Po prostu powiedz kontrolerowi replikacji, aby zarządzać nową liczbą replik do 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 deklaratywne podejście. Zamiast uruchamiać lub zatrzymywać nowe instancje, możesz określić, ile instancji powinno być zawsze uruchomionych. Pętle uzgodnień Kubernetes pozwalają sprawdzić, czy rzeczywistość jest zgodna z oczekiwaniami i w razie potrzeby podejmuje działanie.

10. Przejście na wyższą wersję usługi

Od czasu do czasu aplikacja wdrożona w wersji produkcyjnej będzie wymagała poprawek i dodatkowych funkcji. Kubernetes może pomóc Ci wdrożyć nową wersję produkcyjną bez wpływu na użytkowników.

  1. Otwórz edytor kodu, klikając Uruchom edytor w menu Cloud Shell.
  2. Otwórz src/main/java/hello/HelloController.java i zaktualizuj wartość w 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!";
    }
}
  1. Użyj Jib, aby utworzyć i przekazać nową wersję obrazu kontenera.
$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Wszystko gotowe dla platformy Kubernetes, aby łatwo zaktualizować kontroler replikacji do nowej wersji aplikacji.

  1. Aby zmienić etykietę obrazu w aktywnym kontenerze, musisz edytować istniejące wdrożenie hello-java i zmienić obraz z gcr.io/PROJECT_ID/hello-java:v1 na gcr.io/PROJECT_ID/hello-java:v2.
  1. Za pomocą polecenia kubectl set image możesz poprosić Kubernetes o wdrażanie nowej wersji aplikacji w całym klastrze naraz po kolejnych instancjach z aktualizacjami kroczącymi.
$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated
  1. Ponownie sprawdź adres http://EXTERNAL_IP:8080, aby zobaczyć, czy ta odpowiedź zwraca nową odpowiedź.

11. Przywróć

Ups… Czy popełniono błąd w nowej wersji aplikacji? Być może nowa wersja zawierała błąd i chcesz go szybko przywrócić. Kubernetes pozwala łatwo przywrócić poprzedni stan. Wycofaj zmiany aplikacji, uruchamiając następujące polecenie:

$ kubectl rollout undo deployment/hello-java

12. Gratulacje

Nauczyliśmy się tworzyć i wdrażać nową aplikację internetową opartą na Javie w Kubernetes w GKE.

Więcej informacji

bug_report Zgłoś pomyłkę