Sa mundo ng pagbibigay ng imprastraktura at pamamahala, ang Terraform ay lumitaw bilang isang popular na pagpipilian sa mga developer at operations team. Sa declarative syntax nito (HCL – HashiCorp Configuration Language) at suporta para sa iba't ibang provider ng imprastraktura, pinapagana ng Terraform ang mga kasanayan sa infrastructure-as-code (IaC).
Isa sa mga pangunahing tampok nito ay ang paggamit ng mga module na nagbibigay-daan sa paggawa at muling paggamit ng modular infrastructure code. Sa artikulong ito, tutuklasin natin ang konsepto ng mga module ng Terraform at kung paano sila makakatulong upang ayusin at pasimplehin ang aming code sa imprastraktura.
Panimula sa Terraform Module
Ang mga module ng Terraform ay mga self-contained na pakete ng mga configuration ng Terraform na kumakatawan sa isang hanay ng mga mapagkukunan na may tinukoy na mga variable ng input at output. Nagbibigay sila ng paraan para i-encapsulate at muling gamitin ang infrastructure code na nagpapadali sa pamamahala at pagpapanatili ng mga kumplikadong deployment ng imprastraktura.
Ang mga module ay maaaring gawin at gamitin sa loob ng isang proyekto o ibahagi sa maraming proyekto o koponan.
Organisasyon ng Modyul
Kapag inaayos ang mga module ng Terraform, karaniwan ang pagkakaroon ng hierarchical na istraktura na binubuo ng root at child modules. Tuklasin natin kung paano gumagana ang organisasyong ito.
Root Module
Kinakatawan ng root module ang top-level na module sa aming configuration ng Terraform. Ito ang entry point para sa pagtukoy sa pangkalahatang imprastraktura at pamamahala ng mga ugnayan sa pagitan ng iba't ibang mapagkukunan.
Ang root module ay karaniwang naglalaman ng 'main.tf' na file kung saan namin tinutukoy ang mga mapagkukunan at mga configuration na bumubuo sa pundasyon ng aming imprastraktura. Opsyonal, maaari tayong magkaroon ng 'variables.tf' at 'outputs.tf' na mga file kasama nito. Gayundin, maaari naming tukuyin ang aming 'modules' na direktoryo sa loob ng root directory upang madaling ma-access ang mga child module.
Mga Module ng Bata
Ang mga child module ay mga modular na bahagi na sumasaklaw sa mga partikular na hanay ng mga mapagkukunan o configuration. Idinisenyo ang mga ito upang magamit muli at kumakatawan sa mga self-contained na unit ng functionality ng imprastraktura.
Maaaring gamitin ang mga child module sa loob ng root o iba pang child module na nagbibigay-daan para sa komposisyon at kumplikadong gusali ng imprastraktura. Ang bawat child module ay karaniwang may sariling direktoryo na naglalaman ng mga kinakailangang configuration file gaya ng “main.tf”, “variables.tf”, at “outputs.tf”.
Ngayon, tingnan natin kung paano tayo makakagawa ng module ng Terraform.
Paggawa ng Terraform Module
Kapag gumagawa ng mga module ng Terraform, dapat tayong gumawa ng bagong direktoryo para sa module na may kinakailangang mga file ng configuration ng Terraform. Karaniwan, ang direktoryo na iyon ay pinangalanang 'mga module'. Ang pagtukoy nito sa loob ng root directory ng aming proyekto ay isang pinakamahusay na kasanayan.
Kumuha tayo ng madaling halimbawa ng isang simpleng module para makapagbigay ng lokal na web server gamit ang Docker. Una, tinukoy namin ang module sa direktoryo ng 'mga module' bilang 'main.tf'.
mapagkukunan 'docker_container' 'webserver' {pangalan = var.name
larawan = var.image
mga daungan {
panloob = var.internal_port
panlabas = var.external_port
}
}
Dito, lumikha kami ng isang module na tinatawag na 'docker_container' na kumukuha ng pangalan ng container, imahe ng Docker, panloob na port, at panlabas na port bilang mga variable ng input. Isinasama ng module ang lohika upang lumikha ng mapagkukunan ng container ng Docker at pinapayagan ang tumatawag na i-customize ang mga katangian ng container.
Gaya ng ipinakita sa sumusunod na larawan, gumawa kami ng hiwalay na file na tinatawag na 'variables.tf' sa direktoryo ng 'modules' upang tukuyin ang mga variable ng input na maaaring i-customize kapag ginagamit ang module:
variable 'pangalan' {paglalarawan = 'Pangalan ng container ng docker'
uri = string
}
variable 'larawan' {
paglalarawan = 'Larawan ng docker'
uri = string
}
variable 'internal_port' {
paglalarawan = 'Internal na port sa lalagyan ng Docker'
uri = numero
}
variable 'external_port' {
paglalarawan = 'Panlabas na port kung saan imamapa'
uri = numero
}
Dito, nagdeklara kami ng apat na variable, bawat isa ay may 'paglalarawan' at 'uri' bilang mga katangian at nauugnay na mga halaga sa kanila.
Paggamit ng Terraform Module
Dahil ginawa namin ang aming module, magagamit na namin ito sa aming pangunahing configuration ng Terraform sa pamamagitan ng pagtukoy sa pinagmulan nito. Gawin natin ang aming pangunahing configuration file na 'main.tf' sa root directory.
modyul 'webserver_container' {pinagmulan = '../modules/docker_container'
pangalan = 'mywebserver'
larawan = 'nginx:pinakabago'
internal_port = 80
external_port = 8080
}
Ginagamit namin ang bloke ng 'module' sa nakaraang code upang i-instantiate ang module ng container ng Docker. Ibinibigay namin ang mga kinakailangang value ng input para sa module gaya ng pangalan ng container, larawan ng Docker, at configuration ng port. Tinutukoy ng parameter na 'pinagmulan' ang nauugnay na landas sa direktoryo ng 'module'.
Susunod, tingnan natin kung paano gamitin ang mga output ng Terraform para magamit sa mga module.
Mga Output ng Module
Ang mga output ng module sa Terraform ay nagbibigay ng paraan upang ilantad ang mga partikular na halaga mula sa loob ng isang module, na ginagawang available ang mga ito para magamit sa pangunahing configuration o ng iba pang mga module. Ang mga ito ay nagsisilbing channel ng komunikasyon sa pagitan ng module at ng tumatawag na nagpapahintulot sa module na magbigay ng impormasyon o data na maaaring maging kapaki-pakinabang o kinakailangan para sa karagdagang pagsasaayos o paggawa ng desisyon.
output 'container_id' {paglalarawan = 'ID ng ginawang Docker container'
halaga = docker_container.webserver.id
}
Dito, gumawa kami ng 'outputs.tf' na file sa loob ng direktoryo ng 'modules'. Inilalantad ng output variable na ito ang ID ng container ng Docker na ginawa ng resource na 'docker_container' na pinangalanang 'webserver' sa loob ng module.
Ngayon, maa-access na namin ang container ID sa aming root configuration file. Sumangguni sa sumusunod na na-update na code ng 'main.tf' na file sa root directory:
modyul 'webserver_container' {pinagmulan = '../modules/docker_container'
pangalan = 'mywebserver'
larawan = 'nginx:pinakabago'
internal_port = 80
external_port = 8080
}
mapagkukunan 'docker_volume' 'data' {
# Ang natitirang mga argumento ay napupunta dito
magbigkis = module.webserver_container.container_id
}
Sa pamamagitan ng paggamit sa “module.webserver_container.container_id” bilang value para sa argument na “bind,” itinuturo namin sa Terraform na itali ang volume ng Docker sa lokasyon na tinukoy ng container ID ng module na “web_container”. Nagtatatag ito ng ugnayan sa pagitan ng mapagkukunan ng dami ng Docker at ng container na ginawa ng module na 'webserver_container', na tinitiyak na ang volume ay naka-mount sa naaangkop na lokasyon.
Pinakamahuhusay na Kasanayan para sa Terraform Module
Modularize para sa Reusability
Dapat nating isaalang-alang ang muling paggamit kapag nagdidisenyo ng mga module. Gayundin, dapat nating tukuyin ang mga lohikal na bahagi o pattern ng ating imprastraktura at i-encapsulate ang mga ito sa magkakahiwalay na mga module. Itinataguyod nito ang muling paggamit ng code, standardisasyon, at mas madaling pakikipagtulungan sa mga team.
Malinaw at Pare-parehong Pangalan
Ang paggamit ng malinaw at pare-parehong mga kombensiyon sa pagbibigay ng pangalan para sa mga module, variable, at mapagkukunan ay nagpapabuti sa pagiging madaling mabasa at pag-unawa sa codebase na ginagawang mas madali para sa iba na magtrabaho at mapanatili ang mga module.
Ihiwalay ang Dependencies
Dapat nating iwasan ang mahigpit na pagkakabit sa pagitan ng mga module. Ang bawat module ay dapat maglaman ng sarili nitong mga mapagkukunan at dependency. Tinitiyak nito na ang mga module ay maaaring magamit muli nang nakapag-iisa at nagpo-promote ng mas mahusay na paghihiwalay at encapsulation.
Version Control at Module Registry
Maaari naming i-publish ang aming mga module sa isang bersyon na kinokontrol na repository o module registry. Nagbibigay ito ng sentralisadong lokasyon para sa pagbabahagi at pagtuklas ng mga module, na tinitiyak ang madaling pag-access at pag-bersyon.
Konklusyon
Kumuha kami ng maikling pagpapakilala sa mga module ng Terraform at natutunan kung paano likhain ang mga ito gamit ang isang simpleng halimbawa. Pagkatapos, tiningnan namin kung paano gamitin ang mga variable at output sa aming module para mapahusay ang flexibility, reusability, at maintainability nito. Sa konklusyon, ang mga module ng Terraform ay makapangyarihang mga tool upang ayusin at pasimplehin ang code ng imprastraktura. Nagbibigay-daan ang mga ito sa amin na i-encapsulate ang isang hanay ng mga mapagkukunan o configuration sa mga bahaging magagamit muli na nagpo-promote ng modularity, reusability, at collaboration sa loob ng aming mga proyektong imprastraktura-bilang-code.