13 Min. Lesezeit

Lernziele

Am Ende dieses Moduls werden Sie in der Lage sein:

  • Die Rotation von API-Tokens mit der Auth API automatisieren: Erstellen, Verifizieren, Speichern und Widerrufen von Tokens pro Dienst und Umgebung
  • Die Benutzer, Gruppen, Berechtigungen und Ressourcenfreigaben von TaskBoard mit `ionoscloud_user`, `ionoscloud_group` und `ionoscloud_share` verwalten
  • Datenbankanmeldeinformationen aus Terraform-Ausgaben in Kubernetes Secrets übergeben, ohne sie irgendwo zu commiten
  • NSG-Regeln durch die Infrastruktur-Pipeline mit Drift-Erkennung ausführen und MKS-Workloads schützen, wo NSGs nicht greifen
  • SSH-Schlüssel für Linux-Server mit Terraform und cloud-init verteilen und rotieren

Einheit 5.2: Sicherheitsautomatisierung

Einführung

TaskBoard verfügt nun über einen CI-Benutzer mit einem Cloud API Token, einem Pull-Token für die Registry, Object Storage-Schlüsseln, zwei Datenbankpasswörtern und SSH-Zugriff auf die Worker-VM. Jedes dieser Elemente wurde einmalig manuell erstellt, und niemand weiß mehr, wann. So entstehen Credential-Lecks: ein Token eines ehemaligen Kollegen, ein Passwort in einer .tfvars-Datei, eine Firewall-Regel, die jemand während eines Vorfalls im DCD gesetzt hat.

In dieser Einheit wandeln Sie Sicherheit in Code um, der nach Zeitplan ausgeführt wird. Sie rotieren API-Tokens mit der Auth API, modellieren Zugriffe mit Terraform-verwalteten Benutzern und Gruppen, versorgen Kubernetes Secrets mit Terraform-Outputs, halten NSG-Regeln in der Pipeline und behandeln SSH-Schlüssel so, wie IONOS CLOUD sie injiziert. Im Code Lab rotieren Sie den CI-Token von TaskBoard, fügen eine NSG-Regel über Terraform hinzu und verdrahten die PostgreSQL-Authentifizierungsdaten in ein Kubernetes Secret.

1. Automatisierung des API-Token-Lebenszyklus

1.1 Inventur vor der Rotation

curl --silent "https://api.ionos.com/auth/v1/tokens" \
  --header "Authorization: Bearer $IONOS_TOKEN" \
  | jq -r '.tokens[] | "\(.id)  created \(.createdDate)  expires \(.expirationDate)"'

GET /tokens listet die Tokens des authentifizierten Benutzers mit id, createdDate und expirationDate auf. Benutzer mit mehreren Verträgen fügen den X-Contract-Number-Header hinzu. Der Token-Wert selbst erscheint nie wieder: Der Token Manager zeigt ihn nur einmal an, bei der Generierung. Ein Benutzer kann bis zu 100 Tokens halten, sodass ein Rotationsjob, der alte Tokens nie löscht, schließlich fehlschlägt.

1.2 Ein Rotationsjob

Jeder Dienst erhält seinen eigenen IONOS CLOUD-Benutzer (Abschnitt 2), und der Rotationsjob wird unter dem aktuellen Token dieses Benutzers ausgeführt:

import base64
import json
import os
import subprocess

import requests

AUTH = "https://api.ionos.com/auth/v1"
TTL = 30 * 24 * 3600  # seconds; the API accepts 60 to 31536000


def key_id(jwt: str) -> str:
    header = jwt.split(".")[0]
    header += "=" * (-len(header) % 4)
    return json.loads(base64.urlsafe_b64decode(header))["kid"]


