Riot Games

ebben az első bemutató a Docker sorozat, megtudhatja:

• mit próbálunk elérni a Riot-ban

• a Docker alapvető beállítása

• alapvető Docker Pull parancsok

• hogyan kell futtatni a Docker konténereket démonként

• alapvető Jenkins konfigurációs lehetőségek

amikor egy évvel ezelőtt elkezdtem tanulni a Docker – ről és feltárni annak használatát, nehezen találtam nagyszerű dokumentációt és példákat-még ma is sokan olyan egyszerű használati eseteket írnak le, amelyek végül nem állnak készen a gyártásra. Az alkalmazások Docker konténerekkel történő előállítása megköveteli a mulandó természetükhöz és az egyfolyamatos fókuszhoz való alkalmazkodást. Ez kihívásokat jelent az adatperzisztencia-igényű alkalmazások vagy a többfolyamatos architektúrák számára.

ahogy az előző bejegyzésemben említettem, a Jenkins-t a nyílt forráskódú szoftverek alapjaként használjuk, amelyre az automatizálást építjük. A Jenkins egy nagyszerű alkalmazás is, amely bemutatja az alkalmazások “dokkolásának” gondolkodásának egyik módját. Ezeket az építészeti elemeket szem előtt tartva telepítjük a Jenkins-t:

• Jenkins master server (Java folyamat)

• Jenkins törzsadatok (Bővítmények, Feladatmeghatározások stb)

• NGINX web proxy (SSL tanúsítványokat használunk stb., az NGINX itt könnyű választás)

• Építsd szolga ügynökök (gépek vagy hogy SSH ‘ d be, vagy JNLP csatlakozik, Jenkins mester)

ez egy jó hely a kezdéshez. A blogbejegyzések ezen sorozata során kitérek arra, hogyan lehet a fentieket konténerként gondolkodni, és befejezem a Docker konténerek rabszolgákként történő felhasználásának módjait. Kezdetnek létrehozunk egy Jenkins master szervert egy Docker tárolóban. Ezután folytatjuk az adatok perzisztenciájának kezelését és egy webes proxy hozzáadását az NGINX-hez.

ez a teljes blog sorozat a következő Docker fogalmakat fedi le:

• saját Dockerfiles készítése

• a nyilvános képek képfüggőségének minimalizálása

• adatkötetek létrehozása és használata, beleértve a biztonsági mentéseket is

• konténeres “építési környezetek” létrehozása konténerek használatával

• “titkos” adatok kezelése képekkel és Jenkins-szel

ha még nem vettél egy pillantást a Cloudbees Jenkins Docker képre, kezdd el ott, mert nagyon jó. Ez volt a referenciapontom, amikor először arra gondoltam, hogy Jenkins-t egy Docker konténerben futtatom, és sok ember számára ez elegendő lehet. A dokumentációt itt, a Git repo / Dockerfile fájlt pedig itt találja.

ez az első blog két óratervre oszlik. Mindegyik mérete körülbelül 30 percet vesz igénybe. Először is, az első rész A fejlesztői környezet előkészítése és a Cloudbees által kínált alapértelmezett Jenkins Docker konténerrel való együttműködés megtanulása. A második rész arról szól, hogy megalapozza ezt a képet a saját Dokkolófájljába, és elegánsabban kezeli a képet. Együtt úgy tervezték, hogy elinduljon, különösen akkor, ha még soha nem dolgozott a Docker—rel, vagy viszonylag új a Docker számára-bár feltételezik, hogy már tudja és megérti, hogyan kell dolgozni a Jenkins-szel. Ha tapasztalt a Docker-rel, az 1. lecke anyagának egy része egy kicsit olyan dolog lesz, amelyet valószínűleg már tud.

1.lecke: állítsa be és futtassa az első képet

készen állunk a forgatásra. Itt a Riot-nál a Docker-rel (és Jenkins-szel) dolgozunk Windows, Mac OSX és Linux rendszeren. Inkább a Dockerrel dolgozom az OSX-en, bár a Docker 1.6 óta tökéletesen működik a Windows rendszeren. Manapság kiváló telepítők vannak mindkét operációs rendszer számára. OSX szempontból fogok dolgozni, de ugyanazok az eszközök léteznek a Windows számára.

ELŐZETES KÖVETELMÉNYEK:

1. Szükséged lesz a Windows 10 Pro vagy Mac OSX Yosemite 10.10.3 (vagy újabb)

2. Ha Windows rendszert használ, győződjön meg róla, hogy engedélyezve van a Windows virtualizáció (lásd a Docker dokumentációját)

gyors megjegyzés a KITEMATIC

a Docker 1.8 és a Docker Toolbox kiadásával a Docker mostantól tartalmazza a “Kitematic” – ot, egy remek GUI eszközt, amely segít kezelni és megjeleníteni, hogy mi történik a Docker képeivel és tárolóival. A bemutató nagy része a parancssori argumentumok használatára és a Docker használatára összpontosít a Kitematikai GUI nélkül. Ennek célja, hogy jobban kitegye Önt a mögöttes mechanizmusoknak. Hasonlóképpen, a későbbi blogokban elkezdem lefedni a Compose használatát több konténer indításához és leállításához egyszerre.

1.LÉPÉS: TELEPÍTSE A DOKKOLÓ

1. Ugrás: https://www.docker.com/docker-mac vagy https://www.docker.com/docker-windows

2. Töltse le és telepítse a Docker megfelelő verzióját az operációs rendszeréhez

3. Kövesse az összes beállítási utasítást.

4. Ellenőrizze, hogy a telepítés működik-e, ha megnyitja az operációs rendszerhez ajánlott héjat (Terminal for OSX, PowerShell for windows) a “Docker Quickstart Terminal”futtatásával. Windows rendszeren ez egy parancsikon lesz az asztalon. Az OSX – en az alkalmazások/Dokkoló mappában találja meg. Ellenőrizze a következő parancsokat, és győződjön meg róla, hogy nem kap hibát

docker ps

docker info

5. Mielőtt bármi mást tennénk, növelnünk kell a Docker által használt alapértelmezett memória-és CPU-beállításokat. Később ráhangoljuk Jenkinst, hogy több memóriát használjon, és ha először nem módosítjuk ezeket a beállításokat, Jenkins összeomolhat.

• nyissa meg a Docker widgetet az eszköztáron, és válassza a “Beállítások ” lehetőséget”

• lépjen a speciális Konfiguráció fülre

• növelje a CPU használatát legalább 4 magra

6. Növelje a memóriahasználatot legalább 8 GB-ra, lehetőleg többre, például 12 GB-ra a biztonság érdekében (ha rendelkezésre áll)

2.lépés: húzza meg és futtassa a CLOUDBEES JENKINS konténert

1. Maradjon a dokkoló Terminál ablakában.

2. Húzza ki Jenkins-t a nyilvános repóból futással:

docker pull jenkins/jenkins

docker run -p 8080:8080 --name=jenkins-master jenkins/jenkins

3. Ne feledje, hogy a shell ablakban a” Jenkins kezdeti beállítás ” üzenet létrehoz egy jelszót az Ön számára. Írja le, mivel később szüksége lesz rá. Ha elveszíti, futtathatja a ‘ docker exec jenkins-master cat / var/jenkins_home/secrets / initialAdminPassword` fájlt, miközben a tároló fut a letöltéshez.

4. Nyissa meg kedvenc böngészőjét, és mutasson rá http://localhost:8080

kérjük, vegye figyelembe, látni fogja, hogy a Dockert használom-név zászló és név a konténer jenkins-master-ez egy olyan konvenció, amelyet az egész blogban használni fogok. A konténerek elnevezése praktikus legjobb gyakorlat, három előnnyel:

1. Ez teszi őket könnyen megjegyezhető és kölcsönhatásba

2. A Docker nem engedélyezi, hogy két konténer azonos névvel rendelkezzen, ami megakadályozza az olyan hibákat, mint például két azonos

3. Számos általános Docker eszköz (például a Docker Compose) speciális tárolóneveket használ, ezért a tárolók elnevezésének megszokása jó bevált gyakorlat.

3. lépés: ennek egy kicsit praktikusabbá tétele

az előző lépés a Jenkins-t a legalapvetőbb indítási beállításokkal indítja el. Még azt is láthatja, hogy Jenkinsnek alapvető konfigurációra van szüksége, és rendszergazdai jelszót kér (amelyet az indítás során a képernyőn megjelenő naplókból kaphat). Ha olyan vagy, mint a Riot, nem valószínű, hogy a Jenkins alapértelmezett beállításokkal fut. Menjünk át néhány hasznos lehetőség hozzáadásával. Még nem zavarjuk a Jenkins konfigurálását; elég tudni, hogy elindulhat és futtatható.

3A lépés: démonizálás

valószínűleg nem akarja látni, hogy a Jenkins naplók a legtöbb időt szabványosítják. Tehát használja a Docker démon jelzőt a tároló indításához (- d).

1. Ctrl-c a terminál ablak fut a konténer megállítani

2. Futtassa a következő parancsokat

docker rm jenkins-master

docker run -p 8080:8080 --name=jenkins-master -d jenkins/jenkins

most már csak kap egy hash karakterlánc jelenik meg, és vissza kell küldeni a terminál. Ha még nem ismeri a Dockert, akkor ez a hash karakterlánc valójában a tároló egyedi azonosítója (hasznos, ha elkezdi automatizálni ezeket a parancsokat).

3B lépés: MEMÓRIABEÁLLÍTÁSOK

hajlamosak vagyunk Jenkins-t futtatni néhány húsos beállítással a Riot-nál. Emlékszel, amikor növelte a CPU / memória Docker használ korábban? Ez az elsődleges oka annak. Alapvető indításhoz futtassa a következő parancsokat

docker stop jenkins-master

docker rm jenkins-master

docker run -p 8080:8080 --name=jenkins-master -d --env JAVA_OPTS="-Xmx8192m" jenkins/jenkins

ez ad Jenkins egy szép 8 GB memória medence és a szoba kezelni szemétgyűjtés.

3C lépés: a KAPCSOLATKÉSZLET növelése

a Riot-nál sok forgalmat kapunk a Jenkins szerverünkre, így megtanultuk, hogy Jenkinsnek egy kicsit több légzési teret adjunk. Futtassa a következőket

docker stop jenkins-master

docker rm jenkins-master

így Jenkins-nek lesz egy jó kis bázisa rakodóknak és egy sapkának. Véletlenül megtanulta, hogyan kell mind a JAVA OPTS, mind a JENKINS OPTS környezeti változóként értelmes módon használni. Felhívjuk figyelmét, hogy ez azért működik, mert a Cloudbees kényelmesen strukturálta a Jenkins Dockerfilét.

4. lépés: mindent összerakva

mindent, amit itt megtanultunk, egy egyszerű makefile-be helyeztem, így a make parancsokkal vezérelheti a Jenkins docker konténer futtatását. Megtalálható itt:

• https://github.com/maxfields2000/docker Jenkins_tutorial / fa / mester / tutorial_01

a következő parancsokat használhatja:

• készítsen építést – húzza a Jenkins képet

• make run-fut a konténer

• stop-leállítja a tartályt

• clean-megáll, és törli a meglévő konténer

nem kell használnia a makefile-t, csak könnyebbnek találom, mint a teljes Futtatás parancs beírását. Akkor könnyen tegye ezeket a script az Ön által választott helyett.

remélhetőleg látod, milyen könnyű felállni és futni a Docker és Jenkins segítségével. Megpróbáltam néhány alapvető lehetőséget adni az alapértelmezett Cloudbees Jenkins konténer használatához, és egy kicsit használhatóbbá tenni. A Cloudbees számos hasznos oktatóanyagot tartalmaz a tároló futtatásához, például a pluginek előzetes telepítéséhez és a Jenkins adatok tárolásához.

ez a témával kapcsolatos jövőbeli bejegyzésekhez vezet. Ez a tároló/kép hasznos, de van néhány hátránya: nincs következetes naplózás, nincs perzisztencia, nincs webszerver proxy előtte, és nincs tiszta módja annak, hogy garantálja a Jenkins kívánt verzióját. Ez olyan kérdéseket vet fel, mint: mi van, ha ragaszkodni szeretne egy régebbi verzióhoz? Vagy mi van, ha a legújabb elérhető kiadási időszakot szeretné használni?

a következő leckében kitérek arra, hogy ez a tartály egy kicsit robusztusabb legyen. Különösen:

• saját Dockerfile létrehozása a Cloudbees alap becsomagolásához

• néhány környezeti változó áthelyezése ebbe az új képbe

• naplómappa létrehozása, engedélyek és egyéb hasznos Jenkins könyvtárak beállítása, valamint a Jenkins naplók letöltése futás közben

2. lecke-a JENKINS BASE IMAGE WRAPPER

az előző leckében megvitattam a Docker futtatásához szükséges fejlesztői környezet beállítását, és kísérleteztem a Cloudbees által biztosított Jenkins Docker képpel. Megállapítottuk, hogy egyszerű és könnyen használható, néhány nagyszerű funkcióval a dobozból. Ahhoz, hogy haladást érjünk el az általunk azonosított fejlesztési területeken, az ebben a leckében szereplő Docker fogalmak a következők:

• saját Dockerfile készítése

• környezeti változók beállítása egy Dockerfile-ben

• mappák és engedélyek létrehozása egy Dokkolófájlban

• a docker exec használata parancsok futtatásához egy futó konténer ellen

így a bázis DOCKERFILE

azt akarjuk, hogy néhány változtatást, hogyan Jenkins indul alapértelmezés szerint. Az utolsó blogban ezt úgy kezeltük, hogy létrehoztunk egy makefile-t, amely argumentumként környezeti változókként telt el. Tekintettel arra, hogy azt akarjuk, hogy ezt minden alkalommal, akkor csak mozgatni azokat a saját Dockerfile. Ezenkívül a saját Dockerfile lehetővé teszi a Jenkins általunk használt verziójának zárolását arra az esetre, ha a Cloudbees frissítené az övékét, és nem vagyunk készek frissíteni.

ezt négy lépésben hajtjuk végre:

1. Hozzon létre egy

2 munkakönyvtárat. A kedvenc szövegszerkesztőben hozzon létre egy új fájlt, amelynek neve “Dockerfile”

3. Adja hozzá a következőket A fájlhoz, majd mentse el:

FROM jenkins/jenkins:2.112LABEL maintainer=""

4. Ezután a parancssorba írja be:

docker build -t myjenkins .

amit itt csináltunk, az a Jenkins kép egy bizonyos változata volt a nyilvános dokkoló repóból. Az összes elérhető verziót itt találja:

• mindig beállíthatja a FROM záradékot, hogy a kép bármilyen verziója elérhető legyen. Azonban nem állíthatja be a verziót a Jenkins tetszőleges verziójára. Ez a “tag” vagy “label” képverzió, a Cloudbees pedig elég szép ahhoz, hogy megfeleljen a képen belüli Jenkins verziónak. Cloudbees kínál “jenkins / jenkins”, mint egy kényelmes módja annak, hogy a legújabb verziót, vagy” jenkins/jenkins:lts”, hogy a legújabb” hosszú távú támogatás ” verzió. Ebben a példában egy adott verziót használok. Ezek a címkék, amelyek a kiadások típusait címkézik, nagyszerűek, de használatuk azt jelenti, hogy a Jenkins verziója megváltozhat alatta, ami komplikációkat okozhat, ha nem áll készen a frissítésre. A “verziózárást” javaslom általános bevált gyakorlatként, amikor a Docker vagy más függőségkezelő eszközök függőségeivel foglalkozik. Azt akarja, hogy a dolgok megváltozzanak, amikor szándékában áll, nem korábban. Ezért használok itt egy speciális verziót.

  az új DOKKOLÓFÁJL tesztelése

  nagyon egyszerűen átkapcsolhatunk a képre, ha módosítjuk a docker run parancsot a következőre:

  docker run -p 8080:8080 --name=jenkins-master -d --env JAVA_OPTS="-Xmx8192m" --env JENKINS_OPTS=" --handlerCountMax=300" myjenkins

  most megtisztíthatjuk ezeket a környezeti változókat azáltal, hogy elhelyezzük őket a saját Dokkerfájlunkban.

  környezeti változók hozzáadása a DOCKERFILE-hez

  könnyen hozzáadhat alapértelmezett beállításokat olyan dolgokhoz, mint a környezeti változók a Dockerfiles-hez. Ez egy szép darab öndokumentációt is nyújt. És mivel ezeket mindig felülírhatja a Docker tároló futtatásakor, valójában nincs hátránya.

  1. A Dockerfile-ben adja hozzá a következő sorokat a “karbantartó” sor után:

  ENV JAVA_OPTS="-Xmx8192m"ENV JENKINS_OPTS=" --handlerCountMax=300"

  2. Kép mentése és újjáépítése:

  • dokkoló build-t myjenkins .

  docker build -t myjenkins .

  elég egyszerű! A következő három parancs megadásával tesztelheti, hogy továbbra is működik-e:

  docker stop jenkins-master

  docker rm jenkins-master

  docker run -p 8080:8080 --name=jenkins-master -d myjenkins

  

  a kép kell kezdeni egészen! De honnan tudod, hogy a környezeti változók működtek? Egyszerű: ugyanígy ellenőrizné, hogy milyen érvek indították el a Jenkins alkalmazást általában a ps használatával. És ez akkor is működik, ha Windows rendszeren fejleszt.

  BASIC parancs futtatása a TÁROLÓDON

  a Java és a Jenkins beállítások helyes beállításának megerősítéséhez futtathatjuk a PS-t a tárolónkban, és megnézhetjük a futó Jenkins Java folyamatot a docker exec használatával

  docker exec jenkins-master ps -ef | grep java

  valami hasonlót kell látnod

  jenkins 1 0 99 21:28 ? 00:00:35 java -Xmx8192m -jar /usr/share/jenkins/jenkins.war --handlerCountMax=300

  

  ebből könnyen láthatja, hogy a Beállítások elakadtak. docker exec egy egyszerű módja annak, hogy végre shell parancsokat belül a konténer, valamint egy hihetetlenül egyszerű módja annak, hogy ellenőrizze őket. Ez még Windows rendszeren is működik, mert ne feledje, hogy az “exec” utáni parancs a tárolóban fut, így bármilyen alapképen alapul, amelyet a tároló használ.

  NAPLÓMAPPA beállítása

  az előző blogban megjegyeztük, hogy elvesztettük a láthatóságot a Jenkins naplókban, amikor a tárolónkat a daemonize zászlóval (-d) futtattuk. A beépített Jenkins funkciót akarjuk használni a napló mappa beállításához. Ezt meg kell tennünk a Dockerfile-ben, majd át kell adnunk a naplózási lehetőséget Jenkinsnek.

  szerkesszük újra a Dokkolófájlt. A “karbantartó” és az első ENV sor között a következő

  RUN mkdir /var/log/jenkins

  a parancsot ezen a helyen helyezzük el a fájlban, hogy kövessük a legjobb gyakorlatokat. Valószínűbb, hogy megváltoztatjuk a környezeti változókat, mint ezek a beállítási könyvtárak, és a Dockerfile minden parancssora lényegében saját képréteggé válik. Maximalizálja a réteg újrafelhasználását azáltal, hogy a gyakran módosított elemeket az alja közelében helyezi el.

  most építsd újra a képet:

  docker build -t myjenkins

  kapsz egy hiba, hogy néz ki

  ---> Running in 0b5ac2bce13bmkdir: cannot create directory '/var/log/jenkins': Permission denied

  

  semmi gond. Ennek oka az, hogy az alapértelmezett Cloudbees tároló a futó felhasználót a “Jenkins” felhasználóra állítja. Ha megnézed a Docker-fájljukat (itt található: https://github.com/ Jenkinsci/docker/blob/master/Dockerfile), akkor az alsó rész közelében látnod kell

  USER ${user}

  ez a szintaxis kissé zavaró lehet. A Docker build “argumentumait” használja a felhasználó meghatározásához. Ha tovább nézi a Docker fájlt, megtalálja az alapértelmezett értéket. A

  ARG user=jenkins

  Fájl tetején keresse meg a “user” argumentumot (ARG), és állítsa be a Jenkins felhasználóhoz. Ez lehetővé teszi, hogy módosítsa a felhasználónevet, hogy Jenkins használ, amikor hívja docker build –build-arg somevariable=somevalue. Ne feledje, hogy ez csak akkor működik, ha a Dockerfile-t a semmiből építi. Ezek az értékek nem módosíthatók docker-húzással vagy docker-futtatással. A build argumentumokról itt olvashat bővebben. Mivel egy előre elkészített verziót használunk a FROM záradékban, az alapértelmezett felhasználóhoz jutunk: “jenkins”.

  normál Linuxban csak SUDO-t vagy más eszközt használna a mappa létrehozásához (a/var/log a root tulajdonában van). Szerencsére számunkra a Docker lehetővé teszi a felhasználók váltását.

  adja hozzá a következőket A Dokkolófájlhoz:

  1. A futtatás előtt mkdir sor hozzáadása

  USER root

  2. A futtatás után mkdir sor hozzáadása

  RUN chown -R jenkins:jenkins /var/log/jenkins

  3. A futtatás után chown sor hozzáadása:

  USER jenkins

  vegye figyelembe, hogy hozzá kellett adnunk egy chown parancsot is, mert azt akarjuk, hogy a Jenkins felhasználó képes legyen írni a mappába. Ezután beállítjuk a root-ot, majd visszaállítjuk a Jenkins-t, hogy a Dockerfile viselkedése megmaradjon.

  most építsd újra a képet:

  docker build -t myjenkins .

  

  és… a hibáidnak el kell tűnniük.

  a log könyvtár készlet (kérjük, vegye figyelembe: akkor helyezze ezt a mappát, ahol szeretné, használjuk /var/log következetesség) most már mondani Jenkins írni, hogy a mappa indításkor módosításával JENKINS_OPTS környezeti változók.

  a Dockerfile szerkeszteni a JENKINS_OPTS sort, hogy így néz ki:

  • ENV JENKINS_OPTS=” — handlerCountMax=300 — logfile= / var/log/jenkins / jenkins.napló”

  ENV JENKINS_OPTS="--handlerCountMax=300 --logfile=/var/log/jenkins/jenkins.log"

  most készítsd el a képet még egyszer

  docker build -t myjenkins .

  teszteljük az új képet, és ha tudjuk követni a naplófájlt! Próbálja ki a következő parancsokat

  docker stop jenkins-master

  docker rm jenkins-master

  docker run -p 8080:8080 --name=jenkins-master -d myjenkins

  a konténer fut tudjuk farok a log fájlt, ha minden működött

  docker exec jenkins-master tail -f /var/log/jenkins/jenkins.log

  letölteni naplók, ha JENKINS összeomlik

  ideje egy bónusz kör! Amíg a naplókról beszélünk, a Docker érdekes problémát jelent, ha Jenkins összeomlik. A tároló leáll, és a docker exec már nem fog működni. Tehát mi a teendő?

  a naplófájl megőrzésének fejlettebb módjait később tárgyaljuk. Egyelőre, mivel a tároló leállt, fájlokat másolhatunk ki belőle a docker cp paranccsal. Szimuláljuk az összeomlást a tároló leállításával, majd a naplók visszakeresésével:

  1. ctrl-c, hogy kilépjen a naplófájl farok

  2. Futtassa a következő parancsokat

  docker stop jenkins-master

  docker cp jenkins-master:/var/log/jenkins/jenkins.log jenkins.log

  cat jenkins.log

  

  záró gondolatok

  megtalálható az összes munkát a bemutató Git repo (és a frissített kényelem makefile) itt:

  • https://github.com/maxfields2000/docker Jenkins_tutorial / fa / mester / tutorial_02

  azáltal, hogy elkészítettük a saját Dockerfile-t, amely becsomagolja a Cloudbees fájlt, képesek voltunk egy kicsit könnyebbé tenni az életet magunknak. Létrehoztunk egy kényelmes helyet a naplók tárolására, és megtanultuk, hogyan kell megnézni őket a docker exec paranccsal. Az alapértelmezett beállításokat áthelyeztük a Dockerfile-be, és most ezt a forrásvezérlésben tárolhatjuk, mint egy jó öndokumentációt.

  még mindig van egy adatperzisztencia kihívás. Megtanultuk, hogyan kell kihúzni a naplófájlokat egy leállított tárolóból (hasznos, ha Jenkins összeomlik). De általában, ha a konténerünk leáll, akkor is elveszítjük az összes létrehozott munkahelyet. Tehát kitartás nélkül ez a Jenkins-kép csak a helyi fejlesztéshez és teszteléshez hasznos.

  ez elvezet minket a következő cikkhez. Alapjainkkal – a saját Dockerfile csomagolónkkal, a Jenkins praktikus verziójához rögzítve-megoldhatjuk a perzisztencia problémát. A következő cikk ezeket a fogalmakat vizsgálja:

  • Jenkins Job és Plugin adatok megőrzése

  • Docker adatok tartóssága kötetekkel

  • adatmennyiség-tároló készítése

  • adatok megosztása kötetekben más tárolókkal

  további információkért tekintse meg a sorozat többi részét:

  I. rész: gondolkodás a konténer belsejében
  II. rész: Jenkins behelyezése egy Docker konténerbe (ez a cikk)
  III. rész: Docker &Jenkins: adatok, amelyek megmaradnak
  IV. rész: Jenkins, Docker, proxyk, and Compose
  V. rész: Átveszi az irányítást a Docker Image
  Vi. rész: épület Jenkins belsejében egy efemer Docker konténer
  VII. rész: bemutató: épület Jenkins belsejében egy efemer Docker konténer
  VIII. rész: DockerCon Talk and the Story So Far