Nutzung von Terraform für verbesserte Asset-Sicherheit mit Mondoo - Teil 3: Importe

In den vorangegangenen Beiträgen dieser Blogserie haben wir die Mondoo-Plattform, ihren Terraform Provider Ressourcen und Data Sources vorgestellt und untersucht, wie diese die Sicherheit und Compliance von Assets verbessern. In diesem dritten Teil werden wir uns mit einer wesentlichen Funktion von Terraform beschäftigen - Importe. Das Verständnis von Terraform-Importen ist entscheidend für die Integration bestehender Infrastrukturen in Ihren Terraform-Status und ermöglicht eine effektivere Verwaltung der Ressourcen mit Hilfe der leistungsstarken IaC-Funktionen (Infrastructure as Code) von Terraform.

Was sind Terraform-Importe?

Terraform-Importe ermöglichen es, bestehende Infrastrukturen unter das Terraform-Management zu bringen. Bei diesem Prozess wird der aktuelle Zustand der Infrastrukturressourcen in die Terraform-Zustandsdatei importiert, so dass diese Ressourcen so verwaltet und nachverfolgt werden können, als wären sie von Anfang an mit Terraform erstellt worden. Diese Fähigkeit ist von unschätzbarem Wert für Organisationen, die auf Terraform umsteigen oder Ressourcen verwalten, die außerhalb von Terraform erstellt wurden.

Warum Terraform-Importe verwenden?

• Nahtlose Integration: Vorhandene Ressourcen können einfach in die Terraform-Konfigurationen integriert werden, ohne sie neu erstellen zu müssen.
• Einheitliches Management: Pflegen und verwalten aller Infrastruktur-Ressourcen von einer einzigen Terraform-Konfiguration aus.
• Verfolgung von Änderungen: Nutzung der Statusverwaltung und der Planfunktionen von Terraform, um Änderungen zu verfolgen und den Lebenszyklus der importierten Ressourcen zu verwalten.

Wie man Terraform-Importe verwendet

Um eine Ressource zu importieren, werden normalerweise die folgenden Schritte durchgeführt:

• Identifizieren der Ressource: Bestimmen der Ressource und des entsprechenden Terraform-Ressourcentyps.
• Definieren der Ressourcen-Konfiguration: Hinzufügen der Ressourcen-Konfiguration zu den Terraform-Dateien.
• Ausführen des Import-Befehl: Verwenden des Befehls terraform import, um die Ressource in die Zustandsdatei zu bringen.
• Aktualisieren der Ressourcen-Konfiguration: Um die Konsistenz zu gewährleisten, müssen nach einem Import der Resource die Werte in den Terraform Dateien mit den tatsächlichen Werten im State aktualisiert werden.

Ab Juli 2024 haben viele Ressourcen dank unserer Zusammenarbeit mit dem Mondoo-Team eine Import-Integration erhalten.

Schritt-für-Schritt-Anleitung zum Importieren von Ressourcen

Sehen wir uns den Prozess des Imports einer bestehenden Ressource in Terraform mit Hilfe des Mondoo Terraform Providers an.

Beispiel: Importieren einer AWS-Integration

Identifizieren der Ressource: Angenommen, wir haben eine bestehende AWS-Integration in Mondoo, die wir mit Terraform verwalten wollen. Wir müssen ihren Identifikator ermitteln. Bei Mondoo-Ressourcen ist dies die MRN, die einfach über die Benutzeroberfläche abgerufen werden kann:

Definieren der Ressourcen-Konfiguration: Bevor wir importieren, müssen wir eine Terraform-Datei (z.B. main.tf) erstellen, die den Mondoo Provider und die Ressourcen-Konfiguration enthält. Wir können die aktuellen Werte leer lassen, da wir sie nach dem Ausführen des import-Befehls erhalten:

 1terraform {
 2  required_providers {
 3    mondoo = {
 4      source  = "mondoohq/mondoo"
 5      version = ">= 0.4.0"
 6    }
 7  }
 8}
 9
10provider "mondoo" {}
11
12resource "mondoo_integration_aws" "example_integration" {
13  space_id = ""
14  name     = ""
15
16  credentials = {
17    key = {
18      access_key = ""
19      secret_key = ""
20    }
21  }
22}

Aussfüren des Import-Befehls:

1terraform import mondoo_integration_aws.example_integration [RESOURCE_ID]

Hier ersetzen wir [RESOURCE_ID] durch die tatsächliche ID unserer AWS-Integration.

Aktualisieren der Ressourcen-Konfiguration: Nach dem Import sollten wir einen Blick auf die Zustandsdatei werfen und die korrekten Werte in die Datei main.tf übertragen, um die Konsistenz zu gewährleisten, wenn wir in Zukunft mit der Ressource arbeiten:

 1terraform {
 2  required_providers {
 3    mondoo = {
 4      source  = "mondoohq/mondoo"
 5      version = ">= 0.4.0"
 6    }
 7  }
 8}
 9
10provider "mondoo" {}
11
12resource "mondoo_integration_aws" "example_integration" {
13  space_id = "the space id found inside the .tfstate file"
14  name     = "the name found inside the .tfstate file"
15
16  credentials = {
17    key = {
18      access_key = "the ACCESS_KEY found inside the .tfstate file"
19      secret_key = "you will not be able to find this in the .tfstate file"
20    }
21  }
22}

Wie Sie vielleicht bemerkt haben, können nicht alle Werte in der Datei .tfstate gefunden werden. In diesem Fall werden wir nicht in der Lage sein, den secret_key zu erhalten, da es ein sensibler Wert ist.

Beispiel: Importieren einer Google Cloud Platform (GCP) Integration

Identifizieren der Ressource: Angenommen, wir haben eine bestehende GCP-Integration in Mondoo eingerichtet, die wir mit Terraform verwalten wollen. Wir müssen ihre Identifikator ermitteln, wie wir es auch bei der AWS Integration getan haben.

Definieren der Ressourcen-Konfiguration: Bevor wir importieren, müssen wir eine Terraform-Datei (z.B. main.tf) erstellen, die den Mondoo Provider und die Ressourcen-Konfiguration enthält. Wir können die aktuellen Werte leer lassen, da wir sie nach dem Ausführen des Import-Befehls erhalten:

 1terraform {
 2  required_providers {
 3    mondoo = {
 4      source  = "mondoohq/mondoo"
 5      version = ">= 0.4.0"
 6    }
 7  }
 8}
 9
10provider "mondoo" {}
11
12resource "mondoo_integration_gcp" "example_integration" {
13  space_id   = ""
14  name       = ""
15  project_id = ""
16  credentials = {
17    private_key = ""
18  }
19}

Ausführen des import-Befehls:

1terraform import mondoo_integration_gcp.example_integration [RESOURCE_ID]

Hier ersetzen wir [RESOURCE_ID] durch die tatsächliche ID unserer GCP-Integration.

Aktualisieren der Ressourcen-Konfiguration: Nach dem Import sollten wir einen Blick auf die Zustandsdatei werfen und die korrekten Werte in die Datei main.tf übertragen, um die Konsistenz zu gewährleisten, wenn wir in Zukunft mit der Ressource arbeiten:

 1terraform {
 2  required_providers {
 3    mondoo = {
 4      source  = "mondoohq/mondoo"
 5      version = ">= 0.4.0"
 6    }
 7  }
 8}
 9
10provider "mondoo" {}
11
12resource "mondoo_integration_gcp" "example_integration" {
13  space_id   = "the space id found inside the .tfstate file"
14  name       = "the name found inside the .tfstate file
15  project_id = "the project id found inside the .tfstate file"
16  credentials = {
17    private_key = "you will not be able to find this in the .tfstate file"
18  }
19}

Genau wie bei der AWS-Integration enthält die GCP-Integration bestimmte sensible Werte wie das Feld private_key, die nicht in der Datei .tfstate zu finden sind.

Validierung des Imports

Nach dem Import von Ressourcen ist es wichtig zu überprüfen, ob der importierte Zustand mit der tatsächlichen Ressourcenkonfiguration übereinstimmt. Mit dem Befehl terraform plan können wir die Änderungen überprüfen und sicherstellen, dass es keine Unstimmigkeiten gibt.

1terraform plan

Best Practices für Terraform-Importe

• Sichern des Zustandes: Das Sichern des aktuellen Terraform-Zustandes vor dem Importieren verhindert versehentliche Datenverluste.
• Verwenden aussagekräftiger Namen: Das Benennen der Ressourcen in Terraform, mit aussagekräftigen Namen, erleichtert die Identifizierung und Verwaltung der Ressourcen.
• Prüfen und Testen: Prüfen und testen der importierten Konfigurationen, um sicherzustellen, dass sie wie erwartet funktionieren.

Erstellen von Terraform Provider Importen

Die Erstellung von Importen für einen Terraform Provider beinhaltet die Definition der Logik, die es Terraform ermöglicht, bestehende Ressourcen in sein State Management zu integrieren. Dieser Prozess stellt sicher, dass die Terraform-Konfiguration Ressourcen erkennen und verwalten kann, die außerhalb von Terraform erstellt wurden. In diesem Abschnitt stellen wir die wesentlichen Funktionen vor, die benötigt werden, um Terraform Provider Importe zu erstellen. Als Beispiel dient der Mondoo Terraform Provider.

Mondoo verwendet das terraform-plugin-codegen-framework, das eine einfache und konsistente Erweiterung des Terraform Providers ermöglicht. Die Import Funktion von Terraform baut auf der Standard Terraform Ressource auf, die mit dem Plugin Framework erstellt wurde. Sie fügt einfach eine weitere Funktion namens ImportState zu den bestehenden Funktionen Metadata, Schema, Create, Read, Update, und Delete hinzu. Wir haben die notwendigen Bausteine für eine Terraform Ressource bereits im ersten Teil dieser Serie besprochen und werden daher nicht noch einmal darauf eingehen.

ImportState Funktion

 1func (r *TestResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) {
 2    testPayload, err := r.client.GetTest(ctx, req.ID)
 3    if err != nil {
 4        resp.Diagnostics.AddError("Client Error", fmt.Sprintf("Unable to retrieve test, got error: %s", err))
 5        return
 6    }
 7
 8    model := testResourceResourceModel {
 9        Id:  types.StringValue(testPayload.Id),
10    }
11
12    resp.State.Set(ctx, &model)
13}

Die Funktion ImportState liest den Zustand der bestehenden Ressource und ordnet ihn dem Terraform-Ressourcenschema zu. Diese Funktion ist entscheidend für den Importprozess, da sie sicherstellt, dass der Zustand der Ressource in Terraform korrekt wiedergegeben wird. Im Fall dieser Testimplementierung rufen wir eine fiktive Funktion namens GetTest auf, die im Fall von Mondoo die GraphQL API verwendet, um die Ressource anzufordern. Anschließend speichern wir die zurückgegebenen Daten in unserem Terraform State mit resp.State.Set(ctx, &model).

Zusammenfassung

Terraform's import ist ein mächtiges Feature, das die Verwaltung der bestehenden Infrastruktur in Terraform erleichtert. Indem diese Funktionalität genutzt wird, können die Verwaltung der Infrastruktur vereinheitlicht, die Konsistenz aufrechterhalten und die Sicherheit mit Mondoo und Terraform verbessert werden. In diesem Blogbeitrag haben wir die Bedeutung von Terraform-Importen untersucht, eine Schritt-für-Schritt-Anleitung für den Import von Ressourcen bereitgestellt und Best Practices für einen reibungslosen Importprozess mitgeteilt.

Vergessen Sie nicht, sich unseren letzten Blogbeitrag dieser Blogserie über die erweiterten Fähigkeiten von Mondoo anzusehen, in dem wir die benutzerdefinierten Ressourcen von Mondoo mit Terraform entdecken. Bleiben Sie dran, um mehr darüber zu erfahren, wie Sie das volle Potenzial von Mondoo und Terraform für eine robuste Infrastruktursicherheit und Compliance ausschöpfen können.