def main() -> None:
    old = os.environ["IONOS_TOKEN"]
    resp = requests.get(f"{AUTH}/tokens/generate", params={"ttl": TTL},
                        headers={"Authorization": f"Bearer {old}"}, timeout=30)
    resp.raise_for_status()
    new = resp.json()["token"]
    auth_new = {"Authorization": f"Bearer {new}"}

    # 1. prove the new token works before anything depends on it
    requests.get("https://api.ionos.com/cloudapi/v6/datacenters", params={"depth": 0},
                 headers=auth_new, timeout=30).raise_for_status()

    # 2. store it (stdin, so the value never appears in the process list)
    subprocess.run(["gh", "secret", "set", "IONOS_TOKEN"], input=new, text=True, check=True)

    # 3. revoke the old token by its key ID, then remove expired tokens
    requests.delete(f"{AUTH}/tokens/{key_id(old)}", headers=auth_new, timeout=30).raise_for_status()
    requests.delete(f"{AUTH}/tokens", params={"criteria": "EXPIRED"},
                    headers=auth_new, timeout=30).raise_for_status()
    print("rotated, new token expires in", TTL // 86400, "days")


if __name__ == "__main__":
    main()

Der Pfadparameter von DELETE /tokens/{tokenId} ist die Key ID aus dem Header-Bereich des Tokens. Das Löschen eines Tokens deaktiviert es sofort, auch bevor es abläuft, daher ist die Reihenfolge entscheidend: generieren, verifizieren, speichern, dann widerrufen. Benutzer mit Zwei-Faktor-Authentifizierung müssen 2FA-gesicherte Tokens verwenden, um Tokens zu löschen; führen Sie Rotationen unter dedizierten Dienstbenutzern durch.

1.3 Planung und Bereinigung

Speichern Sie den Job als .github/workflows/rotate-token.yml:

on:
  schedule:
    - cron: "0 3 * * 1"
jobs:
  rotate:
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v4
      - run: pip install requests && python ops/rotate_token.py
        env:
          IONOS_TOKEN: ${{ secrets.IONOS_TOKEN }}
          GH_TOKEN: ${{ secrets.SECRETS_ADMIN_PAT }}

Ein wöchentlicher Job mit einer 30-Tage-ttl lässt genug Spielraum für einen fehlgeschlagenen Lauf. Der letzte Aufruf des Skripts verwendet criteria=EXPIRED, der abgelaufene Tokens für den Vertrag löscht. Die anderen Werte sind ALL und CURRENT, daher niemals diesen Parameter aus Eingaben erstellen. GH_TOKEN muss das Schreiben von Repository-Secrets erlaubt sein; das Standard-Workflow-Token darf dies nicht.

2. IAM as Code

2.1 Benutzer und Gruppen pro Dienst

Berechtigungen in IONOS CLOUD werden über Gruppen zugewiesen. Eine Gruppe trägt Berechtigungen, und ein Benutzer erbt sie von jeder Gruppe, der er angehört:

resource "ionoscloud_group" "taskboard_ci" {
  name                           = "taskboard-ci"
  create_datacenter              = false
  create_k8s_cluster             = true
  create_network_security_groups = true
  access_and_manage_monitoring   = true
  access_and_manage_logging      = true
  manage_dbaas                   = true
}

resource "ionoscloud_user" "taskboard_ci" {
  first_name          = "taskboard"
  last_name           = "ci"
  email               = "taskboard-ci@example.com"
  password_wo         = random_password.ci.result
  password_wo_version = "1"
  administrator       = false
  force_sec_auth      = false
  active              = true
  group_ids           = [ionoscloud_group.taskboard_ci.id]
}

resource "random_password" "ci" {
  length  = 24
  special = true
}

password_wo ist nur schreibbar: Er wird nicht im Zustand gespeichert, erfordert Terraform 1.11 oder höher und wird aktualisiert, wenn Sie password_wo_version erhöhen. Bewahren Sie administrator = false für jeden Dienstbenutzer auf. Administratoren müssen nicht in Gruppen verwaltet werden, da sie automatisch Zugriff auf alle Ressourcen des Vertrags haben, sodass ein Administratortoken jede andere Steuerung in dieser Einheit umgeht.

2.2 Ressourcen teilen

Berechtigungen ermöglichen es einer Gruppe, Ressourcen zu erstellen. Der Zugriff auf vorhandene Ressourcen erfolgt über Freigaben:

resource "ionoscloud_share" "ci_datacenter" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_datacenter.taskboard.id
  edit_privilege  = true
  share_privilege = false
}

