Infrastructure as Code mit Terraform und Ansible

Die Verwaltung von Infrastruktur als Code (IaC) hat die Art und Weise, wie wir Cloud-Ressourcen bereitstellen und konfigurieren, revolutioniert. In diesem Artikel tauchen wir tief in die Welt von Terraform und Ansible ein und zeigen, wie man beide Tools effektiv kombinieren kann.

Was ist Infrastructure as Code?

Infrastructure as Code ist ein Ansatz zur Automatisierung der Infrastruktur, bei dem dieselben Versionskontroll- und CI/CD-Praktiken verwendet werden, die auch für die Softwareentwicklung üblich sind.

Vorteile von IaC:

• Konsistenz: Eliminiert Abweichungen zwischen Umgebungen
• Wiederholbarkeit: Identische Bereitstellungen, jedes Mal
• Versionierung: Vollständiger Änderungsverlauf der Infrastruktur
• Selbstdokumentation: Der Code beschreibt die Infrastruktur
• Skalierbarkeit: Einfache Replikation für mehrere Umgebungen

Terraform: Infrastruktur deklarativ definieren

Terraform ist ein Open-Source-Tool von HashiCorp für die deklarative Infrastrukturdefinition. Es unterstützt eine Vielzahl von Providern wie AWS, Azure, GCP, und mehr.

Grundlegende Terraform-Struktur

# provider.tf
provider "aws" {
  region = "eu-central-1"
}

# variables.tf
variable "instance_type" {
  description = "EC2 instance type"
  default     = "t2.micro"
}

# main.tf
resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = var.instance_type
  
  tags = {
    Name = "WebServer"
    Environment = "Production"
  }
}

# outputs.tf
output "instance_ip" {
  value = aws_instance.web_server.public_ip
}

Terraform-Workflow

# Initialisieren
terraform init

# Plan anzeigen
terraform plan

# Anwenden
terraform apply

# Zerstören
terraform destroy

Terraform-Module

Module sind wiederverwendbare Terraform-Konfigurationen:

module "vpc" {
  source = "./modules/vpc"
  
  name = "production-vpc"
  cidr = "10.0.0.0/16"
  azs  = ["eu-central-1a", "eu-central-1b", "eu-central-1c"]
}

Ansible: Konfigurationsmanagement und Orchestrierung

Während Terraform sich hervorragend für die Bereitstellung von Infrastruktur eignet, glänzt Ansible bei der Konfiguration von Servern und Anwendungen.

Ansible-Playbook Beispiel

---
- name: Configure web server
  hosts: web_servers
  become: true
  
  vars:
    http_port: 80
    
  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present
        
    - name: Start Nginx service
      service:
        name: nginx
        state: started
        enabled: yes
        
    - name: Deploy website content
      template:
        src: templates/index.html.j2
        dest: /var/www/html/index.html
      notify: Reload Nginx
      
  handlers:
    - name: Reload Nginx
      service:
        name: nginx
        state: reloaded

Terraform und Ansible zusammen nutzen

Die Kombination beider Tools nutzt ihre jeweiligen Stärken:

1. Terraform erstellt die Infrastruktur (VMs, Netzwerke, etc.)
2. Ansible konfiguriert die bereitgestellten Ressourcen (Software, Dienste, etc.)

Integration mit Terraform-Provisioners

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  
  provisioner "local-exec" {
    command = "ANSIBLE_HOST_KEY_CHECKING=False ansible-playbook -i '${self.public_ip},' playbook.yml"
  }
}

Dynamisches Ansible-Inventar aus Terraform

# terraform-inventory.py - generiert dynamisches Ansible-Inventar aus Terraform-Output
terraform output -json | jq -r '.instance_ips.value | to_entries | .[] | "web_server_\(.key) ansible_host=\(.value)"'

Best Practices für IaC

1. State-Management

Terraform-State sollte entfernt gespeichert werden:

terraform {
  backend "s3" {
    bucket = "my-terraform-state"
    key    = "production/terraform.tfstate"
    region = "eu-central-1"
    encrypt = true
  }
}

2. Umgebungsspezifische Konfiguration

Verwende Terraform-Workspaces oder separate Verzeichnisse für verschiedene Umgebungen:

terraform workspace new production
terraform workspace select production
terraform apply -var-file=production.tfvars

3. Geheimnismanagement

Verwende externe Geheimnisverwaltungslösungen:

data "vault_generic_secret" "db_credentials" {
  path = "secret/database"
}

resource "aws_db_instance" "default" {
  username = data.vault_generic_secret.db_credentials.data.username
  password = data.vault_generic_secret.db_credentials.data.password
  # ...
}

CI/CD für Infrastructure as Code

Ein Beispiel-Pipeline für Terraform in GitLab CI:

stages:
  - validate
  - plan
  - apply

terraform:validate:
  stage: validate
  script:
    - terraform init
    - terraform validate

terraform:plan:
  stage: plan
  script:
    - terraform init
    - terraform plan -out=tfplan
  artifacts:
    paths:
      - tfplan

terraform:apply:
  stage: apply
  script:
    - terraform init
    - terraform apply -auto-approve tfplan
  dependencies:
    - terraform:plan
  when: manual
  only:
    - main

Abschließende Gedanken

Die Kombination von Terraform und Ansible bietet einen leistungsfähigen Ansatz zur Verwaltung der gesamten Infrastruktur als Code. Terraform übernimmt die Bereitstellung und Ansible kümmert sich um die Konfiguration, was zu einer vollständig automatisierten, reproduzierbaren Infrastruktur führt.

Diese Werkzeuge zusammen mit Best Practices wie Versionskontrolle, CI/CD und Geheimnisverwaltung bilden die Grundlage für moderne DevOps-Praktiken und ermöglichen es Teams, Infrastruktur mit der gleichen Agilität zu verwalten wie Anwendungscode.

Welche IaC-Tools verwendest du? Hast du Erfahrung mit Terraform und Ansible? Teile deine Gedanken in den Kommentaren!