Docker alapú példány megoldás. A Docker alapvető funkcióinak bemutatása

Referencia a Docker kép- és tárolókezelési parancsaihoz.

Feltételek

Kép egy statikus build, amely egy adott operációs rendszeren alapul.

Tartály a kép futó példánya.

Docker indítási jogok

Ha a Docker-tárolókat saját felhasználója alatt szeretné futtatni (sudo nélkül), hozzá kell adnia a megfelelő csoporthoz:

Sudo usermod -aG docker YOU_USER

Docker szolgáltatás

Docker Service Management "a:

Sudo service docker start | stop | restart | status sudo restart docker # alias

Képek

Az elérhető skinek listája:

Docker képek

Töltse le a képet (vagy a teljes adattárat) a hivatalos regiszterből (képtár):

Docker pull ubuntu: 14.04

Kép információinak megtekintése:

Docker megvizsgálja az ubuntut

Kép törlése:

A Docker véglegesíti a következőt: CONTAINER_ID IMAGE_NAME

Konténerek

Figyelem!

A Docker konténer elindítása után a szolgáltatások / démonok (például SSH, Supervisor stb.) nem indulnak el automatikusan! Több órát töltöttem a hibakereséssel: " ssh_exchange_identification: read: A kapcsolatot alaphelyzetbe állította a peer"amikor SSH-n keresztül próbált csatlakozni a tárolóhoz. De kiderült, hogy csak az sshd démon nem indult el. A tároló elindítása után manuálisan kell elindítania a szükséges démonokat vagy felügyelőt:

Docker exec CONTAINER_ID bash -c "szolgáltatás ssh indítása"

Az összes konténer listája (indított és leállított):

Docker ps -a

Távolítsa el a tartály(oka)t:

Docker rm CONTAINER_ID CONTAINER_ID

Távolítsa el az összes tartályt:

Docker rm $ (docker ps -aq)

Hozzon létre és futtasson egy Docker-tárolót az Ubuntu 14.04-el interaktív módban (nyissa meg a tároló shelljét):

Docker futtatása -it ubuntu bash docker futtatása [beállítások] kép [parancs] -i Interaktív mód, STDIN nyitva tartása -t Lefoglalás / létrehoz egy pszeudo-TTY-t, amely stdin-t és stdout-ot csatol --name Tárolónév azonosító helyett -w Munkakönyvtár megadása ( --workdir) -e A környezeti változó beállítása a tárolóban -u Felhasználó: a csoport, amelyen belül a tárolót futtatni kell -v A gazdagép rendszer fájljának vagy könyvtárának beillesztése a tárolóba -p A port(ok) továbbítása a konténer -<порт хост-системы>:<порт контейнера>(--publish =) --entrypoint Cserélje le az ENTRYPOINT Dockerfile alapértelmezett parancsát

jegyzet

A TTY leválasztásához a tároló leállítása nélkül nyomja meg a Ctr + P + Ctrl + Q billentyűket.

Hozzon létre és futtasson egy Docker-tárolót démon módban SSH port továbbítással:

Docker run -itd -p 127.0.0.1:221:22 ubuntu

Hozzon létre és indítson el egy tárolót, majd leállítás után törölje ezt a tárolót (hasznos hibakereséshez):

Docker run -i -t --rm ubuntu bash

Leállított tároló interaktív indítása:

Docker start -i CONTAINER_ID

Csatlakozás démonizált tárolóhoz:

Docker csatolja a CONTAINER_ID-t

Docker parancsok

Használat: docker COMMAND docker démon [--help | ...] dokkoló [--help | -v | --version] Önellátó futási környezet tárolókhoz. Opciók: --config = ~ / .docker Az ügyfél konfigurációs fájljainak helye -D, --debug = false Hibakeresési mód engedélyezése --disable-legacy-registry = false Ne lépjen kapcsolatba a régebbi nyilvántartásokkal -H, --host = Daemon socket ( s) csatlakozni a -h-hoz, --help = false Nyomtatáshasználat -l, --log-level = info A naplózási szint beállítása --tls = false TLS használata; a --tlsverify által feltételezett --tlscacert = ~ / .docker / ca.pem Megbízhatósági tanúsítványok, amelyeket csak ez a CA írt alá --tlscert = ~ / .docker / cert.pem A TLS tanúsítványfájl elérési útja --tlskey = ~ / .docker / key.pem A TLS kulcsfájl elérési útja --tlsverify = false Használja a TLS-t és ellenőrizze a távoli -v, --version = false Verzióinformációk nyomtatása és kilépés Parancsok: csatol Csatolás futó konténer buildhez Kép készítése Dockerfile véglegesítésből Hozzon létre egy új kép egy tárolóból "s változások cp Fájlok/mappák másolása egy tároló és a helyi fájlrendszer között Create Új tároló diff létrehozása Konténer változásainak vizsgálata" s fájlrendszer eseményei Valós idejű események lekérése a kiszolgálóról exec Parancs futtatása egy futó tárolóban export Konténer fájlrendszerének exportálása tar archívum előzményeként Kép előzményeinek megjelenítése képek listája képek importálása Tarball importálása Tarballból importálhatja a tartalmat egy fájlrendszer létrehozásához képinformáció A rendszerszintű információk ellenőrzése A konténer vagy kép alacsony szintű információinak visszaadása megöl megöl egy futó konténert l oad Kép betöltése tar archívumból vagy STDIN bejelentkezésből Regisztráljon vagy jelentkezzen be egy Docker rendszerleíró adatbázisba Kijelentkezés Kijelentkezés a Docker rendszerleíró adatbázisból Konténerhálózat naplóinak lekérése Docker hálózatok kezelése szüneteltetés Minden folyamat szüneteltetése egy tárolóporton belül Portleképezések listázása vagy speciális leképezés a CONTAINER-hez ps Konténerek listája pull Kép vagy lerakat lehívása rendszerleíró adatbázisból Kép vagy lerakat áthelyezése rendszerleíró adatbázis átnevezésébe Tároló átnevezése újraindítás Tároló újraindítása rm Egy vagy több tároló eltávolítása rmi Egy vagy több kép eltávolítása futtatás Futtatás egy parancs egy új tárolóban mentés Kép(ek) mentése tar archívumba keresés Keressen a Docker Hubban a képekért Indítás Egy vagy több leállított konténer statisztikáinak indítása A tároló(k) élő adatfolyamának megjelenítése erőforráshasználati statisztikák leállítása Futó tárolócímke leállítása Kép címkézése a tárhely tetejére Egy tároló futó folyamatainak megjelenítése szüneteltetés feloldása A tárolóköteten belüli összes folyamat szüneteltetésének feloldása Docker-kötetek kezelése várjon Blokkolás unt il egy tároló leáll, majd kinyomtatja a kilépési kódját. Futtassa a "docker COMMAND --help" parancsot a parancsokkal kapcsolatos további információkért.