resource "ionoscloud_share" "ci_cluster" {
  group_id        = ionoscloud_group.taskboard_ci.id
  resource_id     = ionoscloud_k8s_cluster.taskboard.id
  edit_privilege  = true
  share_privilege = false
  depends_on      = [ionoscloud_share.ci_datacenter]
}

Freigaben steuern den Zugriff auf Rechenzentren, Snapshots, Images, IP-Blöcke, Cross Connects, Sicherungseinheiten und Kubernetes-Cluster mit drei Autorisierungsebenen: Read, Edit und Sharing. Lesezugriff ist implizit vorhanden, sobald einer Gruppe ein Ressource zugewiesen wird. Das gleichzeitige Erstellen mehrerer Shares führt zu einem Fehler, weshalb der zweite Share depends_on verwendet; terraform apply -parallelism=1 ist die Alternative.

Für TaskBoard verwenden Sie eine Gruppe pro Service und Umgebung: taskboard-ci-dev mit Schreibrechten nur für das Rechenzentrum dev, taskboard-ci-prod für Produktion und eine schreibgeschützte taskboard-monitor-Gruppe für Skripte wie den Activity-Log-Abrufer aus Einheit 5.1, der ebenfalls access_activity_log = true benötigt.

3. Kubernetes Secrets aus Terraform-Outputs

3.1 Das Pipeline-Muster

Einheit 2.5 hat das PostgreSQL-Passwort aus dem Terraform-State ausgeschlossen, indem ein nur-schreibbares Argument verwendet und nur der Host exportiert wurde. Der Deploy-Job kombiniert beide zu einem Secret:

PGHOST="$(terraform -chdir=infra output -raw pg_host)"

kubectl -n taskboard create secret generic taskboard-db \
  --from-literal=PGHOST="$PGHOST" \
  --from-literal=PGUSER=taskboard \
  --from-literal=PGPASSWORD="$TF_VAR_pg_password" \
  --from-literal=PGSSLMODE=verify-full \
  --dry-run=client -o yaml | kubectl apply -f -

--dry-run=client -o yaml | kubectl apply macht den Schritt idempotent, sodass derselbe Job das Secret erstellt oder aktualisiert. Nichts berührt die Festplatte oder Git. Vermeiden Sie den Kubernetes Terraform Provider für Zugangsdaten, die Sie bewusst aus dem State herausgehalten haben: Eine Secret-Ressource speichert ihre Daten in der State-Datei.

3.2 Externe Secrets und Rotation

Wenn das Passwort in einem Secret Store gespeichert ist, lassen Sie den Cluster es abrufen, anstatt es aus CI zu schieben:

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: taskboard-db
  namespace: taskboard
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: ClusterSecretStore
    name: vault
  target:
    name: taskboard-db
  data:
    - secretKey: PGPASSWORD
      remoteRef: { key: secret/taskboard/prod, property: pg_password }

Eine Rotation umfasst dann drei Schritte: das neue Kennwort in den Speicher schreiben, Terraform mit password_version um eins erhöht anwenden und die Pods mit kubectl rollout restart deploy/taskboard-api neu starten, nachdem der Operator das Secret aktualisiert hat. Umgebungsvariablen werden nur beim Containerstart gelesen. Auf MKS kann die Verschlüsselung von Secret-Daten bei der Speicherung aktiviert und konfiguriert werden.

4. NSG-Automatisierung in der Pipeline

4.1 Regeln als Daten

Einheit 2.3 hat ionoscloud_nsg und ionoscloud_nsg_firewallrule eingeführt. In der Produktion sollten die Regeln als Daten beschrieben werden, damit ein Pull Request genau zeigt, welcher Port für welche Quelle geöffnet wird:

variable "app_ingress" {
  type = map(object({ source_ip = string, port = number }))
  default = {
    http-from-alb = { source_ip = "10.10.1.6", port = 80 }
  }
}

resource "ionoscloud_nsg_firewallrule" "app" {
  for_each         = var.app_ingress
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.app.id
  name             = each.key
  type             = "INGRESS"
  protocol         = "TCP"
  source_ip        = each.value.source_ip
  port_range_start = each.value.port
  port_range_end   = each.value.port
}

Die Gruppe des CI-Benutzers benötigt create_network_security_groups. protocol kann nach der Erstellung nicht geändert werden; eine Änderung erzwingt eine neue Regel.

4.2 Drift Detection

Eine Regel, die während eines Vorfalls in den DCD übernommen wurde, bleibt bestehen, bis jemand sie bemerkt. Ein geplanter Plan bemerkt es für Sie:

terraform plan -input=false -detailed-exitcode -lock=false > drift.txt
case $? in
  0) echo "no drift" ;;
  2) echo "drift detected"; gh issue create --title "NSG drift" --body-file drift.txt ;;
  *) echo "plan failed"; exit 1 ;;
esac

Der Exit-Code 2 bedeutet, dass die tatsächliche Konfiguration vom Code abweicht. Lösen Sie dies, indem Sie den Code ändern und die Änderungen anwenden. Hinterlassen Sie die manuelle Änderung niemals im System.

4.3 Wo NSGs nicht greifen

NSG-Mitglieder sind VMs und NICs. Der ALB und der NLB sind keine Mitglieder, und die Knoten der Node Pools von Managed Kubernetes sind von NSGs ausgenommen. Für Pod-zu-Pod-Verkehr auf MKS verwenden Sie Kubernetes NetworkPolicies, die der Calico CNI-Plugin auf MKS unterstützt:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-ingress-only
  namespace: taskboard
spec:
  podSelector: { matchLabels: { app: taskboard-api } }
  policyTypes: [Ingress]
  ingress:
    - from:
        - namespaceSelector: { matchLabels: { kubernetes.io/metadata.name: ingress } }
      ports:
        - { port: 8000, protocol: TCP }

5. SSH-Schlüssel

5.1 Einspritzung bei der Bereitstellung

variable "team_ssh_keys" {
  type = list(string)   # public keys, one per team member
}

resource "ionoscloud_vcpu_server" "worker" {
  # ... arguments and volume from Unit 2.1 ...
  image_name = data.ionoscloud_image.ubuntu.id
  ssh_keys   = var.team_ssh_keys
}

Die Cloud API injiziert öffentliche Schlüssel, wenn ein Volume aus einem IONOS CLOUD Linux-Image erstellt wird; Windows-Images, Snapshots, private Images und MS SQL-Images unterstützen keine Injektion. ssh_keys ist unveränderlich und kann nur bei der Erstellung festgelegt werden. Die im SSH Key Manager des DCD gespeicherten Schlüssel (bis zu 100 pro Benutzer) sind eine Komfortfunktion des DCD; die Cloud API verwaltet diesen Speicher nicht, daher die Team-Schüsselliste im Code pflegen.

5.2 Rotation

Da injizierte Schlüssel auf einem laufenden Server nicht geändert werden können, authorized_keys mit cloud-init (Einheit 2.1) für neue Server und mit Ihrer Konfigurationsverwaltung für laufende Server verwalten:

#cloud-config
users:
  - name: deploy
    groups: [sudo]
    shell: /bin/bash
    ssh_authorized_keys:
      - ssh-ed25519 AAAA... alice@taskboard
      - ssh-ed25519 AAAA... bob@taskboard

Um den Schlüssel eines ausgeschiedenen Mitarbeiters zu entfernen, löschen Sie ihn aus der Variable, starten Sie neue Worker-VMs oder führen Sie den Konfigurationsjob aus und bestätigen Sie dies mit ssh-keygen -lf auf dem Server.

