Konteneryzowanie aplikacji Java

Ukończone

W tej lekcji konteneryzujesz aplikację Java.

Jak wspomniano wcześniej, kontenery działają bezpośrednio na hoście systemu operacyjnego, jądra i sprzętu, co zasadniczo tylko kolejny proces systemowy. 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 w systemie operacyjnym hosta komputera lokalnego. Na koniec wdrożysz obraz kontenera systemu Linux w usłudze Azure Kubernetes Service.

Przegląd platformy Docker

Środowisko uruchomieniowe platformy Docker służy do kompilowania, ściągania, uruchamiania i wypychania obrazów kontenerów. Na poniższej ilustracji przedstawiono te przypadki użycia, a następnie opis każdego przypadku użycia/polecenia platformy Docker.

Polecenie platformy Docker	opis
docker build	Tworzy obraz kontenera; zasadniczo instrukcje/warstwy potrzebne do platformy Docker do utworzenia uruchomionego 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 Usługa Azure Container Registry, i jest to miejsce, z którego usługa Azure Kubernetes Service będzie ściągać. Wynikiem tego polecenia jest ściągnięcie sieciowe obrazu, który wystąpi 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 Flight Booking System for Airline Reservations i cd do folderu projektu aplikacji internetowej Airlines.

Uwaga

Jeśli tworzenie usługi Azure Kubernetes Service zostało pomyślnie ukończone na karcie interfejsu wiersza polecenia, użyj tej karty; Jeśli nadal działa, otwórz nową kartę i przejdź do lokalizacji, w której wolisz sklonować system rezerwacji lotów dla rezerwacji linii lotniczych.

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

Uwaga

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

Uwaga

Użyliśmy mvn clean install polecenia w celu zilustrowania wyzwań operacyjnych związanych z nieużywaniu kompilacji wieloestrowych platformy 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 dla rezerwacji linii lotniczych Web Application Archive artefakt FlightBookingSystemSample-0.0.-SNAPSHOT.war, jak 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 skompilujesz ten element 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, szczególnie na żądanie, gdy zwiększone obciążenie uderza w aplikację. W przypadku kontenerów te wyzwania są złagodzone.

Konstruowanie pliku 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.warobiektu ; jest to zależność zewnętrzna wymagana do FlightBookingSystemSample-0.0.1-SNAPSHOT.war 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 pewnym serwerze fizycznym i/lub maszynie wirtualnej przed wdrożeniem FlightBookingSystemSample-0.0.1-SNAPSHOT.war go. Inżynierowie operacji musieliby również upewnić się, że zestaw JDK używany na maszynie (co mvn clean install było używane do kompilowania pliku war) w rzeczywistości odpowiada temu samemu środowisku JRE używanemu przez serwer aplikacji. Zarządzanie tymi zależnościami jest trudne i czasochłonne.

Za pomocą pliku Dockerfile możesz napisać instrukcje (warstwy), które są potrzebne do wykonania tego automatycznie, nakładając warstwy w krokach niezbędnych do zapewnienia, że system rezerwacji lotów dla rezerwacji linii lotniczych ma wszystkie zależności wymagane do wdrożenia w środowisku uruchomieniowym kontenera platformy Docker. Jest to bardzo atrakcyjne, gdy zaczniesz myśleć o skali na żądanie w nieplanowanych odstępach czasu. Warto zauważyć, że każda warstwa wykorzystuje pamięć podręczną platformy Docker, która zawiera stan obrazu kontenera w każdym instruktażowym kamieniu milowym, optymalizowanie czasu obliczeniowego 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órną warstwą jest system rezerwacji odczytu/zapisu dla warstwy aplikacji internetowej Rezerwacje linii lotniczych, która jest oparta na poprzednich warstwach tylko do odczytu, z których wszystkie są wynikiem poleceń w pliku Dockerfile.

Platforma Docker ma również koncepcję kompilacji wieloeeżowych, funkcję, która umożliwia utworzenie mniejszego obrazu kontenera z lepszym buforowaniem i mniejszym zużyciem zabezpieczeń, 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 pozostałości FlightBookingSystemSample-0.0.1-SNAPSHOT.war kompilacji w tyle, co spowoduje zmniejszenie śladu. W dłuższej perspektywie płaci to dywidendy, gdy zaczniesz myśleć o tych obrazach podróżujących po sieci. W przypadku kompilacji wieloestużych 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 czystego łupka, usuwając wszelkie niepotrzebne pliki w warstwie buforowania, która może być zwykle buforowana.

