Konteneryzowanie aplikacji Java

Ukończone

W tej lekcji konteneryzujesz aplikację Java.

Jak wspomniano wcześniej, kontenery działają bezpośrednio na systemie operacyjnym hosta, jądrze i sprzęcie, będąc w istocie tylko kolejnym procesem systemowym. Kontenery wymagają mniejszej liczby zasobów systemowych, co skutkuje mniejszym zużyciem, mniejszym obciążeniem i krótszym czasem uruchamiania aplikacji. Są to doskonałe przypadki użycia skalowania na żądanie.

Istnieją kontenery systemu Windows i kontenery systemu Linux. W tym module użyjesz powszechnie używanego środowiska uruchomieniowego platformy Docker do utworzenia obrazu kontenera systemu Linux. Następnie wdrożysz obraz kontenera systemu Linux na system operacyjny lokalnego komputera-host. Na koniec wdrożysz obraz kontenera systemu Linux w usłudze Azure Kubernetes Service.

Omówienie platformy Docker

Środowisko uruchomieniowe Docker służy do budowania, pobierania, uruchamiania i przesyłania obrazów kontenerów. Na poniższym obrazie przedstawiono te przypadki użycia, po którym następuje opis poszczególnych przypadków użycia/poleceń Dockera.

Polecenie Docker	Opis
docker build	Tworzy obraz kontenera; w zasadzie instrukcje/warstwy potrzebne platformie Docker do utworzenia na końcu działającego kontenera na podstawie obrazu. Wynikiem tego polecenia jest obraz.
docker pull	Kontenery są inicjowane z obrazów, które są pobierane z rejestrów, takich jak Azure Container Registry, i z tego miejsca będzie pobierać Azure Kubernetes Service. Wynikiem tego polecenia będzie pobranie sieciowe obrazu na platformie Azure. Należy pamiętać, że opcjonalnie możesz ściągać obrazy lokalnie; Jest to typowe w przypadku tworzenia obrazów wymagających zależności/warstw, których aplikacja może potrzebować, na przykład serwera aplikacji.
docker run	Uruchomione wystąpienie obrazu jest kontenerem, a to polecenie wykonuje wszystkie warstwy potrzebne do uruchomienia i interakcji z uruchomioną aplikacją kontenera. Wynikiem tego polecenia jest uruchomiony proces aplikacji w systemie operacyjnym hosta.
docker push	Usługa Azure Container Registry będzie przechowywać obrazy, aby były łatwo dostępne i blisko sieci dla wdrożeń i skalowania platformy Azure.

Klonowanie aplikacji Java

Najpierw sklonujesz repozytorium Systemu Rezerwacji Lotów, a następnie przejdziesz do folderu projektu aplikacji internetowej linii lotniczych.

Notatka

Jeśli tworzenie usługi Azure Kubernetes Service zostało pomyślnie ukończone w zakładce CLI, użyj tej zakładki; Jeśli nadal trwa, otwórz nową zakładkę i przejdź do lokalizacji, w której wolisz sklonować system rezerwacji lotów.

Uruchom następujące polecenie w interfejsie wiersza polecenia:

git clone https://github.com/Azure-Samples/containerize-and-deploy-Java-app-to-Azure.git

Uruchom następujące polecenie w interfejsie wiersza polecenia:

cd containerize-and-deploy-Java-app-to-Azure/Project/Airlines

Notatka

Opcjonalnie, jeśli masz zainstalowane języki Java i Maven, możesz uruchomić następujące polecenia w interfejsie wiersza polecenia, aby zrozumieć środowisko tworzenia aplikacji bez platformy Docker. Jeśli nie masz zainstalowanego środowiska Java i narzędzia Maven, możesz bezpiecznie przejść do następnej sekcji, Konstruowanie pliku platformy Docker. W tej sekcji użyjesz platformy Docker, aby ściągnąć środowisko Java i narzędzie Maven w celu wykonania kompilacji w Twoim imieniu.

Opcjonalnie, jeśli masz zainstalowany zestaw Maven i zestaw JDK(8) lub nowszy, możesz uruchomić następujące polecenie w interfejsie wiersza polecenia:

mvn clean install

Notatka

Użyliśmy polecenia mvn clean install, aby zilustrować wyzwania operacyjne związane z niekorzystaniem z kompilacji wieloetapowych Docker, które omówimy w następnej kolejności. Ponownie ten krok jest opcjonalny; tak czy inaczej, można bezpiecznie poruszać się bez wykonywania polecenia Maven.

Narzędzie Maven powinno pomyślnie skompilować system rezerwacji lotów, tworząc archiwum aplikacji internetowej dla rezerwacji linii lotniczych o nazwie artefakt FlightBookingSystemSample-0.0.-SNAPSHOT.war, jak przedstawiono w następujących danych wyjściowych.

