PostgreSQL auf AWS mit Terraform automatisiert bereitstellen

Die Bereitstellung einer relationalen Datenbank in der Cloud gehört zu den Kernaufgaben moderner Softwareentwicklung. Mit Amazon RDS (Relational Database Service) können Entwickler eine verwaltete PostgreSQL-Instanz ohne manuelle Konfiguration von Servern oder Betriebssystemen einrichten. Doch wie lässt sich dieser Prozess automatisieren?

Die Antwort liegt in Terraform, einem Infrastructure-as-Code-Tool, das die Erstellung und Verwaltung von Cloud-Ressourcen in deklarativer Syntax ermöglicht. In diesem Leitfaden erfahren Sie, wie Sie eine PostgreSQL-Datenbank auf AWS RDS mit Terraform provisionieren – von der Netzwerkkonfiguration bis zur Sicherheitsgruppe.

Warum eine verwaltete PostgreSQL-Datenbank in AWS RDS?

PostgreSQL ist eine der beliebtesten Open-Source-Relational-Datenbanken und bietet:

• ACID-konforme Transaktionen für Datenintegrität
• Erweiterte SQL-Unterstützung mit komplexen Abfragen und Joins
• Hohe Skalierbarkeit durch vertikale und horizontale Erweiterung
• Automatisierte Backups und Failover-Mechanismen (in Produktionsumgebungen)

AWS RDS übernimmt dabei den Großteil der administrativen Aufgaben wie Patch-Management, Backups und Monitoring. Terraform ermöglicht es, diese Infrastruktur als Code zu definieren und reproduzierbar bereitzustellen – ideal für Entwicklung, Test und Produktion.

Schritt 1: Terraform-Modul für PostgreSQL-Datenbank erstellen

Zuerst legen Sie ein neues Terraform-Modul für die RDS-Datenbank an. Erstellen Sie dazu einen Ordner modules/rds und fügen Sie folgende Dateien hinzu:

# modules/rds/main.tf

resource "aws_db_instance" "postgres" {
  identifier             = "postgres-db"
  engine                 = "postgres"
  engine_version         = "15"
  instance_class         = "db.t3.micro"
  allocated_storage      = 20
  storage_type           = "gp2"
  skip_final_snapshot    = true
  publicly_accessible    = true
  username               = var.database_username
  password               = var.database_password
  db_name                = var.database_name
  vpc_security_group_ids = [aws_security_group.rds_sg.id]
  db_subnet_group_name   = aws_db_subnet_group.default.name
}

Wichtige Parameter im Detail:

• `instance_class`: Die Instanzklasse db.t3.micro ist kostengünstig und eignet sich für Entwicklungs- und Testumgebungen. Für Produktionslasten sollten Sie größere Klassen wie db.m5.large wählen.
• `allocated_storage`: Standardmäßig sind 20 GB Speicherplatz reserviert. Dieser Wert lässt sich später anpassen.
• `skip_final_snapshot`: Bei true wird kein finales Snapshot vor der Löschung erstellt – praktisch für Testumgebungen, aber nicht für Produktionssysteme empfohlen.
• `publicly_accessible`: Die Datenbank erhält eine öffentliche IP-Adresse. Dies ist für Tests nützlich, sollte in Produktionsumgebungen jedoch über false deaktiviert werden.

Schritt 2: Variablen für dynamische Konfiguration definieren

Um sensible Daten wie Benutzername und Passwort nicht hartkodiert zu hinterlegen, nutzen Sie Variablen. Erstellen Sie die Datei modules/rds/variables.tf:

# modules/rds/variables.tf

variable "database_name" {
  type        = string
  description = "Name der PostgreSQL-Datenbank"
}

variable "database_username" {
  type        = string
  description = "Administrativer Datenbankbenutzer"
}

variable "database_password" {
  type        = string
  sensitive   = true
  description = "Sicheres Passwort für die Datenbank"
}

variable "subnet_ids" {
  type        = list(string)
  description = "Liste der Subnetz-IDs für die Datenbank"
}

variable "vpc_id" {
  type        = string
  description = "ID des VPC, in dem die Datenbank bereitgestellt wird"
}

Tipp zur Passwortverwaltung:

Nutzen Sie Terraform-Variablendateien (z. B. terraform.tfvars) oder AWS Secrets Manager, um Passwörter sicher zu hinterlegen. Vermeiden Sie die Speicherung in Versionskontrollsystemen wie Git.

Schritt 3: Sicherheitsgruppe für den Datenbankzugriff konfigurieren

