Apakah Modul Terraform dan Bagaimana Cara Kerja?

Pengaturcaraan

Anehnya, banyak pemula melangkau modul Terraform demi kesederhanaan, atau seperti yang mereka fikirkan.

Kemudian, mereka mendapati melalui ratusan baris kod konfigurasi.

Saya menganggap anda sudah mengetahui beberapa asas mengenai Terraform, dan pernah mencuba menggunakannya sebelum ini. Sekiranya tidak, lihat gambaran keseluruhan Terraform dan tutorial video ini sebelum anda terus membaca.

Harap maklum: Saya tidak menggunakan contoh kod sebenar dengan penyedia tertentu seperti AWS atau Google dengan sengaja, hanya demi kesederhanaan.

Modul terraform

Anda sudah menulis modul

Walaupun anda tidak membuat modul dengan sengaja, jika anda menggunakan Terraform, anda sudah menulis modul - modul " root " yang disebut .

Sebarang fail konfigurasi Terraform ( .tf) dalam direktori, walaupun hanya satu, membentuk modul.

Apa yang dilakukan oleh modul?

Modul Terraform membolehkan anda membuat abstraksi logik di bahagian atas beberapa set sumber. Dengan kata lain, modul membolehkan anda mengumpulkan sumber dan menggunakan semula kumpulan ini kemudian, mungkin berkali-kali.

Anggaplah kita mempunyai pelayan maya dengan beberapa ciri yang dihoskan di awan. Apa sumber yang mungkin menggambarkan pelayan itu? Sebagai contoh:

  • mesin maya itu sendiri, dibuat dari beberapa gambar
  • peranti blok terpasang dengan ukuran yang ditentukan untuk penyimpanan tambahan
  • IP awam statik yang dipetakan ke antara muka rangkaian maya pelayan
  • satu set peraturan firewall yang akan dilampirkan ke pelayan
  • perkara lain seperti peranti blok lain, antara muka rangkaian tambahan dan sebagainya

Sekarang mari kita anggap bahawa anda perlu membuat pelayan ini dengan sekumpulan sumber berkali-kali. Di sinilah modul sangat membantu - anda tidak mahu mengulangi kod konfigurasi yang sama berulang kali, bukan?

Berikut adalah contoh yang menggambarkan bagaimana modul "pelayan" kami dipanggil.

" Untuk memanggil modul " bermaksud menggunakannya dalam fail konfigurasi.

Di sini kita membuat 5 contoh "pelayan" menggunakan satu set konfigurasi (dalam modul):

module "server" { count = 5 source = "./module_server" some_variable = some_value }

Organisasi modul: anak dan akar

Sudah tentu, anda mungkin mahu membuat lebih daripada satu modul. Berikut adalah beberapa contoh biasa:

  • rangkaian seperti awan peribadi maya (VPC)
  • hosting kandungan statik (iaitu baldi)
  • pengimbang beban dan sumber yang berkaitan
  • konfigurasi pembalakan
  • atau apa sahaja yang anda anggap komponen logik yang berbeza dari infrastruktur

Katakan kita mempunyai dua modul yang berbeza: modul "pelayan" dan modul "rangkaian". Modul yang disebut "rangkaian" adalah tempat kami menentukan dan mengkonfigurasi rangkaian maya kami dan menempatkan pelayan di dalamnya:

module "server" { source = "./module_server" some_variable = some_value } module "network" { source = "./module_network" some_other_variable = some_other_value }

Setelah kami mempunyai beberapa modul khusus, kami dapat menyebutnya sebagai modul "anak". Dan fail konfigurasi di mana kita memanggil modul anak berkaitan dengan modul root.

Modul kanak-kanak boleh diperoleh dari beberapa tempat:

  • jalan tempatan
  • Pendaftaran Terraform rasmi - jika anda sudah biasa dengan pendaftaran lain seperti Docker Registry maka anda sudah memahami idea
  • repositori Git (yang disesuaikan atau GitHub / BitBucket)
  • URL HTTP ke arkib .zip dengan modul

Tetapi bagaimana anda dapat menyampaikan perincian sumber antara modul?

Dalam contoh kami, pelayan harus dibuat dalam rangkaian. Jadi bagaimana kita dapat memberitahu modul "pelayan" untuk membuat VM dalam rangkaian yang dibuat dalam modul yang disebut "rangkaian"?

Di sinilah enkapsulasi masuk.

Enkapsulasi modul

Encapsulation in Terraform terdiri daripada dua konsep asas: skop modul dan pendedahan sumber eksplisit.

Skop Modul

Semua contoh sumber, nama, dan oleh itu, keterlihatan sumber, diasingkan dalam skop modul. Sebagai contoh, modul "A" tidak dapat melihat dan tidak mengetahui tentang sumber dalam modul "B" secara lalai.

Keterlihatan sumber, kadang-kadang disebut pengasingan sumber, memastikan bahawa sumber akan mempunyai nama yang unik dalam ruang nama modul. Contohnya, dengan 5 contoh modul "pelayan" kami:

module.server[0].resource_type.resource_name module.server[1].resource_type.resource_name module.server[2].resource_type.resource_name ...

Sebaliknya, kita dapat membuat dua contoh modul yang sama dengan nama yang berbeza:

module "server-alpha" { source = "./module_server" some_variable = some_value } module "server-beta" { source = "./module_server" some_variable = some_value }

Dalam kes ini, penamaan atau alamat sumber adalah seperti berikut:

module.server-alpha.resource_type.resource_name module.server-beta.resource_type.resource_name

Pendedahan sumber yang jelas

Sekiranya anda ingin mengakses beberapa perincian sumber dalam modul lain, anda perlu mengkonfigurasinya secara jelas.

Secara lalai, modul "pelayan" kami tidak mengetahui tentang rangkaian yang dibuat dalam modul "rangkaian".

Oleh itu, kita mesti menyatakan outputnilai dalam modul "rangkaian" untuk mengeksport sumbernya, atau atribut sumber, ke modul lain.

Modul "pelayan" mesti menyatakan variableuntuk digunakan kemudian sebagai input:

Pernyataan eksplisit output ini adalah cara untuk mengekspos beberapa sumber (atau maklumat mengenainya) di luar - ke ruang lingkup modul 'root', oleh itu untuk membuatnya tersedia untuk modul lain.

Seterusnya, apabila kita memanggil modul anak "pelayan" dalam modul root, kita harus menetapkan output dari modul "rangkaian" ke pemboleh ubah modul "pelayan":

network_id = module.network.network_id

Inilah kod akhir untuk memanggil modul anak kita:

module "server" { count = 5 source = "./module_server" some_variable = some_value network_id = module.network.network_id } module "network" { source = "./module_network" some_other_variable = some_other_value }

Contoh konfigurasi ini akan membuat 5 contoh pelayan yang sama, dengan semua sumber yang diperlukan, dalam rangkaian yang kita buat sebagai modul yang terpisah.

Mengakhiri

Sekarang anda harus memahami apa modul dan apa yang mereka buat.

Sekiranya anda berada di awal perjalanan Terraform anda, berikut adalah beberapa cadangan untuk langkah seterusnya.

I encourage you to take this short tutorial from HashiCorp, the creators of Terraform, about modules: "Organize Configuration".

Also, there is a great comprehensive study guide which covers everything from beginner to advanced concepts about Terraform: "Study Guide - Terraform Associate Certification".

The modular code structure makes your configuration more flexible and yet easy to be understood by others. The latter is especially useful for a team.

If you liked the article, follow me on Twitter (@vasylenko) where I occasionally share my findings and tips about Terraform, AWS, Ansible, and other DevOps-related technologies.