Kumpletong tutorial sa Docker Compose para sa pag-o-orchestrate ng mga container

Kung nakapag-eksperimento ka na sa mga container at nakita mo na para sa isang "totoong" app na kailangan mo higit sa isang serbisyo na tumatakbo nang sabay-sabay (database, API, frontend, cache…), maya-maya ay makakatagpo ka ng Docker Compose. Binibigyang-daan ka ng tool na ito na i-set up ang lahat ng kagamitang iyon gamit ang isang file at ilang command, nang hindi kinakailangang mag-juggle ng mga terminal at walang katapusang script.

Sa tutorial na ito, matututunan mo kung ano ang Docker Compose, kung paano gumagana ang file nito. compose.yaml at kung paano i-orchestrate ang mga application Malinis na mga setup ng multi-container: mula sa mga simpleng halimbawa gamit ang Flask at Redis hanggang sa mas kumplikadong mga arkitektura gamit ang frontend, backend, at database. Matututunan mo rin ang tungkol sa networking, mga volume, mga configuration, mga sikreto, at ang mga pangunahing utos upang gumana nang kumportable sa mga development at mas mahirap na kapaligiran.

Ano ang Docker Compose at bakit ito sulit gamitin?

Ang Docker Compose ay isang extension ng Docker na nagbibigay-daan sa tukuyin at pamahalaan ang maraming lalagyan na parang iisang aplikasyon lang sila. Sa halip na manu-manong simulan ang bawat serbisyo gamit ang "docker run" at mga parameter nito, ilalarawan mo ang lahat sa isang YAML file at sisimulan ito gamit ang iisang command.

Ang kagandahan ng Compose ay maraming modernong aplikasyon ang binuo dito. mga microservice na nakatira sa mga indibidwal na lalagyanIsang database, isang API, isang frontend, isang queuing system, isang Redis-like cache, atbp. Inirerekomenda ng Docker na ang bawat container ay magpatakbo ng isang serbisyo lamang, kaya kung susubukan mong pagkasyahin ang lahat sa isang imahe, magtatapos ka sa isang napakalaking halimaw na mahirap i-scale at panatilihin.

Maaari kang magpatakbo ng dalawa o higit pang mga serbisyo sa loob ng iisang lalagyan, ngunit Binabalewala nito ang marami sa mga bentahe ng Docker.Kung mabigo ang isa, mahihila nito pababa ang iba; hindi mo maaaring i-scale lamang ang bahaging tumatanggap ng pinakamaraming load, at ang pamamahala ng mga log, resources, at mga pagkabigo ay nagiging isang malaking gulo.

Gamit ang Docker Compose, hiwalay mong tinutukoy ang bawat serbisyo, tinutukoy kung paano sila kumokonekta sa isa't isa, kung anong data ang kanilang pinapanatili, kung anong mga port ang kanilang inilalantad, kung anong mga environment variable ang kanilang ginagamit... Sa ganitong paraan Kung ang isang lalagyan ay masira, ang natitira ay maaaring patuloy na gumana. depende sa kung paano mo ito iko-configure, at ang pag-scale ng isang partikular na piraso ay kasing simple ng pagbabago ng mga setting nito o ng bilang ng mga replica.

Bukod pa rito, ang Compose ay perpektong akma sa mga daloy ng trabaho ng CI/CD at pag-deploy sa produksyonMaaari mo itong gamitin nang direkta gamit ang mga tool tulad ng Portainer o Docker Swarm, at kung gumagamit ka ng Kubernetes, ang mga proyektong tulad ng Kompose ay nagbibigay-daan sa iyong isalin ang isang compose.yaml file sa mga manifest ng Kubernetes nang hindi kinakailangang manu-manong isulat muli ang lahat.

Mga kinakailangan para sa pagsunod sa tutorial ng Docker Compose

