Ang containerization ay isang mekanismo na kadalasang ginagamit sa pagsasanay. Halimbawa, kapag naghanap ka sa headhunter, makakahanap ka ng 477 bakante sa ngayon na nagbabanggit ng Docker. Samakatuwid, hindi masamang ideya na maging pamilyar sa kung ano ito. Umaasa ako na ang maikling pagsusuri na ito ay makakatulong sa pagbuo ng isang unang ideya. Well, i-back up niya ito ng mga karagdagang materyales, tulad ng mga kurso sa Udemy.
Panimula
Sa maikling pagsusuri na ito, nais kong hawakan ang isang paksa tulad ng containerization. At kailangan mong magsimula sa pamamagitan ng pag-unawa kung ano talaga ang containerization. Ayon sa Wikipedia, ang " Containerization " ay virtualization sa antas ng operating system (i.e. HINDI hardware) kung saan ang kernel ng operating system ay nagpapanatili ng maraming nakahiwalay na mga pagkakataon sa espasyo ng gumagamit sa halip na isa lamang. Ang " User space " ay ang virtual memory address space ng operating system na nakalaan para sa mga program ng user. Ang mga instance ng user space (karaniwang tinatawag na mga container) ay ganap na magkapareho sa isang instance ng operating system mula sa pananaw ng user. Tinitiyak ng kernel ang kumpletong paghihiwalay ng lalagyan, kaya ang mga programa mula sa iba't ibang lalagyan ay hindi makakaapekto sa isa't isa. Lumalabas na ang containerization ay software virtualization, iyon ay, virtualization sa antas ng operating system, kung saan ang kernel ng operating system ang may pananagutan. Ang isa sa mga tampok na katangian ng diskarteng ito ay ang lahat ng mga lalagyan ay gumagamit ng isang karaniwang kernel, katulad ng host operating system (iyon ay, ang isa kung saan matatagpuan ang mga lalagyan). Binibigyang-daan ka nitong alisin ang overhead ng pagtulad sa virtual na hardware at paglulunsad ng ganap na instance ng operating system. Maaari nating sabihin na ito ay "magaan" na virtualization. Ang kernel ay ang gitnang bahagi ng OS na nagbibigay ng mga application na may coordinated na access sa mga mapagkukunan ng computer, tulad ng oras ng processor, memorya, panlabas na hardware, at panlabas na input at output device. Karaniwan ding nagbibigay ang kernel ng file system at mga serbisyo ng network protocol. Sa pangkalahatan, ito ang puso ng buong sistema. Para sa karagdagang impormasyon, maaaring maging kapaki-pakinabang na suriin ang materyal na " Pangkalahatang impormasyon tungkol sa mga lalagyan ". At ilang salita pa para maging kumpleto ang pagpapakilala. Mayroon na tayong pag-unawa na ang isang operating system ay may kernel. Nagbibigay ito ng paghihiwalay para sa mga pagkakataon ng espasyo ng gumagamit. Sa kontekstong ito, maaari mong makita ang terminong " cgroups ". Ito ang pangalan ng mismong mekanismo ng kernel ng Linux na nagpapahintulot sa iyo na makamit ito. Samakatuwid, maaari nating sabihin na ang landas ng containerization ay nagsimula sa mga Linux system. Gayunpaman, simula sa Windows 10, lumitaw din ang suporta para sa containerization. Upang gumana sa virtualization, kailangan mong i-configure ang suporta sa virtualization sa BIOS ng iyong computer. Kung paano ito gagawin ay depende sa computer. Halimbawa, maaaring ganito ang hitsura nito:
Sa Windows maaari mong suriin ito sa iba't ibang paraan. Halimbawa, maaari kang mag-download ng isang espesyal na utility mula sa website ng Microsoft: Hardware-Assisted Virtualization Detection Tool . Well, ito ay nagkakahalaga ng pagbanggit ng isa pang mahalagang konsepto - Hypervisor. Ang Hypervisor ay isang virtual machine monitor, isang programa para sa pagtiyak ng parallel execution ng ilang mga operating system sa parehong computer. Tinitiyak ng hypervisor na ang mga operating system ay nakahiwalay sa isa't isa at nagbabahagi ng mga mapagkukunan sa pagitan ng mga tumatakbong OS. Ang isa sa gayong hypervisor ay ang Oracle VirtualBox .
Docker
Kaya, kung ano ang virtualization ay malinaw. Ngunit paano ito gamitin? At narito ang Docker ay tumulong sa amin. Ang Docker ay software para sa pag-automate ng deployment at pamamahala ng mga application sa mga containerized na kapaligiran. Ito ay nagkakahalaga ng pagsisimula sa katotohanan na ang Docker ay kinakatawan ng isang konsepto bilang Docker Enginge. At dapat kang magsimula sa opisyal na website ng Docker at ang seksyong " Pangkalahatang-ideya ng Docker ".
Sinasabi ng dokumentasyon na ang docker ay binubuo ng:
Docker server na tinatawag na Docker Daemon na proseso (dockerd).
Command line interface, na kilala rin bilang CLI (docker).
Isang REST API na naglalarawan kung paano "makakausap" ang mga program sa deamon at sabihin dito kung ano ang gagawin.
Bago tayo sumisid pa, i-install natin ang docker, ibig sabihin, i-install ang docker daemon. Ang website ng Docker ay may mga tagubilin para sa pag-install ng " Docker para sa Windows ". Kapansin-pansin, ang Docker ay may sariling mga kinakailangan sa system. At kung ikaw, tulad ko, ay may lumang Windows, halimbawa Windows 7, kailangan mong gumamit ng Docker Toolbox.
Docker Toolbox
Upang i-install ang Docker sa mga lumang machine na hindi nakakatugon sa mga kinakailangan ng system. Ganito ang sabi ng website, "Legacy Desktop Solution". Pumunta tayo sa pahina ng " Docker Toolbox " at i-download ito. Ang set na ito ay tumitimbang ng humigit-kumulang 211 megabytes. I-install namin ito bilang isang default, iyon ay, simpleng sasang-ayon kami sa lahat nang hindi muling inaayos ang mga flag. Pagkatapos ng pag-install, susuriin namin kung maayos ang lahat. Sa hinaharap, ang ating larangan ng digmaan ang magiging command line. Inirerekumenda ko na huwag gamitin ang linya ng command ng Windows, dahil maaaring may mga hindi halatang problema dito. Mas mainam na gumamit ng bash shell. Sa Windows, ang pinaka-inirerekumendang paraan upang makuha ito ay ang pag-install ng git version control system , ito ay magagamit pa rin. Dahil "kasama" dito ang magiging bash na kailangan natin. Para sa pagsusuring ito gagamitin ko ang git bash. Maaari ka ring mag-install ng bash gamit ang CYGWIN . Ilunsad natin ang bash o git bash. Siguraduhin natin na na-install natin ang Docker Machine, na kilala rin bilang Docker Machine: docker-machine -version Ano itong Docker Machine? Ang Docker Machine ay isang utility para sa pamamahala ng mga dockerized host (ito ang mga host kung saan naka-install ang Docker Engine). Kung pagkatapos naming i-install ang Docket Toolbox tingnan ang mga docker machine gamit ang command docker-machine ls, makakakita kami ng walang laman na listahan:
Gumawa tayo ng bagong makina. Upang gawin ito, kailangan nating patakbuhin ang create command : docker-machine create -- driver virtualbox javarush: Makikita natin ang log ng paggawa ng docker machine:
Ano ang interes sa amin dito ay ang mga sumusunod. Ano ang Boot2Docker? Ito ay isang minimalistic na pamamahagi ng Linux para sa pagpapatakbo ng Docker Engine (naiintindihan namin na gumagana ang Docker salamat sa mga tool sa virtualization ng Linux, at sa Windows ang kinakailangang mekanismo ay lumitaw lamang simula sa Windows 10). Ang pamamahagi na ito ay batay sa pamamahagi ng " Tiny Core Linux ". Nabanggit din ang tungkol sa VirtualBox VM. Ito ay dahil tinukoy namin --driver virtualbox. Isang bagong virtual machine ang nilikha sa VirtualBox mula sa imahe ng Boot2Docker. Pagkatapos ng paglikha, maaari naming ilunsad ang VirtualBox (dahil naka-install ang VirtualBox kasama ang Docker Toolbox) at makita ang nilikha na virtual machine para sa docker machine:
Pagkatapos ng paglikha, sasabihan kaming patakbuhin ang command na " docker-machine env " upang makuha ang mga variable ng kapaligiran na kailangang i-configure upang kumonekta sa docker machine:
Pagkatapos isagawa ang command na ito gamit ang docker-machine, kumonekta kami sa isang remote dockerized host (sa kasong ito, isang virtual na naka-host sa Virtual Box) at maaaring magsagawa ng mga docker command nang lokal na parang pinapagana namin ang mga ito sa isang remote host. Upang suriin, maaari naming patakbuhin ang command na " info docker ". Kung hindi naitatag ang koneksyon sa docker machine, makakatanggap kami ng error. At kung maayos ang lahat, impormasyon tungkol sa docker sa docker machine. Ngayon na ang oras upang maunawaan kung paano gumagana ang Docker sa pangkalahatan at kung paano ito gamitin.
Mga Lalagyan ng Docker
Kaya mayroon kaming docker. Ano pa rin ang docker na ito? Ang dokumentasyon ng Docker at ang seksyong " Magsimula " ay makakatulong sa amin na maunawaan ito . Ang panimulang bahagi ng seksyong ito ay nagpapakilala sa Mga Konsepto ng Docker . Sinasabi nito na ang Docker ay isang platform para sa pagbuo, pag-debug at pagpapatakbo ng mga application sa mga lalagyan. Samakatuwid, ang pangunahing bagay para sa Docker ay mga lalagyan. Kahit na tingnan mo ang logo ng docker, ito ay isang balyena na may hawak na mga lalagyan sa likod nito. Ngunit ano ang isang lalagyan? Susunod sa seksyong " Mga Larawan at Mga Lalagyan " sinasabi nito na ang isang lalagyan ay isang tumatakbong halimbawa ng Larawan. At ang Imahe ay isang "package" na naglalaman ng lahat ng kailangan para sa application (code, environment, library, setting, atbp.). Ngayon subukan natin ito sa ating sarili. Ang website ng Docker ay may seksyong tinatawag na " Docker samples " na kinabibilangan ng " Docker for Beginners ". Ang mga halimbawa mula rito ay tila mas kawili-wili sa akin. Kaya, bigla naming gustong makilala ang Alpine Linux at magagawa namin ito gamit ang mga container ng Docker. Upang makakuha ng isang imahe, kailangan nating "hilahin" o "hilahin" ito palabas. Samakatuwid, isinasagawa namin ang docker pull command :docker pull apline
Tulad ng nakikita natin, nagda-download kami mula sa kung saan. Bilang default, tinitingnan ng Docker ang repository nito sa network https://hub.docker.com . Matapos matagumpay na makuha ang imahe, maaari naming suriin ang listahan ng mga magagamit na larawan sa pamamagitan ng pagpapatakbo ng docker images command :
Ngayon mayroon kaming isang imahe ng apline. Dahil ang lalagyan ay tumatakbong halimbawa ng larawan, ilunsad natin ang mismong larawang ito. Ilunsad natin ang lalagyan gamit ang command docker run alpine. Sa nakikita natin, walang nangyari. Kung ipapatupad namin ang command docker psna ipakita ang lahat ng aktibong container, wala rin kaming makukuha. Ngunit kung ipapatupad natin, docker ps -amakikita natin ang lahat ng mga lalagyan:
Ang bagay ay hindi namin inilunsad ang Docker sa interactive na mode. Kaya naman, isinagawa niya ang utos at tumigil. Ang utos ay buksan ang terminal. Gawin natin ang parehong bagay, ngunit sa interactive na mode (na may -it flag ):
Tulad ng nakikita mo, na nalampasan ang isang pagkakamali at ginamit ang pahiwatig, nakarating kami sa lalagyan at magagawa namin ito! Upang lumabas sa lalagyan nang hindi humihinto sa pagpapatakbo nito, maaari mong pindutin ang Ctrl + p + q. Kung tatakbo tayo ngayon docker ps, makakakita tayo ng isang aktibong lalagyan. Upang magpasok ng tumatakbo nang container, patakbuhin ang docker exec command :
Inirerekomenda kong basahin ang paglalarawan ng sample ng Docker para sa isang mahusay na paglalarawan kung paano nangyayari ang lahat ng ito: " 1.0 Running your first container ". Gusto ko ito dahil ang lahat ay nakasulat doon sa isang napaka-accessible at naiintindihan na paraan. Upang maikli ang pag-rephrase, nakakonekta kami gamit ang docker-machine sa isang virtual machine na nagpapatakbo ng Docker Daemon. Gamit ang CLI sa REST API, hinihiling naming ilunsad ang alpine image. Nahanap ito ng Docker at samakatuwid ay hindi ito dina-download. Gumagawa ang Docker ng bagong container at pinapatakbo ang command na tinukoy namin sa container na ito. At lahat ng ito, siyempre, ay mabuti. Ngunit bakit kailangan natin ang lahat ng ito? At dito kailangan nating malaman kung paano lumilikha ang docker ng isang imahe. At nilikha niya ang mga ito batay sa dockerfile.
Dockerfile
Gaya ng nakasaad sa sanggunian ng Dockerfile , ang dockerfile ay isang text file na naglalaman ng lahat ng mga utos para sa pagkuha ng isang imahe. Sa katunayan, ang lahat ng mga imahe na natatanggap namin (kahit Alpine, mula sa halimbawa sa itaas) ay nilikha mula sa isang dockerfile. Buuin natin ang ating imahe gamit ang isang Java application. At una kailangan namin ang Java application na ito. Iminumungkahi ko ang paggamit ng Gradle build system, na maaari mong basahin ang higit pa tungkol sa maikling pagsusuri na ito: " Isang Maikling Panimula sa Gradle ". Makakatulong sa amin sa paggawa ng proyektong " Gradle Build init plugin ". Gumawa tayo ng bagong Java application gamit ang Gradle: gradle init --type java-application Lumilikha ang command na ito ng template na proyekto ng Java. Ito ay isang standalone na application, ngunit gusto naming lumikha ng isang web application. Alisin natin ang mga klase ng App at AppTest (awtomatikong nabuo ang mga ito ng Gradle Build Init Plugin). Upang mabilis na gumawa ng web application, gagamitin namin ang tutorial mula sa Gradle: " Pagbuo ng Java Web Applications ". Ayon sa tutorial, gawin natin:
plugins {
id 'war'
id 'org.gretty' version '2.2.0'}
Nakakatuwang hindi nakikita ni Gretty ang error sa HelloServlet, na inilarawan sa itaas. Ito ay nagpapatunay na ang isang application ay maaaring kumilos nang iba sa iba't ibang mga kapaligiran. Maaaring gumana si Gretty kung saan ang isang regular na standalone na server ay maghagis ng error. Ang natitira na lang ay suriin kung gumagana nang tama ang application. Ating gawin:gradle appRun
Kung maayos ang lahat, pagkatapos ay gamitin ang command gradle warpara mangolekta ng archive na may extension war (web archive). Bilang default, binubuo ito ng gradle sa \build\libs. Ngayon, handa na kaming isulat ang aming dockerfile. Gamit ang " Dockerfile reference " gagawa kami ng Dockerfile. Gumawa tayo ng file na tinatawag na "Dockerfile" sa ugat ng aming proyekto sa Java (sa parehong lugar ng build script). Buksan natin ito para sa pag-edit. Ang file na ito ay may sariling format, na inilarawan sa seksyong " Dockerfile reference: Format ". Ang anumang dockerfile ay nagsisimula sa isang FROM na pahayag, na nagpapahiwatig ng "base na imahe". Maaari nating sabihin na ito ang imahe ng magulang na batayan ng paggawa ng ating imahe. Napakadali para sa amin na pumili ng imahe ng magulang. Ang isang web application ay nangangailangan ng isang web server. Halimbawa, maaari naming gamitin ang Tomcat web server. Pumunta kami sa opisyal na imbakan ng Docker, na tinatawag na docker hub . Tumingin kami doon upang makita kung ang imahe na kailangan namin ay naroroon:
Ito rin ay nagkakahalaga ng pag-unawa na ang imahe ng tomcat ay tinatawag. Pero bukod sa pangalan ay may tag ito. Ang isang tag ay parang isang bersyon. Ang mga larawan ng Tomcat ng iba't ibang bersyon ay naiiba sa kung aling bersyon ng Tomcat ang ginagamit, kung aling bersyon ng jre at kung aling batayang larawan. Halimbawa, makakakuha tayo ng isang imahe docker pull tomcat:9-jre8-alpine Gumagamit ito ng bersyon 9 ng tomcat, jre bersyon 8 at ang alpine image bilang base. Ito ay maaaring maging mahalaga upang bawasan ang laki ng aming larawan:
Tulad ng nakikita natin, ang pagkakaiba ay napakalaki. Kung bubuo kami ng aming imahe batay sa tomcata alpine, magsisimula kami sa 100 megabytes lamang, at hindi sa 600. Alinsunod dito, idaragdag namin ang sumusunod na nilalaman sa naunang ginawang dockerfile:
# Базовый образ,"наследуемся" от него
FROM tomcat:9-jre8-alpine
# Копируем из BuildContext'а собранный web archive в каталог томката
COPY build/libs/docker.war /usr/local/tomcat/webapps/docker.war
# Меняем рабочий каталог на томкатовский
WORKDIR /usr/local/tomcat
# Открываем порт 8080 для контейнера, т.к. его слушает томкат
EXPOSE 8080
At ngayon, isagawa natin ang utos na buuin ang imahe: docker build -t jrdocker ..
-t- ito ay isang tag, iyon ay, kung ano ang tawag sa naka-assemble na imahe. Ang tuldok sa dulo ay nangangahulugan na idinagdag namin ang kasalukuyang direktoryo (ang direktoryo kung saan matatagpuan ang dockerfile at kung saan namin pinatakbo ang utos mula) sa Build context. Build context- ito ang konteksto ng mga file na iyon na available kapag gumagawa ng dockerfile. Tulad ng nakikita mo, salamat dito, nakopya namin ang pinagsama-samang file ng digmaan sa aming imahe, sa direktoryo ng web server. Ngayon patakbuhin natin ang aming imahe:docker run -d --rm -p 8888:8080 jrdocker
Upang maunawaan kung nagsimula na ang server, maaari mong tingnan ang log mula sa lalagyan. Maaaring makuha ang log gamit ang docker logs command, na tumutukoy sa container sa pamamagitan ng ID o pangalan nito. Halimbawa:
Buweno, huwag kalimutan na maaari tayong palaging pumunta sa isang tumatakbong lalagyan ayon sa pangalan gamit ang utos: winpty docker exec -it NameКонтейнера sh Ngayon ang natitira na lang ay kumonekta. Noong nakaraan, tinukoy namin ang EXPOSE , ibig sabihin, pinayagan namin ang pag-access sa port 8080 mula sa loob ng container. Noong inilunsad namin ang container mismo, tinukoy namin ang -p ( incoming ports ) na tag, at sa gayon ay iniuugnay ang port 8080 sa container (ang Tomcat web server ay naghihintay ng mga koneksyon doon) gamit ang port 8888 sa isang makina na may docker daemon. Tulad ng naaalala namin, inilunsad namin ang docker daemon hindi direkta, ngunit sa pamamagitan ng docker-machine. Samakatuwid, muli tayong humingi ng data sa ating mga docker machine gamit ang docker-machine ls command at makipag-ugnayan sa server sa container:
Kaya, inilunsad mo at ko ang aming web application sa isang lalagyan ng Docker! ) Gusto ko ring tandaan ang mga sumusunod. Sa kaso ng mga problema sa pag-access, dapat mong tandaan na ang Docker machine ay una at pangunahin sa isang Virtual BOx virtual machine. Maaaring may mga problema sa mga setting ng network ng virtual machine. Maaaring ganito ang hitsura ng isang gumaganang configuration ng VMBox:
Mga layer
Napag-alaman na namin na ang mga imahe ay nilikha mula sa mga dockerfile at ang mga dockerfile ay isang hanay ng mga utos. Nalaman din namin na ang isang dockerfile ay may magulang. At na ang laki ng mga imahe ay iba. Kapansin-pansin, makikita mo ang kasaysayan kung paano ginawa ang imahe gamit ang command ng docker history . Halimbawa:
Mahalagang sabihin ito upang maunawaan na, sa esensya, ang bawat larawan ay isang hanay ng mga larawan. Ang bawat pagbabago ng imahe (bawat bagong command sa dockerfile) ay lumilikha ng bagong layer na may sariling ID. Maaari kang magbasa nang higit pa tungkol sa mga layer sa dokumentasyong " Docker: Mga Larawan at Mga Layer ". Lubos kong inirerekumenda na basahin ang artikulo sa Habré: " Mga larawan at lalagyan ng docker sa mga larawan ."
Konklusyon
Sana ay sapat na ang maikling pangkalahatang-ideya na ito para maging interesado ka sa containerization. Nasa ibaba ang mga link sa karagdagang materyal na maaaring maging kapaki-pakinabang:
GO TO FULL VERSION