[INFO] Building war: /mnt/c/Users/chtrembl/dev/git/containerize-and-deploy-Java-app-to-Azure/Project/FlightBookingSystemSample/target/FlightBookingSystemSample-0.0.1-SNAPSHOT.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  17.698 s
[INFO] Finished at: 2021-09-28T15:18:07-04:00
[INFO] ------------------------------------------------------------------------

Wyobraź sobie, że jesteś deweloperem języka Java i właśnie zbudowałeś ten FlightBookingSystemSample-0.0.1-SNAPSHOT.war. Następnym krokiem jest prawdopodobnie współpraca z inżynierami operacji w celu wdrożenia tego artefaktu na serwerze lokalnym lub maszynie wirtualnej. Aby aplikacja mogła uruchomić i uruchomić pomyślnie, wymaga to dostępności serwerów i maszyn wirtualnych oraz skonfigurowania ich z wymaganymi zależnościami. Jest to trudne i czasochłonne, zwłaszcza gdy nagle wzrasta obciążenie w aplikacji. W przypadku kontenerów te wyzwania są złagodzone.

Utwórz plik Dockerfile

Na tym etapie możesz utworzyć plik Dockerfile. Plik Dockerfile to dokument tekstowy zawierający wszystkie polecenia, które użytkownik może wykonać w wierszu polecenia, aby utworzyć obraz kontenera, z których każda jest warstwą (którą można buforować w celu zwiększenia wydajności).

Na przykład system rezerwacji lotów dla rezerwacji linii lotniczych musi zostać wdrożony i uruchomiony na serwerze aplikacji. Serwer aplikacji nie jest spakowany wewnątrz FlightBookingSystemSample-0.0.1-SNAPSHOT.war; jest to zależność zewnętrzna wymagana dla FlightBookingSystemSample-0.0.1-SNAPSHOT.war do uruchamiania, nasłuchiwania i przetwarzania żądań HTTP, zarządzania sesjami użytkowników i ułatwiania rezerwacji lotów. Jeśli było to tradycyjne, niekontenerowe wdrożenie, inżynierowie operacji zainstalują i skonfigurują serwer aplikacji na niektórych serwerach fizycznych i/lub maszynie wirtualnej przed wdrożeniem FlightBookingSystemSample-0.0.1-SNAPSHOT.war w nim. Inżynierowie operacji musieliby również upewnić się, że zestaw JDK używany na waszej maszynie (ten, którego używał mvn clean install do kompilowania pliku .war) w rzeczywistości odpowiada temu samemu środowisku JRE, które jest używane przez serwer aplikacji. Zarządzanie tymi zależnościami jest trudne i czasochłonne.

Za pomocą pliku Dockerfile możesz napisać instrukcje (warstwy) potrzebne do automatycznego wykonania tego, krok po kroku zapewniając, że System rezerwacji lotów ma wszystkie zależności wymagane do wdrożenia w środowisku uruchomieniowym kontenera Docker. Jest to niezwykle przekonujące, gdy zaczynamy rozważać skalowanie na żądanie w niespodziewanych momentach. Warto zauważyć, że każda warstwa wykorzystuje pamięć podręczną Docker, która zawiera stan obrazu kontenera na każdym etapie instrukcji, optymalizując czas obliczeniowy i ponowne użycie. Jeśli warstwa nie zmienia się, używane są buforowane warstwy. Typowe przypadki użycia buforowanych warstw to takie elementy jak środowisko uruchomieniowe Java, serwer aplikacji i/lub inne zależności dla aplikacji internetowej Rezerwacji lotów lotniczych. Jeśli i kiedy wersja zmieni się na wcześniej buforowanej warstwie, zostanie utworzony nowy buforowany wpis.

Na poniższej ilustracji przedstawiono warstwy obrazu kontenera. Zauważysz, że górna warstwa to system rezerwacji lotów z funkcją odczytu/zapisu dla warstwy aplikacji internetowej Rezerwacje linii lotniczych, która jest oparta na poprzednich warstwach tylko do odczytu, a wszystkie one są wynikiem poleceń w pliku Dockerfile.