Schnellreferenz für die API

Wichtige API-Endpunkte für das Thema dieser Einheit:

Methode Endpunkt Beschreibung
GET https://api.ionos.com/auth/v1/tokens/generate?ttl=<seconds> Neues Token generieren
GET https://api.ionos.com/auth/v1/tokens Token des Benutzers auflisten
DELETE https://api.ionos.com/auth/v1/tokens/{tokenId} Token anhand der Key ID widerrufen
DELETE https://api.ionos.com/auth/v1/tokens?criteria=EXPIRED Abgelaufene Token entfernen
POST /datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules NSG-Regel hinzufügen

Basis-URL: https://api.ionos.com/cloudapi/v6 (Authentifizierungs-API wie aufgeführt) Authentifizierung: Authorization: Bearer <token>

Code-Labor

Ziel: Das CI-Token von TaskBoard rotieren, eine NSG-Regel über Terraform hinzufügen und die PostgreSQL-Anmeldedaten in ein Kubernetes-Secret einbinden.

Voraussetzungen:

  • Ein dedizierter CI-Benutzer und dessen Token in IONOS_TOKEN
  • Das Terraform-Projekt mit der NSG aus Einheit 2.3 und PostgreSQL aus Einheit 2.5
  • kubectl-Zugriff auf den TaskBoard-Namespace, jq, gh und Python 3 mit requests

Schritt 1: Aktuelle Tokens auflisten

curl --silent "https://api.ionos.com/auth/v1/tokens" -H "Authorization: Bearer $IONOS_TOKEN" | jq '.tokens | length'

Erwartete Ausgabe:

3

Schritt 2: Token rotieren

python ops/rotate_token.py

Erwartete Ausgabe:

✓ Set Actions secret IONOS_TOKEN for <org>/taskboard
rotated, new token expires in 30 days

Schritt 3: Bestätigen, dass der alte Token widerrufen wurde

curl --silent -o /dev/null -w "%{http_code}\n" \
  "https://api.ionos.com/cloudapi/v6/datacenters" -H "Authorization: Bearer $IONOS_TOKEN"

Erwartete Ausgabe:

401

Laden Sie den neuen Wert aus Ihrem Secret Store in IONOS_TOKEN, bevor Sie fortfahren.

Schritt 4: NSG-Regel über einen Pull Request hinzufügen

Fügen Sie ssh-from-vpn = { source_ip = "10.10.9.10", port = 22 } zu var.app_ingress (Abschnitt 4.1) hinzu, schieben Sie einen Branch und öffnen Sie einen Pull Request.

terraform plan

Erwartete Ausgabe:

  # ionoscloud_nsg_firewallrule.app["ssh-from-vpn"] will be created
Plan: 1 to add, 0 to change, 0 to destroy.

Schritt 5: Drift prüfen

Nach dem Merge und Apply führen Sie das Skript aus Abschnitt 4.2 aus. Erwartete Ausgabe:

no drift

Schritt 6: Das Datenbank-Secret erstellen

export TF_VAR_pg_password="$(vault kv get -field=pg_password secret/taskboard/dev)"
bash ops/db-secret.sh    # the commands from Section 3.1
kubectl -n taskboard get secret taskboard-db -o jsonpath='{.data.PGHOST}' | base64 -d

Erwartete Ausgabe:

secret/taskboard-db configured
<cluster-dns-name>

Prüfliste:

  • [ ] Der alte Token liefert 401, der neue funktioniert aus CI
  • [ ] Die NSG-Regel existiert nur aufgrund eines zusammengeführten Pull Requests
  • [ ] Die Drift-Prüfung meldet keine Drift
  • [ ] taskboard-db existiert im Cluster und in keiner Datei in Git

Aufräumarbeiten:

unset TF_VAR_pg_password
history -c

