I verden for infrastrukturtilførsel og -administrasjon har Terraform dukket opp som et populært valg blant utviklere og driftsteam. Med sin deklarative syntaks (HCL – HashiCorp Configuration Language) og støtte for ulike infrastrukturleverandører, muliggjør Terraform infrastruktur-som-kode (IaC)-praksis.
En av nøkkelfunksjonene er bruken av moduler som gjør det mulig å lage og gjenbruke den modulære infrastrukturkoden. I denne artikkelen vil vi utforske konseptet med Terraform-moduler og hvordan de kan bidra til å organisere og forenkle infrastrukturkoden vår.
Introduksjon til Terraform-moduler
Terraform-moduler er selvstendige pakker med Terraform-konfigurasjoner som representerer et sett med ressurser med definerte inngangs- og utdatavariabler. De gir en måte å innkapsle og gjenbruke infrastrukturkoden som gjør administrasjon og vedlikehold av komplekse infrastrukturimplementeringer enklere.
Moduler kan opprettes og brukes internt i et prosjekt eller deles på tvers av flere prosjekter eller team.
Organisering av modulen
Ved organisering av Terraform-modulene er det vanlig å ha en hierarkisk struktur som består av rot- og underordnede moduler. La oss utforske hvordan denne organisasjonen fungerer.
Rotmodul
Rotmodulen representerer toppnivåmodulen i vår Terraform-konfigurasjon. Det er inngangspunktet for å definere den overordnede infrastrukturen og administrere relasjonene mellom ulike ressurser.
Rotmodulen inneholder vanligvis 'main.tf'-filen der vi definerer ressursene og konfigurasjonene som danner grunnlaget for infrastrukturen vår. Eventuelt kan vi ha filene 'variables.tf' og 'outputs.tf' med den. Vi kan også definere 'moduler'-katalogen vår i rotkatalogen for å enkelt få tilgang til barnemodulene.
Barnemoduler
Underordnede moduler er modulære komponenter som innkapsler spesifikke sett med ressurser eller konfigurasjoner. De er designet for å være gjenbrukbare og representerer de selvstendige enhetene for infrastrukturfunksjonalitet.
Underordnede moduler kan brukes i rot- eller andre underordnede moduler som tillater komposisjon og kompleks infrastrukturbygging. Hver barnemodul har vanligvis sin katalog som inneholder de nødvendige konfigurasjonsfilene som 'main.tf', 'variables.tf' og 'outputs.tf'.
La oss nå se hvordan vi kan lage en Terraform-modul.
Opprette en Terraform-modul
Når vi oppretter Terraform-moduler, må vi lage en ny katalog for modulen med de nødvendige Terraform-konfigurasjonsfilene. Vanligvis heter den katalogen 'moduler'. Å definere det i prosjektets rotkatalog er en beste praksis.
La oss ta et enkelt eksempel på en enkel modul for å klargjøre en lokal webserver ved å bruke Docker. Først definerer vi modulen i 'modules'-katalogen som 'main.tf'.
ressurs 'docker_container' 'Internett server' {navn = var.navn
bilde = var.bilde
havner {
intern = var.intern_port
ekstern = var.ekstern_port
}
}
Her lager vi en modul kalt 'docker_container' som tar containernavnet, Docker-bildet, intern port og ekstern port som inngangsvariabler. Modulen innkapsler logikken for å lage en Docker-beholderressurs og lar innringeren tilpasse beholderens egenskaper.
Som demonstrert i følgende bilde, lager vi en egen fil kalt 'variables.tf' i 'modules'-katalogen for å definere inngangsvariablene som kan tilpasses når du bruker modulen:
variabel 'Navn' {beskrivelse = 'Docker-beholdernavn'
type = streng
}
variabel 'bilde' {
beskrivelse = 'Docker-bilde'
type = streng
}
variabel 'intern_port' {
beskrivelse = 'Intern port på Docker-beholderen'
type = tall
}
variabel 'ekstern_port' {
beskrivelse = 'Ekstern port å kartlegge til'
type = tall
}
Her erklærte vi fire variabler, hver med 'beskrivelse' og 'type' som attributter og relevante verdier for dem.
Bruke en Terraform-modul
Siden vi opprettet modulen vår, kan vi nå bruke den i Terraform-konfigurasjonen vår ved å referere til kilden. La oss lage vår hovedkonfigurasjonsfil som er 'main.tf' i rotkatalogen.
modul 'webserver_container' {kilde = '../modules/docker_container'
navn = 'minwebserver'
bilde = 'nginx: siste'
intern_port = 80
ekstern_port = 8080
}
Vi bruker 'modul'-blokken i forrige kode for å instansiere Docker-beholdermodulen. Vi gir de nødvendige inngangsverdiene for modulen, for eksempel containernavnet, Docker-bildet og portkonfigurasjonen. 'Source'-parameteren spesifiserer den relative banen til 'modul'-katalogen.
Deretter, la oss se hvordan du bruker Terraform-utgangene til bruk med moduler.
Modulutganger
Modulutganger i Terraform gir en måte å eksponere spesifikke verdier fra en modul, og gjør dem tilgjengelige for bruk i hovedkonfigurasjonen eller av andre moduler. De fungerer som en kommunikasjonskanal mellom modulen og den som ringer som lar modulen gi en informasjon eller data som kan være nyttig eller nødvendig for videre konfigurasjon eller beslutningstaking.
produksjon 'container_id' {beskrivelse = 'ID for den opprettede Docker-beholderen'
verdi = docker_container.webserver.id
}
Her opprettet vi en 'outputs.tf'-fil inne i 'modules'-katalogen. Denne utdatavariabelen viser IDen til Docker-beholderen som er opprettet av 'docker_container'-ressursen kalt 'webserver' i modulen.
Nå kan vi få tilgang til container-ID-en i rotkonfigurasjonsfilen vår. Se følgende oppdaterte kode for 'main.tf'-filen i rotkatalogen:
modul 'webserver_container' {kilde = '../modules/docker_container'
navn = 'minwebserver'
bilde = 'nginx: siste'
intern_port = 80
ekstern_port = 8080
}
ressurs 'docker_volum' 'data' {
# Resten av argumentene går her
binde = module.webserver_container.container_id
}
Ved å bruke «module.webserver_container.container_id» som verdien for «bind»-argumentet, instruerer vi Terraform om å binde Docker-volumet til plasseringen som er spesifisert av container-IDen til «web_container»-modulen. Dette etablerer et forhold mellom Docker-volumressursen og beholderen som er opprettet av 'webserver_container'-modulen, og sikrer at volumet er montert på riktig sted.
Beste praksis for Terraform-moduler
Modulariser for gjenbruk
Vi bør vurdere gjenbrukbarheten når vi designer modulene. Vi må også identifisere infrastrukturens logiske komponenter eller mønstre og kapsle dem inn i separate moduler. Dette fremmer gjenbruk av kode, standardisering og enklere samarbeid på tvers av team.
Tydelig og konsekvent navngivning
Å bruke klare og konsistente navnekonvensjoner for moduler, variabler og ressurser forbedrer lesbarheten og forståelsen av kodebasen som gjør det lettere for andre å jobbe med og vedlikeholde modulene.
Isoler avhengigheter
Vi må unngå tett kobling mellom moduler. Hver modul bør innkapsle sine egne ressurser og avhengigheter. Dette sikrer at modulene kan gjenbrukes uavhengig og fremmer bedre isolasjon og innkapsling.
Versjonskontroll og modulregister
Vi kan publisere modulene våre til et versjonskontrollert arkiv eller modulregister. Dette gir en sentralisert plassering for deling og oppdagelse av moduler, og sikrer enkel tilgang og versjonskontroll.
Konklusjon
Vi tok en kort introduksjon til Terraform-moduler og lærte hvordan vi lager dem med et enkelt eksempel. Deretter så vi på hvordan vi kunne bruke variablene og utgangene med modulen vår for å forbedre dens fleksibilitet, gjenbrukbarhet og vedlikeholdsmuligheter. Som konklusjon er Terraform-moduler kraftige verktøy for å organisere og forenkle infrastrukturkoden. De lar oss kapsle inn et sett med ressurser eller konfigurasjoner i gjenbrukbare komponenter som fremmer modularitet, gjenbrukbarhet og samarbeid innenfor våre infrastruktur-som-kode-prosjekter.