streamalism.org

1. Áttekintés

Ebben a cikkben arra fogunk koncentrálni, hogy hogyan lehet dokkolni a Tavaszi csomagtartó alkalmazás futtatni elszigetelt környezetben, más néven. tartály.

Ezenkívül megmutatjuk, hogyan lehet létrehozni egy olyan tárolók összetételét, amelyek függenek egymástól és össze vannak kapcsolva egymással egy virtuális magánhálózaton. Meglátjuk azt is, hogyan lehet őket egyetlen parancsokkal együtt kezelni.

Kezdjük egy Java-kompatibilis, könnyű alapkép létrehozásával, futtatásával Alpine Linux.

2. A Buildpacks támogatása a Spring Boot 2.3-ban

A Spring Boot 2.3 támogatást adott a következőhöz: buildpacks. Egyszerűen fogalmazva, ahelyett, hogy saját Dockerfile-t hoznánk létre, és valami hasonlóval építenénk dokkoló építése, mindössze annyit kell tennünk, hogy kiadjuk a következő parancsot:

$ ./mvnw spring-boot: build-image

Vagy Gradle-ben:

$ ./gradlew bootBuildImage

A build-ek mögött álló fő motiváció ugyanaz a telepítési élmény megteremtése, amelyet néhány jól ismert felhőszolgáltatás, például a Heroku vagy a Cloud Foundry nyújt egy ideig. Csak mi futtatjuk a build-image és a platform maga gondoskodik a műtárgy felépítéséről és telepítéséről.

Ezenkívül segíthet abban, hogy hatékonyabban változtassunk a Docker képek felépítésén. Ahelyett, hogy ugyanazt a változást alkalmaznánk sok Dockerfile-ra különböző projektekben, csupán annyit kell tennünk, hogy megváltoztatjuk vagy hangoljuk a buildpackok képalkotóját.

A könnyű használat és a jobb általános fejlesztői élmény mellett hatékonyabb is lehet. Például a buildpacks megközelítés létrehoz egy réteges Docker-képet, és a Jar fájl felrobbant változatát használja.

3. Közös alapkép

Használni fogjuk Docker saját build-fájl formátum: a Dockerfile.

A Dockerfile elvileg egy vonalas kötegelt fájl, amely parancsokat tartalmaz egy kép felépítésére. Nem feltétlenül szükséges ezeket a parancsokat fájlba helyezni, mert képesek vagyunk átadni őket a parancssornak is - a fájl egyszerűen kényelmesebb.

Tehát írjuk meg először Dockerfile:

FROM alpine: edge MAINTAINER baeldung.com RUN apk hozzáadása --no-cache openjdk8 COPY files / UnlimitedJCEPolicyJDK8 / * \ /usr/lib/jvm/java-1.8-openjdk/jre/lib/security/

• TÓL TŐL: A kulcsszó TÓL TŐL, mondja Dokkmunkás hogy egy adott képet a címkéjével építési alapként használjon. Ha ez a kép nincs a helyi könyvtárban, akkor keressen online DockerHub, vagy bármely más konfigurált távoli nyilvántartáson
• KARBANTARTÓ: A KARBANTARTÓ általában e-mail cím, amely azonosítja a kép szerzőjét
• FUSS: A ... val FUSS parancsot, egy parancssort futtatunk a célrendszeren belül. Itt hasznosítjuk Alpine Linuxok csomagkezelő apk a Java 8 OpenJDK
• MÁSOLAT: Az utolsó parancs megmondja Dokkmunkás nak nek MÁSOLAT néhány fájl a helyi fájlrendszerből, konkrétan egy almappát a build könyvtárba, egy adott elérési út képébe

Követelmények: Az oktatóanyag sikeres futtatásához le kell töltenie a Java kriptográfiai kiterjesztés (JCE) korlátlan erősségű joghatósági házirend-fájlok tól től Jóslat. Egyszerűen vonja ki a letöltött archívumot egy helyi nevű mappába „Akták”.

A kép elkészítéséhez és a helyi könyvtárban való tárolásához futtatnunk kell:

docker build --tag = alpine-java: base --rm = true.