Már több hónapja a dockert használom webprojektek fejlesztésének/szállításának strukturálására. A "Habrahabr" olvasóinak felajánlom a dockerről szóló bevezető cikk fordítását - "A dokkoló megértése".

Mi az a docker?

A Docker egy nyílt platform alkalmazások fejlesztésére, szállítására és üzemeltetésére. A Dockert úgy tervezték, hogy alkalmazásai gyorsabban induljanak és futhassanak. A docker segítségével leválaszthatja az alkalmazást az infrastruktúráról, és kezelt alkalmazásként kezelheti az infrastruktúrát. A Docker segítségével gyorsabban telepítheti a kódot, gyorsabban tesztelheti, gyorsabban telepítheti az alkalmazásokat, és csökkentheti a kód írása és a kód futtatása közötti időt. A Docker ezt egy könnyű konténervirtualizációs keretrendszerrel teszi, amely folyamatokat és segédprogramokat használ az alkalmazások kezeléséhez és üzembe helyezéséhez.

A docker lényegében szinte bármilyen alkalmazás futtatását teszi lehetővé, biztonságosan egy tárolóban elszigetelve. A biztonságos elkülönítés lehetővé teszi több tároló futtatását ugyanazon a gazdagépen egyidejűleg. A konténer könnyű jellege, amely további hypervisor terhelés nélkül fut, lehetővé teszi, hogy többet hozzon ki hardveréből.

A konténervirtualizációs platform és eszközök a következő esetekben lehetnek hasznosak:

• az alkalmazás (és a használt alkatrészek) becsomagolása docker konténerekbe;
• ezeknek a tárolóknak a forgalmazása és szállítása a csapatok számára fejlesztés és tesztelés céljából;
• feltöltheti ezeket a tárolókat a produkcióiba, adatközpontokban és felhőkben egyaránt.

Mire használhatom a dockert?

Az alkalmazások gyors feltöltése

A Docker kiválóan alkalmas a fejlesztési ciklus megszervezésére. A Docker lehetővé teszi a fejlesztők számára, hogy helyi konténereket használjanak alkalmazásokkal és szolgáltatásokkal. Ez később lehetővé teszi, hogy integrálódjon a folyamatos integrációs és üzembe helyezési munkafolyamatba.

Például a fejlesztők helyileg írnak kódot, és megosztják fejlesztői veremüket (docker-képkészletüket) társaikkal. Amikor készen állnak, elküldik a kódot és a tárolókat a teszthelyre, és lefuttatják a szükséges teszteket. A teszthelyről kódot és képeket küldhetnek a termelésbe.

Könnyebb kihelyezés és kibontás

A konténer alapú dokkoló platform megkönnyíti a rakomány hordozását. A Docker-tárolók futhatnak a helyi gépen, mind a valós, mind az adatközpont virtuális gépén, valamint a felhőben.

A docker hordozhatósága és könnyű súlya megkönnyíti a munkaterhelés dinamikus kezelését. A docker segítségével telepítheti vagy telepítheti alkalmazását vagy szolgáltatásait. A Docker sebessége lehetővé teszi ezt közel valós időben.

Nagyobb terhelés és több hasznos teher

A Docker könnyű és gyors. Robusztus, költséghatékony alternatívát kínál a hypervisor-alapú virtuális gépekhez. Különösen hasznos nagy terhelésű környezetekben, például saját felhő vagy platform-as-service felépítésében. De ugyanolyan hasznos kis és közepes alkalmazásoknál, amikor többet szeretne kihozni a rendelkezésre álló erőforrásokból.

A Docker fő összetevői

A Dockernek két fő összetevője van:

• Docker: nyílt forráskódú virtualizációs platform;
• Docker Hub: Platformunk a dokkolókonténerek elosztására és kezelésére szolgáló szolgáltatásként.

Jegyzet! A Dockert az Apache 2.0 licenc alatt terjesztik.

Docker architektúra

A Docker kliens-szerver architektúrát használ. A Docker kliens kommunikál a Docker démonnal, amely átveszi a konténerek létrehozásának, futtatásának és elosztásának terhét. A kliens és a szerver is futhat ugyanazon a rendszeren, a klienst egy távoli docker démonhoz csatlakoztathatja. Az ügyfél és a szerver socketen vagy RESTful API-n keresztül kommunikál.

Docker démon

Ahogy az ábrán látható, a démon elindul a gazdagépen. A felhasználó nem lép kapcsolatba közvetlenül a szerverrel, hanem a klienst használja erre.

Docker kliens

Docker kliens, a docker program a Docker fő felülete. Parancsokat kap a felhasználótól, és interakcióba lép a docker démonnal.

Belső dokkoló

Ahhoz, hogy megértse, miből áll a docker, három összetevőt kell ismernie:

• képeket
• nyilvántartás (nyilvántartások)
• konténerek

Képek

A Docker-kép csak olvasható sablon. Például egy kép tartalmazhat egy Ubuntu operációs rendszert Apache-t és egy alkalmazást. A képeket konténerek létrehozására használják. A Docker segítségével egyszerűen hozhat létre új képeket, frissítheti a meglévőket, vagy letöltheti a mások által készített képeket. A képek a docker build összetevői.

Iktató hivatal

A Docker registry tárolja a képeket. Vannak nyilvános és privát nyilvántartások, amelyekből képeket tölthet le vagy tölthet fel. A nyilvános Docker-nyilvántartás a Docker Hub. Hatalmas képgyűjtemény van. Mint tudja, a képeket Ön is létrehozhatja, vagy használhatja mások által készített képeket. A nyilvántartások terjesztési összetevők.

Konténerek

A konténerek olyanok, mint a könyvtárak. A tárolók mindent tartalmaznak, amire az alkalmazásnak szüksége van. Minden tároló egy képből jön létre. A tárolók létrehozhatók, elindíthatók, leállíthatók, migrálhatók vagy törölhetők. Minden tároló elszigetelt, és biztonságos platform az alkalmazás számára. A konténerek a munka részét képezik.

Tehát hogyan működik a Docker?

Eddig azt tudjuk, hogy:

• képeket készíthetünk, amelyekben az alkalmazásaink találhatók;
• konténereket készíthetünk képekből az alkalmazások futtatásához;
• képeket terjeszthetünk a Docker Hubon vagy más képregisztrációs adatbázison keresztül.

Nézzük meg, hogyan illeszkednek egymáshoz ezek az alkatrészek.

Hogyan működik a kép?

