Ang mga lalagyan ng Docker ay isa sa mga mahahalagang bahagi ng platform ng Docker na nag-package ng programa, mga setting ng pagsasaayos, at mga dependency gamit ang imahe ng Docker. Ang Docker image ay isang simpleng template o snapshot ng isang container na gumagabay sa container kung paano maglagay ng container sa isang application. Ang mga larawang ito ay kadalasang magagamit sa opisyal na pagpapatala ng Docker hub. Maaari ding idisenyo ng mga user ang mga larawang ito ayon sa mga kinakailangan ng proyekto gamit ang Dockerfile.
Ang blog na ito ay magpapaliwanag:
- Ano ang isang Dockerfile?
- Mga Pangunahing Utos ng Dockerfile
- Paano Magpatakbo ng isang Instance Mula sa isang Dockerfile sa Docker?
- Paano Magpatakbo ng isang Instance Mula sa isang Dockerfile sa Docker Compose?
- Konklusyon
Ano ang isang Dockerfile?
Ang Dockerfile ay isang normal na text file na naglalaman ng mga command at tagubilin na tumutukoy sa pangunahing istraktura ng isang Docker container. Ang mga tagubiling ito ay maaaring isagawa sa terminal nang walang anumang file ngunit ang pagpapatakbo ng bawat utos nang paisa-isa ay isang abalang at kumplikadong gawain. Pinapadali ng Dockerfile para sa mga developer na tukuyin ang lahat ng mga kinakailangan at tagubilin sa isang file. Gagamitin ang file na ito para buuin ang template ng container na isang imahe ng Docker. Pagkatapos nito, ang docker image ay isasagawa upang simulan ang instance sa Docker container.
Mga Pangunahing Utos ng Dockerfile
Ang ilang mga pangunahing utos ng Dockerfile na ginagamit upang tukuyin ang pangunahing snapshot ng lalagyan ay nakalista sa ibaba sa tabular na anyo:
| Mga utos | Paglalarawan |
| MULA SA | Ang ' MULA SA Ang command na ” ay ginagamit upang tukuyin ang batayang larawan para sa template ng lalagyan. Ang mga larawang ito ay nakuha mula sa opisyal na Docker registry na Docker Hub. |
| MAINTAINER | Ang ' MAINTAINER Tinutukoy ng command na ” ang impormasyon ng may-akda (Pangalan at Email) na gumagawa ng imahe ng Docker. |
| WORKDIR | Tinutukoy nito ang gumaganang direktoryo ng isang containerized na application. |
| KOPYA | Ginagamit upang kopyahin ang source at configuration file mula sa host system patungo sa tinukoy na path ng Docker container. |
| ADD | Ang ' ADD Ang 'utos ay katulad ng' KOPYA ” command ngunit sinusuportahan din nito ang malayuang URL upang idagdag ang file mula sa URL patungo sa container path gaya ng mula sa GitHub repository hanggang sa container path. |
| TAKBO | Ang ' TAKBO ” ay ginagamit upang patakbuhin ang mga utos sa lalagyan. Sa Dockerfile, ito ay kadalasang ginagamit upang pamahalaan at mag-install ng mga karagdagang dependency sa loob ng lalagyan. |
| CMD | “ CMD ” ay tumutukoy sa mga default na punto ng mga container ng Docker. Karaniwang tinutukoy nito ang mga executable at default na parameter ng ' PASUKAN ”. |
| PASUKAN | Ang ' PASUKAN Ginagamit din ang command na ” para itakda ang mga executable ng container ng Docker. Ito ay karaniwang nagtatakda ng mga default na application na ginagamit sa isang lalagyan sa bawat oras. Ang ENTRYPOINT command ay ginagamit din minsan sa isang Dockerfile. |
| USER | Ginagamit ang command na ito para itakda ang UID (user name) para isagawa ang mga command sa Container |
| VOLUME | Ang ' VOLUME Ang utos ng ” ay ginagamit upang itali o i-mount ang panlabas na volume(file system) gamit ang isang lalagyan. |
| ENV | Ang ' ENV Ginagamit ang command na ” para itakda ang mga variable ng environment ng container. |
| ARG | Ang ' ARG ” ay ginagamit upang ipasa ang mga argumento sa loob ng lalagyan. |
| EXPOSE | Ang ' EXPOSE ” utos ay tumutukoy sa paglalantad ng mga port kung saan ang lalagyan ay isasagawa. |
| ONBUILD | Nagbabasa ito ng mga tagubilin mula sa base na imahe ngunit pinalitaw ang mga tagubiling ito sa pamamagitan ng downstream na imahe. |
| LABEL | Ang ' LABEL ” ay ginagamit upang tukuyin ang metadata ng snapshot ng container. |
Paano Magpatakbo ng isang Docker Instance Mula sa isang Dockerfile sa Docker?
Para magpatakbo ng Docker instance o container gamit ang Dockerfile, gumawa muna ng Dockerfile. Pagkatapos, gawin ang pangunahing snapshot para sa lalagyan gamit ang Dockerfile. Pagkatapos nito, patakbuhin ang snapshot upang simulan ang halimbawa ng Docker.
Sundin ang mga tagubilin sa ibaba para sa paglalarawan.
Hakbang 1: Gumawa ng Dockerfile
Una, lumikha ng isang Dockerfile. Tandaan na ang Dockerfile ay walang anumang extension ng file. Pagkatapos nito, i-paste ang mga sumusunod na command sa file:
MULA sa golang: 1.8
WORKDIR / pumunta ka / src / app
Kopyahin ang main.go .
RUN go build -O webserver .
EXPOSE 8080 : 8080
PASUKAN [ './webserver' ]
Hakbang 2: Gumawa ng File ng Programa
Susunod, gumawa ng bagong file na pinangalanang ' main.go ” na naglalaman ng simpleng programang Golang. Para sa layuning ito, i-paste ang sumusunod na programa sa file:
pangunahing paketeangkat (
'fmt'
'log'
'net/http'
)
func handler ( Sa http.ResponseWriter, r * http.Kahilingan ) {
fmt.Fprintf ( Sa , 'Hello! Welcome sa LinuxHint Tutorial' )
}
func main ( ) {
http.HandleFunc ( '/' , handler )
log.Fatal ( http.ListenAndServe ( '0.0.0.0:8080' , wala ) )
}
Hakbang 3: Bumuo ng Snapshot ng Container
Ngayon, buuin ang snapshot ng Docker ng lalagyan gamit ang ' docker build -t
Sa utos sa itaas, ang ' -t 'Ang opsyon ay nagtatakda ng pangalan o tag ng larawan,' -f ” na opsyon ay tumutukoy sa landas patungo sa Dockerfile kung saan kailangang basahin ng Docker engine ang konteksto ng build:
Upang suriin kung matagumpay na nalikha ang imahe o hindi, patakbuhin ang ' mga docker na larawan
Ipinapakita ng output na matagumpay naming nagawa ang snapshot ng container mula sa Dockerfile:
Hakbang 4: Patakbuhin ang Snapshot para Paganahin ang Container
Ngayon, simulan ang halimbawa ng Docker sa lalagyan ng Docker sa pamamagitan ng pagsasagawa ng snapshot ng lalagyan na nilikha sa hakbang sa itaas:
tumakbo sa pantalan -p 8080 : 8080 --pangalan go-cont -d go-imgSa utos sa itaas, ang ' -p Ang pagpipilian ay nagpapatakbo ng lalagyan sa ' 8080 'port,' –pangalan ' nagtatakda ng pangalan ng lalagyan at ang ' -d ” na opsyon ay nagpapatakbo ng lalagyan sa detached mode (background service):
Upang i-verify kung ang container ay gumagana o hindi, ilista ang mga tumatakbong container gamit ang “ docker ps ” utos:
docker ps 
Ngayon, mag-navigate sa ' http://localhost:8080 ” at i-verify kung ang application ay tumatakbo sa expose port o hindi:
Ang output sa itaas ay nagpapahiwatig na epektibo naming nasimulan ang Docker instance gamit ang Dockerfile.
Paano Magpatakbo ng isang Instance Mula sa isang Dockerfile sa Docker Compose?
Ang Docker compose ay isa pang pangunahing plugin ng Docker platform na nagbibigay-daan sa amin na magpatakbo ng maraming pagkakataon sa iba't ibang container nang sabay-sabay. Maaari ding patakbuhin ng mga user ang Docker instance mula sa Dockerfile gamit ang Docker compose plugin. Para sa paglalarawan, sundin ang mga ibinigay na hakbang.
Hakbang 1: Lumikha ng Dockerfile
Una, lumikha ng isang Dockerfile. Halimbawa, ginagamit namin ang parehong Dockerfile at program file na ginagamit sa seksyon sa itaas:
MULA sa golang: 1.8WORKDIR / pumunta ka / src / app
Kopyahin ang main.go .
RUN go build -O webserver .
EXPOSE 8080 : 8080
PASUKAN [ './webserver' ]
Hakbang 2: Gumawa ng docker-compose.yml File
Susunod, lumikha ng ' docker-compose.yml ” file at kopyahin ang mga sumusunod na key pairs sa file:
bersyon: '3'mga serbisyo:
web:
bumuo: .
mga port:
- 8080 : 8080
Sa nabanggit na snipped:
- “ serbisyo ” ay ginagamit upang tukuyin ang mga serbisyo sa pagbuo na isasagawa sa isang hiwalay na lalagyan. Para sa paglalarawan, nag-configure lamang kami ng isang serbisyo ' web ” para panatilihing malinis at simple ang code.
- “ magtayo 'Ang key pair ay ginagamit para basahin ang build context mula sa Dockerfile. Dito, babasahin ng docker ang mga tagubilin mula sa Dockerfile at bubuo ng container nang naaayon.
- “ mga daungan Tinutukoy ng ” key ang mga naglalantad na port kung saan ipapatupad ang container.
Hakbang 3: Simulan ang Docker Instance
Ngayon, patakbuhin ang Docker instance sa isang lalagyan gamit ang ' docker-compose up ” utos:
docker-compose up -d 
Para sa pag-verify, tingnan ang listahan ng mga tumatakbong compose container gamit ang “ docker-compose ps ” utos:
docker-compose psAng output ay nagpapakita na ang ' web ' ang serbisyo ay matagumpay na naisakatuparan sa ' golangapp-web-1 ” lalagyan:
Mag-navigate sa naglalantad na port ng serbisyo ng pag-email at i-verify kung ang programa ay gumagana o hindi. Ang resulta sa ibaba ay nagpapakita na matagumpay naming nasimulan ang Docker instance mula sa Dockerfile gamit ang Docker compose:
Iyon ay tungkol sa pagpapatakbo ng isang halimbawa ng docker mula sa isang Dockerfile.
Konklusyon
Upang magsagawa ng isang Docker instance sa isang container mula sa isang Dockerfile, gumawa muna ng Dockerfile. Idagdag ang mga command sa loob ng file para gawin ang imahe o template ng container ng Docker. Pagkatapos, gawin ang lalagyan na larawan o snapshot gamit ang “ docker build -t