Para komportableng masundan ang mga halimbawa sa tutorial na ito, kailangan mo naka-install na ang Docker at Docker ComposeSa kasalukuyan, mayroong dalawang pangunahing landas:

• Docker Engine + Pagsulat ng Docker naka-install bilang mga standalone na binary.
• DockerDesktop, na kinabibilangan ng Docker Engine, Docker Compose, at isang graphical interface.

Mahalaga na mayroon kang pinakamababang pundasyon ng mga pangunahing utos ng Docker (mga imahe, lalagyan, port, volume) at huwag matakot na gamitin ang command line. Ang mga halimbawa ay karaniwang ipinapalagay sa Linux (halimbawa, Ubuntu 22.04), ngunit ang lohika ay pantay na naaangkop sa Windows at macOS na may Docker Desktop.

Suriin kung maayos ang lahat sa pamamagitan ng pagpapatakbo nito sa iyong pandulo isang bagay na kasing simple ng "docker –version" at "docker compose version"Kung ang parehong utos ay tumugon nang walang error, handa ka nang magpatuloy sa mga halimbawa.

Pangunahing istruktura ng isang compose.yaml file

Ang puso ng Docker Compose ay ang file compose.yaml (o docker-compose.yml)Doon namin ilalarawan kung aling mga serbisyo ang gusto naming i-set up at kung paano dapat iugnay ang mga ito. Bagama't dati ay ginagamit ang field na ito version Para markahan ang bersyon ng format, inirerekomenda ng kasalukuyang dokumentasyon na huwag itong tukuyin upang ang pinakabagong bersyon ng schema ang palaging gamitin.

Sa loob ng Compose file, magkakaroon ka ng ilang posibleng seksyon, bagama't isa lang ang kinakailangan: mga serbisyoMula doon, maaari kang magdagdag ng iba pang mga seksyon depende sa pagiging kumplikado ng iyong proyekto:

• mga serbisyo: kahulugan ng bawat microservice (ipinag-uutos).
• network: mga pasadyang network upang kontrolin ang komunikasyon sa pagitan ng mga container.
• mga volume: mga volume upang mapanatili ang data o ibahagi ito sa pagitan ng mga serbisyo.
• mga config: konpigurasyon ng serbisyo (hal., mga file ng konpigurasyon ng web server).
• lihim: pamamahala ng sensitibong impormasyon (mga password, mga API key…).

Sa buong tutorial na ito, makikita mo kung paano pagsamahin ang lahat ng mga seksyong ito para sa isang tipikal na proyekto na kinabibilangan ng aplikasyon, isang database, at isang APIat isa ring halimbawa ng isang web app sa Sawa gamit ang prasko at Redis.

Mga Serbisyo sa Docker Compose: ang pangunahing kahulugan

Seksyon ang mga serbisyo ay ang mahalagang bahagi mula sa anumang Compose file. Dito mo tinutukoy ang bawat isa sa mga container na bubuo sa iyong aplikasyon, na binibigyan ang mga ito ng pangalang gusto mo (halimbawa, web, database, api, redis, Atbp).

Para sa bawat serbisyo, maaari kang magtakda ng isang mahusay na bilang ng mga parameterKabilang sa mga ito ang ilan na malawakang ginagamit sa mga proyekto sa totoong mundo:

Parameter build nagpapahiwatig kung saan matatagpuan ang Dockerfile kung saan bubuuin ang imahe ng serbisyo. Kadalasan, isang konteksto (direktoryo) ang tinutukoy kung saan matatagpuan ang Dockerfile ng aplikasyon na gusto mong i-package.

Kung mayroon ka nang nagawang imahe o gusto mong gamitin ang isa mula sa registry, gamitin mo image para i-reference itoAng pangalan ay sumusunod sa format [<registry>/][<project>/]<image>[:<tag>|@<digest>]At kung kailangan mong kontrolin kung kailan na-download o na-update ang larawang iyon, maaari mong gamitin ang pull_policy.