Azt már tudjuk, hogy a kép egy csak olvasható sablon, amelyből egy konténer jön létre. Minden kép egy sor szintből áll. A Docker az unió fájlrendszert használja, hogy ezeket a rétegeket egyetlen képpé egyesítse. Az union fájlrendszer lehetővé teszi a különböző fájlrendszerekből (különböző ágakból) származó fájlok és könyvtárak átlátható átfedését, így koherens fájlrendszer jön létre.

A docker könnyű súlyának egyik oka az ilyen rétegek használata. Amikor módosítja a képet, például frissíti az alkalmazást, egy új réteg jön létre. Tehát a teljes kép cseréje vagy újjáépítése nélkül, ahogyan egy virtuális géphez kell, csak a szint kerül hozzáadásra vagy frissítésre. És nem kell a teljesen új képet terjeszteni, csak a frissítés kerül kiosztásra, ami megkönnyíti és gyorsabbá teszi a képek terjesztését.

Minden megjelenés középpontjában az alap megjelenés áll. Például ubuntu, egy Ubuntu alapkép vagy fedora, egy Fedora alapkép. A képeket új képek készítésének alapjaként is használhatja. Ha például van egy apache-képe, akkor azt használhatja webalkalmazásai alapképeként.

Jegyzet! A Docker általában a Docker Hub rendszerleíró adatbázisából gyűjti be a képeket.

Ezekből az alapképekből Docker-képek hozhatók létre, a képek létrehozásának leírási lépéseit utasításoknak nevezzük. Minden utasítás új képet vagy szintet hoz létre. Az utasítások a következők lesznek:

• futtató parancs
• fájl vagy könyvtár hozzáadása
• környezeti változó létrehozása
• megadja, hogy mit kell futtatni a kép tárolójának elindításakor

Ezeket az utasításokat a Dockerfile tárolja. A Docker beolvassa ezt a Docker-fájlt a kép létrehozásakor, követi ezeket az utasításokat, és visszaadja a végleges képet.

Hogyan működik a docker registry?

A rendszerleíró adatbázis a docker képek tárháza. A kép létrehozása után közzéteheti azt a nyilvános Docker Hub nyilvántartásban vagy a személyes nyilvántartásban.

A docker kliens segítségével megkeresheti a már közzétett képeket, és letöltheti azokat a gépére a dockerből, hogy tárolókat hozzon létre.

A Docker Hub nyilvános és privát képtárakat biztosít. A nyilvános adattárakból való képek keresése és letöltése mindenki számára elérhető. A magántárhelyek tartalma nem szerepel a keresési eredmények között. És csak Ön és felhasználói kaphatják meg ezeket a képeket, és hozhatnak létre tárolókat belőlük.

Hogyan működik egy konténer?

A tároló az operációs rendszerből, a felhasználói fájlokból és a metaadatokból áll. Mint tudjuk, minden tároló egy képből jön létre. Ez a kép tájékoztatja a dockert, hogy mi van a tárolóban, milyen folyamatot kell futtatni, mikor indul a tároló, és más konfigurációs adatokat is tartalmaz. A Docker kép csak olvasható. Amikor a docker elindítja a tárolót, létrehoz egy olvasási/írási réteget a kép tetején (a korábban említett union fájlrendszer használatával), amelyben az alkalmazás futhat.

Mi történik, ha egy konténer elindul?

Akár a docker program, akár a RESTful API használatával a docker-ügyfél utasítja a docker-démont, hogy indítsa el a tárolót.

$ sudo docker run -i -t ubuntu / bin / bash

Foglalkozzunk ezzel a paranccsal. A kliens a docker paranccsal indul el, egy futtatási opcióval, amely szerint egy új tároló fog elindulni. A tároló indításának minimális követelményei a következő attribútumok:

• melyik képet használja a tároló létrehozásához. Esetünkben az ubuntu
• a tároló indításakor futtatni kívánt parancsot. Esetünkben / bin / bash

Mi történik a motorháztető alatt, amikor futtatjuk ezt a parancsot?

A Docker sorrendben a következőket teszi:

• letölti az ubuntu képet: A docker ellenőrzi, hogy van-e ubuntu lemezkép a helyi gépen, és ha nem, letölti a Docker Hubról. Ha van kép, akkor azt egy tároló létrehozásához használja;
• tárolót hoz létre: a kép fogadásakor a docker azt használja a tároló létrehozásához;
• inicializálja a fájlrendszert és csatlakoztatja a csak olvasható szintet: a tároló létrejön a fájlrendszerben, és a csak olvasható szint hozzáadódik a képhez;
• inicializálja a hálózatot/hidat: létrehoz egy hálózati interfészt, amely lehetővé teszi a docker számára, hogy kommunikáljon a gazdagéppel;
• Az IP-cím beállítása: megkeresi és beállítja a címet;
• Elindítja a megadott folyamatot: elindítja az alkalmazást;
• Feldolgozza és kiadja az alkalmazás kimenetét:összekapcsolja és naplózza az alkalmazás szabványos bemeneti, kimeneti és hibafolyamát, így nyomon követheti, hogyan fut az alkalmazás.

Most már van egy működő konténer. Kezelheti tárolóját, interakcióba léphet az alkalmazással. Ha úgy dönt, hogy leállítja az alkalmazást, távolítsa el a tárolót.

Alkalmazott technológiák

A Docker Go nyelven íródott, és a Linux kernel egyes funkcióit használja a fenti funkciók megvalósításához.

Névterek

A Docker névterek technológiát használ az elszigetelt munkaterületek szervezésére, amelyeket konténereknek nevezünk. Amikor elindítunk egy tárolót, a docker névtereket hoz létre az adott tárolóhoz.

Ez egy elszigetelt réteget hoz létre, a tároló minden eleme a saját névterében fut, és nem fér hozzá a külső rendszerhez.

A Docker által használt névterek listája:

• pid: a folyamat elkülönítése;
• háló: hálózati interfészek kezelésére;
• ipc: az IPC erőforrások kezelésére. (ICP: InterProccess Communication);
• mnt: csatolási pontok kezelésére;
• utc: a kernel elkülönítéséhez és a verziógeneráláshoz (UTC: Unix időmegosztási rendszer).

Kontroll csoportok

A Docker cgroups technológiát vagy vezérlőcsoportokat is használ. Az alkalmazások elkülönített futtatásának kulcsa, hogy az alkalmazást csak a kívánt erőforrásokkal látja el. Ez biztosítja, hogy a konténerek jó szomszédok legyenek. A vezérlőcsoportok lehetővé teszik a rendelkezésre álló hardvererőforrások megosztását, és szükség esetén korlátok és korlátok beállítását. Például korlátozza egy tároló számára elérhető memória mennyiségét.

