Automatisierte Cloud-Sicherheit mit HashiCorp Terraform und Vault

In der heutigen, cloudzentrierten Welt ist es von größter Bedeutung, Infrastruktur zu verwalten und gleichzeitig die Sicherheit zu gewährleisten. HashiCorp bietet mit Terraform und Vault zwei leistungsstarke Werkzeuge, die Entwicklern helfen, Infrastruktur effizient bereitzustellen und sensible Daten sowie Zugangskontrollen sicher zu verwalten. In diesem Artikel betrachten wir, wie diese Tools zusammenarbeiten können, um dynamische Authentifizierung für Cloud-Ressourcen zu ermöglichen und den Zugriff von Entwicklern effektiv zu steuern.

Was ist HashiCorp Terraform?

Terraform ist ein Open-Source-Tool für Infrastruktur als Code (IaC), das Entwicklern ermöglicht, Cloud-Ressourcen deklarativ zu definieren und bereitzustellen. Mit einer einfachen, lesbaren Konfigurationssprache können Benutzer Ressourcen wie virtuelle Maschinen, Datenbanken und Netzwerke über verschiedene Cloud-Anbieter bereitstellen. Die Stärke von Terraform liegt in seiner Fähigkeit, Infrastrukturänderungen sicher zu verwalten und nachzuverfolgen, was den Prozess der Bereitstellung und Wartung von Cloud-Umgebungen erheblich vereinfacht.

Was ist HashiCorp Vault?

Vault ist ein Tool zur Verwaltung und Sicherung sensibler Informationen wie API-Schlüsseln, Tokens und Passwörtern. Es bietet eine Vielzahl von Funktionen, darunter die Verwaltung von Geheimnissen, die Verschlüsselung von Daten und die Unterstützung dynamischer Geheimnisse, die bei Bedarf erstellt und zurückgezogen werden können. Diese Funktionalität ermöglicht es, den Zugriff auf Ressourcen dynamisch zu steuern, was besonders in modernen, containerisierten und cloudbasierten Umgebungen von Bedeutung ist.

Die Synergie zwischen Terraform und Vault

Die Integration von Terraform und Vault bietet eine umfassende Lösung für die Verwaltung von Infrastruktur und Sicherheit. Hier sind einige zentrale Vorteile:

1. Dynamische Authentifizierung

Durch die Verwendung von Vault können Sie dynamische Geheimnisse generieren, die spezifisch für Ihre Cloud-Plattformen sind. Das bedeutet, dass Entwickler keine statischen Anmeldeinformationen verwenden müssen, die potenziell gefährdet werden können. Stattdessen erhalten sie temporäre, zeitlich begrenzte Anmeldeinformationen, die nur für die Dauer ihrer Sitzung gültig sind, wodurch das Risiko eines Missbrauchs von Geheimnissen verringert wird.

2. Fein granulare Zugriffskontrolle

Vault ermöglicht es Ihnen, feingranulare Zugriffskontrollen für verschiedene Benutzer und Teams festzulegen. Durch die Integration von Terraform mit Vault können Sie sicherstellen, dass nur autorisierte Entwickler Zugriff auf bestimmte Cloud-Ressourcen haben. Sie können Richtlinien definieren, die den Zugriff auf bestimmte Umgebungen oder Ressourcen basierend auf Benutzerrollen steuern.

3. Automatisierte Geheimnisrotation

Ein weiterer großer Vorteil von Vault ist die Fähigkeit zur automatisierten Geheimnisrotation. Wenn ein Entwickler eine Ressource über Terraform bereitstellt, kann Vault automatisch Anmeldeinformationen generieren und diese nach einer festgelegten Zeitspanne rotieren. Dies verringert das Risiko, dass kompromittierte Anmeldeinformationen über längere Zeiträume verwendet werden.

4. Einheitliche API für Ressourcenmanagement

Die Kombination von Terraform und Vault ermöglicht es Ihnen, eine einheitliche API für das Management von Cloud-Ressourcen und deren Zugang zu erstellen. Mit Terraform können Sie die Infrastruktur deklarativ definieren, während Vault Ihnen die notwendigen Geheimnisse bereitstellt, um diese Infrastruktur sicher zu nutzen. Dies fördert nicht nur die Effizienz, sondern auch die Konsistenz in der Verwaltung von Cloud-Ressourcen.

Beispiel: Verwendung von Terraform mit Vault für dynamische Geheimnisse

Hier ist ein einfaches Beispiel, um zu veranschaulichen, wie Terraform mit Vault für dynamische Geheimnisse verwendet werden kann. In diesem Beispiel erstellen wir eine AWS RDS-Instanz, deren Anmeldeinformationen von Vault verwaltet werden.

Voraussetzungen

1. Terraform installiert.
2. HashiCorp Vault installiert und ausgeführt.
3. AWS-Konto mit den entsprechenden Berechtigungen.

Schritt 1: Vault konfigurieren

Zuerst aktivieren wir die AWS Secret Engine in Vault und konfigurieren sie so, dass sie AWS-Anmeldeinformationen generiert, die es den Clients ermöglichen, auf EC2-Instanzen zuzugreifen.