Platforma Docker ma również koncepcję kompilacji wieloetapowej, funkcję, która umożliwia utworzenie mniejszego obrazu kontenera z lepszym buforowaniem i mniejszym śladem bezpieczeństwa, co pozwala na zwiększenie optymalizacji i konserwacji pliku Dockerfile w czasie; Na przykład instrukcje, których można użyć do wykonania zarówno kompilacji aplikacji (FlightBookingSystemSample-0.0.1-SNAPSHOT.war), jak i kompilacji samego obrazu kontenera, pozostawiając za sobą pozostałości kompilacji FlightBookingSystemSample-0.0.1-SNAPSHOT.war, co powoduje mniejszy ślad. W dłuższej perspektywie przynosi to korzyści, gdy zaczynasz myśleć o tych obrazach krążących po sieci. W kompilacjach wielostopniowych można używać wielu instrukcji FROM w pliku Dockerfile. Każda instrukcja FROM może używać innej bazy, a każda z tych instrukcji zaczyna się od nowa, usuwając wszelkie niepotrzebne pliki w warstwie buforowania, które normalnie byłyby buforowane.

Należy upewnić się, że aplikacja jest budowana przez ten sam JDK odpowiadający temu samemu JRE, który będzie izolowany w obrazie kontenera podczas działania. W poniższym przykładzie będziesz mieć etap kompilacji, który wykorzystuje określoną wersję zestawu Maven i określoną wersję zestawu JDK w celu skompilowania FlightBookingSystemSample-0.0.1-SNAPSHOT.war. Ten etap gwarantuje, że każde środowisko uruchomieniowe Docker wykonujące ten etap otrzyma oczekiwany wygenerowany kod bajtowy określony przez autora pliku Dockerfile (w przeciwnym razie inżynierowie ds. operacyjnych musieliby skonsultować swoje środowisko uruchomieniowe Java i serwera aplikacji z deweloperem). Etap pakietowania będzie następnie używać określonej wersji serwera Tomcat i środowiska JRE odpowiadającego JDK na etapie budowania. Ponownie należy to zrobić, aby upewnić się, że wszystkie zależności (Zestaw Java Development Kit JDK, Java Runtime Environment JRE, serwer aplikacji) są kontrolowane i izolowane w celu zapewnienia oczekiwanego zachowania na wszystkich maszynach, na których zostanie uruchomiony ten obraz.

Warto również zauważyć, że w przypadku tej wieloestowej kompilacji technicznie nie ma potrzeby zainstalowania narzędzia Maven i języka Java w systemie. Docker pobierze je do wykorzystania zarówno przy budowaniu aplikacji, jak i jej środowisku uruchomieniowym, unikając potencjalnych konfliktów wersji i nieoczekiwanego zachowania; chyba że oczywiście kompilujesz kod i tworzysz artefakty poza Dockerem.

Na poniższej ilustracji przedstawiono kompilację wieloetapową i to, co dzieje się na każdym etapie na podstawie poleceń określonych w pliku Dockerfile. W Etapie 0, Etapie Budowy, aplikacja internetowa Flight Booking System for Airline Reservations zostanie skompilowana i wygenerowana zostanie FlightBookingSystemSample-0.0.1-SNAPSHOT.war. Ten etap umożliwia spójność wersji maven i Java używanych do kompilowania tej aplikacji. Po utworzeniu FlightBookingSystemSample-0.0.1-SNAPSHOT.war jest to jedyna warstwa wymagana dla etapu 1 (etap środowiska uruchomieniowego), a wszystkie poprzednie warstwy można odrzucić. Platforma Docker będzie następnie używać tej warstwy FlightBookingSystemSample-0.0.1-SNAPSHOT.war z etapu 0 do konstruowania pozostałych warstw potrzebnych do środowiska uruchomieniowego; w tym przypadku skonfigurowanie serwera aplikacji i uruchomienie aplikacji.

W katalogu głównym twojego projektu containerize-and-deploy-Java-app-to-Azure/Project/Airlines, utwórz plik o nazwie Dockerfile:

vi Dockerfile

Dodaj następującą zawartość do pliku Dockerfile, a następnie zapisz i zakończ, naciskając ESC, a następnie wpisując :wq! i naciśnij Enter:

#
# Build stage
#
FROM maven:3.6.0-jdk-11-slim AS build
WORKDIR /build
COPY pom.xml .
COPY src ./src
COPY web ./web
RUN mvn clean package

