In de wereld van infrastructuurvoorziening en -beheer is Terraform uitgegroeid tot een populaire keuze onder ontwikkelaars en operationele teams. Met zijn declaratieve syntaxis (HCL – HashiCorp Configuration Language) en ondersteuning voor verschillende infrastructuurproviders, maakt Terraform infrastructure-as-code (IaC)-praktijken mogelijk.
Een van de belangrijkste kenmerken is het gebruik van modules waarmee de modulaire infrastructuurcode kan worden gemaakt en hergebruikt. In dit artikel zullen we het concept van Terraform-modules onderzoeken en hoe ze kunnen helpen bij het organiseren en vereenvoudigen van onze infrastructuurcode.
Inleiding tot Terraform-modules
Terraform-modules zijn op zichzelf staande pakketten van Terraform-configuraties die een set bronnen vertegenwoordigen met gedefinieerde invoer- en uitvoervariabelen. Ze bieden een manier om de infrastructuurcode in te kapselen en opnieuw te gebruiken, waardoor het beheer en onderhoud van complexe infrastructuurimplementaties eenvoudiger wordt.
Modules kunnen intern binnen een project worden gemaakt en gebruikt of worden gedeeld met meerdere projecten of teams.
Organisatie van de module
Bij het organiseren van de Terraform-modules is het gebruikelijk om een hiërarchische structuur te hebben die bestaat uit root- en onderliggende modules. Laten we eens kijken hoe deze organisatie werkt.
Root-module
De rootmodule vertegenwoordigt de module op het hoogste niveau in onze Terraform-configuratie. Het is het startpunt voor het definiëren van de algehele infrastructuur en het beheren van de relaties tussen verschillende bronnen.
De rootmodule bevat doorgaans het bestand 'main.tf' waarin we de bronnen en configuraties definiëren die de basis vormen van onze infrastructuur. Optioneel kunnen we de bestanden 'variables.tf' en 'outputs.tf' erbij hebben. We kunnen ook onze map 'modules' in de hoofdmap definiëren om gemakkelijk toegang te krijgen tot de onderliggende modules.
Kindmodules
Onderliggende modules zijn modulaire componenten die specifieke sets bronnen of configuraties inkapselen. Ze zijn ontworpen om herbruikbaar te zijn en vertegenwoordigen de op zichzelf staande eenheden van infrastructuurfunctionaliteit.
Kindmodules kunnen worden gebruikt binnen de root of andere kindmodules die samenstelling en complexe infrastructuuropbouw mogelijk maken. Elke onderliggende module heeft typisch een map die de noodzakelijke configuratiebestanden bevat, zoals 'main.tf', 'variables.tf' en 'outputs.tf'.
Laten we nu kijken hoe we een Terraform-module kunnen maken.
Een Terraform-module maken
Bij het maken van Terraform-modules moeten we een nieuwe map maken voor de module met de vereiste Terraform-configuratiebestanden. Gewoonlijk wordt die map 'modules' genoemd. Het definiëren ervan in de hoofdmap van ons project is een best practice.
Laten we een eenvoudig voorbeeld nemen van een eenvoudige module om een lokale webserver in te richten met behulp van de Docker. Eerst definiëren we de module in de map 'modules' als 'main.tf'.
bron 'docker_container' 'web Server' {naam = var.naam
afbeelding = var.afbeelding
havens {
internal = var.internal_port
extern = var.externe_poort
}
}
Hier maken we een module met de naam 'docker_container' die de containernaam, Docker-afbeelding, interne poort en externe poort als invoervariabelen gebruikt. De module bevat de logica om een Docker-containerresource te maken en stelt de aanroeper in staat om de eigenschappen van de container aan te passen.
Zoals wordt aangetoond in de volgende afbeelding, maken we een apart bestand met de naam 'variables.tf' in de map 'modules' om de invoervariabelen te definiëren die kunnen worden aangepast bij het gebruik van de module:
variabel 'naam' {beschrijving = 'Docker-containernaam'
type = tekenreeks
}
variabel 'afbeelding' {
beschrijving = 'Docker-afbeelding'
type = tekenreeks
}
variabel 'interne_poort' {
beschrijving = 'Interne poort op de Docker-container'
type = aantal
}
variabel 'externe_poort' {
beschrijving = 'Externe poort om naar toe te wijzen'
type = aantal
}
Hier hebben we vier variabelen gedeclareerd, elk met 'beschrijving' en 'type' als attributen en relevante waarden daarvoor.
Een Terraform-module gebruiken
Sinds we onze module hebben gemaakt, kunnen we deze nu gebruiken in onze belangrijkste Terraform-configuratie door naar de bron te verwijzen. Laten we ons hoofdconfiguratiebestand maken dat 'main.tf' is in de hoofdmap.
moduul 'webserver_container' {bron = '../modules/docker_container'
naam = 'mijnwebserver'
afbeelding = 'nginx:nieuwste'
interne_poort = 80
externe_poort = 8080
}
We gebruiken het 'module' -blok in de vorige code om de Docker-containermodule te instantiëren. We bieden de benodigde invoerwaarden voor de module, zoals de containernaam, Docker-image en poortconfiguratie. De parameter 'source' specificeert het relatieve pad naar de map 'module'.
Laten we vervolgens kijken hoe we de Terraform-uitvoer kunnen gebruiken voor gebruik met modules.
Module-uitgangen
Module-uitvoer in Terraform biedt een manier om specifieke waarden binnen een module bloot te leggen, waardoor ze beschikbaar zijn voor gebruik in de hoofdconfiguratie of door andere modules. Ze dienen als een communicatiekanaal tussen de module en de beller, waardoor de module informatie of gegevens kan verstrekken die nuttig of noodzakelijk kunnen zijn voor verdere configuratie of besluitvorming.
uitvoer 'container_id' {beschrijving = 'ID van de gemaakte Docker-container'
waarde = docker_container.webserver.id
}
Hier hebben we een bestand 'outputs.tf' gemaakt in de map 'modules'. Deze uitvoervariabele geeft de ID weer van de Docker-container die is gemaakt door de resource 'docker_container' met de naam 'webserver' binnen de module.
Nu hebben we toegang tot de container-ID in ons rootconfiguratiebestand. Raadpleeg de volgende bijgewerkte code van het bestand 'main.tf' in de hoofdmap:
moduul 'webserver_container' {bron = '../modules/docker_container'
naam = 'mijnwebserver'
afbeelding = 'nginx:nieuwste'
interne_poort = 80
externe_poort = 8080
}
bron 'docker_volume' 'gegevens' {
# De rest van de argumenten komt hier
binden = module.webserver_container.container_id
}
Door de 'module.webserver_container.container_id' te gebruiken als de waarde voor het 'bind' argument, instrueren we Terraform om het Docker-volume te binden aan de locatie die wordt gespecificeerd door de container-ID van de 'web_container'-module. Dit brengt een relatie tot stand tussen de Docker-volumeresource en de container die is gemaakt door de module 'webserver_container', zodat het volume op de juiste locatie wordt aangekoppeld.
Best practices voor Terraform-modules
Modulariseer voor herbruikbaarheid
We moeten rekening houden met de herbruikbaarheid bij het ontwerpen van de modules. We moeten ook de logische componenten of patronen van onze infrastructuur identificeren en deze in afzonderlijke modules inkapselen. Dit bevordert hergebruik van code, standaardisatie en eenvoudigere samenwerking tussen teams.
Duidelijke en consistente naamgeving
Het gebruik van duidelijke en consistente naamgevingsconventies voor modules, variabelen en bronnen verbetert de leesbaarheid en het begrip van de codebase, waardoor het voor anderen gemakkelijker wordt om met de modules te werken en deze te onderhouden.
Isoleer afhankelijkheden
We moeten nauwe koppelingen tussen modules vermijden. Elke module moet zijn eigen bronnen en afhankelijkheden bevatten. Dit zorgt ervoor dat de modules onafhankelijk kunnen worden hergebruikt en bevordert een betere isolatie en inkapseling.
Versiebeheer en moduleregister
We kunnen onze modules publiceren naar een versiebeheerde repository of moduleregister. Dit biedt een gecentraliseerde locatie voor het delen en ontdekken van modules, wat zorgt voor gemakkelijke toegang en versiebeheer.
Conclusie
We hebben een korte inleiding gegeven tot Terraform-modules en geleerd hoe u ze kunt maken met een eenvoudig voorbeeld. Vervolgens hebben we gekeken hoe we de variabelen en outputs met onze module kunnen gebruiken om de flexibiliteit, herbruikbaarheid en onderhoudbaarheid te verbeteren. Kortom, Terraform-modules zijn krachtige hulpmiddelen om de infrastructuurcode te organiseren en te vereenvoudigen. Ze stellen ons in staat om een reeks bronnen of configuraties in te kapselen in herbruikbare componenten die modulariteit, herbruikbaarheid en samenwerking binnen onze infrastructuur-als-code-projecten bevorderen.