Implementierung von Terraform-Modulen

Einführung

Terraform-Module sind ein Kernkonzept in Infrastructure as Code (IaC), das es Ihnen ermöglicht, wiederverwendbare, konfigurierbare und organisierte Komponenten zu erstellen. Anstatt denselben Codeblock an mehreren Stellen zu schreiben, können Sie ihn in einem Modul kapseln und bei Bedarf aufrufen. Diese Vorgehensweise verbessert die Wartbarkeit des Codes und die Konsistenz über Ihre Projekte hinweg erheblich.

In diesem Lab lernen Sie die Grundlagen der Implementierung von Terraform-Modulen kennen. Sie beginnen mit der Erstellung einer Standard-Modulverzeichnisstruktur. Anschließend definieren Sie ein einfaches Modul, das eine lokale Datei erstellt. Sie werden dieses Modul mithilfe von Variablen konfigurierbar machen und seine Ergebnisse über Outputs (Ausgaben) zugänglich machen. Schließlich rufen Sie dieses Modul aus Ihrer Root-Terraform-Konfiguration auf, um die Ressource bereitzustellen.

Am Ende dieses Labs werden Sie ein praktisches Verständnis dafür entwickelt haben, wie Sie Ihre eigenen Terraform-Module erstellen und verwenden.

Erstellen des Modulverzeichnisses im Projekt-Root

In diesem Schritt erstellen Sie die Standardverzeichnisstruktur für ein lokales Terraform-Modul. Es ist eine gängige Konvention, alle lokalen Module in einem Verzeichnis namens modules im Stammverzeichnis Ihres Projekts abzulegen. Jedes Unterverzeichnis innerhalb von modules repräsentiert dann ein einzelnes, in sich geschlossenes Modul.

Zuerst erstellen wir ein Verzeichnis für unsere Module und ein spezifisches Unterverzeichnis für ein Modul, das wir localfile_creator nennen werden. Alle Operationen werden im Verzeichnis ~/project durchgeführt.

Führen Sie den folgenden Befehl aus, um die verschachtelte Verzeichnisstruktur zu erstellen:

mkdir -p modules/localfile_creator

Das Flag -p stellt sicher, dass mkdir das übergeordnete Verzeichnis modules erstellt, falls es noch nicht existiert.

Nun können Sie überprüfen, ob die Verzeichnisse korrekt erstellt wurden, indem Sie den Befehl tree verwenden. Falls tree nicht installiert ist, können Sie ls -R verwenden.

tree

Sie sollten die folgende Ausgabe sehen, die Ihre neue Verzeichnisstruktur bestätigt:

.
└── modules
    └── localfile_creator

2 directories, 0 files

Diese Struktur trennt Ihren wiederverwendbaren Modulcode klar von der Root-Konfiguration, die ihn verwenden wird.

Erstellen von main.tf im Modul für die local_file-Ressource

In diesem Schritt erstellen Sie die primäre Konfigurationsdatei für Ihr neues Modul. Jedes Modul ist ein in sich geschlossenes Terraform-Projekt und verfügt daher über einen eigenen Satz von .tf-Dateien. Die Datei main.tf ist typischerweise der Ort, an dem die Kernressourcen des Moduls definiert werden.

Wir werden eine Ressource vom Typ local_file definieren, die Teil des Providers hashicorp/local ist. Diese Ressource eignet sich hervorragend für Lernzwecke, da sie einfach Dateien auf dem lokalen Dateisystem verwaltet, ohne dass Cloud-Provider-Anmeldeinformationen erforderlich sind.

Erstellen Sie zunächst die Datei main.tf im Verzeichnis Ihres Moduls mit dem Editor nano:

nano modules/localfile_creator/main.tf

Fügen Sie nun den folgenden HCL (HashiCorp Configuration Language)-Code in die Datei ein. Dieser Code definiert eine Ressource vom Typ local_file mit dem lokalen Namen example.

resource "local_file" "example" {
  content  = "This is a file created by a Terraform module."
  filename = "${path.module}/module_output.txt"
}

Lassen Sie uns diesen Code aufschlüsseln:

• resource "local_file" "example": Dies deklariert eine Ressource vom Typ local_file und gibt ihr den lokalen Namen example.
• content: Dieses Argument legt den Inhalt fest, der in die Datei geschrieben wird.
• filename: Dieses Argument gibt den Pfad und den Namen der zu erstellenden Datei an. Wir verwenden die eingebaute Variable path.module, die sich immer auf den Dateisystempfad des Moduls bezieht, in dem der Ausdruck platziert ist. Dadurch wird der Dateipfad relativ zum Modul selbst.

Speichern Sie die Datei und beenden Sie nano, indem Sie Strg+X drücken, gefolgt von J (oder Y, je nach Spracheinstellung) und dann Enter.

Modulvariablen und -ausgaben definieren

In diesem Schritt machen Sie Ihr Modul konfigurierbar und in der Lage, Informationen zurückzugeben. Das Festschreiben (Hardcoding) von Werten wie Dateinamen und Inhalten schränkt die Wiederverwendbarkeit eines Moduls ein. Wir werden Eingabevariablen verwenden, um benutzerdefinierte Werte zu übergeben, und Ausgabewerte, um Informationen über die vom Modul erstellten Ressourcen offenzulegen.

Gemäß Konvention werden Variablen in einer Datei namens variables.tf und Ausgaben in einer Datei namens outputs.tf definiert.

Erstellen Sie zunächst die Datei variables.tf für Ihr Modul:

nano modules/localfile_creator/variables.tf

Fügen Sie den folgenden Code hinzu, um zwei Eingabevariablen zu definieren: file_content und file_name.

variable "file_content" {
  description = "The content of the file."
  type        = string
  default     = "Default content."
}

variable "file_name" {
  description = "The name of the file to create."
  type        = string
}

Als Nächstes erstellen Sie die Datei outputs.tf, um zu deklarieren, welche Informationen das Modul zurückgeben soll:

nano modules/localfile_creator/outputs.tf

Fügen Sie den folgenden Code hinzu, um den vollständigen Pfad der erstellten Datei auszugeben:

output "filename" {
  description = "The full path to the created file."
  value       = local_file.example.filename
}

Schließlich müssen Sie die main.tf des Moduls aktualisieren, um diese neuen Variablen anstelle der fest codierten Werte zu verwenden. Öffnen Sie die Datei erneut:

nano modules/localfile_creator/main.tf

Ändern Sie die Datei so, dass sie wie folgt aussieht. Wir ersetzen die fest codierten Zeichenketten durch var.file_content und var.file_name.

resource "local_file" "example" {
  content  = var.file_content
  filename = "${path.module}/${var.file_name}"
}

Speichern Sie die Datei und beenden Sie den Editor. Ihr Modul ist nun flexibel und bereit für die Verwendung mit unterschiedlichen Eingaben.

Modul im Root-main.tf aufrufen

In diesem Schritt erstellen Sie eine Root-Konfigurationsdatei, die das gerade erstellte Modul aufruft. Die Root-main.tf ist der Einstiegspunkt für Ihre Terraform-Ausführung. Hier stellen Sie Ihre Infrastruktur zusammen, indem Sie ein oder mehrere Module aufrufen.

Sie arbeiten nun im Stammverzeichnis Ihres Projekts, ~/project. Erstellen Sie hier eine Datei namens main.tf:

nano main.tf

Fügen Sie den folgenden Code in diese Datei ein. Diese Konfiguration verwendet das Modul localfile_creator.

terraform {
  required_providers {
    local = {
      source  = "hashicorp/local"
      version = "2.4.0"
    }
  }
}

module "file_creator_instance" {
  source = "./modules/localfile_creator"

  file_content = "Hello from the root module!"
  file_name    = "my_test_file.txt"
}

output "created_file_path" {
  description = "Path of the file created by the module."
  value       = module.file_creator_instance.filename
}

Analysieren wir diese Root-Konfiguration:

• terraform { ... }: Dieser Block definiert die Provider-Anforderungen. Da unser Modul den Provider local verwendet, muss auch das Root-Modul, das es aufruft, diesen deklarieren.
• module "file_creator_instance" { ... }: Dies ist der Modulblock. file_creator_instance ist ein lokaler Name für diese spezifische Instanz des Moduls.
• source = "./modules/localfile_creator": Dies teilt Terraform mit, wo der Quellcode des Moduls zu finden ist. In diesem Fall ist es ein lokaler Pfad.
• file_content = "..." und file_name = "...": Hier übergeben Sie Werte an die Eingabevariablen, die in der variables.tf des Moduls definiert sind.
• output "created_file_path" { ... }: Dieser Output-Block auf Root-Ebene ruft einen Wert aus dem Modul ab. Die Syntax lautet module.<MODUL_INSTANZ_NAME>.<OUTPUT_NAME>.

