Java-alkalmazás tárolóba helyezése

Befejeződött

Ebben a leckében egy Java-alkalmazást tárolóba helyez.

Ahogy korábban említettük, a tárolók közvetlenül a gazdagép operációs rendszerének, kernelének és hardverének tetején futnak, mint szokásos rendszerfolyamatok. A tárolók kevesebb rendszererőforrást igényelnek, ami kisebb erőforrásigényt, kevesebb többletterhelést és gyorsabb alkalmazásindítási időt eredményez. Ezek az előnyök nagy felhasználási esetek az igény szerinti skálázáshoz.

Vannak Windows-tárolók és Linux-tárolók. Ebben a modulban a széles körben használt Docker-futtatókörnyezetet használja Linux-tárolólemezképek létrehozásához. Ezután üzembe helyezi a Linux-tárolórendszerképet a helyi gép gazda operációs rendszerére. Végül üzembe helyezi a Linux-tárolórendszerképet az Azure Kubernetes Service-ben.

A Docker áttekintése

A Docker-futtatókörnyezet tárolólemezképek létrehozására, lekérésére, futtatására és leküldésére szolgál, ahogyan az alábbi ábrán látható:

Az alábbi táblázat az egyes Docker-parancsokat ismerteti:

Docker-parancs	Leírás
docker build	Létrehoz egy tárolórendszerképet, amely a Dockerhez szükséges utasításokat vagy rétegeket tartalmazza egy futó tároló lemezképből való létrehozásához. A parancs eredménye egy kép.
docker pull	A tárolók rendszerképekből inicializálódnak, amelyeket a rendszer olyan regisztrációs adatbázisokból von le, mint az Azure Container Registry. Ebből a beállításjegyzékből kér le az Azure Kubernetes Service. Ennek a parancsnak az eredménye egy rendszerkép hálózati lekérése, amely az Azure-ban történik. Igény szerint helyileg is lekérheti a képeket. Ezt a beállítást gyakran használják, amikor olyan rendszerképeket készítenek, amelyekre az alkalmazásának szüksége lehet, mint például egy alkalmazáskiszolgáló, ami különböző függőségeket vagy rétegeket igényelhet.
docker run	A képfájl futó példánya egy tároló, és ez a parancs végrehajtja az összes réteget, amelyek szükségesek a futó tárolóalkalmazással való futtatáshoz és interakcióhoz. Ennek a parancsnak az eredménye egy futó alkalmazásfolyamat a gazdagép operációs rendszerén.
docker push	Az Azure Container Registry tárolja a rendszerképeket, hogy könnyen elérhetők legyenek és hálózati közelségben legyenek az Azure-ba történő kiépítésekhez és a méretezéshez.

A Java-alkalmazás klónozása

Először klónozza a Flight Booking System for Airline Reservations adattárat, és keresse meg a Airlines webalkalmazás projektmappáját.

Jegyzet

Ha az Azure Kubernetes Service létrehozása befejeződött a CLI lapján, használja ezt a lapot. Ha még mindig fut, nyisson meg egy új lapot, és keresse meg azt a helyet, ahol a repülőjárat-foglalási rendszert szeretné klónozni.

Futtassa az alábbi parancsot:

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

Ha telepítve van a Java és a Maven, a terminálkonzolon futtathatja a következő parancsot, hogy átlássa az alkalmazás Docker nélküli létrehozásának élményét. Ha nincs telepítve a Java és a Maven, folytassa a következő, Docker-fájl összeállítása című szakaszsal. Ebben a szakaszban Dockert használ a Java és a Maven letöltésére, hogy azok az Ön helyett hajtsák végre az építési folyamatokat.

mvn clean package

Jegyzet

A mvn clean package parancs segítségével bemutattuk a Docker multistage-buildek használatának sikertelenségével kapcsolatos üzemeltetési kihívásokat, amelyeket a következő lépésben bemutatunk. Ez a lépés nem kötelező. Akárhogy is, a Maven parancs végrehajtása nélkül is biztonságosan folytathatja a műveletet.