Uniós fájlrendszer

Az Union File Sysem vagy UnionFS egy olyan fájlrendszer, amely rétegek létrehozásával működik, így nagyon könnyű és gyors. A Docker az UnionFS segítségével hozza létre azokat a blokkokat, amelyekből a tároló épül. A Docker számos UnionFS-változatot használhat, beleértve: AUFS, btrfs, vfs és DeviceMapper.

Konténer formátumok

A Docker ezeket az összetevőket egy burkolóba egyesíti, amelyet konténerformátumnak nevezünk. Az alapértelmezett formátum a libcontainer. A Docker a hagyományos Linux konténerformátumot is támogatja az LXC használatával. A Docker a jövőben más konténerformátumokat is támogathat. Például a BSD Jails vagy a Solaris Zones integrálása.

Többször érintettük a témát, és számos rendszert figyelembe vettünk a felépítésükhöz. Ma egy másik nagyszerű rendszert mutatunk be a Docker konténerekkel.

Kezdjük azzal, hogy leírjuk azokat az alapvető funkciókat, amelyek hasznosak lesznek a sorozat további cikkeiben, és röviden idézzük fel a Docker architektúrát. A Docker kliens-szerver architektúrát használ, és egy kliens-docker segédprogramból áll, amely a kiszolgálóhoz a RESTful API, és egy démon a Linux operációs rendszerben (lásd: 1. ábra). Bár a Docker nem Linux operációs rendszereken is működik, ez a cikk nem foglalkozik velük.

A Docker fő összetevői:

• Konténerek- operációs rendszer-technológiákkal elkülönített felhasználói környezetek, amelyekben az alkalmazások futnak. A legegyszerűbb módja az, hogy egy Docker-tárolót egy képből indított alkalmazásként határoz meg. A Docker egyébként ideológiailag pont ebben különbözik például az LXC-től ( Linux konténerek), bár ugyanazokat a Linux kerneltechnológiákat használják. A Docker projekt fejlesztői elkötelezettek azon elv mellett, hogy egy konténer egy alkalmazás.
• Képek- csak olvasható alkalmazássablonok. A meglévő képek fölé új szinteket lehet hozzáadni, amelyek együttesen képviselik a fájlrendszert, módosítva vagy kiegészítve az előző szintet. Az új lemezkép általában úgy jön létre, hogy egy már futó tárolót elment egy új lemezképre egy meglévő fölé, vagy a segédprogram speciális utasításainak használatával. A tároló különböző szintjei fájlrendszer szintű elkülönítéséhez AUFS, btrfs, vfs és Device Mapper... Ha a Dockert a következővel együtt kívánja használni SELinux, akkor kötelező Eszközleképező.
• Nyilvántartások tárolókat tartalmaz ( adattár) képek, - hálózati képtárolók. Lehetnek magán- és nyilvánosak is. A leghíresebb nyilvántartás az.

A GNU/Linux operációs rendszerek szabványos Linux kerneltechnológiákat használnak a konténerek elkülönítésére, mint például:

• Névterek ( Linux névterek).
• Kontroll csoportok ( Ccsoportok).
• Jogosultságkezelő eszközök ( Linux képességek).
• További, kötelező biztonsági rendszerek, mint pl AppArmor vagy SELinux.

Tekintsük a felsorolt ​​technológiákat egy kicsit részletesebben.

Vezérlőcsoport mechanizmus (Ccsoportok) eszközt biztosít a rendszererőforrások allokációjának, priorizálásának és kezelésének finomhangolásához. A vezérlőcsoportok a Linux kernelben vannak megvalósítva. A modern disztribúciókban a vezérlőcsoport-kezelést keresztül valósítják meg systemd azonban továbbra is lehetséges a vezérlés a könyvtár használatával libcgroupés közművek cgconfig... Az alábbiakban felsoroljuk a fő cgroup hierarchiákat (más néven vezérlőket):

• blkio- korlátozza a bemeneti-kimeneti műveleteket és a blokkeszközökhöz való hozzáférést;
• processzor- a folyamatütemező segítségével elosztja a processzoridőt a feladatok között;
• cpuacct- Automatikus jelentéseket készít a CPU erőforrások használatáról. A vezérlővel együtt működik processzor fentebb leírtak szerint;
• cpuset- feladatokhoz rendel bizonyos processzorokat és memória csomópontokat;
• eszközöket- szabályozza a feladatok meghatározott eszközökhöz való hozzáférését;
• mélyhűtő- felfüggeszti vagy folytatja a feladatokat;
• memória- korlátokat állít fel és jelentéseket készít a memóriahasználatról a vezérlőcsoport feladatai szerint;
• net_cls- elvégzi a hálózati csomagok osztályazonosítóval való címkézését ( osztály azonosító). Ez lehetővé teszi a forgalomirányító ( tc parancsot) és tűzfal ( iptables) vegye figyelembe ezeket a címkéket a forgalom feldolgozásakor;
• perf_event- lehetővé teszi a vezérlőcsoportok figyelését a segédprogram segítségével perf;
• hugetlb- lehetővé teszi nagy virtuális memória oldalak használatát és korlátok alkalmazását azokra.

Névterek, viszont nem az erőforrás-allokációt, hanem a kernel adatstruktúráihoz való hozzáférést szabályozzák. Valójában ez a folyamatok egymástól való elszigetelését, valamint azt a lehetőséget, hogy párhuzamosan „azonos”, de egymással nem átfedő folyamatok, felhasználók és hálózati interfészek hierarchiái legyenek. Igény szerint a különböző szolgáltatásoknak sajátjuk is lehet loopback interfészek.

Példák a Docker által használt névterekre:

• PID, folyamatazonosító- a folyamatok hierarchiájának elszigeteltsége.
• NET, hálózat- hálózati interfészek leválasztása.
• PC, InterProcess kommunikáció- a folyamatok közötti interakció menedzselése.
• MNT, Mount- Csatlakozási pontok kezelése.
• UTS, Unix Timesharing System- a kernel és a verzióazonosítók elkülönítése.

Az úgynevezett mechanizmus Képességek lehetővé teszi, hogy a root felhasználó jogosultságait kis csoportokra ossza fel, és külön rendelje hozzá őket. Ez a funkció a verzió óta megjelent a GNU/Linux alatt kernelek 2.2. Kezdetben a tárolók korlátozott jogosultságokkal indulnak.

Engedélyezheti és letilthatja a docker parancs beállításait:

• szerelési műveletek;
• hozzáférés az aljzatokhoz;
• Bizonyos műveletek végrehajtása a fájlrendszeren, például a fájlok attribútumai vagy a tulajdonos megváltoztatása.

