streamalism.org

1. Uvod

Kako se sve više organizacija kreće prema kontejnerima i virtualnim poslužiteljima, Docker postaje sve značajniji dio procesa razvoja softvera. U tu svrhu jedna od sjajnih novih značajki Spring Boot-a 2.3 je sposobnost jednostavnog stvaranja Dockerove slike za Spring Boot programe.

U ovom ćemo uputstvu pogledati kako stvoriti Docker slike za aplikaciju Spring Boot.

2. Tradicionalne Docker građevine

Tradicionalni način izrade Dockerovih slika pomoću Spring Boot-a je upotreba Dockerfile-a. Slijedi jednostavan primjer:

OD openjdk: 8-jdk-alpine EXPOSE 8080 ARG JAR_FILE = target / demo-app-1.0.0.jar DODAJ $ {JAR_FILE} app.jar ENTRYPOINT ["java", "- jar", "/ app.jar"]

Tada bismo mogli koristiti gradnja dockera naredba za stvaranje Dockerove slike. To dobro funkcionira za većinu aplikacija, ali postoji nekoliko nedostataka.

Prvo, koristimo staklenku masti koju je stvorio Spring Boot. To može utjecati na vrijeme pokretanja, posebno u kontejneriranom okruženju. Vrijeme uštede možemo uštedjeti dodavanjem eksplodiranog sadržaja jar datoteke.

Drugo, Dockerove slike ugrađene su u slojeve. Priroda staklenki masti Spring Boot uzrokuje da se sav aplikacijski kod i biblioteke trećih strana stave u jedan sloj. To znači da se čak i kada se promijeni samo jedan redak koda, cijeli sloj mora obnoviti.

Eksplodiranjem staklenke prije gradnje, aplikacijski kod i knjižnice nezavisnih proizvođača dobivaju svaki svoj sloj. To nam omogućuje da iskoristimo Dockerov mehanizam za predmemoriranje. Sada, kada se promijeni jedan redak koda, treba obnoviti samo taj odgovarajući sloj.

Imajući ovo na umu, pogledajmo kako je Spring Boot poboljšao postupak stvaranja Dockerovih slika.

3. Građevinski paketi

Buildpacks su alat koji pruža ovisnosti o okviru i aplikacijama.

Na primjer, s obzirom na staklenku masti Spring Boot, buildpack bi nam pružio Java radno vrijeme. To nam omogućuje da preskočimo Dockerfile i automatski dobijemo razumnu Dockerovu sliku.

Spring Boot uključuje podršku za Maven i Gradle za buildpacks. Na primjer, gradeći s Mavenom, pokrenuli bismo naredbu:

./mvnw spring-boot: build-image

Pogledajmo neke od relevantnih rezultata kako bismo vidjeli što se događa:

[INFO] Izrada jar: target / demo-0.0.1-SNAPSHOT.jar ... [INFO] Izgradnja slike 'docker.io/library/demo-0.0.1-SNAPSHOT' ... [INFO]> Povlačenje slike graditelja 'gcr.io/paketo-buildpacks/builder:base-platform-api-0.3' 100% ... [INFO] [kreator] ===> OTKRIVANJE [INFO] [kreator] 5 od 15 graditeljskih paketa koji sudjeluju [INFO] [ kreator] paketo-buildpacks / bellsoft-liberica 2.8.1 [INFO] [kreator] paketo-buildpacks / izvršna-jar 1.2.8 [INFO] [kreator] paketo-buildpacks / apache-tomcat 1.3.1 [INFO] [kreator] paketo-buildpacks / dist-zip 1.3.6 [INFO] [kreator] paketo-buildpacks / spring-boot 1.9.1 ... [INFO] Uspješno izgrađena slika 'docker.io/library/demo-0.0.1-SNAPSHOT' [INFO] Ukupno vrijeme: 44.796 s

Prva linija pokazuje da smo izgradili našu standardnu ​​staklenku za masnoću, baš kao i svaki tipični maven paket.

Sljedeći redak započinje izgradnju Dockerove slike. Odmah nakon toga vidimo kako gradnja povlači Packeto graditelj.

Packeto je implementacija cloud-native buildpacks-a. Obavlja posao analize našeg projekta i određivanja potrebnih okvira i knjižnica. U našem slučaju utvrđuje da imamo projekt Spring Boot i dodaje potrebne građevinske pakete.

Konačno, vidimo generiranu Dockerovu sliku i ukupno vrijeme izrade. Primijetite kako prvi put kada gradimo provodimo poprilično vremena preuzimajući buildpacks i stvarajući različite slojeve.

Jedna od sjajnih značajki buildpack-a je ta da je Dockerova slika višestruka. Dakle, ako promijenimo samo kod aplikacije, naknadne izrade bit će mnogo brže:

... [INFO] [kreator] Ponovna upotreba sloja 'paketo-buildpacks / izvršna-jar: put-klasa' [INFO] [kreator] Ponovna upotreba sloja 'paketo-buildpacks / spring-boot: web-application-type' ... [INFO] Uspješno izgrađena slika 'docker.io/library/demo-0.0-SNAPSHOT' ... [INFO] Ukupno vrijeme: 10.591 s