Ha a folyamat sikeres volt, a Maven sikeresen elkészítette a Flight Booking System for Airline Reservations Web Application Archive artifact AirlinesReservationSample-0.0.1-SNAPSHOT.war összetevőt, amint az a következő kimenetben látható:

[INFO] Building war: $PROJECT_PATH/containerize-and-deploy-Java-app-to-Azure/Project/Airlines/target/AirlinesReservationSample-0.0.1-SNAPSHOT.war
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  11.776 s
[INFO] Finished at: 2024-11-15T09:33:26+09:00
[INFO] ------------------------------------------------------------------------

Tegyük fel, hogy Ön Java-fejlesztő, és most építette fel a AirlinesReservationSample-0.0.1-SNAPSHOT.war-t. A következő lépés valószínűleg az, hogy a műveleti mérnökökkel együttműködve üzembe helyezi ezt az összetevőt egy helyszíni kiszolgálón vagy egy virtuális gépen. Ahhoz, hogy az alkalmazás sikeresen elinduljon és fusson, a kiszolgálóknak és a virtuális gépeknek elérhetőnek kell lenniük, és konfigurálniuk kell a szükséges függőségekkel. Ez a folyamat kihívást jelent és időigényes, különösen igény szerint, amikor a megnövekedett terhelés eléri az alkalmazást. A tárolók enyhítik ezeket a kihívásokat.

Docker-fájl létrehozása

Most már készen állsz egy Docker-fájl megírására. A Dockerfile egy szöveges dokumentum, amely tartalmazza az összes parancsot, amelyet a felhasználó végrehajtana a parancssorban egy tárolólemezkép összeállításához. Minden kép egy olyan réteg, amely gyorsítótárazható a hatékonyság érdekében. A rétegek egymásra épülnek.

A Flight Booking System for Airline Reservations rendszernek például egy alkalmazáskiszolgálón kell üzembe helyeznie és futtatnia kell. Az alkalmazáskiszolgálók nincsenek a AirlinesReservationSample-0.0.1-SNAPSHOT.war csomagban. Ez egy külső függőség, amely szükséges a AirlinesReservationSample-0.0.1-SNAPSHOT.war futtatásához, HTTP-kérések figyeléséhez és feldolgozásához, a felhasználói munkamenetek kezeléséhez és a járatfoglalások megkönnyítéséhez. Ha hagyományos, nem tárolóalapú üzembe helyezést használ, a műveleti mérnökök egy alkalmazáskiszolgálót telepítenének és konfigurálnak valamilyen fizikai kiszolgálón vagy virtuális gépen, mielőtt üzembe helyeznék a AirlinesReservationSample-0.0.1-SNAPSHOT.war parancsot. Ezeknek a műveleti mérnököknek azt is biztosítaniuk kell, hogy a gépen használt JDK - amely mvn clean package a WAR-fájl fordításához használatos - valójában megegyezik az alkalmazáskiszolgáló által használt JRE-val. Ezeknek a függőségeknek a kezelése kihívást jelent és időigényes.

Egy Dockerfile használatával automatikusan megírhatja a cél eléréséhez szükséges utasításokat vagy rétegeket, ha rétegezi azokat a lépéseket, amelyek biztosítják, hogy a Flight Booking System for Airline Reservations tartalmazza a Docker-tároló futtatókörnyezetben való üzembe helyezéshez szükséges összes függőséget. Ez a megoldás meggyőző, ha igény szerint kell skálázni nem tervezett időközönként. Minden réteg Docker-gyorsítótárat használ, amely tartalmazza a tárolólemezkép állapotát minden egyes utasítási mérföldkőnél, optimalizálva a számítási időt és az újrafelhasználást. Ha egy réteg nem változik, a rendszer gyorsítótárazott rétegeket használ. A gyorsítótárazott rétegek gyakori használati esetei a Java-futtatókörnyezet, az alkalmazáskiszolgáló és a Flight Booking System for Airline Reservations webalkalmazás egyéb függőségei. Ha egy verzió megváltozik egy korábban gyorsítótárazott rétegen, létrejön egy új gyorsítótárazott bejegyzés.

