Maluwag na nagsasalita, ang Docker ay nagiging mas at mas katulad ng isang unibersal na manager ng package na gumagana sa lahat ng mga posibleng platform sa Linux. Tumatagal ng mga lalagyan at ginagamit ang mga ito upang malutas ang isang ganap na magkakaibang problema na kinakaharap ng mga developer. Ang problema ay ginagamit ng mga developer ang kanilang operating system ng desktop (tulad ng Windows, macOS o Linux na may isang toneladang mga pakete na nauugnay sa desktop) upang magsulat ng mga application. Ang application na isinusulat nila ay madalas na tumatakbo sa isang ganap na magkakaibang operating system sa isang server sa isang lugar na may ilang pamamahagi ng Linux na ganap na naiiba kaysa sa laptop ng developer.
Sa Docker ang ideya ay ang iyong aplikasyon ay naka-pack bilang isang imahe ng Docker. Trabaho ng Docker na kunin ang imaheng ito at patakbuhin ito bilang isang lalagyan na aplikasyon para sa iyo. Ang pagiging containerized ay nangangahulugang ang application, at mga dependency nito, ay tatakbo sa isang nakahiwalay na kapaligiran na maaaring ganap na magkakaiba mula sa laptop ng developer at maging sa server ng produksyon. Hangga't pareho silang sumusuporta sa Docker, pareho silang maaaring magpatakbo ng parehong application sa eksaktong parehong paraan.
Anatomy ng isang Docker Image
Tulad ng nabanggit kanina, tatakbo ang isang Docker app sa isang napagkasunduang kapaligiran. Ngayon ang tanong ay paano natin malilikha ang kapaligiran na iyon? Karamihan sa mga imahe ng application ay mag-i-import ng isang Docker base na imahe at itatayo ang kanilang aplikasyon sa itaas nito.
Ang mga aplikasyon ay ginawa mula sa mga layer ng software. Ang isang imahe ng lalagyan ng wordpress ay binuo gamit ang isang imahe ng lalagyan na httpd na, sa turn, ay itinayo sa tuktok ng isang imahe ng Ubuntu. Ang imaheng pinagtayo ng isang mas bagong imahe ay kilala bilang PARENT IMAGE sa Docker terminology. Sa Dockerfile (makakarating kami sa kung ano ang ibig sabihin ng isang Dockerfile, kaunti pa mamaya), ang imaheng magulang na ito ay nabanggit sa tuktok ng file tulad ng ipinakita sa ibaba:
MULA sa Ubuntu: 18.04
## Pahinga ng Dockerfile
Ang Dockerfile na ito kapag naisakatuparan ay nagko-convert ang iyong application sa isang Docker na imahe (isang binary ng mga uri) na maaari mong itulak sa isang pagpapatala mula sa kung saan maaari itong hilahin upang lumikha ng mga bagong lalagyan sa ibang lugar. Gayunpaman, magkakaroon silang lahat ng Ubuntu: 18.04 bilang kanilang batayang imahe, at tatakbo na parang ito ay isang Ubuntu system na kanilang tinatakbo.
Maaaring napansin mo ito kapag sinusubukang hilahin ang isang bagong imahe ng docker.
Ipinapakita nito kung gaano karaming mga layer ang hinila bago ang aktwal na application (na maaaring kaunting Megabytes ang laki) ay dinala.
Para sa kadahilanang ito, nais naming lumikha ng kung ano ang kilala bilang isang batayang imahe. Alin ang hindi itinayo sa tuktok ng anumang bagay. Ginamit ang simula ng keyword upang ipahiwatig na ang layer na ito ay hindi itinayo sa tuktok ng anupaman. Tulad nito:
Mula sa wala## Pahinga ng Dcokerfile
Lilikha muna kami ng isang simpleng hello-world application at pagkatapos ay alamin kung ano ang mangyayari sa natitirang Dockerfile. Ang host system ay ang Ubuntu: 18.04 LTS at ginagamit namin ang Docker bersyon 17.12.1-ce para sa eksperimento.
Lumilikha ng isang static na binary
Ang mga lalagyan ng docker ay isang koleksyon ng mga proseso na tumatakbo na nakahiwalay mula sa natitirang operating system. Ang tanging bagay na ang proseso na ay nakikipag-ugnay sa ay ang Kernel. Si Kernel ay responsable para sa pag-iiskedyul ng mga prosesong ito sa CPU, paggawa ng pamamahala ng memorya at ilang iba pang mga pangunahing gawain sa pag-book ng pagpapanatili.
Ngunit ang karamihan sa mga application ng mataas na antas ay nakasalalay sa maraming mga library ng system (tulad ng glibc, musl, klibc, atbp ) at maraming mga dependency ng runtime tulad ng Python o Node.js o Java Runtime. Ang application binary ay walang lahat ng mga library na magagamit sa loob nito, ngunit kapag nagsimula itong ipatupad tinawag nito ang mga aklatan mula sa operating system ng host.
Dahil sinusubukan naming lumikha ng isang imahe mula sa simula, hindi namin makukuha ang mga kagandahang ito. Kaya't ang aming aplikasyon ay kailangang isang static na file o isang standalone na maipapatupad.
Magsimula tayo sa pamamagitan ng paglikha ng isang folder na tinatawag na MyDockerImage at paglikha ng isang file hello.cc sa loob nito.
$mkdirMyDockerImage$CDMyDockerImage
$hawakanhello.cc
Buksan ang hello.cc gamit ang iyong paboritong text editor at idagdag ang mga sumusunod na linya sa loob nito.
# isamagamit ang namespace std;
intpangunahing(){
gastos<< 'Kamusta! Ang mensahe na ito ay nagmumula sa isang lalagyan n';
bumalik ka 0;
}
Ito ay isang simpleng programa ng C ++ na nagpi-print Kumusta! Ang mensaheng ito…
Para sa mga kadahilanang tinalakay nang mas maaga, isasaayos namin ito gamit ang static flag. Ginagamit ang tagatala ay g ++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
Upang maipon ang programa, sa parehong direktoryo patakbuhin ang sumusunod na utos:
$ g++ -o hello-staticKamusta.DCLumilikha ito ng isang binary maipapatupad na file hello sa parehong direktoryo. Iyon ang aming static na file. Subukan kung tumatakbo ito na inilaan sa pamamagitan ng pagbanggit ng filename sa terminal.
$./Kamusta 
Ngayon handa na kaming ilagay ang simpleng programa na ito.
Dockerfile
Ang Dockerfile ay binubuo ng isang hanay ng mga patakaran na kumukuha ng iyong mga file ng application (tulad ng mga binary, mga file ng pinagmulan, atbp) kasama ang iba't ibang mga parameter ng pagsasaayos tulad ng layout ng system system, nakalantad na mga port, atbp at ginagawang isang file ng imahe ng Docker. Maaari mong ibahagi ang file ng imahe sa sinumang nais na patakbuhin ang application na iyon.
Hindi kami maghuhukay sa bawat pagpipilian na magagamit para sa Dockerfile, sa halip ay magsusulat kami ng isang napakaliit na Dockerfile. Sa parehong direktoryo, kung saan nakatira ang iyong hello executable, lumikha ng isang walang laman na file na pinangalanan Dockerfile.
$hawakanDockerfileBuksan ito sa iyong paboritong text editor, at isulat dito ang mga sumusunod na linya:
Mula sa walaADD hello/
CMD['/Kamusta']
gasgas ay hindi isang imahe ng magulang. Sa halip ipinapahiwatig nito ang Docker na ang imahe ay hindi itinayo sa tuktok ng anumang iba pang imahe. Ito ay binuo mula sa simula. Ang ADD command ay kukuha ng static binary na pinangalanang hello mula sa kasalukuyang direktoryo at idagdag ito sa root Directory ng file ng imahe. Kapag sa wakas ay magpatakbo kami ng isang lalagyan batay sa imaheng ito, ang hello na naisasagawa ay makikita sa loob ng direktoryo ng ugat mismo sa /hello.
Panghuli, ang linya ng CMD ay may isang string /Kamusta ang string na ito ay papatayin bilang isang command ng shell tuwing isang lalagyan ay nilikha mula sa imaheng ito, sa gayon ang binary file na idinagdag namin sa aming lalagyan at nai-print ang mensahe na isinulat namin sa aming app.
Buuin natin ang imahe sa pamamagitan ng pagtawag sa docker build utos kung saan dumaan sa mga nilalaman ng Dockerfile at bubuo ng imahe. Patakbuhin ang sumusunod na utos sa parehong direktoryo tulad ng Dockerfile at ang maipapatupad na binary.
$docker build--tagKamusta .Ang –Tag hello itinakda ng flag ang pangalan ng imahe sa Kamusta at ang tuldok ( . ) sa huli ay nagsasabi docker build upang tingnan ang kasalukuyang direktoryo para sa Dockerfile at mga kaugnay na nilalaman.
Pagpapatakbo ng lalagyan ng Docker
Upang suriin kung ang imahen na nilikha lamang namin ay nagpapakita sa listahan ng mga imahe, patakbuhin:
$mga imahe ng docker 
Pansinin kung gaano kaliit ang imahe ng hello kung ihinahambing sa ibang mga imahe. Sa anumang kaso, handa na itong patakbuhin bilang isang lalagyan,
$docker patakbo kamusta 
Ayan yun! Nilikha mo ang iyong unang minimalistic na lalagyan mula sa simula.
Iba pang mga pagpipilian
Habang ang paglikha ng mga imahe mula sa simula ay palaging isang pagpipilian, ang mga tao ay madalas na may posibilidad na lumikha ng mga imahe mula sa iba pang mga magaan na distrito ng Linux. Halimbawa ng mga imahe tulad ng alpine at busybox ay talagang magaan ang mga kapaligiran na may mas maliit na mga library tulad ng musl sa halip na glibc.
Paggamit sa kanila bilang iyong magulang na imahe sa pamamagitan ng paggamit MULA sa alpine: pinakabago ay magreresulta sa mas maliit na mga imahe pati na rin. Dahil ang mga pangunahing imahe ay 2-5 MB lamang ang laki. Ipaalam sa amin kung mayroong anumang paksa na nauugnay sa Docker na maaaring gusto mong sakupin namin sa susunod. Maaari mong abutin kami sa Twitter , Facebook o mag-subscribe sa amin sa pamamagitan ng email.