Erstellen Sie eine Datei vault/aws_secret_engine.tf mit folgendem Inhalt:

 1provider "vault" {
 2  address = "http://127.0.0.1:8200"
 3}
 4
 5variable "account_name" {
 6  description = "The name of the AWS account"
 7  type        = string
 8}
 9variable "aws_region" {
10  description = "The AWS region"
11  type        = string
12}
13resource "aws_iam_user" "secrets_engine" {
14  name = "vault-secrets-${var.account_name}"
15}
16
17resource "aws_iam_access_key" "secrets_engine_credentials" {
18  user = aws_iam_user.secrets_engine.name
19}
20
21resource "aws_iam_user_policy" "secrets_engine" {
22  user = aws_iam_user.secrets_engine.name
23
24  policy = jsonencode({
25    Statement = [
26      {
27        Action = [
28          "iam:*"
29        ]
30        Effect   = "Allow"
31        Resource = "*"
32      },
33    ]
34    Version = "2012-10-17"
35  })
36}
37
38resource "vault_aws_secret_backend" "aws" {
39  access_key = aws_iam_access_key.secrets_engine_credentials.id
40  secret_key = aws_iam_access_key.secrets_engine_credentials.secret
41  region     = var.aws_region
42  path       = "aws-${var.account_name}-${var.aws_region}"
43
44
45  default_lease_ttl_seconds = 60 * 60
46  max_lease_ttl_seconds     = 60 * 60 * 24
47}
48
49resource "vault_aws_secret_backend_role" "ec2" {
50  backend         = vault_aws_secret_backend.aws.path
51  name            = "ec2"
52  credential_type = "iam_user"
53
54  policy_document = <<EOF
55{
56    "Version": "2012-10-17",
57    "Statement": [
58      {
59        "Effect": "Allow",
60        "Action": [
61          "sts:GetCallerIdentity",
62          "ec2:*",
63          "iam:GetUser"
64        ],
65        "Resource": "*"
66      }
67    ]
68  }
69EOF
70}
71
72resource "vault_policy" "aws_ec2" {
73  name     = "aws-${var.account_name}-${var.aws_region}-ec2"
74  policy = <<EOF
75# Allow tokens to query themselves
76path "auth/token/lookup-self" {
77  capabilities = ["read"]
78}
79
80# Allow tokens to renew themselves
81path "auth/token/renew-self" {
82    capabilities = ["update"]
83}
84
85# Allow tokens to revoke themselves
86path "auth/token/revoke-self" {
87    capabilities = ["update"]
88}
89
90path "aws-${ var.account_name }-${ var.aws_region }/creds/ec2" {
91    capabilities = [ "read" ]
92}
93EOF
94
95}

Step 2: Initialisieren und Anwenden der Vault-Konfiguration

Als nächstes initialisieren und wenden Sie die Vault-Konfiguration an:

1terraform -chdir=vault init
2terraform -chdir=vault vault

Dies konfiguriert Vault so, dass dynamische AWS-Anmeldeinformationen für den Zugriff auf EC2-Instanzen generiert werden können.

Step 3: Application Terraform Konfiguration

Nun können wir die Terraform-Konfiguration erstellen, um eine EC2-Instanz zu erstellen, die dynamische Anmeldeinformationen von Vault verwaltet. Diese Konfiguration ec2/main.tf könnte wie folgt aussehen:

 1provider "vault" {
 2  address = "http://127.0.0.1:8200"
 3}
 4
 5variable "account_name" {
 6  description = "The name of the AWS account"
 7  type        = string
 8}
 9variable "aws_region" {
10  description = "The AWS region"
11  type        = string
12}
13
14data "vault_aws_access_credentials" "ec2" {
15  backend = "aws-${var.account_name}-${var.aws_region}"
16  region  = var.aws_region
17  role    = "ec2"
18  type    = "creds"
19  ttl     = "2h"
20}
21
22provider "aws" {
23  region     = var.aws_region
24  access_key = data.vault_aws_access_credentials.ec2.access_key
25  secret_key = data.vault_aws_access_credentials.ec2.secret_key
26}
27
28data "aws_ami" "ubuntu" {
29  most_recent = true
30  owners      = ["099720109477"] # Canonical
31  filter {
32    name   = "name"
33    values = ["ubuntu/images/hvm-ssd/ubuntu-noble-24.04-amd64-server-*"]
34  }
35  filter {
36    name   = "virtualization-type"
37    values = ["hvm"]
38  }
39}
40
41resource "aws_instance" "web" {
42  ami           = data.aws_ami.ubuntu.id
43  instance_type = "t3.micro"
44
45  tags = {
46    Name = "HelloWorld"
47  }
48}

Schritt 4: Initialisieren und Anwenden der Anwendungskonfiguration

Schließlich initialisieren und wenden Sie die Terraform Anwendungs-Konfiguration an:

1terraform init
2terraform apply

Dies wird eine AWS EC2-Instanz bereitstellen, für die die AWS Anmeldeinformationen dynamisch von Vault verwaltet werden.

Fazit

Die Integration von HashiCorp Terraform und Vault bietet eine leistungsstarke Lösung zur effizienten Verwaltung von Cloud-Ressourcen und zur Verbesserung der Sicherheit. Durch die Nutzung dynamischer Geheimnisse und fein granularer Zugriffskontrollen können Unternehmen sicherstellen, dass ihre Entwickler den erforderlichen Zugriff haben, ohne die Sicherheit ihrer Umgebung zu gefährden. In einer Zeit, in der Cyber-Sicherheit zunehmend an Bedeutung gewinnt, sind solche Lösungen unerlässlich, um die Integrität und Sicherheit von Cloud-Infrastrukturen zu gewährleisten.

Für weitere Einblicke in die Verwendung von Vault-gestützten dynamischen Anmeldeinformationen, schauen Sie sich diese LinkedIn Postings über Dynamic Credentials und terraform, das Secrets von Vault nutzt, den HashiCorp-Blog sowie den Bereich in der Developer Documentation an.

Die Zukunft der Cloud-Infrastruktur gehört denen, die Automatisierung und Sicherheit nahtlos miteinander verbinden – und mit HashiCorp haben Sie die richtigen Werkzeuge dafür.