Az alábbi ábra egy tárolórendszerkép rétegeit ábrázolja. A Dockerfile parancsainak végrehajtásakor a rétegek létrejönnek. A legfelső réteg a Repülőjegy Foglalási Rendszer olvasási/írási rendszere a Légitársasági Foglalások webalkalmazás rétegéhez. Ez a réteg az előző írásvédett rétegekre épül.

A Docker többlépcsős buildek koncepcióját használja, amely lehetővé teszi egy kisebb tárolórendszerkép létrehozását jobb gyorsítótárazással és kisebb biztonsági lábnyommal, ami lehetővé teszi a Dockerfile optimalizálását és karbantartását az idő múlásával. Különválaszthatja például a tároló buildelési szakaszát az alkalmazás összeállításához és elkészítéséhez az alkalmazás futtatásának fázisától. Ez a funkció lehetővé teszi, hogy csak a build folyamat során létrehozott artifaktumokat másolja az éles konténerképre, ezzel csökkentve a lábnyomot. Mivel a tárolólemezképek gyorsítótárazva vannak, ha nincsenek változások, a gyorsítótárazott rendszerképek újra felhasználhatók, így csökkenthető a hálózatról való letöltés költsége és ideje.

Az éles környezetben közzétett szolgáltatásokat gondosan kell felügyelni a biztonság érdekében. Ezért az éles környezet biztonságos tárolórendszerképet használ és üzemeltet. A példa a CBL-Mariner Microsoft által biztosított képet használja.

CBL-Mariner Linux egy egyszerű operációs rendszer, amely csak a felhőkörnyezethez szükséges csomagokat tartalmazza. Egyéni csomagokkal és eszközökkel testre szabhatja az alkalmazás követelményeinek megfelelően. CBL-Mariner Azure-érvényesítési teszteken megy keresztül, és kompatibilis az Azure-ügynökökkel. A Microsoft különböző használati eseteket fejleszt és tesztel CBL-Mariner, az Azure-szolgáltatásoktól kezdve az IoT-infrastruktúra kiépítéséig. Ez a Belsőleg ajánlott Linux-disztribúció a Microsoft felhőszolgáltatásaival és a kapcsolódó termékekkel való használatra.

Jegyzet

A Microsoft az OpenJDK-val csomagba helyezett tárolólemezképeket, köztük Ubuntu, CBL-Marinerés distroless képeket is biztosít. A distroless kép mérete a legkisebb, viszont a Tomcat futtatása rajta kihívást jelent. A könnyű kialakítás érdekében a distroless rendszerkép számos parancsot és eszközt eltávolít, köztük a shellt is, ami azt jelenti, hogy nem tudja használni a catalina.sh fájlt a Tomcat elindításához. A distroless rendszerkép végrehajtható JAR-k futtatására alkalmas, például a Spring Boothoz vagy a Quarkushoz használtakhoz.

Az alábbi példában az OpenJDK Microsoft Buildjének ugyanazt a verzióját használják a buildelési szakaszban és az utolsó szakaszban is. Ez a megközelítés biztosítja, hogy a forráskódot a Szolgáltatás üzembe helyezése Tomcat által használt JDK-verzióval hozza létre, amely segít elkerülni a verzióeltérések miatti váratlan viselkedést.

Az alábbi képen a Dockerfile-ban megadott parancsok alapján a többlépcsős build és az egyes szakaszokban előforduló események láthatók:

A 0. fázisban a Rendszer letölti és kinyeri a Tomcatet egy környezeti változó által megadott könyvtárba egy Ubuntu-rendszerképen. A TOMCAT_VERSION változó megadja a letölteni kívánt Tomcat verzióját. Ha megjelent a Tomcat új verziója, frissítenie kell a verziószámot, mivel a rendszer csak a verziószám változásakor kéri le az új lemezképet. Ellenkező esetben a gyorsítótárazott képet használja. A letöltött Tomcat a végső fázis környezetébe másolódik használatra.

