---
title: "Infrastruktur"
description: "Keine Geheimnisse in der Konfiguration. Keine Geheimnisse in Logs. Docker, Kubernetes, Terraform, Ansible, CI/CD und alles andere."
lang: de
url: https://clavitor.ai/de/developers/infrastructure
markdown: https://clavitor.ai/de/developers/infrastructure.md
translation_of: https://clavitor.ai/en/developers/infrastructure.md
authoritative: false
publisher: Clavitor LLC
---

> This is the German translation of [Infrastructure](https://clavitor.ai/en/developers/infrastructure.md). The original English text is authoritative; where the two differ, the English version prevails.

# Infrastruktur: Keine Geheimnisse in der Konfiguration. Keine Geheimnisse in Logs.

Jede Plattform, jeder Orchestrator, jeder CI-Runner. Der Proxy funktioniert mit allem, was HTTP-Aufrufe tätigt. Die CLI funktioniert mit allem, was Shell-Befehle ausführen kann. Wenn Ihr System älter ist als Ihre Karriere, funktioniert es trotzdem.

## Der Proxy ist die universelle Integration.

Wenn Ihre Workload HTTPS-Aufrufe tätigt, injiziert der Clavitor-Proxy Anmeldedaten auf Netzwerkebene. Keine Codeänderungen. Keine SDKs. Keine Geheimnisse in Umgebungsvariablen, Konfigurationsdateien oder Logs. Setzen Sie `HTTPS_PROXY` und Ihr bestehender Code funktioniert unverändert – der Proxy löst `clavitor://`-Referenzen in Anforderungsheadern auf, bevor die Anfrage die Maschine verlässt.

```
$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://Stripe API/key" \
  https://api.stripe.com/v1/charges
# The agent never sees sk_live_... — only clavitor:// appears in logs

```

## Container: Docker und Kubernetes

### Docker Compose

Führen Sie den Clavitor-Proxy auf dem Host aus und leiten Sie Ihre Container darauf. Anmeldedaten werden transparent in ausgehende Anfragen injiziert – keine Geheimnisse in Umgebungsvariablen, keine Geheimnisse in Images eingebacken.

```
# On the Docker host

$ clavitor-proxy serve &
```

```
# docker-compose.yml — containers route through the host-mode proxy

services:
  app:
    environment:
      - HTTPS_PROXY=http://host.docker.internal:1983
    extra_hosts:
      - "host.docker.internal:host-gateway"
```

Oder verwenden Sie `render`, um eine Konfigurationsvorlage beim Start aufzulösen:

```
$ clavitor-cli render app.config.template.yml | docker compose -f - up
```

### Kubernetes

Erstellen Sie Geheimnisse aus dem Tresor, ohne Werte in Manifesten fest zu codieren:

```
$ kubectl create secret generic app-secrets \
  --from-literal=db-pass="$(clavitor-cli get 'Production DB' --field password)" \
  --from-literal=api-key="$(clavitor-cli get 'Stripe API' --field key)"
```

Für die Laufzeitinjektion von Anmeldedaten stellen Sie den Proxy als Sidecar-Container in Ihrem Pod bereit. Anwendungscontainer setzen `HTTPS_PROXY` auf den Sidecar. Anmeldedaten werden pro Anfrage aufgelöst, niemals in etcd gespeichert.

## IaC: Terraform, Ansible, Pulumi

### Terraform

Lösen Sie Anmeldedaten in der Provider-Umgebung auf, bevor `terraform apply` ausgeführt wird. Der AWS-Provider liest seine Anmeldedaten aus Standard-Umgebungsvariablen – Clavitor füllt diese inline, die .tf-Datei erwähnt kein Geheimnis.

```
$ export AWS_ACCESS_KEY_ID=$(clavitor-cli get "AWS Root" --field access_key_id)
$ export AWS_SECRET_ACCESS_KEY=$(clavitor-cli get "AWS Root" --field secret_key)
$ terraform apply
```

Der `provider "aws" {}`-Block bleibt in Ihrem Code leer. Dasselbe Muster funktioniert für jeden Terraform-Provider, der Umgebungsvariablen-Anmeldedaten unterstützt (was die meisten tun).

### Ansible

```
- name: Get database password
  command: clavitor-cli get "Production DB" --field password
  register: db_pass
  no_log: true

- name: Configure app
  template:
    src: app.conf.j2
  vars:
    db_password: "{{ db_pass.stdout }}"
```

### Pulumi

```
import { execSync } from 'child_process';
const dbPass = execSync('clavitor-cli get "Production DB" --field password').toString().trim();
new aws.rds.Instance("db", { masterPassword: new pulumi.secret(dbPass) });
```

## CI/CD: GitHub Actions, GitLab CI, Jenkins

Das Token wird in allen untenstehenden Beispielen über stdin übergeben – es wird aus `argv` herausgehalten, damit es nicht in `/proc/<pid>/cmdline` oder Build-Logs erscheint.

### GitHub Actions

```
- name: Deploy
  env:
    CLAVITOR_TOKEN: ${{ secrets.CLAVITOR_TOKEN }}
  run: |
    echo "$CLAVITOR_TOKEN" | clavitor-cli init
    kubectl create secret generic app-secrets \
      --from-literal=api-key="$(clavitor-cli get 'Deploy Token' --field key)" \
      --dry-run=client -o yaml | kubectl apply -f -
```

### GitLab CI

```
deploy:
  script:
    - echo "$CLAVITOR_TOKEN" | clavitor-cli init
    - clavitor-cli get "Deploy Key" --field private_key | ssh-add -
    - ssh deploy@production "systemctl restart app"
```

### Jenkins

```
pipeline {
  stages {
    stage('Deploy') {
      steps {
        sh 'echo "$CLAVITOR_TOKEN" | clavitor-cli init'
        sh 'clavitor-cli get "Deploy Key" --field private_key | ssh-add -'
        sh 'ssh deploy@production "systemctl restart app"'
      }
    }
  }
}
```

## SSH: Im Tresor gespeicherte Schlüssel

```
$ clavitor-cli get "Deploy Key" --field private_key | ssh-add -
$ ssh deploy@production
```

Der private Schlüssel wird direkt in `ssh-add` übergeben. Er berührt niemals die Festplatte, erscheint nie im Shell-Verlauf und wird aus dem Agenten gelöscht, wenn die Sitzung endet.

## Altsysteme: Wenn es einen HTTP-Aufruf tätigt, funktioniert es.

Dem Proxy ist es egal, welche Sprache die Anfrage gestellt hat. COBOL, FORTRAN, Perl, Visual Basic, ein 30 Jahre alter Batch-Job – wenn der Prozess eine HTTPS-Anfrage stellt, fängt der Proxy sie ab, löst die `clavitor://`-Referenz auf und injiziert die tatsächlichen Anmeldedaten. Keine Codeänderungen erforderlich.

Für Systeme, die keine HTTP-Aufrufe tätigen können, verwenden Sie `clavitor-cli render`, um eine Konfigurationsvorlage aufzulösen, bevor der Prozess startet. Die Vorlage kann sicher überall gespeichert werden. Die aufgelöste Ausgabe geht an stdin oder eine temporäre Datei mit eingeschränkten Berechtigungen.

```
# Resolve credentials before the batch job starts

$ clavitor-cli render db-connect.template.cfg > /tmp/db-connect.cfg
$ chmod 600 /tmp/db-connect.cfg
$ /opt/legacy/batch-job --config /tmp/db-connect.cfg
$ rm /tmp/db-connect.cfg
```

## Das Muster ist immer dasselbe.

CLI für Skripte und Pipelines. Proxy für HTTP-Workloads. Render für Konfigurationsdateien. Jedes Geheimnis wird zur Laufzeit aufgelöst, niemals gespeichert.
[Kostenlos starten](https://clavitor.ai/de/checkout)
[Entwicklerübersicht →](https://clavitor.ai/de/developers)