4. Slojevite staklenke

U nekim slučajevima možda radije ne koristimo buildpack-ove - možda je naša infrastruktura već povezana s drugim alatom ili već imamo prilagođene Dockerfilove koje želimo ponovno koristiti.

Iz tih razloga Spring Boot također podržava izgradnju Dockerovih slika pomoću slojevitih posuda. Da bismo razumjeli kako to funkcionira, pogledajmo tipični raspored staklenki za masti Spring Boot:

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

Staklenka masti sastoji se od 3 glavna područja:

• Klase pokretanja potrebne za pokretanje aplikacije Spring
• Šifra aplikacije
• Biblioteke treće strane

Kod slojevitih staklenki struktura izgleda slično, ali dobivamo novu slojevi.idx datoteka koja preslikava svaki direktorij u staklenki masti u sloj:

- "ovisnosti": - "BOOT-INF / lib /" - "spring-boot-loader": - "org /" - "snapshot-dependencies": - "application": - "BOOT-INF / classes /" - "BOOT-INF / classpath.idx" - "BOOT-INF / layer.idx" - "META-INF /"

Izvan okvira, Spring Boot nudi četiri sloja:

• ovisnosti: tipične ovisnosti trećih strana
• ovisnosti o snimkama: ovisnosti o snimkama trećih strana
• resursi: statički resursi
• primjena: aplikacijski kod i resursi

Cilj je smjestiti kod aplikacije i biblioteke trećih strana u slojeve koji odražavaju koliko se često mijenjaju.

Na primjer, aplikacijski kôd je vjerojatno ono što se najčešće mijenja, pa dobiva svoj vlastiti sloj. Nadalje, svaki se sloj može samostalno razvijati i tek kad se sloj promijeni, obnovit će se za Dockerovu sliku.

Sad kad razumijemo novu strukturu slojevitih posuda, pogledajmo kako je možemo koristiti za izradu Dockerovih slika.

4.1. Stvaranje slojevitih staklenki

Prvo, moramo postaviti naš projekt za stvaranje slojevite tegle. S Mavenom to znači dodavanje nove konfiguracije u odjeljak dodatka Spring Boot našeg POM-a:

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

S ovom konfiguracijom, Maven paket naredba (zajedno s bilo kojom od njezinih ovisnih naredbi) generirat će novu slojevitu jar koristeći četiri prethodno spomenuta zadana sloja.

4.2. Pregled i izdvajanje slojeva

Dalje, moramo izvući slojeve iz staklenke kako bi Dockerova slika imala odgovarajuće slojeve.

Da bismo ispitali slojeve bilo koje slojevite staklenke, možemo pokrenuti naredbu:

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

Tada bismo ih izvukli, pokrenuli bismo:

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

4.3. Stvaranje Dockerove slike

Najlakši način da se ovi slojevi ugrade u Dockerovu sliku je pomoću Dockerfile-a:

OD usvajanjapenjdk: 11-jre-hotspot kao graditelj ARG JAR_FILE = target / *. Jar COPY $ {JAR_FILE} application.jar RUN java -Djarmode = layertools -jar application.jar ekstrakt IZ adoptopenjdk: 11-jre-hotspot COPY --od = graditeljske ovisnosti / ./ COPY - od = graditelj snapshot-ovisnosti / ./ COPY --od = builder spring-boot-loader / ./ COPY --od = application builder / ./ ENTRYPOINT ["java", "org .springframework.boot.loader.JarLauncher "]

Ovaj Dockerfile ekstrahira slojeve iz naše staklenke masti, a zatim kopira svaki sloj u Dockerovu sliku. Svaki KOPIRATI direktiva rezultira novim slojem na konačnoj Dockerovoj slici.

Ako izgradimo ovaj Dockerfile, možemo vidjeti kako se svaki sloj iz slojevite staklenke dodaje na Dockerovu sliku kao vlastiti sloj:

... Korak 6/10: COPY --from = graditeljske ovisnosti / ./ ---> 2c631b8f9993 Korak 7/10: COPY --from = builder snapshot-dependencies / ./ ---> 26e8ceb86b7d Korak 8/10: COPY --from = builder spring-boot-loader / ./ ---> 6dd9eaddad7f Korak 9/10: COPY --from = aplikacija graditelja / ./ ---> dc80cc00a655 ...

5. Zaključak

U ovom uputstvu vidjeli smo razne načine za izgradnju Dockerovih slika pomoću Spring Boot-a. Korištenjem buildpacka možemo dobiti odgovarajuće Dockerove slike bez uzorka ili prilagođenih konfiguracija. Ili, uz malo više truda, možemo koristiti slojevite staklenke kako bismo dobili prilagođeniju Dockerovu sliku.

Svi primjeri u ovom vodiču mogu se naći na GitHubu.

Za daljnje informacije o korištenju Jave i Dockera pogledajte tutorial o jibu.