Eine Sicherheitsgruppe steuert den Netzwerkverkehr zur Datenbank. Erstellen Sie in modules/rds/main.tf eine Regel für den PostgreSQL-Standardport 5432:

# modules/rds/main.tf

resource "aws_security_group" "rds_sg" {
  name        = "rds-postgres-sg"
  description = "Erlaubt Zugriff auf PostgreSQL-Port 5432"
  vpc_id      = var.vpc_id

  ingress {
    from_port   = 5432
    to_port     = 5432
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"] # In Produktionsumgebungen einschränken!
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

Sicherheitshinweis:

Die Regel cidr_blocks = ["0.0.0.0/0"] erlaubt Verbindungen von jedem IP-Adressbereich. In Produktionsumgebungen sollten Sie dies auf vertrauenswürdige IP-Ranges oder VPNs einschränken.

Schritt 4: Subnetzgruppe für Hochverfügbarkeit erstellen

AWS RDS erfordert eine Subnetzgruppe mit mindestens zwei Subnetzen in unterschiedlichen Availability Zones (AZs) für Failover-Unterstützung. Nutzen Sie bestehende Subnetze oder erstellen Sie neue:

# modules/rds/main.tf

resource "aws_db_subnet_group" "default" {
  name       = "rds-subnet-group"
  subnet_ids = var.subnet_ids
  tags = {
    Name = "Subnetzgruppe für PostgreSQL-RDS"
  }
}

Diese Gruppe wird später der Datenbankinstanz zugewiesen und ermöglicht automatische Failover-Mechanismen.

Schritt 5: Modul in der Hauptkonfiguration einbinden

Im Haupt-Terraform-Projekt (main.tf) integrieren Sie das RDS-Modul wie folgt:

# main.tf

module "rds" {
  source               = "./modules/rds"
  database_name        = "my_app_db"
  database_username    = "db_admin"
  database_password    = var.db_password # Aus terraform.tfvars
  subnet_ids           = module.network.private_subnet_ids # Für Produktion
  vpc_id               = module.network.vpc_id
}

Unterschiede zwischen Entwicklung und Produktion:

• Entwicklung: Nutzen Sie öffentliche Subnetze und skip_final_snapshot = true.
• Produktion: Verwenden Sie private Subnetze und aktivieren Sie finale Snapshots für Backups.

Schritt 6: Ausgaben für die Verbindung konfigurieren

Damit Sie die Datenbankverbindung nutzen können, fügen Sie in outputs.tf folgende Ausgaben hinzu:

# outputs.tf

output "database_endpoint" {
  value       = module.rds.database_endpoint
  description = "Endpunkt der PostgreSQL-Datenbank für Verbindungen"
}

output "database_port" {
  value       = 5432
  description = "Standard-Port für PostgreSQL-Verbindungen"
}

Nach der Ausführung von terraform apply erhalten Sie den Endpunkt der Datenbank, z. B. postgres-db.abc123.us-east-1.rds.amazonaws.com.

Infrastruktur bereitstellen und testen

Führen Sie die folgenden Befehle aus, um die Infrastruktur zu provisionieren:

terraform init
terraform apply --auto-approve

Nach erfolgreicher Bereitstellung können Sie die Datenbank mit einem PostgreSQL-Client wie psql oder DBeaver verbinden:

psql -h <DATABASE_ENDPOINT> -U <USERNAME> -d <DATABASE_NAME>

Vergessen Sie nicht, die Datenbank nach dem Testen zu löschen, um unnötige Kosten zu vermeiden – besonders in Entwicklungsumgebungen.

Fazit: Automatisierte PostgreSQL-Datenbanken mit Terraform

Die Kombination aus AWS RDS und Terraform ermöglicht eine effiziente, reproduzierbare und sichere Bereitstellung von PostgreSQL-Datenbanken in der Cloud. Durch die modulare Struktur können Sie die Infrastruktur an verschiedene Umgebungen anpassen – von kostengünstigen Testumgebungen bis hin zu hochverfügbaren Produktionssystemen.

Nutzen Sie die vorgestellten Best Practices für Sicherheitsgruppen, Subnetzgruppen und Passwortverwaltung, um eine stabile und wartbare Datenbankinfrastruktur zu schaffen. Mit Terraform als zentralem Werkzeug lässt sich die Datenbankkomponente nahtlos in Ihre CI/CD-Pipelines integrieren.

Für größere Projekte empfiehlt sich die Erweiterung um Terraform-Workspaces oder Terraform Cloud, um Umgebungen wie Entwicklung, Staging und Produktion klar zu trennen.