Dalam dunia penyediaan dan pengurusan infrastruktur, Terraform telah muncul sebagai pilihan popular dalam kalangan pemaju dan pasukan operasi. Dengan sintaks pengisytiharannya (HCL – Bahasa Konfigurasi HashiCorp) dan sokongan untuk pelbagai penyedia infrastruktur, Terraform mendayakan amalan infrastruktur-sebagai-kod (IaC).
Salah satu ciri utamanya ialah penggunaan modul yang membolehkan untuk mencipta dan menggunakan semula kod infrastruktur modular. Dalam artikel ini, kami akan meneroka tentang konsep modul Terraform dan cara ia boleh membantu mengatur dan memudahkan kod infrastruktur kami.
Pengenalan kepada Modul Terraform
Modul Terraform ialah pakej serba lengkap bagi konfigurasi Terraform yang mewakili satu set sumber dengan pembolehubah input dan output yang ditentukan. Mereka menyediakan cara untuk merangkum dan menggunakan semula kod infrastruktur yang memudahkan pengurusan dan penyelenggaraan penempatan infrastruktur yang kompleks.
Modul boleh dibuat dan digunakan secara dalaman dalam projek atau dikongsi merentas berbilang projek atau pasukan.
Organisasi Modul
Apabila mengatur modul Terraform, adalah perkara biasa untuk mempunyai struktur hierarki yang terdiri daripada modul akar dan anak. Mari kita terokai cara organisasi ini berfungsi.
Modul Akar
Modul akar mewakili modul peringkat atas dalam konfigurasi Terraform kami. Ia adalah titik masuk untuk mentakrifkan keseluruhan infrastruktur dan mengurus perhubungan antara sumber yang berbeza.
Modul akar biasanya mengandungi fail 'main.tf' di mana kami mentakrifkan sumber dan konfigurasi yang membentuk asas infrastruktur kami. Secara pilihan, kita boleh mempunyai fail 'variables.tf' dan 'outputs.tf' bersamanya. Selain itu, kami boleh menentukan direktori 'modul' kami dalam direktori akar untuk mengakses modul kanak-kanak dengan mudah.
Modul Kanak-kanak
Modul kanak-kanak ialah komponen modular yang merangkumi set sumber atau konfigurasi tertentu. Ia direka bentuk untuk boleh diguna semula dan mewakili unit kefungsian infrastruktur serba lengkap.
Modul kanak-kanak boleh digunakan dalam akar atau modul kanak-kanak lain yang membenarkan komposisi dan pembinaan infrastruktur yang kompleks. Setiap modul kanak-kanak biasanya mempunyai direktorinya yang mengandungi fail konfigurasi yang diperlukan seperti 'main.tf', 'variables.tf', dan 'outputs.tf'.
Sekarang, mari lihat bagaimana kita boleh mencipta modul Terraform.
Mencipta Modul Terraform
Apabila mencipta modul Terraform, kita mesti membuat direktori baharu untuk modul dengan fail konfigurasi Terraform yang diperlukan. Biasanya, direktori itu dinamakan 'modul'. Mentakrifkannya dalam direktori akar projek kami ialah amalan terbaik.
Mari kita ambil contoh mudah modul mudah untuk menyediakan pelayan web tempatan menggunakan Docker. Pertama, kami mentakrifkan modul dalam direktori 'modul' sebagai 'main.tf'.
sumber 'docker_container' 'pelayan web' {nama = var.name
imej = var.imej
pelabuhan {
dalaman = var.internal_port
luaran = var.external_port
}
}
Di sini, kami mencipta modul yang dipanggil 'docker_container' yang mengambil nama kontena, imej Docker, port dalaman dan port luaran sebagai pembolehubah input. Modul ini merangkum logik untuk mencipta sumber bekas Docker dan membenarkan pemanggil untuk menyesuaikan sifat kontena.
Seperti yang ditunjukkan dalam imej berikut, kami mencipta fail berasingan yang dipanggil 'variables.tf' dalam direktori 'modules' untuk menentukan pembolehubah input yang boleh disesuaikan apabila menggunakan modul:
pembolehubah 'nama' {penerangan = 'Nama bekas Docker'
menaip = rentetan
}
pembolehubah 'gambar' {
penerangan = 'Imej Docker'
menaip = rentetan
}
pembolehubah 'port_dalam' {
penerangan = 'Port dalaman pada bekas Docker'
menaip = nombor
}
pembolehubah 'port_luar' {
penerangan = 'Port luaran untuk dipetakan'
menaip = nombor
}
Di sini, kami mengisytiharkan empat pembolehubah, setiap satu dengan 'penerangan' dan 'jenis' sebagai atribut dan nilai yang berkaitan dengannya.
Menggunakan Modul Terraform
Sejak kami mencipta modul kami, kami kini boleh menggunakannya dalam konfigurasi Terraform utama kami dengan merujuk sumbernya. Mari buat fail konfigurasi utama kami iaitu 'main.tf' dalam direktori root.
modul 'webserver_container' {sumber = '../modules/docker_container'
nama = 'pelayan web saya'
imej = 'nginx:terbaru'
port_dalam = 80
external_port = 8080
}
Kami menggunakan blok 'modul' dalam kod sebelumnya untuk membuat seketika modul kontena Docker. Kami menyediakan nilai input yang diperlukan untuk modul seperti nama bekas, imej Docker dan konfigurasi port. Parameter 'sumber' menentukan laluan relatif kepada direktori 'modul'.
Seterusnya, mari lihat cara menggunakan output Terraform untuk digunakan dengan modul.
Output Modul
Output modul dalam Terraform menyediakan cara untuk mendedahkan nilai tertentu dari dalam modul, menjadikannya tersedia untuk digunakan dalam konfigurasi utama atau oleh modul lain. Ia berfungsi sebagai saluran komunikasi antara modul dan pemanggil yang membolehkan modul menyediakan maklumat atau data yang mungkin berguna atau perlu untuk konfigurasi atau membuat keputusan selanjutnya.
pengeluaran 'id_kontena' {penerangan = 'ID bekas Docker yang dibuat'
nilai = docker_container.webserver.id
}
Di sini, kami mencipta fail 'outputs.tf' di dalam direktori 'modules'. Pembolehubah output ini mendedahkan ID bekas Docker yang dicipta oleh sumber 'docker_container' bernama 'pelayan web' dalam modul.
Kini, kami boleh mengakses ID bekas dalam fail konfigurasi akar kami. Rujuk kepada kod fail 'main.tf' yang dikemas kini berikut dalam direktori akar:
modul 'webserver_container' {sumber = '../modules/docker_container'
nama = 'pelayan web saya'
imej = 'nginx:terbaru'
port_dalam = 80
external_port = 8080
}
sumber 'docker_volume' 'data' {
# Selebihnya hujah pergi di sini
mengikat = module.webserver_container.container_id
}
Dengan menggunakan 'module.webserver_container.container_id' sebagai nilai untuk hujah 'bind', kami mengarahkan Terraform untuk mengikat volum Docker ke lokasi yang ditentukan oleh ID bekas modul 'web_container'. Ini mewujudkan hubungan antara sumber volum Docker dan bekas yang dicipta oleh modul 'webserver_container', memastikan volum dipasang di lokasi yang sesuai.
Amalan Terbaik untuk Modul Terraform
Memodulasi untuk Kebolehgunaan Semula
Kita harus mempertimbangkan kebolehgunaan semula semasa mereka bentuk modul. Selain itu, kita mesti mengenal pasti komponen atau corak logik infrastruktur kita dan merangkumnya ke dalam modul yang berasingan. Ini menggalakkan penggunaan semula kod, penyeragaman dan kerjasama yang lebih mudah merentas pasukan.
Penamaan yang Jelas dan Konsisten
Menggunakan konvensyen penamaan yang jelas dan konsisten untuk modul, pembolehubah dan sumber meningkatkan kebolehbacaan dan pemahaman asas kod yang memudahkan orang lain bekerja dengan dan mengekalkan modul.
Asingkan Kebergantungan
Kita mesti mengelakkan gandingan yang ketat antara modul. Setiap modul harus merangkumi sumber dan kebergantungan sendiri. Ini memastikan bahawa modul boleh digunakan semula secara bebas dan menggalakkan pengasingan dan enkapsulasi yang lebih baik.
Kawalan Versi dan Pendaftaran Modul
Kami boleh menerbitkan modul kami ke repositori terkawal versi atau daftar modul. Ini menyediakan lokasi terpusat untuk berkongsi dan menemui modul, memastikan akses dan versi yang mudah.
Kesimpulan
Kami mengambil pengenalan ringkas kepada modul Terraform dan mempelajari cara menciptanya dengan contoh mudah. Kemudian, kami melihat cara menggunakan pembolehubah dan output dengan modul kami untuk meningkatkan fleksibiliti, kebolehgunaan semula dan kebolehselenggaraannya. Kesimpulannya, modul Terraform ialah alat yang berkuasa untuk mengatur dan memudahkan kod infrastruktur. Ia membenarkan kami merangkum satu set sumber atau konfigurasi ke dalam komponen boleh guna semula yang menggalakkan modulariti, kebolehgunaan semula dan kerjasama dalam projek infrastruktur-sebagai-kod kami.