HashiCorp Vault Installation und Konfiguration – Secrets Management

Was ist HashiCorp Vault?

HashiCorp Vault ist ein modernes Secrets Management System, das sensible Daten wie Passwörter, API-Keys, Zertifikate, und Verschlüsselungsschlüssel sicher speichert und verwaltet. Im Gegensatz zu .env-Dateien oder Konfigurationsdateien auf dem Server bietet Vault zentrale, verschlüsselte Speicherung mit granularer Zugriffskontrolle, Audit-Logging und automatischer Rotation von Secrets.

Hauptmerkmale

• Zentrale Secrets-Verwaltung
• Dynamische Secrets (automatische Generierung und Rotation)
• Encryption as a Service (verschlüsseln/entschlüsseln über API)
• Audit-Logging aller Zugriffe
• Verschiedene Auth-Methoden (Token, LDAP, AppRole, AWS IAM, etc.)
• Policy-basierte Zugriffskontrolle
• Multi-Server Setup möglich (High Availability)
• Zero Trust Architecture

Voraussetzungen

• Ubuntu 20.04 oder neuer
• Docker und Docker Compose (optional, oder Binary-Installation)
• Mindestens 2GB RAM
• Eine Domain für Zugriff (z.B. vault.example.com)
• Nginx als Reverse Proxy
• Persistenter Speicher (Datenbank oder Dateisystem)

Installation mit Binary

Schritt 1: Vault Binary herunterladen

cd /tmp
VAULT_VERSION="1.15.0"
wget https://releases.hashicorp.com/vault/${VAULT_VERSION}/vault_${VAULT_VERSION}_linux_amd64.zip
unzip vault_${VAULT_VERSION}_linux_amd64.zip
sudo mv vault /usr/local/bin/
sudo chmod +x /usr/local/bin/vault

# Überprüfen
vault version

Schritt 2: Vault User erstellen

sudo useradd --system --home /etc/vault --shell /bin/false vault

Schritt 3: Verzeichnisse erstellen

sudo mkdir -p /etc/vault /var/lib/vault /var/log/vault
sudo chown -R vault:vault /etc/vault /var/lib/vault /var/log/vault
sudo chmod 700 /etc/vault /var/lib/vault

Vault Konfiguration mit File Storage

Schritt 1: Konfigurationsdatei erstellen

sudo cat > /etc/vault/vault.hcl << 'EOF'
# Vault Konfiguration

# Storage Backend (File-basiert für einfache Setups)
storage "file" {
  path = "/var/lib/vault/data"
}

# Listener (HTTP auf localhost)
listener "tcp" {
  address       = "127.0.0.1:8200"
  tls_disable   = "true"
}

# Aktiviert UI
ui = true

# API Adresse für externe Zugriffe
api_addr = "https://vault.example.com"
cluster_addr = "https://vault.example.com:8201"
EOF

sudo chown vault:vault /etc/vault/vault.hcl
sudo chmod 600 /etc/vault/vault.hcl

Schritt 2: Mit PostgreSQL (Optional, für Production)

Für größere Deployments oder High Availability:

cat > /etc/vault/vault-postgres.hcl << 'EOF'
# Vault mit PostgreSQL Backend
storage "postgresql" {
  connection_url = "postgresql://vault:vault-password@localhost:5432/vault"
}

listener "tcp" {
  address       = "127.0.0.1:8200"
  tls_disable   = "true"
}

api_addr = "https://vault.example.com"
ui = true
EOF

Systemd Service erstellen

Vault Service Unit-Datei

sudo cat > /etc/systemd/system/vault.service << 'EOF'
[Unit]
Description=HashiCorp Vault
Documentation=https://www.vaultproject.io/docs/
Requires=network-online.target
After=network-online.target
ConditionFileNotEmpty=/etc/vault/vault.hcl

[Service]
Type=notify
ProtectSystem=full
ProtectHome=yes
NoNewPrivileges=yes
PrivateTmp=yes
PrivateDevices=yes
SecureBits=keep-caps
AmbientCapabilities=CAP_IPC_LOCK
CapabilityBoundingSet=CAP_SYSLOG CAP_IPC_LOCK
LimitNOFILE=65536
LimitNPROC=512
KillMode=process
Restart=on-failure
RestartSec=5
TimeoutStopSec=30
LimitMEMLOCK=infinity
ExecStart=/usr/local/bin/vault server -config=/etc/vault/vault.hcl
ExecReload=/bin/kill -HUP $MAINPID
StandardOutput=journal
StandardError=journal
SyslogIdentifier=vault
User=vault
Group=vault

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable vault
sudo systemctl start vault

Status überprüfen

sudo systemctl status vault
sudo journalctl -u vault -f

Nginx Reverse Proxy (HTTPS)

Nginx-Konfiguration

cat > /etc/nginx/sites-available/vault << 'EOF'
upstream vault {
    server 127.0.0.1:8200;
}