Behalten Sie den Rotationsworkflow bei; entfernen Sie die ssh-from-vpn-Regel mit einem weiteren Pull Request, wenn Sie das VPN nicht verwenden.

Häufige Fehler

Fehler von Entwicklerinnen und Entwicklern, die bei diesem Thema der Einheit vermieden werden sollten:

  1. Widerruf vor Speicherung

    • Problem: Der Rotationsjob löscht das alte Token, scheitert dann beim Schreiben des neuen Tokens, und jede Pipeline gibt 401 zurück.
    • Warum es passiert: Die Löschung wirkt sofort, und der neue Tokenwert wird nur einmal angezeigt.
    • Lösung: Zuerst generieren, verifizieren und speichern, zuletzt löschen (Abschnitt 1.2); ein Notfallverfahren (Break-glass-Verfahren) bereitzustellen, um ein Token mit dem Passwort des Benutzers zu erstellen.
  2. Dienstetokens aus einem Administrator-Konto

    • Problem: Ein geleaktes CI-Token löscht Ressourcen im gesamten Vertragsbereich.
    • Warum es passiert: Administratorinnen und Administratoren haben Zugriff auf alle Ressourcen des Vertrags, unabhängig von Gruppen und Freigaben.
    • Lösung: Einen Nicht-Administrator-Benutzer pro Dienst und Umgebung erstellen, Berechtigungen über eine Gruppe und Ressourcenzugriff über ionoscloud_share zuweisen.
  3. Erwartung, dass NSGs Pods isolieren

    • Problem: Sie fügen eine NSG-Regel für den Datenbankport hinzu, aber Pods auf MKS erreichen sich weiterhin auf jedem Port.
    • Warum es passiert: Knoten in Managed Kubernetes Node Pools sind von NSGs ausgenommen.
    • Lösung: Kubernetes NetworkPolicies für Pod-Verkehr (Abschnitt 4.3) und NSGs für VMs und deren NICs verwenden.

Zusammenfassung

Sie können die Zugangsdaten und Zugriffsregeln von TaskBoard nun als Code ausführen. Token werden nach einem Zeitplan rotiert, mit einer kurzen ttl, Dienstbenutzer erhalten nur die Berechtigungen und Freigaben, die sie benötigen, Datenbankpasswörter werden aus dem Secret Store in Kubernetes übernommen, ohne Git oder den State zu berühren, NSG-Regeln werden nur über Pull Requests mit Drift-Erkennung geändert, und der SSH-Zugriff folgt der Team-Schlüsselliste im Code.

Wichtige Punkte:

  • Token in der Reihenfolge generieren, verifizieren, speichern, widerrufen; die Löschung ist sofort wirksam
  • Ein Nicht-Administrator-Benutzer pro Dienst und Umgebung, Rechte über Gruppen, Zugriff über Freigaben
  • Kubernetes Secrets aus Terraform-Outputs und dem Secret Store speisen, niemals aus Dateien in Git
  • NSGs decken VMs und NICs ab; für Pods auf MKS NetworkPolicies verwenden
  • Injizierte SSH-Schlüssel sind unveränderlich; Rotation über cloud-init und Konfigurationsmanagement verwalten

Wichtige Begriffe:

  • Key ID: Die Token-Kennung im JWT-Header, verwendet von DELETE /tokens/{tokenId}
  • Berechtigung: Ein Gruppenrecht wie create_k8s_cluster, das das Erstellen eines Ressourcentyps ermöglicht
  • Freigabe: Der Read-, Edit- oder Sharing-Zugriff einer Gruppe auf eine bestehende Ressource
  • Nur-schreibbares Argument: Ein Terraform-Argument wie password_wo, das niemals im State gespeichert wird
  • Drift: Eine Abweichung zwischen der tatsächlichen Konfiguration und dem Code, erkannt mit plan -detailed-exitcode

Nächste Schritte

Weiter lernen: Einheit 5.3: GitOps und Deployment-Operationen

Verwandte Themen: