Terraform auf Azure: Ein praktischer Leitfaden für Einsteiger in die IaC

Wenn du dich schon einmal durch das Azure-Portal geklickt und versucht hast, Cloud-Ressourcen manuell zusammenzustellen, habe ich das auch schon erlebt - und es wird schnell langweilig. Hier kommt Terraform ins Spiel. Es ist ein Infrastructure-as-Code (IaC)-Tool, mit dem du deine Cloud-Einrichtung mit nur wenigen Zeilen Code definieren und verwalten kannst.

In diesem Tutorial konzentrieren wir uns auf die Verwendung von Terraform mit Azure. Ich zeige dir, was Terraform ist, wie es im Azure-Ökosystem funktioniert und wie du mit praktischen Beispielen loslegst. Außerdem werden wir einige Best Practices vorstellen, die dir dabei helfen, von Anfang an sichere und zuverlässige Implementierungen zu erstellen.

Wenn du neu im Azure-Ökosystem bist, bietet dir dieser Lernpfad eine strukturierte Einführung in die wichtigsten Dienste und Prinzipien von Azure.

Warum Terraform auf Azure verwenden?

Terraform, entwickeltd von HashiCorp, ist ein Open-Source IaC-Tool, mit dem du eine Cloud-Infrastruktur mithilfe einer deklarativen Syntax definieren und verwalten kannst. In Verbindung mit Microsoft Azure kannst du Ressourcen wie virtuelle Netzwerke, VMs und Datenbanken in menschenlesbaren Konfigurationsdateien skripten.

Warum Terraform mit Azure verwenden? Es geht vor allem um Konsistenz, Skalierbarkeit und Geschwindigkeit. Egal, ob du eine einzelne VM aufbaust oder eine komplexe, mehrschichtige Anwendung orchestrierst, Terraform vereinfacht den Prozess und reduziert menschliche Fehler.

Wenn du Terraform noch nicht kennst,erklärt dir dieser einsteigerfreundliche Leitfadendie Grundlagen und wie du mit der Nutzung von Terraform für Infrastructure as Code beginnen kannst.

Kernkonzepte von Terraform auf Azure

Die Integration von Terraform in Azure bietet eine Reihe von Funktionen, die das Infrastrukturmanagement intuitiv und leistungsstark machen. Schauen wir uns die wichtigsten Komponenten und Arten der verfügbaren Terraform-Ressourcen an.

Deklaratives Infrastrukturmanagement

Mit dem deklarativen Ansatz von Terraform kannst du in .tf Dateien mit der HashiCorp Configuration Language (HCL) definieren, wie deine Azure-Infrastruktur aussehen soll. 

Du kannst zum Beispiel eine Azure-VM mit ihrer Größe, ihrem Standort und ihren Netzwerkeinstellungen angeben und Terraform kümmert sich darum, wie sie erstellt wird. Hier ist ein kurzer Blick darauf:

resource "azurerm_virtual_machine" "example" {
  name                  = "my-vm"
  location              = "East US"
  resource_group_name   = "my-resource-group"
  vm_size               = "Standard_D2s_v3"
  network_interface_ids = [azurerm_network_interface.example.id]
  # ... other necessary configurations like OS disk, admin details
}

Die obige Definition stellt die Idempotenz sicher - wenn du denselben Code mehrmals ausführst, erhältst du das gleiche Ergebnis ohne Duplikate oder Fehler. 

Schauen wir uns nun die Kernkonzepte von Terraform an, die diesen deklarativen Ansatz ermöglichen.

Terraform Status (.tfstate)

Die Datei terraform.tfstate ist das Herzstück des deklarativen Modells von Terraform. Es handelt sich um eine JSON-Datei, die den aktuellen Status deiner Azure-Ressourcen aufzeichnet - was eingesetzt wird, ihre Konfigurationen und ihre Beziehungen. 

Wenn du terraform apply aufrufst, vergleicht Terraform deine .tf Dateien (der gewünschte Zustand) mit der .tfstate Datei (der aktuelle Zustand), um festzustellen, welche Änderungen vorgenommen werden müssen. Wenn du zum Beispiel die Größe einer VM in deinem Code aktualisierst, überprüft Terraform die Datei .tfstate und ändert nur dieses Attribut in Azure. 

Du kannst diese Datei lokal speichern, aber für Teams solltest du Azure Blob Storage verwenden, um die Zusammenarbeit zu ermöglichen und Konflikte zu vermeiden.

Terraform-Variablen (.tfvars)

Variablen machen deine Konfigurationen flexibel und wiederverwendbar. Sie werden in variables.tf und terraform.tfvars definiert und ermöglichen es dir, Werte wie Ressourcennamen oder Regionen zu parametrisieren. 

Zum Beispiel:

# variables.tf
variable "location" {
  type        = string
  default     = "East US"
  description = "The Azure region where resources will be deployed."
}

# terraform.tfvars (for a specific environment, e.g., production)
location = "West US"

# main.tf
resource "azurerm_resource_group" "example" {
  name     = "my-rg"
  location = var.location
}

Die Datei terraform.tfvars setzt die Standardeinstellungen außer Kraft, sodass du denselben Code in verschiedenen Regionen einsetzen kannst, ohne die Kerndateien .tf zu bearbeiten. Damit lassen sich mehrere Umgebungen verwalten (z. B. Dev, Prod).

Terraform Konfigurationsdateien (.tf)

Diese Dateien enthalten deinen Infrastrukturcode, der in HCL geschrieben ist. Sie definieren Ressourcen, Anbieter, Module und mehr. Du kannst sie als eine einzige main.tf organisieren oder sie in mehrere Dateien aufteilen (z.B. variables.tf, outputs.tf, network.tf, compute.tf), um sie übersichtlicher zu gestalten und besser zu organisieren.

Terraform-Plan

Bevor die Änderungen angewendet werden, zeigt der Befehl terraform plan eine Vorschau darauf, was Terraform tun wird - Ressourcen erstellen, aktualisieren oder löschen - basierend auf dem Unterschied zwischen deinen .tf Dateien und den .tfstate. Es ist wie ein Probelauf, der potenzielle Probleme frühzeitig aufdeckt und eine detaillierte Zusammenfassung der vorgeschlagenen Maßnahmen anzeigt.

Terraform anwenden

Der Befehl terraform apply führt die mit terraform plan identifizierten Änderungen aus, aktualisiert Azure auf den gewünschten Stand und aktualisiert die Datei .tfstate. Bevor die Änderungen übernommen werden, wirst du um eine Bestätigung gebeten, was ein Sicherheitsnetz darstellt.

Arbeitsräume

Mit Terraform Workspaces kannst du mehrere Umgebungen (z.B. Dev, Staging, Prod) mit einem einzigen Satz von .tf Dateien verwalten. Jeder Arbeitsbereich hat seine eigene .tfstate Datei, so dass du eine ähnliche Infrastruktur mit unterschiedlichen Konfigurationen bereitstellen kannst (z.B. unterschiedliche VM-Größen für dev vs. prod). 

Um einen neuen Arbeitsbereich zu erstellen, kannst du verwenden:

terraform workspace new production

Dann kannst du zum Arbeitsbereich wechseln:

terraform workspace select production

Module

Module sind wiederverwendbare Pakete mit Terraform-Code. Du kannst zum Beispiel ein Modul für ein virtuelles Azure-Netzwerk erstellen und es projektübergreifend wiederverwenden, um Doppelarbeit zu vermeiden und die Standardisierung zu fördern. Mehr zu den Modulen erfährst du im Abschnitt über die besten Praktiken.

Diese Konzepte -.tfstate, .tfvars und der deklarative Workflow - arbeiten zusammen, um sicherzustellen, dass deine Azure-Infrastruktur vorhersehbar, reproduzierbar und einfach zu verwalten ist.

Staatliche Verwaltung und Zusammenarbeit

Die Datei terraform.tfstate verfolgt den Zustand deiner Infrastruktur. Für Teams ist die Speicherung in Azure Blob Storage eine wichtige Best Practice, um gemeinsamen Zugriff und Versionskontrolle zu ermöglichen. Diese Remote-Backend-Konfiguration ermöglicht es allen Teammitgliedern, mit einer einheitlichen Sicht auf die Infrastruktur zu arbeiten. 

State Locking, eine Funktion, die von vielen Remote-Backends wie Azure Blob Storage automatisch bereitgestellt wird, verhindert Konflikte, wenn mehrere Teammitglieder versuchen, Terraform-Befehle gleichzeitig auszuführen, und gewährleistet so die Datenintegrität.

Hier ist ein Beispiel für die Konfiguration eines Azure Blob Storage Backends:

terraform {
  backend "azurerm" {
    resource_group_name  = "my-terraform-state-rg"
    storage_account_name = "mystorageterraformstate"
    container_name  = "tfstate"
    key  = "production/terraform.tfstate" # Path within the container
  }
}

Bevor du terraform init mit dieser Konfiguration ausführst, musst du das Azure-Speicherkonto und den Container manuell oder über eine separate Terraform-Konfiguration erstellen. Diese Einrichtung gewährleistet eine sichere, kollaborative Verwaltung von Azure-Ressourcen.

Anbieter-Ökosystem und AzureRM

Der azurerm-Anbieter istdie Brücke von Terraformzu Azure und übersetzt HCL in API-Aufrufe, um Dienste wie VMs, Netzwerke und Datenbanken zu verwalten.

Sie unterstützt Hunderte von Ressourcentypen, von Compute (azurerm_linux_virtual_machine, azurerm_windows_virtual_machine) bis zu Analytics (azurerm_synapse_workspace). Einige seiner Funktionen sind:

• Breite Abdeckung: Verwalte eine breite Palette von Azure-Diensten, darunter virtuelle Maschinen, Speicherkonten, Azure Kubernetes Service (AKS), Azure SQL Database, Azure Cosmos DB mit MongoDB API, Azure Functions und vieles mehr. Der Anbieter azurerm wird aktiv weiterentwickelt, um neue Azure-Dienste und -Funktionen zu unterstützen, sobald sie verfügbar werden.
• Dynamische Funktionen: Verwende anbieterdefinierte Funktionen, um eindeutige Namen zu generieren (z. B. azurerm_resource_group.example.name) oder Details über vorhandene Ressourcen abzurufen (z. B. data.azurerm_virtual_network.existing.id). Dies ermöglicht dynamischere und intelligentere Konfigurationen.
• Datenquellen: Der Anbieter azurerm nutzt Datenquellen, um Informationen über vorhandene Azure-Ressourcen abzurufen. Dies ist besonders nützlich, wenn du Ressourcen referenzieren musst, die nicht von deiner aktuellen Terraform-Konfiguration bereitgestellt wurden. Du kannst zum Beispiel die Details eines bestehenden virtuellen Netzwerks abrufen, um neue Subnetze oder virtuelle Maschinen einzusetzen, ohne das VNet neu zu erstellen.

Bevor du dich mit Terraform beschäftigst, ist es hilfreich zu wissen, wie duAzure manuell konfigurierst.

Einrichten einer Terraform-Azure Umgebung

Packen wir's an! Dieser Abschnitt führt dich durch die Ersteinrichtung, die für die Nutzung von Terraform mit deinem Azure-Abonnement erforderlich ist.

Authentifizierung und CLI-Tools

Um mit Azure zu interagieren, musst du zunächstdas Azure Command Line Interface (CLI) installieren und konfigurieren. Das Azure CLI pstellt die notwendigen Tools für die Authentifizierung und Verwaltung deiner Azure-Ressourcen bereit. Nach der Installation loggst du dich in dein Azure-Konto ein:

az login

Der obige Befehl öffnet ein Browserfenster für die interaktive Authentifizierung. Für eine schnellek Referenz kann dieser Azure CLI-Spickzetteldeine Befehlszeilen-Workflows rationalisieren.

Für automatisierte Verteilungen mit Terraform, insbesondere in CI/CD-Pipelines, wird dringend empfohlen, Azure Active Directory (AAD) Service Principals zu erstellen und zu verwenden. Service Principals bieten einen sicheren und programmatischen Weg für Terraform, sich bei deiner Azure Subskription zu authentifizieren, ohne dass interaktive Logins erforderlich sind.

Um einen Dienstprinzipal mit der Rolle "Mitwirkender" im Abonnementbereich zu erstellen, führe aus:

az ad sp create-for-rbac --name "http://myTerraformServicePrincipal" --role "Contributor" --scopes "/subscriptions/<your-subscription-id>"

Die Ausgabe liefert appId, password und tenant (Mieter-ID). Diese kannst du dann als Umgebungsvariablen für Terraform setzen:

export ARM_CLIENT_ID="<appId>"
export ARM_CLIENT_SECRET="<password>"
export ARM_TENANT_ID="<tenant>"
export ARM_SUBSCRIPTION_ID="<your-subscription-id>"

Ein Projekt initialisieren

Ein typisches Terraform-Projekt folgt einem strukturierten Verzeichnisaufbau, oft mit separaten .tf Dateien für verschiedene Ressourcentypen oder Module (z.B. main.tf, variables.tf, outputs.tf, network.tf, compute.tf). 

Um ein Terraform-Projekt zu starten, navigiere zu deinem Projektverzeichnis und führe den Befehl terraform init aus. Dieser Befehl initialisiert das Arbeitsverzeichnis, lädt die notwendigen Provider-Plugins (wie azurerm) herunter und richtet das Backend für die Zustandsverwaltung ein, wie in deiner Konfiguration festgelegt.

mkdir my-azure-terraform-project
cd my-azure-terraform-project
# Create your .tf files here
terraform init

Dieser Befehl bereitet dein Verzeichnis für die Terraform-Operationen vor und stellt sicher, dass alle erforderlichen Plugins vorhanden sind.

Bereitstellung von Azure-Ressourcen

In diesem Abschnitt findest du praktische Beispiele für die Bereitstellung gängiger Azure-Ressourcen mit Terraform, die dir zeigen, wie du sie programmatisch definieren und einsetzen kannst.

Virtuelle Netzwerke und Subnetze

Terraform eignet sich hervorragend für die Definition und den Einsatz der Netzwerkinfrastruktur auf Azure. Du kannst ganz einfach virtuelle Netzwerke (VNets) definieren und sie in Subnetze unterteilen, um IP-Adressräume und Netzwerkisolierung zu kontrollieren. 

Das Terraform-eigene Abhängigkeitsmanagement stellt sicher, dass die Ressourcen in der richtigen Reihenfolge erstellt werden. So werden zum Beispiel Subnetze erst dann bereitgestellt, wenn ihr übergeordnetes VNet erfolgreich erstellt wurde. Hier ist ein Beispiel:

resource "azurerm_resource_group" "network_rg" {
  name     = "my-network-rg"
  location = "East US"
}

resource "azurerm_virtual_network" "main_vnet" {
  name                = "my-vnet"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name
}

resource "azurerm_subnet" "web_subnet" {
  name                 = "web-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_subnet" "app_subnet" {
  name                 = "app-subnet"
  resource_group_name  = azurerm_resource_group.network_rg.name
  virtual_network_name = azurerm_virtual_network.main_vnet.name
  address_prefixes     = ["10.0.2.0/24"]
}

Virtuelle Maschinen mit Cloud-init

Die Bereitstellung von virtuellen Maschinen (VMs) mit Terraform ist ganz einfach. Um die Konfiguration nach der Bereitstellung und die Ersteinrichtung zu automatisieren, kannst du die Skripte von cloud-init nutzen. 

cloud-init ermöglicht es dir, Skripte einzubinden, die beim ersten Start der VM ausgeführt werden und Aufgaben wie die Installation von Software, die Konfiguration von Nutzern oder die Einrichtung von Diensten direkt von deiner Terraform-Konfiguration aus ermöglichen.

Hier ist ein Beispiel für die Bereitstellung einer Linux-VM mit einem einfachen cloud-init Skript zur Installation von Nginx:

resource "azurerm_resource_group" "vm_rg" {
  name     = "my-vm-rg"
  location = "East US"
}

resource "azurerm_network_interface" "vm_nic" {
  name                = "my-vm-nic"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id # Assuming web_subnet defined above
    private_ip_address_allocation = "Dynamic"
    public_ip_address_id          = azurerm_public_ip.vm_public_ip.id
  }
}

resource "azurerm_public_ip" "vm_public_ip" {
  name                = "my-vm-public-ip"
  location            = azurerm_resource_group.vm_rg.location
  resource_group_name = azurerm_resource_group.vm_rg.name
  allocation_method   = "Static"
}

resource "azurerm_linux_virtual_machine" "my_vm" {
  name                  = "my-linux-vm"
  location              = azurerm_resource_group.vm_rg.location
  resource_group_name   = azurerm_resource_group.vm_rg.name
  size                  = "Standard_B2s"
  admin_username        = "azureuser"
  admin_password        = "P@ssw0rd1234!" # In a real scenario, use Azure Key Vault or variables
  network_interface_ids = [azurerm_network_interface.vm_nic.id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }

  # cloud-init script to install Nginx
  custom_data = base64encode(<<EOF
#cloud-config
packages:
  - nginx
runcmd:
  - systemctl start nginx
  - systemctl enable nginx
EOF
  )
}

Modularisierung der Infrastruktur

Wenn deine Azure-Infrastruktur wächst, wird die Modularisierung deiner Terraform-Konfigurationen für Wiederverwendbarkeit, Wartbarkeit und Skalierbarkeit entscheidend. 

Module kapseln eine Reihe von zusammenhängenden Ressourcen und deren Konfigurationen in wiederverwendbaren Einheiten. In diesem Abschnitt findest du eine Anleitung, wie du deinen Terraform-Code in Module unterteilst und wie du diese Module in deinen Hauptkonfigurationen aufrufst, um eine saubere und organisierte Codebasis zu schaffen.

Beispiel: Modulstruktur (modules/web-app/main.tf):

# modules/web-app/main.tf
resource "azurerm_app_service_plan" "app_plan" {
  name                = var.app_service_plan_name
  location            = var.location
  resource_group_name = var.resource_group_name
  kind                = "Linux"
  sku {
    tier = "Basic"
    size = "B1"
  }
}

resource "azurerm_app_service" "app_service" {
  name                = var.app_service_name
  location            = var.location
  resource_group_name = var.resource_group_name
  app_service_plan_id = azurerm_app_service_plan.app_plan.id
}

variable "app_service_plan_name" {
  type = string
}

variable "app_service_name" {
  type = string
}

variable "location" {
  type = string
}

variable "resource_group_name" {
  type = string
}

output "app_service_default_hostname" {
  value = azurerm_app_service.app_service.default_host_name
}

Beispiel: Aufrufen des Moduls (main.tf im Stammverzeichnis):

resource "azurerm_resource_group" "app_rg" {
  name     = "my-webapp-rg"
  location = "East US"
}

module "my_web_app" {
  source                = "./modules/web-app" # Path to your module
  app_service_plan_name = "my-webapp-plan"
  app_service_name      = "my-unique-webapp-2025"
  location              = azurerm_resource_group.app_rg.location
  resource_group_name   = azurerm_resource_group.app_rg.name
}

output "webapp_url" {
  value = module.my_web_app.app_service_default_hostname
}

Diese Struktur macht es einfach, die Logik für die Bereitstellung deiner Webanwendung in verschiedenen Umgebungen oder Projekten wiederzuverwenden.

Erweiterte Terraform Workflows

In diesem Abschnitt werden komplexere Terraform-Funktionen vorgestellt, die die Flexibilität und Leistungsfähigkeit deiner Infrastruktur verbessern und über die grundlegende Ressourcenbereitstellung hinausgehen.

Datenquellen und dynamische Konfigurationen

Mit den Datenquellen in Terraform kannst du Informationen über vorhandene Ressourcen abrufen, sowohl über die von Terraform verwalteten als auch über die nicht verwalteten. Das ist unglaublich nützlich für die Integration in eine bereits bestehende Infrastruktur oder für dynamische Abfragen. 

In Verbindung mit dynamischen Konfigurationen (wie for_each und count) ermöglichen die Datenquellen hochflexible und anpassungsfähige Terraform-Skripte, die auf verschiedene Bedingungen und die Verfügbarkeit von Ressourcen reagieren können.

Beispiel: Verwenden einer Datenquelle, um ein bestehendes VNet zu finden und ein neues Subnetz hinzuzufügen:

# Data source to fetch an existing Virtual Network
data "azurerm_virtual_network" "existing_vnet" {
  name                = "production-vnet"
  resource_group_name = "production-network-rg"
}

# Create a new subnet within the existing VNet
resource "azurerm_subnet" "new_app_subnet" {
  name                 = "new-app-subnet"
  resource_group_name  = data.azurerm_virtual_network.existing_vnet.resource_group_name
  virtual_network_name = data.azurerm_virtual_network.existing_vnet.name
  address_prefixes     = ["10.0.3.0/24"]
}

Beispiel: Dynamische Erstellung mehrerer VMs mit for_each und einer Map-Variable:

variable "vm_configs" {
  type = map(object({
    size = string
    ip   = string
  }))
  default = {
    "web-server-01" = { size = "Standard_B1s", ip = "10.0.1.10" },
    "web-server-02" = { size = "Standard_B1s", ip = "10.0.1.11" }
  }
}

resource "azurerm_linux_virtual_machine" "web_servers" {
  for_each              = var.vm_configs
  name                  = each.key
  location              = azurerm_resource_group.main_rg.location
  resource_group_name   = azurerm_resource_group.main_rg.name
  size                  = each.value.size
  admin_username        = "azureuser"
  admin_password        = "StrongPassword!123" # Use Key Vault in production
  network_interface_ids = [azurerm_network_interface.web_servers_nic[each.key].id]

  os_disk {
    caching              = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "UbuntuServer"
    sku       = "18.04-LTS"
    version   = "latest"
  }
}

resource "azurerm_network_interface" "web_servers_nic" {
  for_each            = var.vm_configs
  name                = "${each.key}-nic"
  location            = azurerm_resource_group.main_rg.location
  resource_group_name = azurerm_resource_group.main_rg.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.web_subnet.id
    private_ip_address_allocation = "Static"
    private_ip_address            = each.value.ip
  }
}