server {
    listen 80;
    server_name vault.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name vault.example.com;

    ssl_certificate /etc/letsencrypt/live/vault.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/vault.example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    client_max_body_size 10M;

    location / {
        proxy_pass http://vault;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
}
EOF

sudo ln -s /etc/nginx/sites-available/vault /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

# SSL-Zertifikat
sudo apt-get install certbot python3-certbot-nginx
sudo certbot certonly --nginx -d vault.example.com

Vault Initialisieren

Schritt 1: Vault mit CLI ansprechen

export VAULT_ADDR='http://127.0.0.1:8200'
export VAULT_SKIP_VERIFY=true

vault status

Schritt 2: Vault initialisieren

Dies generiert Unseal Keys und den Root Token:

vault operator init \
  -key-shares=5 \
  -key-threshold=3

Beispiel-Output:

Unseal Key 1: MKLs3o...
Unseal Key 2: 7X8Vj...
Unseal Key 3: 9P2Qk...
Unseal Key 4: 4R5Sc...
Unseal Key 5: 8W1Tm...

Initial Root Token: s.hj7Lz...

Schritt 3: Vault Unsealing

Geben Sie 3 der 5 Unseal Keys ein:

vault operator unseal MKLs3o...
vault operator unseal 7X8Vj...
vault operator unseal 9P2Qk...

Überprüfen Sie den Status:

vault status

Output sollte zeigen: "Sealed false"

Schritt 4: Mit Root Token anmelden

vault login s.hj7Lz...

Secrets Secrets Engine aktivieren

KV v2 Secrets Engine

vault secrets enable -path=secret kv-v2

Secrets schreiben und lesen

Ein Secret schreiben:

vault kv put secret/my-app/database \
  username="dbuser" \
  password="securepassword" \
  host="db.example.com"

Secret lesen:

vault kv get secret/my-app/database

Nur einen bestimmten Wert anschauen:

vault kv get -field=password secret/my-app/database

AppRole Authentication einrichten

AppRole aktivieren

vault auth enable approle

AppRole erstellen

vault write auth/approle/role/my-app \
  token_num_uses=0 \
  token_ttl=30m \
  secret_id_ttl=30m

Role ID abrufen

vault read auth/approle/role/my-app/role-id

Secret ID generieren

vault write -f auth/approle/role/my-app/secret-id

Mit AppRole authentifizieren

vault write auth/approle/login \
  role_id="ROLE_ID" \
  secret_id="SECRET_ID"

Policies erstellen

Policy in HCL schreiben

cat > /tmp/my-app-policy.hcl << 'EOF'
# Erlaubt Lesen von Secrets unter secret/my-app/
path "secret/data/my-app/*" {
  capabilities = ["read", "list"]
}

# Erlaubt Schreiben von Datenbank-Secrets
path "secret/data/my-app/database" {
  capabilities = ["read", "create", "update"]
}

# Erlaubt Ablesen der eigenen Token-Info
path "auth/token/lookup-self" {
  capabilities = ["read"]
}
EOF

Policy hochladen

vault policy write my-app /tmp/my-app-policy.hcl

Policy überprüfen

vault policy read my-app

Audit Logging aktivieren

File Audit Log aktivieren

vault audit enable file file_path=/var/log/vault/audit.log

Audit Logs anschauen

tail -f /var/log/vault/audit.log | jq .

Auto-Unseal mit AWS KMS (Optional)

KMS Seal konfigurieren

Für Production ist Auto-Unseal empfohlen. Dies nutzt AWS KMS um die Master Key automatisch zu entsperren:

cat >> /etc/vault/vault.hcl << 'EOF'
seal "awskms" {
  region     = "eu-west-1"
  kms_key_id = "arn:aws:kms:eu-west-1:ACCOUNT_ID:key/KEY_ID"
}
EOF

Vault neustarten nach Konfiguration

sudo systemctl restart vault

Transit Engine für Encryption

Transit Engine aktivieren

vault secrets enable transit

Verschlüsselungs-Key erstellen

vault write -f transit/keys/my-key

Daten verschlüsseln

vault write transit/encrypt/my-key plaintext=$(base64 <<< "sensitive data")

Daten entschlüsseln

vault write transit/decrypt/my-key ciphertext="vault:v1:..."

Wichtige Vault Befehle

Befehl	Beschreibung
vault status	Zeigt Vault-Status (sealed/unsealed)
vault login TOKEN	Mit Token authentifizieren
vault kv put path key=value	Secret schreiben
vault kv get path	Secret lesen
vault token revoke TOKEN	Token widerrufen
vault policy list	Alle Policies anzeigen

Backup-Strategie

Vault mit File Storage sichern

sudo tar -czf /backups/vault_$(date +%Y%m%d_%H%M%S).tar.gz /var/lib/vault/data/

Mit Cron automatisieren

0 2 * * * sudo tar -czf /backups/vault_$(date +\%Y\%m\%d_\%H\%M\%S).tar.gz /var/lib/vault/data/

Häufige Fehler und Lösungen

Vault Status zeigt "sealed"

Vault ist verschlossen. Geben Sie 3 Unseal Keys ein:

vault operator unseal KEY1
vault operator unseal KEY2
vault operator unseal KEY3

Authentifizierung fehlgeschlagen

Token ist möglicherweise abgelaufen. Melden Sie sich erneut an oder fordern Sie einen neuen Token an.

Secret nicht lesbar – Permission denied

Ihre Policy erlaubt diesen Pfad nicht. Überprüfen Sie die Policy:

vault token lookup

Best Practices

• Speichern Sie Unseal Keys offline und verteilt
• Verwenden Sie AppRole für Anwendungen, nicht Root Token
• Aktivieren Sie Audit Logging
• Rotieren Sie Secrets regelmäßig
• Verwenden Sie Auto-Unseal in Production
• Implementieren Sie High Availability mit mehreren Vault-Instanzen
• Überwachen Sie den Vault-Zustand regelmäßig
• Erstellen Sie regelmäßig Backups

Verwandte Artikel

• 📖 Secrets Management Best Practices
• 📖 Docker Compose Grundlagen Anleitung
• 📖 Linux Server absichern Anleitung
• 🔧 Enjyn Gen Tools – Passwörter & Keys generieren
• 🔧 Sichere Server bei Enjyn mieten