ÉRTESÍTÉS: A -címke opció megadja a kép nevét és –Rm = igaz a sikeres felépítés után eltávolítja a köztes képeket. A shell parancs utolsó karaktere egy pont, amely build-directory argumentumként működik.

4. Dokkoljon egy önálló rugós indító alkalmazást

Például egy olyan alkalmazásra, amelyet dokkolni tudunk, a spring-cloud-config / server a tavaszi felhő konfigurációs oktatóanyagból. Előkészítésként össze kell állítanunk egy futható üvegfájlt, és át kell másolnunk azt a miénkbe Dokkmunkás build-könyvtár:

oktatóanyagok $> cd spring-cloud-config / server server $> mvn package spring-boot: packack server $> cp target / server-0.0.1-SNAPSHOT.jar \ ../../spring-boot-docker/files /config-server.jar szerver $> cd ../../spring-boot-docker

Most létrehozunk egy Dockerfile nevezett Dockerfile.server a következő tartalommal:

FROM alpine-java: base MAINTAINER baeldung.com COPY files / spring-cloud-config-server.jar / opt / spring-cloud / lib / COPY files / spring-cloud-config-server-entrypoint.sh / opt / spring- cloud / bin / ENV SPRING_APPLICATION_JSON = \ '{"spring": {"cloud": {"config": {"server": \ {"git": {"uri": "/ var / lib / spring-cloud / config-repo ", \" clone-on-start ": true}}}}}} 'ENTRYPOINT [" / usr / bin / java "] CMD [" -jar "," / opt / spring-cloud / lib / spring-cloud-config-server.jar "] VOLUME / var / lib / spring-cloud / config-repo EXPOSE 8888

• TÓL TŐL: Képünk alapjául a Jáva-engedélyezett Alpine Linux, létrehozva az előző szakaszban
• MÁSOLAT: Hagytuk Dokkmunkás másolja be a jar fájlunkat a képbe
• ENV: Ezzel a paranccsal meghatározhatunk néhány környezeti változót, amelyeket a tárolóban futó alkalmazás tiszteletben fog tartani. Itt meghatározhatunk egy testreszabottat Tavaszi csomagtartó alkalmazás konfigurációval, hogy később átadhassuk a jar-futtatható fájlnak
• BELÉPÉSI PONT/CMD: Ez lesz a futtatható, amely akkor indul el, amikor a tároló elindul. Úgy kell meghatároznunk őket JSON-Array, mert egy BELÉPÉSI PONT a-val kombinálva CMD néhány alkalmazási argumentumhoz
• HANGERŐ: Mivel a tárolónk izolált környezetben fog működni, közvetlen hálózati hozzáférés nélkül, meg kell határoznunk a konfigurációs adattárunkhoz egy mountpoint-helyőrzőt
• EXPOZÍCIÓ: Itt mesélünk Dokkmunkás, melyik porton szerepel az alkalmazásunk. Ezt a portot a tároló indításakor közzéteszik a gazdagépen

Kép létrehozása a mi Dockerfile, futnunk kell „Dokkoló építése”, mint korábban:

$> docker build --file = Dockerfile.server \ --tag = config-server: legújabb --rm = true.

De mielőtt egy tárolót futtatnánk a képünkről, létre kell hoznunk egy kötetet a felszereléshez:

$> docker kötet létrehozása --name = spring-cloud-config-repo

ÉRTESÍTÉS: Míg a tároló megváltoztathatatlan, ha az alkalmazás kilépése után nem kötelezik el a képet, a kötetben tárolt adatok több tárolón is megmaradnak.

Végül futtathatjuk a tárolót a képünkről:

$> docker run --name = config-server --publish = 8888: 8888 \ - volum = spring-cloud-config-repo: / var / lib / spring-cloud / config-repo \ config-server: legújabb

• Először is nekünk kell -név a konténerünket. Ha nem, akkor az egyik automatikusan kiválasztásra kerül
• Akkor muszáj –Publikálni kitett kikötőnk (lásd Dockerfile) vendéglátónk egyik kikötőjébe. Az érték formában van megadva „Host-port: konténer-port”. Ha csak egy konténer-port van megadva, akkor véletlenszerűen kiválasztott gazdagép-port lesz használva. Ha ezt az opciót elhagyjuk, a tartály teljesen elszigetelődik
• A -hangerő opció hozzáférést biztosít a gazdagép könyvtárához (ha abszolút elérési utat használ), vagy egy korábban létrehozott könyvtárhoz Dokkmunkás térfogat (ha a kötet-név). A kettőspont utáni út meghatározza a hegy csucs a tartályon belül
• Érvként el kell mondanunk Dokkmunkás, melyik képet kell használni. Itt kell adnunk a képnév a korábbandokkoló építése’Lépés
• Néhány további hasznos lehetőség:
  • -azt - engedélyezze az interaktív módot, és ossza ki a ál-tty
  • -d - indítás után vegye le a tartályról

Ha a tárolót leválasztott módban futtatjuk, a következő parancsokkal ellenőrizhetjük annak részleteit, leállíthatjuk és eltávolíthatjuk:

$> docker ellenőrzi a konfigurációs kiszolgálót $> docker leállítja a konfigurációs kiszolgálót

5. Dockerize függő alkalmazások egy kompozit

Dokkmunkás parancsokat és Dockerfiles különösen alkalmasak egyedi konténerek létrehozására. De ha akarod elszigetelt alkalmazások hálózatán működni, a konténerkezelés gyorsan összezavarodik.

Ennek megoldására Dokkmunkás nevű eszközt nyújt Docker Compose. Ehhez egy saját build-fájl tartozik YAML formátumban, és jobban alkalmas több tároló kezelésére. Például képes elindítani vagy leállítani a szolgáltatások összetettségét egy parancsban, vagy egyesíti a több szolgáltatás naplózási kimenetét egybe ál-tty.

Készítsünk egy példát két alkalmazásra, amelyek különböző Docker-tárolókban futnak. Kommunikálni fognak egymással, és egy egységként kerülnek bemutatásra a fogadó rendszer számára. Felépítjük és lemásoljuk a spring-cloud-config / client a tavaszi felhő konfigurációs oktatóanyagban leírt példa fájlokat mappát, mint ahogy azt korábban a config-server.

Ez lesz a miénk dokkoló-összeállít.yml:

verzió: '2' szolgáltatások: config-server: container_name: config-server build: context:. dockerfile: Dockerfile.server kép: config-server: latest expose: - 8888 hálózatok: - spring-cloud-network kötetek: - spring-cloud-config-repo: / var / lib / spring-cloud / config-repo naplózás: illesztőprogram : json-file config-client: container_name: config-client build: context:. dockerfile: Dockerfile.client kép: config-client: legújabb belépési pont: /opt/spring-cloud/bin/config-client-entrypoint.sh környezet: SPRING_APPLICATION_JSON: \ '{"spring": {"cloud": \ {"config ": {" uri ":" // config-server: 8888 "}}}} '' expose: - 8080 portok: - 8080: 8080 hálózatok: - rugó-felhő-hálózati linkek: - config-szerver: config-kiszolgálótól függ : - config-server naplózás: driver: json-fájlhálózatok: spring-cloud-network: driver: bridge-kötetek: spring-cloud-config-repo: external: true

• változat: Megadja, hogy melyik formátumú verziót kell használni. Ez egy kötelező mező. Itt az újabb verziót használjuk, míg a örökölt formátum „1”
• szolgáltatások: A kulcs minden objektuma meghatározza a szolgáltatás, más néven konténer. Ez a szakasz kötelező
  • épít: Ha megadják, dokkoló-ír képes képet alkotni a Dockerfile
    • kontextus: Ha meg van adva, akkor megadja a build könyvtárat, ahol a Dockerfile fel van keresve
    • dockerfile: Ha megadta, akkor alternatív nevet állít be a Dockerfile
  • kép: Mondja Dokkmunkás melyik nevet kell adnia a képnek a build-funkciók használata esetén. Ellenkező esetben ezt a képet keresi a könyvtárban vagy távoli nyilvántartás
  • hálózatok: Ez a megnevezett hálózatok azonosítója. Egy adott névérték fel kell tüntetni a hálózatok szakasz
  • kötetek: Ez azonosítja a használni kívánt megnevezett köteteket és a csatlakoztatási pontokat a kötetek felhelyezéséhez kettősponttal elválasztva. Hasonlóképpen hálózatok szakasz, a kötet-név külön kell meghatározni kötetek szakasz
  • linkek: Ez létrehoz egy belső hálózati kapcsolatot a ez szolgáltatás és a felsorolt ​​szolgáltatás. Ez szolgáltatás képes lesz csatlakozni a felsorolt ​​szolgáltatáshoz, ahol a kettőspont előtti rész megadja a szolgáltatás neve tól szolgáltatások szakasz és a kettőspont utáni rész határozza meg annak a hosztnévnek a nevét, amelyen a szolgáltatás hallgat egy szabad porton
  • attól függ: Ez elmondja Dokkmunkás csak akkor indítson szolgáltatást, ha a felsorolt ​​szolgáltatások sikeresen elindultak. ÉRTESÍTÉS: Ez csak konténerszinten működik! A megkerülő megoldás elindítja az eltartottat Alkalmazás először lásd config-client-entrypoint.sh
  • fakitermelés: Itt használjuk a „Json-file” illesztőprogram, amely az alapértelmezett. Alternatív megoldásként ’Syslog’ adott cím opcióval vagy 'egyik sem' használható
• hálózatok: Ebben a részben meghatározzuk a hálózatok szolgáltatásaink számára elérhető. Ebben a példában hagytuk dokkoló-ír hozz létre nevet hálózat típusú 'híd' nekünk. Ha az opció külső értékre van állítva igaz, egy meglévő nevet fog használni
• kötetek: Ez nagyon hasonlít a hálózatok szakasz

Mielőtt folytatnánk, ellenőrizni fogjuk a build-fájl szintaktikai hibáit:

$> docker-compose config

Ez lesz a miénk Dockerfile.ügyfél építeni a config-kliens kép. Különbözik a Dockerfile.server abban, hogy kiegészítően telepítjük OpenBSD netcat (amire a következő lépésben szükség van), és készítse el a belépési pont végrehajtható:

Alpine-java-ból: base MAINTAINER baeldung.com RUN apk - no-cache add netcat-openbsd COPY files / config-client.jar / opt / spring-cloud / lib / COPY files / config-client-entrypoint.sh / opt / spring-cloud / bin / RUN chmod 755 /opt/spring-cloud/bin/config-client-entrypoint.sh

És ez lesz a testreszabott belépési pont a mi config-kliens szolgáltatás. Itt használjuk netcat egy hurokban ellenőrizni, hogy a mi config-server készen van. Észre kell vennie, hogy elérhetjük a sajátunkat config-server általa link-név, IP-cím helyett:

#! / bin / sh while! nc -z config-server 8888; do echo "Várakozás a következő Config Serverre" alvás 2 kész java -jar /opt/spring-cloud/lib/config-client.jar

Végül elkészíthetjük a képeinket, létrehozhatjuk a definiált tárolókat, és egy paranccsal elindíthatjuk:

$> docker-compose up --build

A tartályok leállításához távolítsa el Dokkmunkás és távolítsa el a csatlakoztatottat hálózatok és kötetek belőle az ellenkező parancsot használhatjuk:

$> docker-compose down

A dokkoló-ír az a a szolgáltatások skálázásának képessége. Például elmondhatjuk Dokkmunkás futtatni egy konténert a config-server és három konténer a config-kliens.

De ahhoz, hogy ez megfelelően működjön, el kell távolítanunk a tároló_neve tőlünk dokkoló-összeállít.yml, bérbeadásért Dokkmunkás válasszon egyet, és meg kell változtatnunk a kitett port konfiguráció, az ütközések elkerülése érdekében.

Ezt követően képesek vagyunk szolgáltatásainkat így méretezni:

$> docker-compose build $> docker-compose -d $> docker-compose skála config-server = 1 config-client = 3

6. Következtetés

Amint láttuk, most már képesek vagyunk testre szabni Dokkmunkás képek, fut a Tavaszi csomagtartó alkalmazás mint a Dokkmunkás tároló, és függő tárolók létrehozása a dokkoló-ír.

A build-fájlokról a hivatalos személyhez fordulunk Dockerfile hivatkozás és a docker-compose.yml hivatkozás.

Szokás szerint az oktatóanyag forráskódjai megtalálhatók a Githubon.