Politik als Code mit Sentinel

Für Unternehmen, die strenge Compliance- und Governance-Anforderungen haben, bietet HashiCorp Sentinel ein Policy-as-Code-Framework, das sich in Terraform Enterprise integrieren lässt (oder für die individuelle Nutzung mit Terraform Cloud angepasst werden kann). 

Mit Sentinel können Sie detaillierte Richtlinien definieren, die Sicherheit, Kosten und betriebliche Best Practices durchsetzen bevor Infrastruktur bereitgestellt wird.

Eine Richtlinie könnte zum Beispiel die Erstellung von VMs verhindern, die größer als eine bestimmte Größe sind, oder sicherstellen, dass alle Ressourcen bestimmte Tags haben. Vorgefertigte Richtlinien können Compliance-Standards durchsetzen und verhindern, dass nicht konforme Implementierungen deine Azure-Umgebung erreichen.

Strategien zur Kostenoptimierung

Terraform kann in Verbindung mit Azure Policy ein mächtiges Werkzeug sein, um die Kostenkontrolle in deiner Azure-Umgebung durchzusetzen. 

Indem du Azure-Richtlinien definierst, die Ressourcen-SKUs einschränken, Tagging für die Kostenzuweisung erzwingen oder den Einsatz teurer Ressourcen verhindern, kannst du direkt in deinen IaC-Workflows wirksame Sparmaßnahmen umsetzen. 

Terraform kann auch Azure Policies bereitstellen und verwalten und so sicherstellen, dass deine Governance-Regeln versionskontrolliert sind und konsequent angewendet werden.

Beispiel: Bereitstellung einer Azure Policy Definition mit Terraform:

resource "azurerm_resource_group" "policy_rg" {
  name     = "azure-policy-rg"
  location = "global" # Policies are global resources
}

resource "azurerm_policy_definition" "deny_large_vms" {
  name         = "deny-large-vm-skus"
  policy_type  = "Custom"
  mode         = "All"
  display_name = "Deny creation of large VM SKUs (E-series)"
  description  = "This policy denies the creation of Azure Virtual Machines with SKUs from the E-series for cost management."

  policy_rule = <<POLICY_RULE
{
  "if": {
    "allOf": [
      {
        "field": "type",
        "equals": "Microsoft.Compute/virtualMachines"
      },
      {
        "field": "Microsoft.Compute/virtualMachines/sku.name",
        "like": "Standard_E*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}
POLICY_RULE
}

resource "azurerm_policy_assignment" "deny_large_vms_assignment" {
  name                 = "deny-large-vm-skus-assignment"
  scope                = "/subscriptions/${data.azurerm_subscription.current.id}" # Assign to entire subscription
  policy_definition_id = azurerm_policy_definition.deny_large_vms.id
  display_name         = "Deny large VM SKUs"
}

data "azurerm_subscription" "current" {}

Diese Kombination ermöglicht es dir, organisatorische Kostenrichtlinien automatisch durchzusetzen, um übermäßige Ausgaben zu verhindern und die Ressourceneffizienz zu fördern.

CI/CD-Integration

In diesem Abschnitt geht es um die Integration von Terraform in deine Continuous Integration/Continuous Delivery (CI/CD)-Pipelines für automatisierte und zuverlässige Deployments, damit Infrastrukturänderungen nahtlos in den Lebenszyklus deiner Softwareentwicklung integriert werden können.

Azure DevOps Pipelines

Azure DevOps bietet eine robuste Plattform für den Aufbau von CI/CD-Pipelines. Ein üblicher Arbeitsablauf beinhaltet:

1. Initialisieren: terraform init um Anbieter herunterzuladen und das Backend einzurichten.
2. Plan: terraform plan -out um einen Ausführungsplan zu erstellen und ihn zu speichern.
3. Überprüfung (manuelle Genehmigung): Ein Stadium, in dem der erstellte Plan vor der Anwendung von einem Menschen zur Genehmigung geprüft wird.
4. Anwenden: terraform apply tfplan um die Änderungen auszuführen.

In diesem praktischen Tutorialerfährst du, wie Azure DevOps durchgängige CI/CD-Workflows für die Anwendungsbereitstellung unterstützt.

GitHub-Aktionen

GitHub Actions bietet eine flexible und leistungsstarke Möglichkeit, deine Terraform Workflows direkt in deinen GitHub Repositories zu automatisieren. Es verwendet YAML-Dateien, um Workflows zu definieren, die auf Ereignisse wie Push- oder Pull-Anfragen reagieren.

Hier sind die Schritte für eine einfache Terraform-Bereitstellung mit GitHub Actions:

1. Definiere den Workflow-Auslöser: Normalerweise on: push zu einem bestimmten Zweig (z.B. main).
2. Checkout Code: Verwende actions/checkout@v3.
3. Konfiguriere die Azure-Anmeldedaten: Richte Umgebungsvariablen mit GitHub Secrets ein (z.B. AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID, AZURE_SUBSCRIPTION_ID).
4. Installiere Terraform: Verwende hashicorp/setup-terraform@v2.
5. Terraform init: Initialisiere das Arbeitsverzeichnis.
6. Terraforme den Plan: Erstelle den Ausführungsplan und gib ihn aus.
7. Terraform anwenden (bedingt): Änderungen anwenden, oft in Abhängigkeit von einem manuellen Genehmigungsschritt oder einem bestimmten Zweig.

Beispiel: YAML für einen GitHub Actions Workflow (.github/workflows/terraform-azure.yml):

name: 'Terraform Azure CI/CD'

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

env:
  ARM_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
  ARM_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
  ARM_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
  ARM_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  TF_STATE_RG: 'my-terraform-state-rg'
  TF_STATE_SA: 'mystorageterraformstate'
  TF_STATE_CONTAINER: 'tfstate'
  TF_STATE_KEY: 'production/terraform.tfstate'

jobs:
  terraform:
    name: 'Terraform Actions'
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: './terraform' # Assuming Terraform files are in a 'terraform' folder

    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Setup Terraform
        uses: hashicorp/setup-terraform@v2
      - name: Terraform Init
        id: init
        run: terraform init -backend-config="resource_group_name=${{ env.TF_STATE_RG }}" -backend-config="storage_account_name=${{ env.TF_STATE_SA }}" -backend-config="container_name=${{ env.TF_STATE_CONTAINER }}" -backend-config="key=${{ env.TF_STATE_KEY }}"
      - name: Terraform Plan
        id: plan
        run: terraform plan -no-color
      - name: Terraform Apply
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
        run: terraform apply -auto-approve

Sicherheit und Compliance

In diesem Abschnitt werden Sicherheits- und Compliance-Überlegungen bei der Arbeit mit Terraform auf Azure hervorgehoben, wobei der Schwerpunkt auf sicheren Praktiken für sensible Daten und den Netzwerkzugang liegt.

Azure Key Vault Integration

Die Verwaltung sensibler Daten wie API-Schlüssel, Verbindungsstrings, Datenbankanmeldeinformationen und Zertifikate in deinen Terraform-Konfigurationen kann riskant sein, wenn sie nicht richtig gehandhabt wird. Azure Key Vault bietet eine sichere, zentralisierte Lösung für die Speicherung und Verwaltung von Geheimnissen, Schlüsseln und Zertifikaten. 

Beispiel: Abrufen eines Datenbankpassworts aus dem Key Vault:

# Data source to retrieve an existing Azure Key Vault
data "azurerm_key_vault" "my_key_vault" {
  name                = "my-secure-keyvault"
  resource_group_name = "my-secrets-rg"
}

# Data source to retrieve a specific secret from the Key Vault
data "azurerm_key_vault_secret" "db_password" {
  name         = "DbPassword"
  key_vault_id = data.azurerm_key_vault.my_key_vault.id
}

resource "azurerm_sql_server" "example" {
  administrator_login          = "sqladmin"
  administrator_login_password = data.azurerm_key_vault_secret.db_password.value # Securely retrieve password
}

Diese Methode stellt sicher, dass sensible Daten niemals direkt im Terraform-Code oder in der Statusdatei offengelegt werden, um die besten Sicherheitsverfahren einzuhalten.

Netzwerksicherheitsgruppen (NSGs)

Netzwerksicherheitsgruppen (NSGs) sind die Grundlage für die Durchsetzung von Verkehrsregeln und die Sicherung deiner virtuellen Azure-Netzwerke. Sie fungieren als virtuelle Firewall, die den ein- und ausgehenden Netzwerkverkehr zu deinen Azure-Ressourcen auf der Grundlage von Regeln, die du definierst, zulässt oder ablehnt.

Beispiel: Konfigurieren eines NSG für eine Webanwendung:

resource "azurerm_network_security_group" "web_nsg" {
  name                = "web-nsg"
  location            = azurerm_resource_group.network_rg.location
  resource_group_name = azurerm_resource_group.network_rg.name

  security_rule {
    name                       = "AllowHTTPInbound"
    priority                   = 100
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "80"
    source_address_prefix      = "Internet"
    destination_address_prefix = "*"
  }
  security_rule {
    name                       = "AllowSSHInbound"
    priority                   = 120
    direction                  = "Inbound"
    access                     = "Allow"
    protocol                   = "Tcp"
    source_port_range          = "*"
    destination_port_range     = "22"
    source_address_prefix      = "YourTrustedIPRange" # IMPORTANT: Restrict to known IPs
    destination_address_prefix = "*"
  }
}

# Associate NSG with a subnet 
resource "azurerm_subnet_network_security_group_association" "web_subnet_nsg_association" {
  subnet_id                 = azurerm_subnet.web_subnet.id
  network_security_group_id = azurerm_network_security_group.web_nsg.id
}

Best Practices für den Einsatz in Unternehmen

Dieser Abschnitt beschreibt die wichtigsten Best Practices für den Einsatz und die Verwaltung von Terraform in einer Unternehmensumgebung und konzentriert sich dabei auf Design, Wartung und Überwachung.

Referenzarchitekturen

Für robuste und effiziente Azure-Implementierungen solltest du deine Terraform-Konfigurationenmit dem Azure Well-Architected Frameworkabstimmen. DiesesFramework bietet Blaupausen für die Entwicklung hochwertiger, sicherer und kosteneffizienter Cloud-Lösungen, die deine Terraform-Entwürfe in Bezug auf Zuverlässigkeit, Sicherheit, Kostenoptimierung, betriebliche Exzellenz und Leistungseffizienz steuern.

Staatliche Datei Hygiene

Die Terraform-Statusdatei ist die einzige Quelle der Wahrheit für deine Infrastruktur. Stelle seine Integrität und Sicherheit sicher, indem du:

• Fernlagerung: Verwende immer ein Remote-Backend wie Azure Blob Storage für kollaboratives Statusmanagement.
• Verschlüsselung und Zugangskontrolle: Vergewissere dich, dass dein Remote-Status im Ruhezustand verschlüsselt ist und wende strenge Azure RBAC an, um den Zugriff zu beschränken.
• State Locking und Versionierung: Nutze das eingebaute State Locking, um Konflikte zu vermeiden, und aktiviere die Versionierung deines Speichercontainers für die historische Nachverfolgung und Wiederherstellung.

Überwachung und Drifterkennung

Halte die Konsistenz der Infrastruktur aufrecht, indem du aktiv auf "Konfigurationsdrift" achtest - unerlaubte Abweichungen von deinem definierten Terraform-Status.

• Proaktive Erkennung: Implementiere regelmäßige terraform plan Läufe innerhalb deiner CI/CD-Pipelines (z.B. nachts), um Änderungen zu erkennen.
• Azure Überwachung: Nutze Azure Monitor und Log Analytics, um den Zustand der Ressourcen und Ereignisse zu verfolgen.
• Automatisierte Abhilfe: Entwickle (manuelle oder automatisierte) Prozesse, um terraform apply erneut auszuführen, um abgewanderte Ressourcen wieder in Übereinstimmung mit deinen IaC zu bringen.

Um deine Infrastruktur weiter zu überwachen und zu optimieren, bietet Azure Monitor wertvolle Einblicke - dieserLeitfaden zeigt dir, wie du loslegen kannst.

Fazit

Und das war's dann auch schon! Inzwischen hast du gesehen, wie Terraform die Verwaltung von Azure-Ressourcen viel effizienter und berechenbarer machen kann. Wir haben uns angesehen, wie du mit CI/CD-Tools wie Azure DevOps und GitHub Actions Automatisierung in deinen Arbeitsablauf bringst und wie du mit Funktionen wie Azure Key Vault und Netzwerksicherheitsgruppen für Sicherheit sorgst.

Wir haben auch einige wichtige Best Practices angesprochen - wie die Verwendung von Referenzarchitekturen, die sorgfältige Verwaltung von Zustandsdateien und die Überwachung von Änderungen durch Monitoring und Drifterkennung.

Mit diesen Tools und Tipps bist du auf dem besten Weg, eine zuverlässige und skalierbare Infrastruktur auf Azure aufzubauen.

Willst du deine Fähigkeiten unter Beweis stellen? Diese Terraform-Interview-Fragen können dir bei der Vorbereitung auf Stellenangebote oder Zertifizierungen helfen!