Należy upewnić się, że aplikacja jest kompilowana przez ten sam zestaw JDK odpowiadający temu samemu środowisku JRE, który zostanie odizolowany w obrazie kontenera w czasie wykonywania. W poniższym przykładzie będziesz mieć etap kompilacji, który wykorzystuje określoną wersję zestawu Maven i określoną wersję zestawu JDK do skompilowania elementu FlightBookingSystemSample-0.0.1-SNAPSHOT.war. Ten etap gwarantuje, że każde środowisko uruchomieniowe platformy Docker wykonujące ten etap otrzyma oczekiwany wygenerowany kod bajtowy określony przez autora pliku Dockerfile (w przeciwnym razie inżynierowie operacji musieliby odwoływać się do środowiska uruchomieniowego java i serwera aplikacji z deweloperem). Etap Pakiet będzie następnie używać określonej wersji serwera Tomcat i środowiska JRE odpowiadającego zestawowi JDK na etapie kompilacji. 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 instalowania oprogramowania Maven i języka Java w systemie. Platforma Docker ściągnie je do użycia zarówno z kompilowaniem aplikacji, jak i środowiskiem uruchomieniowym aplikacji, unikając potencjalnego konfliktu wersji i nieoczekiwanego zachowania; chyba że oczywiście kompilujesz kod i kompilujesz artefakty poza platformą Docker.

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 etap kompilacji aplikacja internetowa Flight Booking System for Airline Reservations zostanie skompilowana i FlightBookingSystemSample-0.0.1-SNAPSHOT.war wygenerowana. 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 FlightBookingSystemSample-0.0.1-SNAPSHOT.war warstwy z etapu 0 do konstruowania pozostałych warstw wymaganych dla środowiska uruchomieniowego. W tym przypadku skonfigurowanie serwera aplikacji i uruchomienie aplikacji.

W katalogu głównym 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 zamknij, naciskając klawisz ESC, a następnie wpisując polecenie :wq! i naciskając klawisz 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"]

Uwaga

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

Ten etap kompilacji pliku Dockerfile ma sześć instrukcji:

Polecenie platformy Docker	opis
FROM	FROM maven będzie warstwą podstawową, z której FlightBookingSystemSample-0.0.1-SNAPSHOT.war jest utworzona, konkretną wersją zestawu Maven i określoną wersją zestawu JDK, aby upewnić się, że ta sama kompilacja kodu bajtowego występuje na wszystkich maszynach z uruchomioną tą kompilacją.
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 aplikacji internetowej Flight Booking System for Airline Reservations.
URUCHOM	Instrukcja RUN mvn clean package służy do wykonywania dowolnego polecenia na początku bieżącego obrazu. W tym przypadku polecenie RUN jest używane do wykonywania kompilacji narzędzia Maven, która skompiluje element FlightBookingSystemSample-0.0.1-SNAPSHOT.war.

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

Polecenie platformy Docker	opis
FROM	FROM tomcat będzie warstwą podstawową, 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. Jeśli sprawdzono obraz serwera tomcat, do którego się odwołujesz, można stwierdzić, że został utworzony przy użyciu wielu innych warstw, z których wszystkie sprawiają, że można go ponownie używać jako jednego spakowanego obrazu kontenera serwera aplikacji dla świata do użycia podczas wdrażania aplikacji Java. Wybraliśmy i przetestowano tomcat:8.5.72-jre11-openjdk-slim pod kątem 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) do obrazu kontenera tomcat, tak aby był obecny w obrazie kontenera każdego i w każdej chwili tworzony jest obraz kontenera.
ADD	ADD target/*.war /usr/local/tomcat/webapps/FlightBookingSystemSample.war Program skopiuje narzędzie maven skompilowane FlightBookingSystemSample-0.0.1-SNAPSHOT.war do folderu webapps tomcat images, aby upewnić się, że podczas inicjowania serwera aplikacji tomcat znajdzie FlightBookingSystemSample-0.0.1-SNAPSHOT.war element do zainstalowania na serwerze aplikacji.
EXPOSE	EXPOSE 8080 jest wymagany, ponieważ usługa Tomcat jest skonfigurowana do nasłuchiwania ruchu na porcie 8080. Dzięki temu proces platformy 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"] program Docker inicjuje serwer aplikacji Tomcat.

Uwaga

Bez tagu wersji w FROM tomcat wierszu zostanie zastosowana najnowsza wersja. Ogólnie rzecz biorąc, należy użyć tagu wersji (pamiętaj, że buforowanie jest stosowane, więc jeśli warstwy stale się zmieniają, spowoduje to naliczenie przepustowości, opóźnienia, czasu obliczeniowego i/lub skutków ubocznych nietestowanych kompilacji/warstw). Dla dobra tego modułu wybraliśmy wstępnie określone tagi Maven, Tomcat i Java JRE/JDK, które są testowane pod kątem pracy ze FlightBookingSystemSample-0.0.1-SNAPSHOT.war środowiskiem uruchomieniowym.

Aby uzyskać więcej informacji na temat budowy pliku Dockerfile, zobacz Dokumentacja pliku Dockerfile