Ang bukid ports Ginagamit ito upang i-map ang mga port sa pagitan ng host at ng containerAng sintaks ay uri [HOST:]CONTAINER[/PROTOCOL]Halimbawa, kung ang isang PostgreSQL database ay nakikinig sa port 5432 sa loob ng container at gusto mong i-expose ito sa port 5555 ng host, gagawin mo ang ganito: "5555:5432" sa listahan ng mga daungan.

Ang patakaran sa pag-restart ay kinokontrol gamit ang restartna nagpapahiwatig kung ano ang gagawin kapag ang isang lalagyan ay nagwakas nang hindi sinasadya o huminto. Ang mga karaniwang halaga ay no, always, on-failure y unless-stoppednagpapahintulot sa mga kritikal na serbisyo na manatiling gumagana kahit na makaranas sila ng paminsan-minsang pagkawala ng serbisyo.

Kung kailangan ng isang serbisyo na maging available ang isa pa bago ito magsimula, maaari mong gamitin ang depends_on upang tukuyin ang mga dependency sa pagitan ng mga containerAng isang klasikong halimbawa ay isang app na nangangailangan na ang database ay naka-on at tumatakbo upang maiwasan ang pagkabigo sa unang koneksyon.

Para sa configuration at mga kredensyal, mayroon kang dalawang karaniwang pamamaraan: env_file y environment. May env_file Nakaturo ka sa isa o higit pang mga file .env kasama ang mga variable ng kapaligiran, habang nasa environment Maaari mo silang ilista nang direkta sa YAML. Ang pinakamahusay na kasanayan ay ang paggamit ng mga file. .env para maiwasan ang pag-embed ng mga password at sensitibong data sa mismong compose.yaml file.

Parameter volumes nagpapahintulot sa pag-mount ng mga host path o volume Sa loob ng container, gagamitin mo ang parehong data persistence at folder sharing sa pagitan ng mga serbisyo. Dito, ire-refer mo lang ang mga volume na maaari mong tukuyin sa susunod na bahagi sa seksyon sa itaas. volumes kung kailangan mo ang mga ito na ibahagi o pamahalaan nang mas tahasan.

Gamit ang mga field na ito, maaari ka nang bumuo ng halos kumpletong mga serbisyo. Kasama sa ispesipikasyon ng Compose ang marami pang advanced na pagpipilian (kalusugan, mga limitasyon ng mapagkukunan, mga utos ng bootatbp.), ngunit sa mga ito ay sakop mo na ang mga pinakakaraniwang gamit.

Halimbawa 1: Aplikasyon sa web sa Python gamit ang Flask at Redis

Ang isang tipikal na halimbawa upang maunawaan ang Docker Compose ay ang paglikha ng isang simpleng web application sa PythonPaggamit ng Flask upang magsilbi ng mga pahina at Redis bilang isang in-memory store para sa isang hit counter. Ang ideya ay hindi mo kailangang mag-install ng Python o Redis sa iyong makina: lahat ay tumatakbo sa loob ng mga container.

Ang daloy ng trabaho ay magiging ganito: una, gagawa ka ng direktoryo para sa proyekto at sa loob ay magdadagdag ka ng isang file app.py gamit ang Flask code. Sa code na iyon, gagamitin mo "redis" bilang hostname at port 6379, na siyang default na port para sa serbisyo ng Redis sa iyong container.

Ang tungkuling namamahala sa counter ng bisita Ilang beses nitong sinusubukang kumonekta sa Redis. Bago sumuko, tandaan na ang lalagyan ng Redis ay maaaring abutin ng ilang segundo bago maging available kapag nabuhat mo na ang buong stack.

At app.py, gumawa ka ng file requirements.txt may mga dependency sa Python (halimbawa, Flask at redis-py), at isang Dockerfile na tumutukoy kung paano bubuuin ang imahe ng iyong web application: base Python image (3.7, 3.10 o ano pa man), working directory, mga environment variable para sa Flask, gcc installation at mga system dependencies, kopya ng requirements.txt, package installation at kopya ng code.