A jogosultságokról a man oldalon tudhat meg többet. KÉPESSÉGEK (7).

Docker telepítése

Vessünk egy pillantást a Docker telepítésére a CentOS használatával példaként. Ha CentOS-szal dolgozik, választhat: használja a legújabb verziót az u pstream vagy a CentOS projekt által épített változat Red Hat kiegészítőkkel. A változások leírása az oldalon érhető el.

Ez alapvetően az új upstream verziók javításainak és a Red Hat fejlesztői által javasolt, de a fő kódba még nem elfogadott változtatásoknak a fordított áthelyezése. A legszembetűnőbb különbség az írás idején az volt, hogy az újabb verziókban a docker szolgáltatás három részre oszlik: egy démonra. dokkoló, konténeres és runc... A Red Hat még nem tartja stabilnak ezt a változást, és egy monolitikus 1.10-es futtatható verziót szállít.

A tároló beállításai a telepítéshez upstream verziók, valamint az egyéb disztribúciókra és operációs rendszerekre történő telepítésre vonatkozó utasításokat a hivatalos webhelyen található telepítési útmutató tartalmazza. Pontosabban a CentOS 7 tárhely beállításai:

# cat /etc/yum.repos.d/docker.repo name = Docker Repository baseurl = https: //yum.dockerproject.org/repo/main/centos/7 engedélyezve = 1 gpgcheck = 1 gpgkey = https: // yum .dockerproject.org / gpg

# cat /etc/yum.repos.d/docker.repo név = Repository baseurl = https: // yum .dockerproject .org / repo / main / centos / 7 engedélyezve = 1 gpgcheck = 1 gpgkey = https: // yum .dockerproject .org / gpg

Telepítse a szükséges csomagokat, majd indítsa el és engedélyezze a szolgáltatást:

# yum install -y docker-engine # systemctl start docker.service # systemctl enable docker.service

# yum install -y docker-motor # systemctl start docker.service # systemctl enable docker.service

A szolgáltatás állapotának ellenőrzése:

# systemctl status docker.service

# systemctl status docker.service

A Dockerrel és a környezettel kapcsolatos rendszerinformációkat is megtekintheti:

# dokkoló információ

Ha egy hasonló parancsot futtat, és a Dockert a CentOS-tárolókból telepíti, kisebb eltéréseket fog látni a szoftver régebbi verziójának használata miatt. A kimenetből dokkoló információ megtudhatjuk, mit használnak illesztőprogramként az adatok tárolására Készülékleképező, és tárolóként - egy fájlt / var / lib / docker /:

# ls -lh / var / lib / docker / devicemapper / devicemapper / data -rw -------. 1 root root 100G december 27. 12:00 / var / lib / docker / devicemapper / devicemapper / data

# ls -lh / var / lib / docker / devicemapper / devicemapper / data Rw - - - -. 1 root root 100G december 27. 12:00 / var / lib / / devicemapper / devicemapper / data

A démon indítási beállításai, mint általában a CentOS esetében, a rendszerben tárolódnak / etc / sysconfig /... Ebben az esetben a docker fájl neve. Megfelelő sor / etc / sysconfig / docker opciók leírása:

OPCIÓK = "- selinux-enabled --log-driver = naplózott"

Ha nem root felhasználóként vagy a docker csoport tagjaként futtatta a docker parancsot, akkor a következő hibaüzenet jelenik meg:

$ docker keresés mysql

$ keresés mysql-ben

Figyelmeztetés: nem sikerült lekérni az alapértelmezett beállításjegyzék-végpontot a démontól (Nem lehet csatlakozni a Docker-démonhoz. A docker-démon fut ezen a gazdagépen?). A rendszer alapértelmezett használata: https: // index. docker.io/v1/

Nem lehet csatlakozni a Docker démonhoz. A docker démon fut ezen a gazdagépen?

Ne feledje, hogy egy felhasználó hozzáadása a docker csoporthoz egyenértékű a felhasználó hozzáadásával a gyökércsoporthoz.

Az RHEL/CentOS fejlesztők kissé eltérően közelítenek a Docker démon biztonságához, mint maguk a Docker fejlesztői. A Red Hat megközelítésével kapcsolatos további információkért tekintse meg Dan Walsh, az RHEL fejlesztőjének cikkét.

Ha azt szeretné, hogy a CentOS-tárolókból telepítse a Docker "standard" viselkedését (vagyis a hivatalos dokumentációban leírtakat), akkor létre kell hoznia egy dockercsoportot, és hozzá kell adnia a démon indítási beállításait:

OPCIÓK = "- selinux-engedélyezett --log-driver = naplózott ↵ --group = dokkoló"

OPCIÓK = "--selinux-enabled --log-driver = naplózott ↵ --group = dokkoló"

Ezután újraindítjuk a szolgáltatást, és ellenőrizzük, hogy a docker socket fájl a docker csoporthoz tartozik-e, és nem a root:

# ls -l /var/run/docker.sock

Képek és Docker-címkék keresése

Próbáljunk meg egy konténert találni a Docker Hubon.

$ docker kereső haproxy

$ keresés haproxy

Ebben a kimenetben kaptunk egy listát számos HA proxy képről. A lista legfelső eleme a HA Proxy a hivatalos adattárból. Az ilyen képek abban különböznek, hogy a névben nincs szimbólum «/» elválasztja a felhasználó adattárának nevét magának a tárolónak a nevétől. A hivatalos mögötti példa két haproxyképet mutat a nyílt felhasználói tárolókból eeacms és millió12.

Az alábbi kettőhöz hasonló képeket saját maga is létrehozhat, ha regisztrál a Docker Hubon. A hivatalosakat a Docker, Inc. által szponzorált dedikált csapat támogatja. A hivatalos adattár jellemzői:

• Ezek használatra ajánlott képek a bevált gyakorlatok és a bevált gyakorlatok alapján.
• Ezek olyan alapképek, amelyek kiindulópontot jelenthetnek a további testreszabáshoz. Például az Ubuntu, a CentOS vagy a könyvtárak és fejlesztői környezetek alapképei.
• A legújabb szoftververziókat tartalmazza, javított sebezhetőségekkel.
• Ez a termékek hivatalos értékesítési csatornája. Ha csak hivatalos képeket szeretne keresni, használja a lehetőséget -Szűrje: „hivatalos = igaz” parancsokat dokkoló keresés.

Csillagok a parancskimenetben dokkoló keresés megfelel a kép népszerűségének. Ez a gomb analógja Mint közösségi oldalakon vagy könyvjelzővel más felhasználók számára. Automatizált azt jelenti, hogy a kép automatikusan létrejön egy egyéni szkriptből a Docker Hub használatával. Általában előnyben kell részesíteni az automatikusan gyűjtött képeket, mivel azok tartalma a megfelelő fájl ismeretében ellenőrizhető.