Speichern Sie die Datei und beenden Sie nano. Ihr Projekt ist nun vollständig für die Verwendung des Moduls konfiguriert.

Terraform apply ausführen, um über das Modul bereitzustellen

In diesem letzten Schritt verwenden Sie Standard-Terraform-Befehle, um Ihre Konfiguration zu initialisieren, zu planen und anzuwenden. Dadurch wird der Code in Ihrem Modul ausgeführt und die lokale Datei erstellt.

Initialisieren Sie zunächst das Terraform-Arbeitsverzeichnis. Dieser Befehl lädt die notwendigen Provider-Plugins herunter (in diesem Fall hashicorp/local).

terraform init

Sie sollten eine Erfolgsmeldung sehen, die anzeigt, dass Terraform erfolgreich initialisiert wurde.

Initializing the backend...
Initializing provider plugins...
- Finding hashicorp/local versions matching "2.4.0"...
- Installing hashicorp/local v2.4.0...
- Installed hashicorp/local v2.4.0 (signed by HashiCorp)

Terraform has been successfully initialized!
...

Führen Sie als Nächstes terraform plan aus, um zu sehen, welche Änderungen Terraform vornehmen wird. Dies ist ein Probelauf (Dry Run), der nichts ändert, Ihnen aber den Ausführungsplan anzeigt.

terraform plan

Die Ausgabe zeigt, dass eine Ressource (die local_file in Ihrem Modul) erstellt wird.

...
Plan: 1 to add, 0 to change, 0 to destroy.

Changes to Outputs:
  + created_file_path = (known after apply)
...

Wenden Sie nun die Konfiguration an, um die Datei zu erstellen. Wir verwenden das Flag -auto-approve, um die interaktive Bestätigungsaufforderung zu überspringen.

terraform apply -auto-approve

Terraform führt den Plan aus und erstellt die Datei. Die Ausgabe bestätigt die Erstellung und zeigt den von Ihnen definierten Ausgabewert an.

...
module.file_creator_instance.local_file.example: Creating...
module.file_creator_instance.local_file.example: Creation complete after 0s [id=f73598097552a798110a31388c54c1194b539a53]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

Outputs:

created_file_path = "./modules/localfile_creator/my_test_file.txt"

Überprüfen Sie abschließend, ob die Datei mit dem korrekten Inhalt erstellt wurde. Listen Sie die Dateien im Modulverzeichnis auf und zeigen Sie dann den Inhalt der neuen Datei an.

ls -l modules/localfile_creator/

cat modules/localfile_creator/my_test_file.txt

Die Ausgabe des cat-Befehls sollte lauten:

Hello from the root module!

Herzlichen Glückwunsch, Sie haben erfolgreich ein Terraform-Modul erstellt und verwendet!

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Erstellung und Verwendung von Terraform-Modulen erfolgreich erlernt. Sie haben den gesamten Prozess durchlaufen, von der Einrichtung einer geeigneten Verzeichnisstruktur bis zur Bereitstellung einer Ressource über ein wiederverwendbares Modul.

Sie haben gelernt, wie man:

• Eine Standard-Verzeichnisstruktur für lokale Module erstellt.
• Ressourcen in der main.tf-Datei eines Moduls definiert.
• variables.tf verwendet, um Ihr Modul konfigurierbar und wiederverwendbar zu machen.
• outputs.tf verwendet, um Daten aus Ihrem Modul an die aufrufende Konfiguration weiterzugeben.
• Ein lokales Modul aus einer Root-main.tf-Datei aufruft, Eingabevariablen übergibt und auf Ausgabewerte zugreift.
• Die Konfiguration anwendet, um das Modul in Aktion zu sehen.

Durch die Beherrschung von Modulen können Sie saubereren, besser organisierten und skalierbareren Infrastructure as Code (IaC) schreiben. Gut gemacht mit dem Abschluss dieses Labs!