streamalism.org

1. Bemutatkozás

Ahogy egyre több szervezet halad a konténerek és a virtuális szerverek felé, a Docker a szoftverfejlesztési munkafolyamatok egyre jelentősebb részévé válik. Ebből a célból a Spring Boot 2.3 egyik nagyszerű újdonsága, hogy egyszerűen létrehozhat egy Docker képet a Spring Boot alkalmazásokhoz.

Ebben az oktatóanyagban megvizsgáljuk, hogyan lehet Docker képeket létrehozni egy Spring Boot alkalmazáshoz.

2. A hagyományos dokkoló épít

A Docker képek Spring Boot alkalmazással történő elkészítésének hagyományos módja a Dockerfile használata. Az alábbiakban egy egyszerű példa található:

FROM openjdk: 8-jdk-alpine EXPOZÍCIÓ 8080 ARG JAR_FILE = target / demo-app-1.0.0.jar ADD $ {JAR_FILE} app.jar ENTRYPOINT ["java", "- jar", "/ app.jar"]

Ezután használhatnánk a dokkoló építése parancsot egy Docker-kép létrehozásához. Ez a legtöbb alkalmazásnál jól működik, de van néhány hátránya.

Először a Spring Boot által létrehozott kövér edényt használjuk. Ez befolyásolhatja az indítási időt, különösen konténeres környezetben. Az indítási időt úgy spórolhatjuk meg, hogy ehelyett hozzáadjuk a jar fájl felrobbant tartalmát.

Másodszor, a Docker-képek rétegekben vannak felépítve. A Spring Boot zsírtartályok jellege miatt az összes alkalmazáskód és a harmadik fél könyvtárai egyetlen rétegbe kerülnek. Ez azt jelenti, hogy amikor csak egyetlen kódsor változik, a teljes réteget újra kell építeni.

Az építkezés előtt az üveg felrobbantásával az alkalmazáskód és a harmadik fél könyvtárai mindegyike megkapja a saját rétegét. Ez lehetővé teszi számunkra, hogy kihasználjuk a Docker gyorsítótár-mechanizmusának előnyeit. Most, amikor az egyik kódsor megváltozik, csak azt a megfelelő réteget kell újjáépíteni.

Ezt szem előtt tartva nézzük meg, hogyan javította a Spring Boot a Docker képek létrehozásának folyamatát.

3. Építőcsomagok

A Buildpacks egy olyan eszköz, amely keretrendszer- és alkalmazásfüggőségeket biztosít.

Például, ha adunk egy Spring Boot zsírtartályt, egy buildpack biztosítaná a Java futási időt számunkra. Ez lehetővé teszi számunkra, hogy kihagyjuk a Docker fájlt, és automatikusan értelmes Docker képet kapjunk.

A Spring Boot mind a Maven, mind a Gradle támogatást tartalmazza a build-ekhez. Például Maven-lel építve futtatjuk a parancsot:

./mvnw spring-boot: build-image

Nézzünk meg néhány releváns kimenetet, hogy lássuk, mi történik:

[INFO] Építési üveg: target / demo-0.0.1-SNAPSHOT.jar ... [INFO] Épületkép 'docker.io/library/demo:0.0.1-SNAPSHOT' ... [INFO]> Építői kép húzása 'gcr.io/paketo-buildpacks/builder:base-platform-api-0.3' 100% ... [INFO] [alkotó] ===> [INFO] ÉSZLELÉSE [alkotó] 15 résztvevő beépítő csomagból 5 [INFO] [ készítő] paketo-buildpacks / bellsoft-liberica 2.8.1 [INFO] [készítő] paketo-buildpacks / végrehajtható-jar 1.2.8 [INFO] [készítő] paketo-buildpacks / apache-tomcat 1.3.1 [INFO] [készítő] paketo-buildpacks / dist-zip 1.3.6 [INFO] [készítő] paketo-buildpacks / spring-boot 1.9.1 ... [INFO] Sikeresen felépített kép 'docker.io/library/demo:0.0.1-SNAPSHOT' [INFO] Teljes idő: 44,796 s

Az első sor azt mutatja, hogy megépítettük a szokásos zsírtartalmú edényünket, csakúgy, mint minden tipikus maven csomagot.

A következő sorban kezdődik a Docker képépítése. Rögtön utána látjuk, hogy a buildet kihúzza a Packeto készítő.

A Packeto a felhőben natív build-csomagok megvalósítása. A projekt elemzésével, a szükséges keretek és könyvtárak meghatározásával végzi a munkát. Esetünkben meghatározza, hogy van-e Spring Boot projektünk, és hozzáadja a szükséges build-eket.

Végül megnézzük a létrehozott Docker képet és a teljes építési időt. Figyelje meg, hogy az első építkezéskor elég sok időt töltünk a build-ek letöltésével és különböző rétegek létrehozásával.

A build-ek egyik nagyszerű tulajdonsága, hogy a Docker-kép többrétegű. Tehát, ha csak az alkalmazáskódunkat változtatjuk meg, a későbbi buildek sokkal gyorsabbak lesznek:

... [INFO] [készítő] A 'paketo-buildpacks / végrehajtható-jar: class-path' réteg újrafelhasználása [INFO] [alkotó] A 'paketo-buildpacks / spring-boot: web-application-type' réteg újrafelhasználása ... [INFO] Sikeresen elkészített kép: 'docker.io/library/demo:0.0.1-SNAPSHOT' ... [INFO] Teljes idő: 10.591 s

