CloudFront mit Terraform für HTTPS bereitstellen – Schritt-für-Schritt-Anleitung

Die Bereitstellung einer globalen CDN-Lösung auf AWS ist ein entscheidender Schritt, um Webanwendungen schneller und sicherer zu machen. Mit Terraform lässt sich eine CloudFront-Verteilung inklusive HTTPS-Unterstützung automatisieren – eine Herausforderung für viele Entwickler, die sich erstmals mit dieser Infrastruktur beschäftigen. Doch mit der richtigen Strukturierung und klaren Aufteilung der Konfiguration wird der Prozess überschaubar.

Warum CloudFront und HTTPS kombinieren?

Eine statische Website oder Webanwendung profitiert von einer CDN-Lösung wie CloudFront auf mehreren Ebenen:

• Geschwindigkeit: Inhalte werden näher an den Nutzern gespeichert und ausgeliefert.
• Skalierbarkeit: Die Last wird auf mehrere Edge-Server verteilt.
• Sicherheit: HTTPS verschlüsselt die Datenübertragung und stärkt das Vertrauen der Besucher.
• Kostenersparnis: Durch Caching reduziert sich die Auslastung des Ursprungsservers.

Ein klassisches Szenario ist der Wechsel von einem einfachen HTTP-Server auf eine HTTPS-basierte Lösung mit CloudFront als Frontend. Dabei wird die Infrastruktur schrittweise aufgebaut: Zuerst der Ursprungsserver, dann die DNS-Konfiguration und schließlich die CDN-Verteilung mit Zertifikatsverwaltung.

Ursprungsserver mit Route53 definieren

Bevor CloudFront genutzt werden kann, muss ein Ursprung definiert werden. In diesem Beispiel nutzen wir eine EC2-Instanz als Ursprungsserver. Die Verbindung erfolgt über eine Route53-DNS-Einstellung, die auf die öffentliche IP der Instanz zeigt.

Ein typischer Terraform-Code für die Route53-Konfiguration könnte so aussehen:

# modules/dns/main.tf
resource "aws_route53_zone" "main" {
  name = "beispiel.de"
}

resource "aws_route53_record" "origin" {
  zone_id = var.main_zone_id
  name    = var.domain_name
  type    = "A"
  ttl     = 300
  records = [var.origin_ip]
}

Dazu gehören die notwendigen Variablen:

# modules/dns/variables.tf
variable "main_zone_id" {
  type = string
}

variable "domain_name" {
  type = string
}

variable "origin_ip" {
  type = string
}

Die öffentliche IP der EC2-Instanz wird dabei als Eingabe für die Route53-Ressource verwendet. Nach der Konfiguration kann mit terraform apply die Infrastruktur aktualisiert werden. Der Ursprungsserver ist nun unter origin.beispiel.de erreichbar – allerdings nur über HTTP.

CloudFront-Verteilung einrichten

Der nächste Schritt besteht darin, die CloudFront-Verteilung zu definieren. Diese fungiert als Frontend und leitet Anfragen an den Ursprungsserver weiter. Die Konfiguration umfasst mehrere wichtige Komponenten:

• Ursprungskonfiguration: Hier wird der Ursprungsserver (origin.beispiel.de) als Ziel festgelegt.
• Cache-Verhalten: Legt fest, wie Anfragen zwischengespeichert werden.
• Protokollrichtlinie: Steuert die Weiterleitung von HTTP zu HTTPS.

Ein vollständiger Terraform-Block für die CloudFront-Verteilung könnte wie folgt aussehen:

# modules/cloudfront/main.tf
resource "aws_cloudfront_distribution" "cdn" {
  enabled             = true
  default_root_object = "index.html"

  origin {
    domain_name = var.aws_route53_origin_fqdn
    origin_id   = var.aws_route53_origin_fqdn

    custom_origin_config {
      http_port              = 80
      https_port             = 443
      origin_protocol_policy = "http-only"
      origin_ssl_protocols   = ["TLSv1.2"]
    }
  }

  default_cache_behavior {
    allowed_methods        = ["GET", "HEAD"]
    cached_methods         = ["GET", "HEAD"]
    target_origin_id       = var.aws_route53_origin_fqdn

    forwarded_values {
      query_string = false
      cookies {
        forward = "none"
      }
    }

    viewer_protocol_policy = "redirect-to-https"
    min_ttl                = 0
    default_ttl            = 3600
    max_ttl                = 86400
  }

  price_class = "PriceClass_100"

  viewer_certificate {
    cloudfront_default_certificate = true
  }

  restrictions {
    geo_restriction {
      restriction_type = "none"
    }
  }
}

Wichtige Punkte:

• Der Parameter target_origin_id verweist auf den definierten Ursprung.
• Mit viewer_protocol_policy = "redirect-to-https" wird sichergestellt, dass alle Anfragen auf HTTPS umgeleitet werden.
• Die Standardzertifikate von CloudFront werden zunächst genutzt, bis ein eigenes ACM-Zertifikat integriert wird.

Variablen und Ausgaben für die CloudFront-Konfiguration

Damit die CloudFront-Verteilung dynamisch bleibt, werden Variablen benötigt:

# modules/cloudfront/variables.tf
variable "aws_route53_origin_fqdn" {
  type = string
}

Zusätzlich sollte die Domain des CloudFront-Endpunkts als Ausgabe verfügbar sein:

# modules/cloudfront/outputs.tf
output "cloudfront_distribution_domain_name" {
  value       = aws_cloudfront_distribution.cdn.domain_name
  description = "Die Domain der CloudFront-Verteilung"
}

Nach der Integration in die Hauptkonfiguration wird die CloudFront-Verteilung mit den Befehlen terraform init und terraform apply bereitgestellt. Die Ausgabe zeigt dann eine URL wie d123456789abcdef.cloudfront.net.

Sicherheitseinstellungen anpassen

Damit die CDN-Lösung korrekt funktioniert, müssen die Sicherheitsgruppen der EC2-Instanz angepasst werden. Es sollte ein eingehender Datenverkehr über Port 80 (HTTP) von überall erlaubt sein:

# modules/security_group/main.tf
resource "aws_security_group" "my_app" {
  name   = "Sicherheitsgruppe für Webanwendung"
  vpc_id = var.vpc_id

  ingress {
    cidr_blocks = ["0.0.0.0/0"]
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
  }
}

Diese Regel ermöglicht es CloudFront, Anfragen an den Ursprungsserver zu senden.

HTTPS mit ACM-Zertifikaten aktivieren

Der letzte Schritt besteht darin, ein gültiges SSL-Zertifikat über AWS Certificate Manager (ACM) zu erstellen und in die CloudFront-Verteilung zu integrieren. Dies erfordert:

1. Ein Zertifikat in ACM beantragen (Domain muss verifiziert sein).
2. Die Zertifikats-ARN in der CloudFront-Konfiguration referenzieren.
3. Die viewer_certificate-Einstellungen anpassen, um das eigene Zertifikat zu nutzen.

Mit dieser Konfiguration wird die Anwendung nun über eine sichere HTTPS-Verbindung bereitgestellt, während die Performance durch das CDN optimiert bleibt.

Fazit: CloudFront als Standard für Webbereitstellungen nutzen

Die Kombination aus Terraform, CloudFront und ACM bietet eine robuste und automatisierte Möglichkeit, Webanwendungen global und sicher bereitzustellen. Besonders für Entwicklerteams, die Wert auf Infrastruktur-as-Code legen, ist diese Herangehensweise ideal. Mit der schrittweisen Erweiterung der Infrastruktur – von der EC2-Instanz über DNS bis hin zur CDN-Lösung – wird die Komplexität handhabbar.

In Zukunft könnten weitere Optimierungen wie Lambda@Edge-Funktionen oder erweiterte Caching-Strategien integriert werden, um die Leistung weiter zu steigern. Wer heute mit Terraform und CloudFront startet, legt damit den Grundstein für skalierbare und sichere Weblösungen.