#
# Package stage
#
FROM tomcat:8.5.72-jre11-openjdk-slim
COPY tomcat-users.xml /usr/local/tomcat/conf
COPY --from=build /build/target/*.war /usr/local/tomcat/webapps/FlightBookingSystemSample.war
EXPOSE 8080
CMD ["catalina.sh", "run"]

Notatka

Opcjonalnie Dockerfile_Solution w katalogu głównym projektu zawiera wymaganą zawartość.

Ten etap kompilacji pliku Dockerfile ma sześć instrukcji:

Polecenie Docker	Opis
FROM	FROM maven będzie warstwą podstawową, z której utworzono tę FlightBookingSystemSample-0.0.1-SNAPSHOT.war, określoną wersję zestawu Maven i określoną wersję zestawu JDK, aby upewnić się, że na wszystkich maszynach z tą kompilacją występuje taka sama kompilacja kodu bajtowego.
WORKDIR	WORKDIR służy do definiowania katalogu roboczego kontenera w danym momencie; w tym przypadku, gdzie będą znajdować się skompilowane artefakty.
COPY	COPY dodaje pliki z bieżącego katalogu klienta platformy Docker. Skonfigurowanie plików potrzebnych do skompilowania programu Maven pom.xml będzie wymagane przez kontekst platformy Docker.
COPY	Konfiguruje pliki potrzebne do skompilowania narzędzia Maven. Kontekst platformy Docker będzie potrzebował folderu src zawierającego aplikację internetową Flight Booking System for Airline Reservations.
COPY	Konfiguruje pliki potrzebne do skompilowania narzędzia Maven. Kontekst web Docket będzie potrzebował folderu zawierającego zależności niezbędne dla internetowej aplikacji systemu rezerwacji lotów dla linii lotniczych.
BIEGAĆ	Instrukcja RUN mvn clean package służy do wykonywania dowolnego polecenia na wierzchu bieżącego obrazu. W tym przypadku polecenie RUN służy do wykonywania kompilacji narzędzia Maven, która skompiluje FlightBookingSystemSample-0.0.1-SNAPSHOT.war.

Ten etap pakietu plików platformy Docker zawiera pięć instrukcji:

Polecenie Dockera	Opis
FROM	FROM tomcat będzie to warstwa podstawowa, na której zostanie utworzony obraz kontenera. Obraz kontenera Flight Booking System for Airline Reservations będzie obrazem zbudowanym na podstawie obrazu tomcat. Środowisko uruchomieniowe platformy Docker podejmie próbę zlokalizowania obrazu tomcat lokalnie. Jeśli nie ma tej wersji, zostanie ona pobrana z rejestru. Gdybyś sprawdził obraz Tomcat, o którym mowa, zobaczyłbyś, że jest zbudowany przy użyciu wielu innych warstw, co sprawia, że można go ponownie używać jako jednego spakowanego obrazu kontenera serwera aplikacji podczas wdrażania aplikacji Java. Wybraliśmy i przetestowaliśmy tomcat:8.5.72-jre11-openjdk-slim na potrzeby modułu. Pamiętaj, że wszystkie poprzednie warstwy z pierwszego etapu kompilacji znikną po rozpoznaniu tej drugiej instrukcji FROM przez platformę Docker.
COPY	COPY tomcat-users.xml skopiuje plik tomcat-users.xml, który zarządza użytkownikami usługi Flight Booking System for Airline Reservations (zarządzanym w ramach kontroli źródła przy użyciu tożsamości Tomcat; zazwyczaj znajduje się to w zewnętrznym systemie zarządzania tożsamościami) w obrazie kontenera tomcat, tak aby był obecny w obrazie kontenera po każdym utworzeniu obrazu kontenera.
ADD	ADD target/*.war /usr/local/tomcat/webapps/FlightBookingSystemSample.war skopiuje skompilowany FlightBookingSystemSample-0.0.1-SNAPSHOT.war maven do folderu webapps tomcat images, aby upewnić się, że podczas inicjowania serwera aplikacji tomcat znajdzie FlightBookingSystemSample-0.0.1-SNAPSHOT.war do zainstalowania na serwerze aplikacji.
EXPOSE	EXPOSE 8080 jest wymagany, ponieważ program Tomcat jest skonfigurowany do nasłuchiwania ruchu na porcie 8080. Dzięki temu proces Docker będzie nasłuchiwał na tym porcie.
CMD	Instrukcja CMD ustawia polecenie do wykonania podczas uruchamiania kontenera. W takim przypadku CMD ["catalina.sh", "run"] inicjuje platformę Docker, aby zainicjowała serwer aplikacji Tomcat.

Notatka

Bez tagu wersji w wierszu FROM tomcat zostanie zastosowana najnowsza wersja. Ogólnie rzecz biorąc, będziesz chciał wykorzystać tag wersji (pamiętaj, że buforowanie jest stosowane, więc jeśli warstwy stale się zmieniają, może to skutkować zużyciem przepustowości, opóźnieniami, czasem przetwarzania lub skutkami ubocznymi nieuwzględnionych w testach kompilacji/warstw). Dla dobra tego modułu wybraliśmy wstępnie określone tagi Maven, Tomcat i Java JRE/JDK, które są testowane do pracy z FlightBookingSystemSample-0.0.1-SNAPSHOT.war w czasie wykonywania.

Aby uzyskać więcej informacji na temat konstruowania pliku Dockerfile, zobacz odwołanie do pliku Dockerfile