4. Réteges üvegek

Bizonyos esetekben előfordulhat, hogy inkább nem használunk build-eket - infrastruktúránk talán már más eszközhöz van kötve, vagy már vannak egyedi Docker-fájljaink, amelyeket újra fel akarunk használni.

Ezen okok miatt a Spring Boot támogatja a Docker képek építését rétegelt üvegek segítségével. Ahhoz, hogy megértsük, hogyan működik, nézzünk meg egy tipikus Spring Boot zsírzsák elrendezést:

org / springframework / boot / loader / ... BOOT-INF / class / ... lib / ...

A zsíredény 3 fő területből áll:

• Bootstrap osztályok szükségesek a Spring alkalmazás elindításához
• Alkalmazás kódja
• Harmadik fél könyvtárai

Réteges üvegeknél a szerkezet hasonlónak tűnik, de újat kapunk rétegek.idx fájl, amely a kövér edény minden könyvtárát egy réteghez térképezi fel:

- "függőségek": - "BOOT-INF / lib /" - "spring-boot-loader": - "org /" - "pillanatkép-függőségek": - "alkalmazás": - "BOOT-INF / osztályok /" - "BOOT-INF / classpath.idx" - "BOOT-INF / layer.idx" - "META-INF /"

A dobozon kívül a Spring Boot négy réteget kínál:

• függőségek: tipikus függőségek harmadik felektől
• pillanatkép-függőségek: pillanatfelvétel-függőségek harmadik felektől
• erőforrások: statikus erőforrások
• Alkalmazás: alkalmazáskód és erőforrások

A cél az alkalmazáskód és a harmadik féltől származó könyvtárak olyan rétegekbe helyezése, amelyek tükrözik a változtatás gyakoriságát.

Például valószínűleg az alkalmazáskód változik a leggyakrabban, ezért megkapja a saját rétegét. Ezenkívül minden réteg önmagában fejlődhet, és csak akkor, ha egy réteg megváltozott, újjáépítik a Docker képhez.

Most, hogy megértettük az új réteges üvegszerkezetet, nézzük meg, hogyan használhatjuk fel Docker képek készítéséhez.

4.1. Réteges edények készítése

Először fel kell állítanunk a projektünket, hogy létrehozzunk egy réteges edényt. A Mavennél ez azt jelenti, hogy új konfigurációt adunk a POM Spring Boot plugin szakaszához:

 org.springframework.boot spring-boot-maven-plugin true 

Ezzel a konfigurációval a Maven csomag A parancs (bármelyik függő paranccsal együtt) egy új réteget hoz létre az előbb említett négy alapértelmezett réteg felhasználásával.

4.2. Rétegek megtekintése és kinyerése

Ezután ki kell húznunk a rétegeket az üvegből, hogy a Docker kép megfelelő rétegekkel rendelkezzen.

Bármely réteges edény rétegének vizsgálatához futtathatjuk a parancsot:

java -Djarmode = layertools -jar demo-0.0.1.jar lista

Aztán, hogy kivonjuk őket, futnánk:

java -Djarmode = layertools -jar demo-0.0.1.jar kivonat

4.3. A Docker kép létrehozása

Ezeket a rétegeket a Docker képbe a Dockerfájl segítségével lehet legegyszerűbben beépíteni:

FROM adoptopenjdk: 11-jre-hotspot építőként ARG JAR_FILE = target / *. Jar COPY $ {JAR_FILE} application.jar RUN java -Djarmode = layertools -jar application.jar extract FROM adoptopenjdk: 11-jre-hotspot COPY --from = építő függőségek / ./ MÁSOLAT - innen = építő pillanatkép-függőségek / ./ MÁSOLAT - innen: = építő tavaszi rendszerindító-betöltő / ./ MÁSOLAT - innen = építő alkalmazás / ./ ENTRYPOINT ["java", "org .springframework.boot.loader.JarLauncher "]

Ez a Dockerfile kivonja a rétegeket a zsírtartályunkból, majd minden réteget átmásol a Docker képbe. Minden egyes MÁSOLAT irányelv új réteget eredményez a végső Docker-képben.

Ha elkészítjük ezt a Dockerfile-t, láthatjuk, hogy a réteges edény minden egyes rétege saját rétegként kerül a Docker képbe:

... 6/10. Lépés: MÁSOLÁS - from = építő függőségei / ./ ---> 2c631b8f9993 7/10 lépés: COPY - from = építő pillanatkép-függőségei / ./ ---> 26e8ceb86b7d 8/10 lépés: MÁSOLÁS - from = builder spring-boot-loader / ./ ---> 6dd9eaddad7f 9/10 lépés: MÁSOLÁS - from = építő alkalmazás / ./ ---> dc80cc00a655 ...

5. Következtetés

Ebben az oktatóanyagban számos módszert láthattunk a Docker képek tavaszi indítással történő elkészítésére. A buildpackok segítségével megfelelő Docker képeket kaphatunk kazánlemez vagy egyedi konfigurációk nélkül. Vagy egy kicsit nagyobb erőfeszítéssel rétegelt edényeket használhatunk a testre szabottabb Docker kép elkészítéséhez.

Az oktatóanyag összes példája megtalálható a GitHubon.

A Java és a Docker használatával kapcsolatos további információkért tekintse meg a jib oktatóanyagát.