Sa Dockerfile, minarkahan mo rin ang port na magpapakita ng lalagyan (halimbawa 5000) at tinutukoy mo ang default na utos, karaniwan flask run --debug o katulad, para awtomatiko itong magsimula kapag nagawa na ang lalagyan.

Kapag handa na ang lahat ng ito, ang compose.yaml file ay tumutukoy sa dalawang serbisyo: ang isa ay tinatawag, halimbawa, web, na binuo mula sa Dockerfile ng proyekto at inilalantad ang port 8000 sa labas (inimapa ang port 8000 ng host sa port 5000 ng container), at isa pa na tinatawag na redis ito Kunin ang opisyal na imahe ng Redis mula sa Docker Hub.

Para ilunsad ang application, pumunta lang sa project directory at patakbuhin "magsulat ng sulat sa docker"Inaasikaso ng Compose ang pag-download ng Redis image, pagbuo ng iyong web application image, at pagsisimula ng parehong serbisyo sa tamang pagkakasunod-sunod.

Kapag gumagana na ito, papasok ka gamit ang iyong browser sa http://localhost:8000 (o http://127.0.0.1:8000) at dapat kang makakita ng mensaheng "Hello World" at isang Bilang ng bisita na tumataas sa bawat oras na mag-reload ka ang pahina. Kung susuriin mo ang mga lokal na larawan gamit ang docker image lsMakakakita ka ng parang redis y web nilikha o na-download.

Kapag gusto mo nang itigil ang lahat, magagawa mo CTRL+C sa terminal kung saan mo iniwan ang "docker compose up" o isagawa docker compose down mula sa direktoryo ng proyekto. Ititigil at aalisin nito ang mga lalagyan na nilikha ng compose na iyon.

Pagpapabuti ng daloy ng trabaho: Pag-bind ng mga mount at Pag-compose Watch

Mas maginhawa ang pagtatrabaho sa Docker sa development kung Hindi mo kailangang buuin muli ang imahe sa tuwing hahawakan mo ang code. Dito pumapasok ang Bind Mounts at, sa mga mas bagong bersyon, ang Docker Compose Watch.

Ang Bind Mount ay nagsasangkot ng pag-mount ng isang folder mula sa iyong makina sa loob ng container. Sa compose.yaml file, magdaragdag ka ng isang seksyon sa web service. volumes na nagmamapa sa direktoryo ng proyekto sa direktoryo ng pagtatrabaho mula sa lalagyan, halimbawa .:/codeSa ganitong paraan, anumang mga pagbabagong gagawin mo sa iyong editor ay agad na makikita sa loob ng lalagyan.

Kung ia-activate mo rin ang debug mode ng Flask gamit ang variable FLASK_DEBUG=1, ang utos flask run Awtomatiko nitong ire-reload ang application kapag nakakita ito ng mga pagbabago sa mga file, nang hindi na kailangang huminto at mag-restart.

Mas pinalalawak pa ito ng Docker Compose Watch: maaari mong gamitin "docker compose watch" o "docker compose up –watch" Nagbibigay-daan ito sa Compose na mas matalinong subaybayan ang mga project file at i-synchronize ang mga pagbabago sa mga container. Kapag nag-save ka ng file, kinokopya ito sa container, at ia-update ng development server ang application nang hindi nire-restart ang buong container.

Subukan, halimbawa, baguhin ang mensahe ng pagbati sa app.py mula sa "Hello World!" patungo sa isang pariralang tulad ng "Kumusta mula sa Docker"I-save ang file, i-refresh ang iyong browser, at makikita mo agad ang bagong mensahe habang patuloy na tumatakbo ang visit counter nang hindi nawawala ang estado nito.

At kapag natapos mo na ang trabaho, gaya ng dati, maaari mo nang hilahin docker compose down para patayin at linisin ang mga lalagyan na isinasagawa kasama ang stack na iyon.

Halimbawa 2: Full stack app na may frontend, backend at database

Para makita ang Docker Compose sa medyo mas makatotohanang arkitektura, isipin ang isang aplikasyon para sa listahan ng mga dapat gawin (Todo List) na may frontend sa Vue.js, isang API sa Node.js, at isang MongoDB database. Ang bawat bahagi ay nasa sarili nitong direktoryo at may sarili nitong Dockerfile.

Sa repositoryo, maaari kang makakita ng isang folder frontend gamit ang Vue app at isa pa backend gamit ang Node server. Inilalantad ng backend ang mga endpoint para sa lumikha, maglista, mag-update at magbura ng mga gawainat kumokonekta sa MongoDB upang iimbak ang mga ito. Ginagamit ng frontend ang mga endpoint na ito upang ipakita at pamahalaan ang listahan ng gawain sa browser.

Ang file docker-compose.yml Ito ay matatagpuan sa ugat ng proyekto at tumutukoy sa tatlong serbisyo: frontend, backend y databaseAng frontend service ay binuo mula sa Dockerfile sa kaukulang folder, karaniwang inilalantad ang internal port 80 at inima-map ito sa port 5173 ng host (halimbawa, para gamitin ang parehong URL gaya ng sa local development).

Ang backend ay binuo mula sa Dockerfile sa direktoryo backend, inilalantad ang port 3000 (sa loob at labas ng lalagyan, kung gusto mong pasimplehin) at nagpapahayag ng dependency sa database para matiyak na available ang MongoDB kapag nagsimula ito.

Ang serbisyo database gamitin nang direkta ang Opisyal na imahe ng MongoDB at bumuo ng isang volume, sabihin nating mongodb_dataSa /data/db, kung saan iniimbak ng Mongo ang datos nito. Ang volume na iyon ay idineklara sa itaas na seksyon. volumes mula sa compose, para manatili ang data kahit na burahin at muling likhain mo ang mga container.

Panghuli, ang lahat ng mga serbisyong ito ay kumokonekta sa pamamagitan ng isang pasadyang network, halimbawa my-network, tinukoy sa seksyon networksPinapayagan nito ang mga ito na malutas ayon sa pangalan ng serbisyo (ang backend ay maaaring kumonekta sa Mongo gamit ang hostname). database) at ang trapiko ay nakapaloob sa nakahiwalay na network na iyon.

Kapag handa na ang configuration, patakbuhin docker compose up Sa kaibuturan ng proyekto, ito ang may pananagutan sa buuin o i-download ang mga imahe at ilunsad ang tatlong lalagyanMaaari mong suriin kung ang lahat ay nasa lugar gamit ang docker compose ps, pagkatapos ay ina-access http://localhost:5173 para tingnan ang Vue app sa iyong browser at gawin ang iyong mga unang gawain.

Networking sa Docker Compose: pagkonekta ng mga serbisyo sa isa't isa

Ang mga network ay ang layer na nagpapahintulot sa iyong mga container "Nakikita" nila ang isa't isa at nag-uusap nang kontroladoBilang default, lumilikha na ang Docker ng mga network para sa Compose, ngunit ang tahasang pagtukoy sa mga ito ay nagbibigay sa iyo ng higit na kalinawan at kontrol sa kung ano ang maaaring makipag-ugnayan sa kung ano.

Gumagana ito nang simple: ang bawat serbisyo ay may kasamang field networks kung saan mo ipinapahiwatig kung saang mga network ito kabilang, at pagkatapos ay sa itaas na seksyon networks Ikaw ang magtatakda ng mga network na iyon gamit ang kanilang configuration. Ang pinakakaraniwan (at inirerekomenda sa maraming pagkakataon) na paraan ay ang paggamit ng driver. bridge.

