---
title: "Infrastructuur"
description: "Geen geheimen in configuratie. Geen geheimen in logs. Docker, Kubernetes, Terraform, Ansible, CI/CD, en al het andere."
lang: nl
url: https://clavitor.ai/nl/developers/infrastructure
markdown: https://clavitor.ai/nl/developers/infrastructure.md
translation_of: https://clavitor.ai/en/developers/infrastructure.md
authoritative: false
publisher: Clavitor LLC
---

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

# Infrastructuur: Geen geheimen in configuratie. Geen geheimen in logs.

Elk platform, elke orchestrator, elke CI-runner. De proxy werkt met alles wat HTTP-aanroepen doet. De CLI werkt met alles wat een shell kan aanroepen. Als je systeem ouder is dan je carrière, werkt het nog steeds.

## De proxy is de universele integratie.

Als je workload HTTPS-aanroepen doet, injecteert de Clavitor-proxy inloggegevens op netwerkniveau. Geen codeaanpassingen. Geen SDK's. Geen geheimen in omgevingsvariabelen, configuratiebestanden of logs. Stel `HTTPS_PROXY` in en je bestaande code werkt ongewijzigd — de proxy lost `clavitor://`-verwijzingen in request headers op voordat het verzoek de machine verlaat.

```
$ 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

```

## Containers: Docker en Kubernetes

### Docker Compose

Draai de Clavitor-proxy op de host en laat je containers ernaar verwijzen. Inloggegevens worden transparant geïnjecteerd in uitgaande verzoeken — geen geheimen in omgevingsvariabelen, geen geheimen ingebakken in images.

```
# 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"
```

Of gebruik `render` om een configuratiesjabloon op te lossen bij het opstarten:

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

### Kubernetes

Maak geheimen aan vanuit de kluis zonder waarden hard te coderen in manifests:

```
$ 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)"
```

Voor runtime-injectie van inloggegevens, implementeer de proxy als een sidecar-container in je pod. Applicatiecontainers stellen `HTTPS_PROXY` in op de sidecar. Inloggegevens worden per verzoek opgelost, nooit opgeslagen in etcd.

## IaC: Terraform, Ansible, Pulumi

### Terraform

Los inloggegevens op in de provideromgeving voordat `terraform apply` wordt uitgevoerd. De AWS-provider leest zijn inloggegevens uit standaard omgevingsvariabelen — Clavitor vult deze inline aan, het .tf-bestand vermeldt geen geheim.

```
$ 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
```

Het `provider "aws" {}`-blok blijft leeg in je code. Hetzelfde patroon werkt voor elke Terraform-provider die ondersteuning biedt voor omgevingsvariabele-inloggegevens (wat de meeste zijn).

### 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

De token wordt in elk voorbeeld hieronder via stdin doorgegeven — zodat deze niet in `argv` terechtkomt en dus niet verschijnt in `/proc/<pid>/cmdline` of build logs.

### 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: In de kluis opgeslagen sleutels

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

De privésleutel wordt rechtstreeks naar `ssh-add` gepiped. Deze raakt nooit de schijf, verschijnt nooit in de shell-geschiedenis en wordt uit de agent verwijderd wanneer de sessie eindigt.

## Legacy systemen: Als het een HTTP-aanroep doet, werkt het.

De proxy geeft niet om welke taal het verzoek heeft gedaan. COBOL, FORTRAN, Perl, Visual Basic, een 30 jaar oude batch-taak — als het proces een HTTPS-verzoek doet, onderschept de proxy het, lost de `clavitor://`-verwijzing op en injecteert de echte inloggegevens. Geen codeaanpassingen vereist.

Voor systemen die geen HTTP-aanroepen kunnen doen, gebruik `clavitor-cli render` om een configuratiesjabloon op te lossen voordat het proces start. Het sjabloon kan veilig overal worden opgeslagen. De opgeloste uitvoer gaat naar stdin of een tijdelijk bestand met beperkte rechten.

```
# 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
```

## Het patroon is altijd hetzelfde.

CLI voor scripts en pipelines. Proxy voor HTTP-workloads. Render voor configuratiebestanden. Elk geheim wordt op runtime opgelost, nooit opgeslagen.
[Gratis starten](https://clavitor.ai/nl/checkout)
[Ontwikkelaarsoverzicht →](https://clavitor.ai/nl/developers)