Mik azok a Terraform modulok és hogyan működnek?

Meglepő módon sok kezdő kihagyja a Terraform modulokat az egyszerűség kedvéért, vagy legalábbis úgy gondolják.

Később több száz sor konfigurációs kódon mennek keresztül.

Feltételezem, hogy már ismeri a Terraform néhány alapját, és már korábban is megpróbálta használni. Ha nem, akkor olvassa el a Terraform ezen áttekintését és ezt a videó oktatóanyagot, mielőtt folytatja az olvasást.

Megjegyzés: Csak az egyszerűség kedvéért nem használok valós kódokat bizonyos szolgáltatókkal, például az AWS vagy a Google.

Terraform modulok

Már modulokat írsz

Még akkor is, ha nem szándékosan hoz létre modult, ha a Terraformot használja, akkor már ír egy modult - egy úgynevezett " root " modult.

Bármely Terraform konfigurációs fájl ( .tf) egy könyvtárban, akár csak egy, egy modult alkot.

Mit csinál egy modul?

A Terraform modul lehetővé teszi logikai absztrakció létrehozását valamilyen erőforráskészlet tetején. Más szavakkal, egy modul lehetővé teszi az erőforrások csoportosítását és későbbi, esetleg sokszoros újrafelhasználását.

Tegyük fel, hogy van egy virtuális szerverünk, amely néhány funkcióval rendelkezik a felhőben. Milyen erőforrások jellemezhetik azt a szervert? Például:

  • maga a virtuális gép, amely valamilyen képből készült
  • csatolt, meghatározott méretű blokkeszköz további tárolás céljából
  • a szerver virtuális hálózati interfészéhez hozzárendelt statikus nyilvános IP
  • a kiszolgálóhoz csatolandó tűzfalszabálykészlet
  • egyéb dolgok, például egy másik blokkoló eszköz, további hálózati interfész stb

Tegyük fel, hogy ezt a kiszolgálót sokszor erőforráskészlettel kell létrehoznia. Itt a modulok valóban hasznosak - ugye nem akarja ugyanazt a konfigurációs kódot újra és újra megismételni?

Itt van egy példa, amely bemutatja, hogyan hívható meg a "szerver" modulunk.

A " modul meghívása " azt jelenti, hogy azt a konfigurációs fájlban kell használni.

Itt a "szerver" 5 példányát hozzuk létre egyetlen konfigurációs készlet segítségével (a modulban):

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

Modulszervezés: gyermek és root

Természetesen valószínűleg egynél több modult szeretne létrehozni. Íme néhány gyakori példa:

  • egy hálózat, mint egy virtuális magánfelhő (VPC)
  • statikus tartalomtárolás (azaz vödrök)
  • terheléselosztó és a kapcsolódó erőforrások
  • naplózási konfiguráció
  • vagy bármi mást, amit az infrastruktúra külön logikai összetevőjének tekint

Tegyük fel, hogy két különböző modulunk van: egy "szerver" és egy "hálózat" modul. A "hálózat" nevű modulban határozhatjuk meg és konfigurálhatjuk virtuális hálózatunkat, és kiszolgálókat helyezhetünk el benne:

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

Miután megvan néhány egyedi modul, "gyermek" moduloknak nevezhetjük őket. És a konfigurációs fájl, amelyben gyermekmodulokat hívunk, a root modulhoz kapcsolódik.

A gyermekmodul számos helyről beszerezhető:

  • helyi utak
  • a hivatalos Terraform Registry - ha ismeri más regisztereket, például a Docker Registry-t, akkor már megérti az ötletet
  • egy Git-tár (egyedi vagy GitHub / BitBucket)
  • egy HTTP-URL a .zip archívumhoz a modullal együtt

De hogyan adhatja át az erőforrások részleteit a modulok között?

Példánkban a szervereket hálózatban kell létrehozni. Tehát hogyan mondhatjuk el, hogy a "szerver" modul hozzon létre virtuális gépeket egy hálózatban, amelyet a "hálózat" nevű modulban hoztak létre?

Itt jön be a kapszulázás .

Modul beágyazása

A Terraformba történő beágyazás két alapvető fogalomból áll: a modul hatóköréből és az erőforrások kifejezett kitettségéből.

Modul hatóköre

Az összes erőforráspéldány, név és így az erőforrás láthatósága elkülönül a modul hatóköréből. Például az "A" modul alapértelmezés szerint nem lát és nem ismeri a "B" modul erőforrásait.

Az erőforrások láthatósága, amelyet néha erőforrás-elkülönítésnek hívnak, biztosítja, hogy az erőforrások egyedi nevekkel rendelkezzenek a modul névterében. Például a "szerver" modul 5 példányával:

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

Másrészt ugyanabból a modulból két példányt hozhatunk létre, különböző nevekkel:

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

Ebben az esetben az erőforrások megnevezése vagy címe a következő lenne:

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

Kifejezett erőforrás-kitettség

Ha egy másik modul erőforrásainak egyes részleteihez szeretne hozzáférni, ezt kifejezetten be kell állítania.

Alapértelmezés szerint a "szerver" modulunk nem ismeri a "hálózat" modulban létrehozott hálózatot.

Tehát deklarálnunk kell egy outputértéket a "network" modulban, hogy az erőforrását vagy egy erőforrás attribútumát más modulokba exportálhassuk.

A "kiszolgáló" modulnak be kell jelentenie, variablehogy a később felhasználható bemenetként:

This explicit declaration of the output is the way to expose some resource (or information about it) outside — to the scope of the 'root' module, hence to make it available for other modules.

Next, when we call the child module "server" in the root module, we should assign the output from the "network" module to the variable of the "server" module:

network_id = module.network.network_id

Here's what the final code for calling our child modules will look like:

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 }

This example configuration would create 5 instances of the same server, with all the necessary resources, in the network we created with as a separate module.

Wrapping up

Now you should understand what modules are and what do they do.

If you're at the beginning of your Terraform journey, here are some suggestions for the next steps.

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.