Az 1. fázisban a Maven egy Ubuntu-lemezképre van telepítve, és a létrehozott forráskód és konfigurációs fájlok át lesznek másolva a Maven-projekt létrehozása előtt. Minden réteg gyorsítótárazva van, így az operációsrendszer-rendszerkép és a Maven-rendszerképrétegek újra felhasználják a gyorsítótárat. Ha a konfigurációs fájlok, a forráskódfájlok vagy a webkönyvtár frissülnek, a módosításokból származó rétegek újraépülnek. Ha a build a fordítás során hibák nélkül sikeresen befejeződik, a célkönyvtárban létrejön egy AirlinesReservationSample-0.0.1-SNAPSHOT.war nevű összetevő. Ezt az összetevőt a rendszer a végső fázis környezetbe másolja használat céljából.

Az utolsó szakaszban a Microsoft által biztosított biztonságos CBL-Mariner rendszerképet használjuk a Tomcat és Java buildösszetevők másolásához a 0. és az 1. fázisból. Az app nevű felhasználó a projektben használt összes fájl tulajdonosa, és az alkalmazás app felhasználóként fut ahelyett, hogy root jogosultságai lennének. Ez a beállítás biztosítja, hogy a tárolólemezkép biztonságosan, szükségtelen engedélyek megadása nélkül működjön. Végül a 8080-es port ki van téve, és a catalina.sh szkript a Tomcat elindításához lesz végrehajtva. Ha ezt a helyi Docker Desktopban futtatja, az URL-címen http://localhost:8080/AirlinesReservationSamplekeresztül érheti el.

A projekt gyökérmappájában( containerize-and-deploy-Java-app-to-Azure/Project/Airlines) a következő paranccsal hozzon létre egy Dockerfile nevű fájlt:

vi Dockerfile

Adja hozzá a következő tartalmat a Dockerfile-hoz, majd mentse és lépjen ki. A mentéshez és a kilépéshez nyomja le az ESC billentyűt, írja be a következőt: wq!, majd nyomja le az Enter billentyűt.

############################################
# Tomcat Intall stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat

ENV CATALINA_HOME=/usr/local/tomcat

# Configure Tomcat Version (Be sure to use the latest version)
ENV TOMCAT_VERSION=10.1.33

# Install Tomcat and required packages
RUN apt-get update ; \
    apt-get install -y curl ; \
    curl -O https://downloads.apache.org/tomcat/tomcat-10/v${TOMCAT_VERSION}/bin/apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    tar xzf apache-tomcat-${TOMCAT_VERSION}.tar.gz ; \
    mv apache-tomcat-${TOMCAT_VERSION} ${CATALINA_HOME} ; \
    rm apache-tomcat-${TOMCAT_VERSION}.tar.gz && \
    apt-get remove --purge -y curl && \
    apt-get autoremove -y && \
    apt-get clean

############################################
# Build stage (Compiles with Java 17)
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build

WORKDIR /build

# Install Maven
RUN apt-get update && apt-get install -y maven && mvn --version

# Copy source code
COPY pom.xml .
COPY src ./src
COPY web ./web

# Build the project
RUN mvn clean package

############################################
# Package final stage
############################################
FROM mcr.microsoft.com/openjdk/jdk:17-mariner

# Configure the location of the Tomcat installation
ENV CATALINA_HOME=/usr/local/tomcat
# Configure the path to the Tomcat binaries
ENV PATH=$CATALINA_HOME/bin:$PATH

# This is the user that runs the Tomcat process
USER app

# Copy the Tomcat installation from the Tomcat stage
COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME}
# Copy the Tomcat configuration files
COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf
# Copy the compiled WAR file from the build stage
COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war

# Expose the default Tomcat port
EXPOSE 8080
# Start Tomcat
CMD ["catalina.sh", "run"]

Jegyzet

Szükség esetén használhatja a Dockerfile_Solution fájlt a projekt gyökerében, amely tartalmazza a szükséges tartalmat.

A Dockerfile három szakaszra van osztva, amelyeket az alábbi táblázatok írnak le:

• A Tomcat telepítési szakasza:

  Docker-parancs	Leírás
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS tomcat az alaprendszerképet az Ubuntu-on futó OpenJDK 17-es Microsoft-buildre állítja, és ezt a szakaszt tomcatnevezi el. Itt települ a Tomcat.
  ENV	ENV CATALINA_HOME=/usr/local/tomcat beállít egy környezeti változót a Tomcat telepítési könyvtárához.
  ENV	ENV TOMCAT_VERSION=10.1.33 beállítja a Tomcat verzióját a telepítésre. Ezt szükség szerint frissíteni kell a legújabb verzióra.
  RUN	A RUN parancs frissíti a csomaglistát, telepíti curl, letölti a Tomcat megadott verzióját, kinyeri, áthelyezi a megadott könyvtárba, és eltávolítja a szükségtelen fájlokat és csomagokat. Ez biztosítja, hogy a kép könnyű maradjon.

• A Java 17-et tartalmazó buildelési szakasz:

  Docker-parancs	Leírás
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-ubuntu AS build az alaprendszerképet az Ubuntu-on futó OpenJDK 17-es Microsoft-buildre állítja, és ezt a szakaszt buildnevezi el. Ez a szakasz a Java-alkalmazás összeállítására szolgál.
  WORKDIR	WORKDIR /build a tárolóban /buildlévő munkakönyvtárat a forráskód másolásához és fordításához állítja be.
  RUN	RUN apt-get update && apt-get install -y maven && mvn --version Telepíti a Mavent, a Java-projektekhez használt buildautomatizálási eszközt, és ellenőrzi annak telepítését.
  COPY	COPY pom.xml . átmásolja a Maven-konfigurációs fájlt a munkakönyvtárba. Ez a fájl elengedhetetlen a projekt létrehozásához.
  COPY	COPY src ./src átmásolja a forráskód könyvtárát a tárolóba. Itt található a Java-alkalmazás kódja.
  COPY	COPY web ./web átmásolja a webes erőforrások könyvtárát a tárolóba. Ide tartoznak a buildhez szükséges webalkalmazás-erőforrások.
  RUN	RUN mvn clean package végrehajtja a Maven buildelési folyamatát, amely lefordítja a Java-alkalmazást, és egy WAR-fájlba csomagolja.

• A csomag utolsó szakasza:

  Docker-parancs	Leírás
  FROM	FROM mcr.microsoft.com/openjdk/jdk:17-mariner az alaprendszerképet a Microsoft OpenJDK 17-es CBL-Marinerbuildjéhez állítja be, amely az alkalmazás végső üzembe helyezéséhez használatos.
  ENV	ENV CATALINA_HOME=/usr/local/tomcat beállítja a Tomcat telepítési könyvtár környezeti változóját a telepítési fázishoz hasonlóan.
  ENV	ENV PATH=$CATALINA_HOME/bin:$PATH Hozzáadja a Tomcat bin könyvtárat a rendszerhez PATH, így a Tomcat-parancsok egyszerűen futtathatók.
  USER	USER app Meghatározza a felhasználót, amely alatt a Tomcat-folyamat fut, és növeli a biztonságot azáltal, hogy nem főfelhasználóként fut.
  COPY	COPY --chown=app:app --from=tomcat ${CATALINA_HOME} ${CATALINA_HOME} átmásolja a Tomcat-telepítést a tomcat fázisból, és beállítja a tulajdonjogot a app felhasználónak.
  COPY	COPY --chown=app:app tomcat-users.xml ${CATALINA_HOME}/conf átmásolja a Tomcat felhasználói konfigurációs fájlját a tárolóba, és beállítja a felhasználó tulajdonjogát app .
  COPY	COPY --chown=app:app --from=build /build/target/*.war ${CATALINA_HOME}/webapps/AirlinesReservationSample.war átmásolja a lefordított WAR-fájlt a build szakaszból a Tomcat webapps könyvtárba, és a tulajdonost a app felhasználóra állítja.
  EXPOSE	EXPOSE 8080 a Tomcat alapértelmezett portja, a 8080-at teszi elérhetővé, amely lehetővé teszi az alkalmazás külső elérését.
  CMD	CMD ["catalina.sh", "run"] A tároló futtatásakor a Tomcat elindításához szükséges parancsot adja meg.

A Dockerfile felépítéséről további információt a Dockerfile-referencia tartalmaz.