Töltse le a hivatalos HA Proxy képét:

$ docker pull haproxy Az alapértelmezett címke használata: legújabb

A kép teljes neve így nézhet ki:

[felhasználónév] kép neve [: címke]

A letöltött képek listáját a paranccsal tekintheti meg docker képek:

Konténerek indítása

A tároló futtatásához nem szükséges letölteni a képet. Ha elérhető, akkor automatikusan betöltődik. Próbáljunk meg elindítani egy konténert Ubuntuval. Nem listázzuk ki az adattárat, és letöltjük a Canonical által támogatott legújabb hivatalos képet.

$ docker run -it ubuntu [e-mail védett]:/#

$ futni - ez ubuntu root @ d7402d1f7c54: / #

A csapaton kívül fuss, két lehetőséget adtunk meg: -én- a tárolónak interaktívan kell futnia és -t- egy pszeudoterminált kell kiemelni. Amint a kimenetből látható, root felhasználói jogosultságokkal rendelkezünk a tárolóban, és a konténerazonosító jelenik meg gazdagépnévként. Ez utóbbi nem biztos, hogy minden tárolóra igaz, és a tároló fejlesztőjétől függ. Ellenőrizzük, hogy ez valóban az Ubuntu környezet:

[e-mail védett]: / # macska / etc / * kiadás | grep DISTRIB_DESCRIPTION DISTRIB_DESCRIPTION = "Ubuntu 16.04.1 LTS"

root @ d7402d1f7c54: / # macska / etc / * kiadás | grep DISTRIB_DESCRIPTION DISTRIB_DESCRIPTION = "Ubuntu 16.04.1 LTS"

Uname parancs -a ilyen célokra nem fog működni, mivel a tároló a gazdagép kernellel működik.

Az egyik lehetőség lehet egy egyedi tárolónév, amelyre a kényelem érdekében hivatkozni lehet, amellett, hogy Tárolóazonosító.Úgy adják meg -Név<имя>. Ha az opciót kihagyjuk, a név automatikusan generálódik.

Az automatikusan generált konténernevek nem hordoznak szemantikai terhelést, azonban érdekességként megjegyezhető, hogy a nevek véletlenszerűen keletkeznek egy híres tudós, feltaláló vagy hacker jelzőjéből és nevéből. A generátor kódban minden névhez talál egy rövid leírást, hogy miről is ismert az adott figura.

A futó konténerek listáját a paranccsal tekintheti meg. Ehhez nyisson meg egy második terminált:

Ha azonban kiadjuk a parancsot, akkor nem találjuk meg a mysql image-ből létrehozott tárolót. Használjuk az opciót -a amely az összes tárolót mutatja, nem csak a futó tárolókat:

Nyilvánvalóan a konténer indításakor nem adták meg a szükséges paramétereket. A tároló futtatásához szükséges környezeti változók leírását lásd a Docker Hub hivatalos MySQL lemezképében. Próbáljuk meg újra az opció használatával -e amely beállítja a környezeti változókat a tárolóban:

$ docker futtatása --name mysql-test ↵ -e MYSQL_ROOT_PASSWORD = docker -d mysql

Az utolsó paraméter az a parancs, amelyet a tárolón belül szeretnénk végrehajtani. Ebben az esetben a parancsértelmező. Bash... Lehetőségek -azt céljuk hasonló a parancsban korábban használtakhoz dokkolófuttatás.

Valójában a parancs tárolóba való futtatása után mysql-teszt még egy folyamat hozzáadódik - bash... Ez jól látható a pstree paranccsal. A parancs rövidített kimenete docker végrehajtó:

A Dockeren belül csak Linux, és kísérletileg a FreeBSD-t. Natívan fut Linuxon és kísérletileg FreeBSD-n. MacOSX, Windows alatt - virtuális gépen keresztül. A Docker kettős szigetelésű. A Docker-tárolóban található elemek elkülönítése az operációs rendszertől, és az operációs rendszer elkülönítése a Dockerben lévőtől. Az elkülönítés az összes fájl, port és prioritás elkülönítését jelenti. Szinte egy virtuális gép. Majdnem, de nem egészen. Van olyan, hogy "függőségi pokol". A számítógépre telepített bármilyen szoftver függőséget húz(konfigurációs fájlok, statikus fájlok, amelyeket általában eszköznek neveznek, segédprogramok/szolgáltatások, könyvtárak stb.). Számos ilyen könyvtár / segédprogram / szolgáltatás összeegyeztethetetlen egymással.És mivel ezeknek a könyvtáraknak / segédprogramoknak / szolgáltatásoknak megvannak a maga függőségei, a helyzet még rosszabb. Például a Yandex.Cocaine-t használjuk, amely általában csak Ubuntu 14.04-en (és úgy tűnik, Debian 7-en) fordítódik le. De nem CentOS 6, 7, Debian 8, FreeBSD 9, 10, Ubuntu 15, 16 stb. alatt. lehetetlen összeállítani... Ezeket az operációs rendszereket a Dockerben futtatjuk. Másrészt és ezzel egyidejűleg egy másik, modernebb szoftvert kell telepíteni. És egyben idősebb is. És nem is beszélünk a Linux komolyan eltérő verzióiról. Például egyes szoftverekhez legalább Ubuntu 14.10, míg másokhoz legalább 14.04 Linux szükséges. Docker az egy program egy egyedi környezetben az operációs rendszer egyedi verziójával. A puff konténerek rovására, ha egy gyökeret használsz végig, akkor a Docker-tároló mérete csak néhány kilobájttal nagyobb, mint a bináris fájl mérete, futni Docker alatt. Így van egy bináris fájlunk, amely mintha az operációs rendszerünkben futna. Mondhatni - bah, igen, ez egy régóta ismert dolog Virtuális gép. De nem, ez nem így van. Ezek az úgynevezett konténerek. Nincs olyan szaga, mint egy virtuális gépnek. A Windows és a MacOSX kivételével, ahol a virtuális gép nélküli munka továbbra is csak kísérletileg lehetséges, és ezekben az operációs rendszerekben a norma a Docker használata egy teljes értékű virtuális gépen belül. A Docker virtuális gépeket azonban csak fejlesztésre használják. A Docker virtuális gépek nem futnak éles környezetben. A Docker operációs rendszer-tárolókat használ. LXC Linuxon, Jails FreeBSD-n. A konténer az operációs rendszer azon területe, amely el van választva az operációs rendszer törzsétől. A tárolónak saját könyvtárfája van (beleértve a system / dev, / bin, / sbin stb.), saját hálózati portjait stb., stb. De nem használ teljes virtualizációt. Ami jelentősen megtakarítja az erőforrásokat. Futtasson 100 teljes virtuális gépet még egy erős szerveren sem fog működni. És itt 100 Docker konténer futtatása még gyenge otthoni gépen is lehetséges. Igaz, a nem teljes virtualizáció használata korlátozza a konténereken belüli operációs rendszerek használatát. Általános szabály, hogy az a Linux vagy a FreeBSD speciálisan elkészített verziói... Speciálisan képzett. Windows - elvileg lehetetlen konténerben futni. A konténerek a Docker előtt is léteztek. A Docker szigorúan véve csak egy nagyon kényelmes szerszámkészletösszeállítva a konténervirtualizáció kezeléséhez. De nagyon kényelmes. Miért használják? A legkülönfélébb Dropbox, Facebook és más óriáscégek srácai, akik 1 millió különböző programot indítottak el szolgáltatásaikban, szembesültek ezzel. lehetetlen garantálni mindenhol azonos operációs rendszer beállításait.És ez kritikus. Olyan mértékben, hogy egy valódi szerveren tökéletesen megírt és tesztelt program kiszámíthatatlanul kezd el viselkedni. Ezért az egyik okos srác új koncepciót szült – a szervereken minden program a saját egyedi környezetben fut, egyedi operációs rendszer-beállításokkal. Sőt - eredetileg szoftverfejlesztő egy Docker tárolóban lévő programot tesztel, bizonyos beállításokkal. ÉS ugyanabban (vagy azonos beállításokkal) Docker tárolóban a program a szerverhez távozik. azt lehetővé teszi a fejlesztői környezet és a futási környezet sokkal nagyobb azonosságának garantálását. Előtte az emberek szenvedtek, ravasz szerelőkkel álltak elő ... A későbbiekben leköpött az operációs rendszer környezetének egyszerűsítésére tett kísérletekre- és most a koncepció a következő - programokat telepíteni a szerverekre egyedileg testreszabott operációs rendszereikkel együtt- vagyis konténerek belsejében. 1 tároló = 1 operációs rendszer beállítás = 1 program belül. Más szavakkal: Docker-tárolót kell használni a hibakereséshez. Ugyanazt a Docker-tárolót kell használni a szerveren. Ez lehetővé teszi, hogy ne foglalkozzon a beállításokkal. "a szervernek" helyben a fejlesztő gépén. Ez lehetővé teszi a fejlesztő gépén való teljes fejlesztést különböző programokat egyszerre ami megköveteli nem kompatibilis operációs rendszer beállításai... Ezzel sokkal több garanciát vállalhatunk arra, hogy a szerveren lévő program ugyanúgy fog viselkedni, mint a fejlesztő gépén. Ez lehetővé teszi a fejlesztést Windows / MacOSX számára, kényelmes "átlátszó" teszteléssel Linux alatt. A Docker használható létrehozásra / testreszabásra csak szerverszoftver Linuxhoz(kísérleti FreeBSD alatt). Nem okostelefonokhoz. És ha vannak asztali gépek, akkor csak szoftverek grafikus felület nélkül. Amennyire Docker megengedte Egyszerűsítse a fejlesztők és adminisztrátorok munkáját, és javítsa az eredmény minőségét egy csapásra- most dübörög a Docker. Eszközök hatalmas hegyét találták ki a Dockerrel épített alkalmazások telepítésének kezelésére. Ha korábban, 10 000 program futtatásához 1000 szerveren, legalább 3 magasan képzett fejlesztőre volt szükség, akik írtak egy csomó leírást arról, hogyan ezt a Puppet, Salt, Chef, Ansible oldalon megcsinálni, és még akkor sem volt garancia, hónapokig tesztelték az egészet. Most a Dockerrel még egy minősített fejlesztő is több millió programot futtathat több tízezer szerveren. Sokkal nagyobb garanciával, hogy mindez normálisan indul. Hamis benyomásunk lehet, hogy a fejlesztő a Dockerben előkészíti a konténereket, majd átadja őket az adminisztrátornak. A helyes módszertan továbbra is más: A fejlesztő az összes kimenetét elküldi a CI-rendszernek (általában git-en keresztül) A CI minden új véglegesítéshez a Docker segítségével hoz létre egy képet a teszteléshez. Ha a tesztek sikeresek, akkor ugyanazt a Docker-lemezképet küldi el az éles üzembe helyezéshez. Illetve egy kicsit másképp olyan lefordított rendszereken, ahol a forrásokra nincs szükség a termelésben: a Dockerben a fordítási környezetet telepítik, a teszteléshez pedig egy második képet telepítenek a már lefordított jószággal, amelyet már elküldenek a Termelés. Vagyis az ügy helyes megszervezésével a fejlesztőnek nem szabad / nem szabad befolyásolnia, hogy milyen legyen a kép. De tesztkörnyezetben (szerveren fut, nagy csapatok fejlesztői számára elérhetetlen) és éles környezetben csak használják ugyanaz a kép. A fő ötlet az, hogy amit teszteltünk, az pontosan az, amit az éles szerveren futtatunk. Egy az egyhez, beleértve ugyanazokat a fájlokat (nem ugyanaz, mégpedig ugyanaz). A Docker egy népszerű eszköz, amely konténereket használ, hogy mindent biztosítson, ami az alkalmazások futtatásához szükséges. A Docker-tárolók használatával biztos lehet benne, hogy az alkalmazás ugyanúgy fog működni bármely gépen, amelyen futtatja. Ebből az oktatóanyagból megismerheti a tárolók és a Docker-képfájlok összekapcsolását, valamint a tárolók telepítését, elindítását, leállítását és eltávolítását. Áttekintés Docker kép egyfajta sablonnak tekinthető, amelyet tárolók létrehozására használnak. A képek általában a gyökér fájlrendszerrel kezdődnek, amelyhez aztán rétegenként hozzáadódnak a különféle változtatások és a hozzájuk tartozó indítási paraméterek. A tipikus Linux-disztribúciókkal ellentétben a Docker lemezkép általában csak azokat a részeket tartalmazza, amelyek az alkalmazás futtatásához szükségesek. A képeknek nincs állapotuk, és nem is változnak. Helyesebb lenne azt mondani, hogy a Docker konténerek kiindulópontja, alapja. A képek életre kelnek abban a pillanatban, amikor beírja a docker run parancsot – azonnal létrehoz egy tárolót egy új olvasási/írási réteg hozzáadásával a képhez. A csak olvasható szintek ezen kombinációja (amelyen felül egy olvasási-írási szint is hozzáadódik) UnionFS néven is ismert, egy olyan fájlrendszer, amely az egyesített fájlrendszereket kaszkádolja. Amikor egy futó tárolóban lévő meglévő fájlt módosítanak, a fájl a csak olvasható területről az írási-olvasási szintre másolódik, ahol a módosítások alkalmazásra kerülnek. És most az eredeti fájlt elrejti az olvasási / írási verzió, de nem törli. Az olvasási/írási szint ilyen változtatásai csak ebben a különálló tárolóban léteznek. A tároló törlésekor az összes módosítás is elveszik (ha nem mentette őket). Munka konténerekkel Minden alkalommal, amikor a docker run parancsot használja, egy új tároló jön létre a megadott képből. A konkrétabb példákat az alábbiakban tárgyaljuk. 1. lépés: két tároló létrehozása Az alábbi docker run parancs egy új tárolót hoz létre, amely az Ubuntu lemezképet fogja használni alapként. A -t kapcsoló terminált biztosít, az -i kapcsoló pedig a vele való interakció lehetőségét. A tárolóba való bejutáshoz használhatja a szabványos bash parancsot. Vagyis beírhatod: $ docker run -ti ubuntu $ docker run -i -t ubuntu: 14.04 / bin / bash (a második esetben a / bin / bash parancsot futtatja a tárolóban, és automatikusan a tárolóban találja magát) A parancssor megerősíti, hogy szuperfelhasználóként a tárolóban tartózkodik. A @ jel után látni fogja annak a tárolónak az azonosítóját, amelyben éppen tartózkodik: [e-mail védett]:/# Most használja az echo parancsot a / tmp könyvtár szerkesztéséhez, majd ellenőrizze, hogy a változtatásokat a cat paranccsal rögzítették-e: Echo "Example1"> /tmp/Példa1.txt cat /tmp/Példa1.txt A képernyőn a következőket kell látnia: Most lépjen ki a tárolóból: Miután az adott parancs végrehajtásra került, és kilépett a parancssorból, a Docker-tároló leállt. Ezt láthatja, ha a docker ps parancsot használja: A futó tárolók között nem fogja látni a fent használtat: TÉRÉS ID KÉP PARANCS LÉTREHOZOTT ÁLLAPOT PORTNEVEI Azonban hozzáadhatja az -a kapcsolót, hogy lássa az összes tárolót - mind a futó, mind a leállított -, és akkor megjelenik az a tároló, amelyben korábban dolgozott: $ docker ps -a TÉRÉS ID KÉP PARANCS LÉTREHOZOTT ÁLLAPOT PORTNEVEK 11cc47339ee1 ubuntu "/ bin / bash" 9 perce Kilépve (127) 10 másodperce small_sinoussi A tároló létrehozásakor azonosítóval és automatikusan generált névvel rendelkezik. Ebben az esetben a 11cc47339ee1 a tárolóazonosító, a small_sinoussi pedig a generált név. A ps -a parancs megjeleníti ezeket az adatokat, valamint azt a képet, amelyből a konténer létrejött (jelen esetben az ubuntu), mikor jött létre a tároló (9 perce), és milyen parancs futott benne ("/ bin / bash"). Láthatja a tároló állapotát is (10 másodperce hagyta el) Ha a tároló még futott, akkor a „Fel” állapot és a már futásának ideje látható. Most újra megadhatja a parancsot a tároló létrehozásához: $ docker run -ti ubuntu Annak ellenére, hogy a parancs ugyanúgy néz ki, mint legutóbb, egy teljesen új tárolót hoz létre - más lesz az azonosítószáma, és ha megpróbálja megnézni a korábban szerkesztett példa1 fájl tartalmát, akkor nem fog megtalál. [e-mail védett]: / # cat / tmp / Példa1 A kimenet a következő lenne: Cat: / tmp / 1. példa: Nincs ilyen fájl vagy könyvtár Úgy tűnhet, hogy az adatok eltűntek, de természetesen nem ez a helyzet. Lépjen ki a második tárolóból, hogy megbizonyosodjon arról, hogy mindkét tároló (beleértve az elsőt is a megfelelő fájllal) létezik a rendszeren. [e-mail védett]: / # kilépés a $ dockerből ps -a A kimenet a következő lenne: TÉRÉS ID KÉP Parancs LÉTREHOZOTT ÁLLAPOT PORTOK NEVEI 6e4341887b69 ubuntu "/ bin / bash" Körülbelül egy perce Kilépve (1) 6 másodperce kickass_borg 11cc47339ee1 ubuntu "/ bin / bash" 15 perccel ezelőtt kicsi_2 perccel ezelőtt 2. lépés: az első tartály újraindítása Egy már létrehozott tároló újraindításához a start parancsot kell használnia két -ai kapcsolóval. A végére meg kell írni annak a konténernek az azonosító számát, amellyel dolgozni szeretne, vagy a nevét. Ennek eredményeként a parancs így fog kinézni: Docker start -ai 11cc47339ee1 Most újra a tárolóban lévő bash shellben van, és ellenőrizheti, hogy a cikk elején létrehozott fájl még mindig itt van-e: Cat /tmp/Example1.txt A képernyőn látni fogja: Most már kiléphet a tárolóból: Így a tárolón belüli összes módosítás akkor is mentésre kerül, ha leállítja, majd újraindítja a tárolót. Az adatok csak akkor törlődnek, ha magát a tárolót törli. A fenti példa azt is mutatja, hogy a változtatások egy egyedi tárolót érintenek (és nem az összes tárolót egyszerre). 3. lépés: vegye ki mindkét tartályt Az utolsó lépés az oktatóanyag követésével létrehozott két tároló törlése. Ehhez a docker rm parancsot kell használni. Ez azonban csak a leállított konténereket érinti. A parancs után meg kell adnia egy vagy több tároló azonosító számát vagy nevét. Például a korábban létrehozott tárolók törléséhez be kell írnia a következő parancsot: Docker rm 6e4341887b69 small_sinoussi A képernyőn megjelenik: 6e4341887b69 small_sinoussi Mostanra mindkét tartályt eltávolították. Következtetés Ebben az oktatóanyagban megismerkedhetett a Dockerben végzett munka alapvető parancsaival, valamint a tárolók létrehozásával, leállításával, újraindításával és törlésével. Nem talált választ a kérdésére? Nézz ide A PDS-rendszer blokkdiagramja. Ahhoz, hogy egy adott CC G-ből (x) elválasztható ciklikus kódot kapjon, szüksége van Döntő visszacsatolású kommunikációs rendszer Minden zárt hurkú rendszer Rádiótechnikai jelek