Ang isang network ng tulay ay lumilikha ng isang pribadong espasyo network para sa iyong mga containerna may awtomatikong resolusyon ng DNS batay sa pangalan ng serbisyo. Nangangahulugan ito na, halimbawa, kung ang iyong serbisyo sa database ay tinawag databaseMaaaring kumonekta ang anumang ibang serbisyo sa parehong network gamit lamang ang database bilang pangalan ng host.

Sa isang proyektong may frontend, backend, at database, maaari kang magpasya, halimbawa, na lumikha ng frontend network at backend network. Ang frontend ay kokonekta sa backend, at ang backend naman ay kokonekta sa database, ngunit ang frontend at ang database... Hindi nila kinakailangang magbahagi ng networkpagbabawas ng panloob na nakalantad na lawak ng ibabaw.

Sa code, ito ay isinasalin sa isang bagay na kasing simple ng pagtatalaga ng kaukulang network sa bawat serbisyo, at pagkatapos ay pagtukoy sa mga network na iyon gamit ang mga driver bridge. Sa antas ng aplikasyon, ang pinakasimpleng paraan ay ang paggamit ng ang pangalan ng serbisyo bilang host kapag nagko-configure ng mga koneksyon: ng app a databaseHalimbawa, sa pamamagitan lamang ng pagpapahiwatig na ang database host ay "database".

Mga Volume sa Docker Compose: Pagtitiyaga ng Data

Ang mga volume ang inirerekomendang paraan upang nagpapatuloy na impormasyong nabuo ng mga lalagyanBilang mga databaseMga file ng user, backup, atbp. Ginagamit din ang mga ito upang magbahagi ng data sa pagitan ng mga serbisyo sa loob ng iisang stack.

Sa seksyon services Maaari mong direktang i-mount ang mga volume gamit ang volumesNgunit kapag gusto mong ma-access ang volume na iyon ng maraming container o gusto mong pamahalaan ito nang mas malinaw, tinutukoy mo rin ito sa itaas na seksyon. volumes mula sa compose.yaml.

Isipin mong gusto mong mag-set up ng backup system para sa iyong database. Magkakaroon ang database service ng isang volume kung saan nito iniimbak ang data nito at isa pang serbisyo na nakalaan para sa mga backup na iyon. I-mount ang parehong volume sa read mode para magsagawa ng mga pag-export o pag-synchronize nang hindi hinahawakan ang pangunahing lalagyan.

Pinapayagan ka ng Docker na pinuhin ang configuration ng mga volume na may higit pang mga parameter (uri ng driver, mga partikular na opsyon para sa driver mga panlabas na salik, atbp.), ngunit sa karamihan ng mga kaso, ang pinaka-praktikal na bagay ay hayaan itong mangyari. Awtomatikong pinamamahalaan ng Docker ang mga volume nang hindi nababaliw sa mga kakaibang configuration.

Ang mahalagang bagay ay maging malinaw kung aling mga folder sa iyong mga serbisyo ang kailangang maging persistent, at ideklara ang mga ito bilang mga volume sa Compose upang hindi mo mawala ang data kapag gumawa ka ng mga container o nag-update ng mga imahe.

Mga Configuration: pamamahala ng mga configuration file

Seksyon configs Ito ay dinisenyo upang pamahalaan ang mga configuration file ng mga serbisyo sa loob ng iyong stack, katulad ng mga volume ngunit partikular na nakatuon sa configuration.

Mag-isip ng isang Apache o Nginx server na tumatakbo sa Docker. Malamang kakailanganin mo ayusin ang iyong configuration file Ang muling pagbuo ng imahe sa bawat oras na baguhin mo ang mga file na ito ay hindi episyente at nakakainis, lalo na sa mga kapaligiran kung saan madalas na inaayos ang mga parameter.

may mga config Maaari mong tukuyin sa serbisyong gusto mo maglapat ng isang partikular na konpigurasyon at pagkatapos ay ilarawan ito sa seksyon configsMayroong ilang mga paraan upang matukoy ang mga ito, ang pinakakaraniwan ay:

• fileAng configuration ay nabuo mula sa isang lokal na file.
• external: kung ito ay minarkahan bilang trueIpinapalagay ng Compose na umiiral na ang configuration at tinutukoy lamang.
• name: Panloob na pangalan ng config sa Docker, kapaki-pakinabang kapag pinagsama sa external: true.

Sa ganitong paraan, maaari mong i-update ang configuration file sa iyong makina at bumalik sa itaas ang stack nang hindi kinakailangang muling buuin ang base image, pinapanatiling hiwalay ang image code mula sa configuration na partikular sa environment.

Mga Lihim: mga kredensyal at sensitibong datos

Seksyon secrets lumulutas ng isang klasikong problemaSaan ko itatago ang mga password, API key, at iba pang sensitibong impormasyon nang hindi iniiwan ang mga ito na nakakalat sa buong code o YAML?

Tulad ng sa mga config, ang mga sikreto ay maaaring tukuyin sa iba't ibang paraanAng karaniwang bagay ay:

• file: ang sikreto ay nabubuo mula sa mga nilalaman ng isang file (halimbawa, isang text file na may susi).
• environmentAng sikreto ay nalilikha gamit ang halaga ng isang environment variable sa iyong system.
• external: ay nagpapahiwatig na ang sikreto ay nalikha na at kailangan na lamang tukuyin, kapaki-pakinabang upang maiwasan ang pag-overwrite ng mga sikretong pinamamahalaan mula sa labas.
• name: panloob na pangalan ng sikreto, lalong mahalaga kapag pinagsasama external: true na may mga sikretong nilikha ng ibang kagamitan.

Gamit ang mga sikreto, makakagawa ka ng mga lalagyan na nangangailangan ng access sa mga kredensyal na ito. basahin ang mga ito sa kontroladong paraan nang hindi kinakailangang iwanang nakikita ang mga ito sa code repository o sa mismong compose.yaml, na lubos na nagpapatibay sa seguridad ng iyong mga deployment.

Paggawa gamit ang maraming file. Gumawa at kasama ang

Sa malalaking proyekto, hindi pangkaraniwan na ang iyong aplikasyon ay nahahati sa ilang serbisyo, na minsan ay pinamamahalaan ng iba't ibang pangkat. Sa mga kasong ito, praktikal na... paghiwalayin ang configuration sa maraming Compose files upang mas mahusay na i-modularize ang arkitektura.

Ang isang tipikal na pamamaraan ay ang pagkakaroon ng isang compose.yaml pangunahing file para sa application at iba pang mga file para sa mga bahagi ng imprastraktura. Halimbawa, maaari mong ilipat ang kahulugan ng Redis o iba pang mga serbisyo ng suporta sa file infra.yaml at panatilihin lamang sa pangunahing compose ang mga direktang may kinalaman sa iyong app.

Para gawin ito, gagawa ka ng file infra.yaml may sarili nitong seksyon services kung saan mo iniiwan, halimbawa, ang kumpletong serbisyo ng Redis. Pagkatapos, sa iyong compose.yaml pangunahing, magdadagdag ka ng seksyon include na tumuturo sa file infra.yaml.

Kapag tumakbo ka docker compose up Mula sa direktoryo ng proyekto, Gumawa Pagsamahin ang parehong mga file at ipinapakita nito ang lahat ng serbisyo na parang nasa iisang YAML lang sila, pero mas organisado at nakahiwalay pa rin ang lohika.

Pinapadali ng pamamaraang ito para sa iba't ibang pangkat na mapanatili ang sarili nilang mga Compose file at para sa pag-assemble ng pandaigdigang aplikasyon gamit ang mga kasama, na lubhang kapaki-pakinabang sa mga arkitektura na may dose-dosenang mga lalagyan o mga kapaligirang may maraming pinagsasaluhang imprastraktura.

Mahahalagang Docker Compose Command

Bagama't ang Compose ay may mahusay na katalogo ng mga utos, sa pang-araw-araw na gawain karamihan sa mga tao ay gumagamit ng ilan sa mga ito nang paulit-ulitMahalagang maging dalubhasa sa mga ito dahil ang mga ito ang tumutukoy sa iyong daloy ng trabaho.

Ang pinakamahalaga ay docker compose upAng utos na ito ay bubuo ng mga kinakailangang imahe (kung wala pa ang mga ito), lilikha ng mga container, magko-configure ng mga network at volume, at magsisimula ng lahat ng serbisyong tinukoy sa iyong Compose file. Ito ang utos na gagamitin mo kapag gusto mong simulan ang iyong stack.

Karaniwan itong isinasama sa opsyon -d para patakbuhin ito sa "hiwalay" na modeIbig sabihin, nasa background. Sa ganitong paraan, hindi mo mapupuno ang terminal ng mga log at maaari mo nang ipagpatuloy ang paggamit ng session na iyon para sa iba pang mga command. Halimbawa: docker compose up -d.

Para ihinto at linisin ang iyong binuhat, gamitin mo docker compose downna humihinto at nag-aalis ng mga container, network, at mga opsyonal na nauugnay na mga imahe at volume. Dalawang karaniwang flag dito ay --rmi (para magbura ng mga larawan) at -v (upang alisin ang mga volume na tinukoy sa seksyon volumes).

Kung gusto mong makita kung aling mga container ang bahagi ng proyekto at kung ano ang kanilang status, maaari mong patakbuhin ang docker compose psInililista nito ang bawat serbisyo, ang katayuan nito (naka-on, lumabas, atbp.), at ang mga nakalantad na port, na lubhang kapaki-pakinabang para sa pag-verify na gumagana nang tama ang lahat pagkatapos ng isang up.

Kapag inilunsad mo ang iyong stack sa detached mode, hindi lumalabas ang mga log sa terminal. Para makita ang mga ito, kailangan mong gamitin ang... docker compose logsmaging sa buong mundo o sa pamamagitan ng pagsala ayon sa serbisyo. Ang bandila -f Pinapayagan ka nitong subaybayan ang mga log nang real time, na lubhang kapaki-pakinabang para sa i-debug ang isang partikular na serbisyo nang hindi kinakailangang buksan ang loob ng lalagyan.

Karaniwang daloy ng trabaho: tukuyin compose.yaml, isagawa ang a docker compose up -d, suriin sa docker compose ps, suriin ang mga log gamit ang docker compose logs -f <servicio> Kung may magkamali, at kapag tapos ka na, gamitin ang docker compose down para iwanang malinis ang lahat.

Kung sakaling maligaw ka, docker compose --help Ipinapakita nito sa iyo ang listahan ng mga magagamit na subcommand at opsyon upang matulungan kang matandaan kung ano ang ginagawa ng bawat bagay nang hindi kinakailangang pumunta sa dokumentasyon.

Dahil sa lahat ng nabanggit, pangunahing kasangkapan Para sa sinumang nagtatrabaho gamit ang mga container na higit pa sa mga indibidwal na proyekto, ang Compose ay isang mahusay na tool. Pinapayagan ka nitong bumuo nang direkta sa isang kapaligirang halos kapareho (o kapareho ng) produksyon, mga serbisyo sa pagkontrol, mga network, at data mula sa isang simpleng YAML file, at maiwasan ang maraming isyu sa compatibility at deployment na hindi maiiwasang lumilitaw kapag nagtatrabaho lamang "nang lokal" nang walang mga container. Kapag nasanay ka na sa pagsulat ng isang mahusay na Compose YAML file para sa iyong mga proyekto, mahirap nang bumalik.