</details>

### DB-Einrichtung

Kviklet benötigt eine eigene postgres-Datenbank (oder zumindest ein Schema), um Metadaten über Abfragen, Verbindungen, Genehmigungen usw. zu speichern.
Das offizielle Image finden Sie hier: https://hub.docker.com/_/postgres, oder nutzen Sie eine von Ihrem Cloud-Anbieter gehostete Version.

Beim Starten des kviklet-Containers müssen Sie dann diese drei Umgebungsvariablen entsprechend setzen:```
SPRING_DATASOURCE_PASSWORD = password
SPRING_DATASOURCE_USERNAME = username
SPRING_DATASOURCE_URL = jdbc:postgresql://[host]:[port]/[database]?currentSchema=[schema]

Wir veröffentlichen unsere Container derzeit auf GitHub Packages. Mit all diesen Einstellungen können Sie `ghcr.io/kviklet/kviklet:main` ausführen. Vergessen Sie nicht, Port `8080` zu mappen, der der Standardport ist, den Kviklet verwendet.

Ein Beispiel für einen Docker-Run könnte so aussehen:```
docker run \
-e SPRING_DATASOURCE_PASSWORD=postgres \
-e SPRING_DATASOURCE_USERNAME=postgres \
-e SPRING_DATASOURCE_URL=jdbc:postgresql://localhost:5432/Kviklet \
-e [email protected] \
-e INITIAL_USER_PASSWORD=someverysecurepassword \
--network host \
ghcr.io/kviklet/kviklet:main

Die Google-Client-ID und das Geheimnis erhalten Sie ganz einfach, indem Sie den Google-Anleitungen hier folgen:
https://developers.google.com/identity/gsi/web/guides/get-google-api-clientid

Für gültige Weiterleitungs-URIs sollten Sie konfigurieren: https://[kviklet_host]/api/login/oauth2/code/google
Für Zulässige Ursprünge (Allowed Origins) einfach Ihre gehostete Kviklet-URL.

Nachdem Sie diese Umgebungsvariablen gesetzt haben, kann sich jeder in Ihrer Organisation mit dem „Anmelden mit Google“-Button anmelden. Standardmäßig haben sie jedoch keine Berechtigungen. Sie müssen ihnen eine Rolle zuweisen, nachdem sie sich einmal angemeldet haben.

#### Keycloak

Wenn Sie stattdessen SSO mit Keycloak einrichten möchten, müssen Sie diese 4 Umgebungsvariablen setzen:```
KVIKLET_IDENTITYPROVIDER_CLIENTID
KVIKLET_IDENTITYPROVIDER_CLIENTSECRET
KVIKLET_IDENTITYPROVIDER_TYPE=keycloak
KVIKLET_IDENTITYPROVIDER_ISSUERURI=http://[host]:[port]/realms/[realm]

Erstellen Sie eine GitHub OAuth-App unter https://github.com/settings/developers und konfigurieren Sie:

- Autorisierungs-Callback-URL: `https://[kviklet_host]/api/login/oauth2/code/github`
- Homepage-URL: Ihre gehostete Kviklet-URL

`KVIKLET_IDENTITYPROVIDER_GITHUB_ALLOWEDORGS` ist **erforderlich** (Kviklet weigert sich zu starten, ohne dies). GitHub OAuth-Apps können nicht einschränken, wer den OAuth-Fluss durchführt, also ruft Kviklet nach der Authentifizierung `/user/orgs` auf und lehnt Benutzer ab, die kein Mitglied mindestens einer zugelassenen Organisation sind (Groß-/Kleinschreibung egal, die ersten 100 Organisationen werden überprüft).

Damit die Organisationsprüfung die Mitgliedschaft eines Benutzers sieht, muss der Benutzer auf dem OAuth-Zustimmungsbildschirm neben jeder zugelassenen Organisation auf **Erteilen** (oder **Anfordern**) klicken. Wenn die Organisation die Option „Drittanbieter-OAuth-Anwendungen einschränken“ aktiviert hat, muss ein Organisationsbesitzer die OAuth-App einmal genehmigen, bevor die Mitgliedschaft eines Mitglieds sichtbar wird.

Kviklet fordert die Bereiche `read:user`, `user:email` und `read:org` an. E-Mails werden immer von `/user/emails` gelesen und nur ein `primary && verified`-Eintrag wird akzeptiert, sodass sich Benutzer mit privaten E-Mail-Adressen trotzdem erfolgreich anmelden können.

#### Andere OIDC-Anbieter

Andere OIDC-konforme Anbieter (GitLab, Auth0, Okta, usw.) sollten ähnlich wie Keycloak funktionieren. Beachten Sie, dass sich die `redirect URI` je nach gewähltem Typ ändert. Wenn Sie also `gitlab` wählen, lautet sie `https://[kviklet_host]/api/login/oauth2/code/gitlab`. Wenn Sie auf Probleme stoßen, erstellen Sie gerne ein Issue. Wir haben noch nicht jeden einzelnen OIDC-Anbieter getestet und es könnte geringfügige Unterschiede in der Implementierung geben, die Aktualisierungen auf Seiten von Kviklet erfordern könnten.

### LDAP

Kviklet unterstützt LDAP-Authentifizierung. Um LDAP zu aktivieren und zu konfigurieren, können Sie die folgenden Umgebungsvariablen überschreiben:```
LDAP_ENABLED=true
LDAP_URL=ldap://your-ldap-server:389
LDAP_BASE=dc=your,dc=domain,dc=com
LDAP_PRINCIPAL=cn=admin,dc=your,dc=domain,dc=com
LDAP_PASSWORD=your-admin-password
LDAP_UNIQUE_IDENTIFIER_ATTRIBUTE=uid
LDAP_EMAIL_ATTRIBUTE=mail
LDAP_FULL_NAME_ATTRIBUTE=cn
LDAP_USER_OU=people
LDAP_SEARCH_BASE=ou=people

Configuration details:

- `SAML_ENABLED`: Auf `true` setzen, um die SAML-Authentifizierung zu aktivieren
- `SAML_ENTITYID`: Die Entitäts-ID Ihres SAML-Identitätsanbieters
- `SAML_SSOSERVICELOCATION`: Die SSO-Dienst-URL Ihres Identitätsanbieters
- `SAML_VERIFICATIONCERTIFICATE`: Das X.509-Zertifikat, das zur Überprüfung von SAML-Antworten verwendet wird (schließen Sie die BEGIN/END CERTIFICATE-Zeilen ein)

Sie können optional die SAML-Attributzuordnungen anpassen:```
SAML_USERATTRIBUTES_EMAILATTRIBUTE=email
SAML_USERATTRIBUTES_NAMEATTRIBUTE=name
SAML_USERATTRIBUTES_IDATTRIBUTE=nameID

## Konfiguration

### Verbindungen

Nach dem Start von Kviklet müssen Sie zunächst eine Datenbankverbindung konfigurieren. Gehen Sie zu Einstellungen -> Datenbanken -> Verbindung hinzufügen.

![Verbindung hinzufügen](https://assets.kitploit.com/production/public/readmes/7140/3ded2a0b23e5d2f02feb21a854263c91dedea25a789fb75ab8342384c4e39b52.png)
![Verbindung hinzufügen](https://assets.kitploit.com/production/public/readmes/7140/585238c9eddad8ed4e2440096ce0616445a6696e1042f58676a1d0b038edde7f.png)

Hier können Sie Review-Anforderungen und Ausführungslimits für jede Verbindung konfigurieren. Siehe [Review Gates](#review-gates) für Details.

#### AWS IAM AUTH

Kviklet unterstützt die Verwendung von IAM Auth für Postgres- und MySQL-Datenbankverbindungen. Wählen Sie dafür IAM Auth beim Erstellen einer neuen Verbindung.

![IAM Auth](https://assets.kitploit.com/production/public/readmes/7140/14ed42bd639eb9b0ba81b22850e277703f2da9495dd101f68066f95fc51f291c.png)
![IAM Auth](https://assets.kitploit.com/production/public/readmes/7140/5a60a3a9ae527e11679f3c33c787caba4c80b379ddc463db1f871288408517e1.png)

Dadurch wird die Option zum Festlegen eines Passworts entfernt und stattdessen werden AWS-Anmeldeinformationen verwendet, um eine Verbindung zur Datenbank herzustellen.

Kviklet verwendet den `DefaultCredentialsProvider` von AWS, um Anmeldeinformationen zu finden und das Token für die Verbindung zu generieren. Das bedeutet, dass alle üblichen Stellen funktionieren sollten (Umgebungsvariablen oder zugehörige Instanzrollen). Die genaue Reihenfolge ist hier dokumentiert: https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html

Zusätzlich können Sie eine AWS-Rollen-ARN angeben, die Kviklet übernimmt, und diese Anmeldeinformationen verwenden, um das temporäre DB-Token zu erstellen. Dies ist besonders nützlich, um eine Verbindung zu Datenbanken herzustellen, die sich nicht im selben AWS-Konto wie Kviklet befinden. Um diese Funktion zu nutzen, geben Sie einfach die Rollen-ARN in das dafür vorgesehene Feld ein, wenn Sie eine IAM-Auth-Verbindung erstellen oder bearbeiten. Wenn Sie das Feld leer lassen, wird der Standard-Anmeldeinformationsanbieter verwendet (keine Rollenübernahme).

Die während der Token-Generierung zu verwendende AWS-Region wird aus Ihrer Verbindungs-URL abgeleitet, daher gibt es keine Optionen, um sie festzulegen.

Um zu erfahren, wie Sie IAM Auth für Ihre Datenbank einrichten, folgen Sie der offiziellen AWS-Dokumentation: https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.IAMDBAuth.html
Die beiden Hauptpunkte sind:

- Erstellen Sie einen DB-Benutzer mit der IAM-Auth-Option und den richtigen Berechtigungen
- Erstellen Sie eine IAM-Richtlinie, die es der AWS-Entität erlaubt, Token für diesen Benutzer zu generieren

### Review Gates

Standardmäßig erlaubt Kviklet eine einfache Konfiguration der Anzahl der Überprüfungen. Sie können konfigurieren, wie viele Genehmigungen Anfragen für eine bestimmte Verbindung benötigen, bevor sie ausgeführt werden können.

Der Genehmigungsstatus einer Anfrage wird basierend auf der letzten Aktion jedes Prüfers berechnet. Wenn ein Prüfer genehmigt und später Änderungen anfordert, zählt nur die Änderungsanforderung – seine vorherige Genehmigung wird entfernt. Das Bearbeiten einer Anfrage setzt immer alle vorherigen Genehmigungen zurück, um sicherzustellen, dass keine Änderungen ausgeführt werden können, ohne zuerst überprüft zu werden. Ebenso werden bei einem Fehlschlagen der Ausführung (z. B. aufgrund eines SQL-Syntaxfehlers) die Genehmigungen zurückgesetzt, sodass die Anfrage korrigiert und erneut genehmigt werden kann, ohne eine neue erstellen zu müssen.

Sie können auch ein Limit für die **maximale Anzahl an Ausführungen** pro Verbindung konfigurieren, um zu steuern, wie oft eine einzelne genehmigte Anfrage ausgeführt werden kann. Der Standardwert ist 1. Wenn Sie dies auf 0 setzen, sind unbegrenzte Ausführungen möglich. Fehlgeschlagene Ausführungen zählen nicht zu diesem Limit.

#### Rollenbasierte Überprüfungsanforderungen (Enterprise)

Mit einer Kviklet Enterprise-Lizenz können Sie einzelne Verbindungen so konfigurieren, dass Genehmigungen von Benutzern mit bestimmten Rollen erforderlich sind. Dadurch können Sie z. B. die Genehmigung des Teams, das eine bestimmte Datenbank verwaltet, oder die Absicherung sensibler Verbindungen hinter DBA- oder Management-Genehmigungen erfordern.

**So funktioniert es:**

Jede Verbindung hat eine Anzahl **erforderlicher Gesamtüberprüfungen** (`numTotalRequired`), die als Mindestanzahl fungiert – die minimale Anzahl unterschiedlicher Genehmigungen, die unabhängig von Rollen erforderlich sind. Darüber hinaus können Sie **Rollenanforderungen** hinzufügen, die festlegen, wie viele Genehmigungen von Benutzern mit einer bestimmten Rolle stammen müssen (z. B. „1 von DBA, 1 von Sicherheit“).

Eine Anfrage wird nur genehmigt, wenn **beide** Bedingungen erfüllt sind:
- Die Gesamtzahl der unterschiedlichen Genehmigungen erreicht `numTotalRequired`
- Jede Rollenanforderung ist einzeln erfüllt

Wenn ein Benutzer mehreren Rollen angehört, zählt eine einzelne Genehmigung dieses Benutzers für alle übereinstimmenden Rollenanforderungen. Sie zählt jedoch weiterhin nur als eine Genehmigung für die Gesamtzahl.

**Beispiel:** Eine Verbindung erfordert 3 Gesamtgenehmigungen, darunter 1 von einem DBA und 1 von der Sicherheit. Ein Benutzer, der sowohl die DBA- als auch die Sicherheitsrolle besitzt, genehmigt – dies erfüllt beide Rollenanforderungen, zählt aber nur als 1 der 3 erforderlichen Gesamtgenehmigungen. Es sind noch zwei weitere Genehmigungen von beliebigen Benutzern erforderlich.

Wenn Ihre Enterprise-Lizenz abläuft, bleiben bestehende rollenbasierte Überprüfungsanforderungen bestehen, können aber nicht mehr geändert werden. Sie können sie nur entfernen, um auf die einfache Gesamtüberprüfungskonfiguration zurückzufallen.

### Rollen

Kviklet wird mit 3 Rollen ausgeliefert: Standard, Administratoren und Entwickler.

- Die Standardrolle gewährt Lesezugriff auf alle Verbindungen und Anfragen. Diese Rolle wird jedem Benutzer zugewiesen und kann nicht entfernt werden. Sie können die Berechtigungen dieser Rolle jedoch nach Belieben ändern.
- Administratoren haben die Berechtigung, Verbindungen zu erstellen und zu bearbeiten sowie neue Benutzer hinzuzufügen und deren Berechtigungen festzulegen.
- Entwickler können Anfragen erstellen sowie genehmigen, kommentieren und natürlich die eigentlichen Anweisungen ausführen.

Sie können Rollen anpassen und z. B. einer Rolle nur Zugriff auf eine bestimmte Verbindung oder eine Gruppe von DB-Verbindungen geben. Dies ist nützlich, wenn Sie verschiedene Teams mit unterschiedlichen Datenbanken haben und den Zugriff granularer steuern möchten.

#### Erstellen einer neuen Rolle

Das Erstellen einer neuen Rolle funktioniert wie folgt. Gehen Sie zu Einstellungen -> Rollen -> Rolle hinzufügen.

![Rolle hinzufügen](https://assets.kitploit.com/production/public/readmes/7140/a91b79287c0b3130b83bdde1c059f49b89c5d43a1c0deae33b211ea427956f8e.png)
![Rolle hinzufügen](https://assets.kitploit.com/production/public/readmes/7140/c535ac152759bb21bea04a0968ce43fa7bf946c7699feca23c71f9eaba41ceaf.png)

Die Standardeinstellungen sind für die meisten Rollen nicht so relevant und Sie können einfach Benutzer-Lese- und Rollenansichtszugriff gewähren und es dabei belassen. Interessanter ist das Hinzufügen einzelner Berechtigungen für Verbindungen. Hier fügen Sie zunächst einen Selektor hinzu, um bestimmte Verbindungen auszuwählen. Dies kann entweder eine bestimmte ID sein oder Sie verwenden Platzhalter mit `*`, um mehrere Verbindungen abzugleichen. Wenn Sie z. B. eine Rolle haben möchten, die Zugriff auf alle Dev-Datenbanken hat (falls Sie auch den Zugriff darauf mit Kviklet verwalten), würden Sie einen Selektor wie `dev-*` verwenden und sicherstellen, dass die IDs der Verbindungen korrekt eingestellt sind.

Sie können natürlich auch ein System erstellen, das Sie für Ihre verschiedenen Teams innerhalb Ihrer Organisation verwenden.

### Rollensynchronisation (Enterprise)

Synchronisieren Sie Benutzerrollen automatisch aus Ihren Identity-Provider-Gruppen. Diese Funktion erfordert eine Enterprise-Lizenz.

**Konfiguration** erfolgt unter Einstellungen > Rollensynchronisation:

- **Rollensynchronisation aktivieren**: Synchronisation ein-/ausschalten
- **Synchronisationsmodus**:
  - **Vollsynchronisation** – Benutzerrollen stimmen genau mit ihren IdP-Gruppenzuordnungen überein (plus der Standardrolle)
  - **Additiv** – IdP-Gruppen fügen Rollen hinzu, entfernen jedoch keine vorhandenen
  - **Nur erster Login** – Rollen werden nur beim ersten Login synchronisiert, manuelle Änderungen bleiben danach erhalten
- **Gruppenattribut**: Das IdP-Attribut, das Gruppenmitgliedschaften enthält (Standard: `groups`)
- **Rollenmappings**: Ordnen Sie IdP-Gruppennamen (z. B. `engineering`) Kviklet-Rollen zu

#### OIDC-Einrichtung

Konfigurieren Sie Ihren OIDC-Anbieter so, dass ein `groups`-Anspruch im ID-Token enthalten ist:

- **Keycloak**:

  Keycloak enthält standardmäßig keine Gruppen in Token, daher müssen Sie dem Client einen Mapper hinzufügen.

  1. Navigieren Sie im linken Menü zu **Clients**
  2. Wählen Sie Ihren Kviklet-Client aus
  3. Gehen Sie zum Tab **Client Scopes**
  4. Klicken Sie auf den dedizierten Scope (z. B. `kviklet-dedicated`)
  5. Gehen Sie zum Tab **Mappers**
  6. Klicken Sie auf **Mapper hinzufügen** → **Nach Konfiguration**
  7. Wählen Sie **Gruppenmitgliedschaft**
  8. Konfigurieren Sie den Mapper:

  | Einstellung | Wert |
  |---------|-------|
  | Name | `groups` |
  | Token Claim Name | `groups` |
  | Vollständiger Gruppenpfad | **OFF** |
  | Zum ID-Token hinzufügen | **ON** |
  | Zum Zugriffstoken hinzufügen | **ON** |
  | Zu userinfo hinzufügen | **ON** |

  9. Klicken Sie auf **Speichern**

  > **Wichtig:** Der „Token Claim Name“ muss mit dem „Gruppenattribut“ übereinstimmen, das in den Rollensynchronisationseinstellungen von Kviklet konfiguriert ist (Standard: `groups`).

- **Andere OIDC-Anbieter**: Fügen Sie einen Gruppen-Mapper/-Anspruch hinzu, der die Gruppenmitgliedschaften des Benutzers im ID-Token enthält. Dies erfolgt normalerweise in der Admin-Oberfläche des Anbieters.

  Wenn Sie auf Probleme stoßen, erstellen Sie bitte ein Issue. Wir haben noch nicht jeden einzelnen OIDC-Anbieter getestet und es könnte geringfügige Unterschiede in der Implementierung geben, die Aktualisierungen auf Kviklets Seite erfordern.

#### LDAP-Einrichtung

Die LDAP-Rollensynchronisation verwendet das `memberOf`-Attribut:

1. Stellen Sie sicher, dass auf Ihrem LDAP-Server das `memberOf`-Overlay aktiviert ist
2. Setzen Sie das **Gruppenattribut** in Kviklet auf `memberOf`
3. Die Gruppennamen werden dann aus dem `memberOf`-Attribut in den Benutzerattributen extrahiert.

#### SAML-Einrichtung

Konfigurieren Sie Ihren SAML-IdP so, dass er Gruppen in der Assertion enthält:

1. Fügen Sie eine Attribut-Anweisung hinzu, die Benutzergruppenmitgliedschaften abbildet
2. Setzen Sie das **Gruppenattribut** in Kviklet so, dass es mit Ihrem SAML-Attributnamen übereinstimmt
3. Die Gruppennamen werden dann aus dem SAML-Attribut in den Benutzerattributen extrahiert.

### Benachrichtigungen

Sie können Kviklet so konfigurieren, dass Benachrichtigungen an einen Kanal in Slack oder Teams gesendet werden. Dies ist nützlich, um Ihr Team über neue Anfragen zu informieren, die überprüft werden müssen. Sie können dies unter Einstellungen -> Allgemein -> Benachrichtigungseinstellungen konfigurieren.

#### Slack

Um Slack-Benachrichtigungen zu konfigurieren, müssen Sie eine Slack-App erstellen und Webhooks dafür aktivieren. Sie können die Anweisungen hier befolgen: https://api.slack.com/messaging/webhooks

#### Teams

Teams-Benachrichtigungen verwenden einen Power Automate **Workflow**-Webhook. Kviklet sendet eine Adaptive Card, die die Webhook-Vorlage in Ihren Kanal postet.

**Empfohlen: Verwenden Sie die Workflow-Vorlage**

1. Öffnen Sie in Teams den Kanal, in dem Sie Benachrichtigungen erhalten möchten, klicken Sie auf die **...** neben dem Kanalnamen und wählen Sie **Workflows** (oder fügen Sie die **Workflows**-App hinzu).
2. Suchen Sie nach der Vorlage **"Webhook-Benachrichtigungen an einen Kanal senden"** und erstellen Sie diese.
3. Melden Sie sich an, wenn Sie dazu aufgefordert werden, wählen Sie das Zielteam und den Zielkanal aus und erstellen Sie den Workflow.
4. Öffnen Sie den Triggerschritt und kopieren Sie die generierte **HTTP-POST-URL**.
5. Fügen Sie die URL in Kviklet unter Einstellungen -> Allgemein -> Benachrichtigungseinstellungen ein und klicken Sie auf Speichern.

**Alternative: Workflow manuell erstellen**

Wenn Sie den Flow lieber selbst erstellen möchten (oder die Vorlage nicht verfügbar ist):

1. Kanal **...** -> **Workflows** -> Erstellen Sie einen Flow mit dem Trigger **"Wenn eine Teams-Webhook-Anfrage empfangen wird"**.
2. Fügen Sie die Aktion **Microsoft Teams -> "Karte in einem Chat oder Kanal posten"** hinzu.
3. Setzen Sie das Feld **Adaptive Card** der Aktion auf den Ausdruck `string(triggerBody())`, damit die von Kviklet gesendete Karte gepostet wird.
4. Wählen Sie das Zielteam und den Zielkanal aus, **speichern** Sie, und kopieren Sie dann die **HTTP-POST-URL** aus dem Triggerschritt.

Derzeit gibt es Benachrichtigungen für:

- Neue Anfragen, die Genehmigungen benötigen
- Neue Genehmigungen für Anfragen

#### Basis-URL-Konfiguration

Wenn Kviklet hinter einem Reverse-Proxy oder Kubernetes-Ingress ausgeführt wird, können Benachrichtigungslinks die interne IP-Adresse anstelle Ihrer öffentlichen Domain verwenden. Kviklet versucht, die korrekte URL zu verfolgen, indem es eingehende Anfragen prüft, aber einige Reverse-Proxys setzen die Forwarded-Header nicht korrekt. Um dies zu beheben, legen Sie die Basis-URL explizit fest:```
KVIKLET_BASE_URL=https://kviklet.example.com

## Verschlüsselung

Wenn Sie nicht möchten, dass die Anmeldeinformationen im Klartext in der Datenbank gespeichert werden, wird empfohlen, die Datenbankverschlüsselung für die Kviklet-Postgres-DB selbst zu aktivieren. Bei den meisten Hosting-Anbietern ist dies ein einfaches Ankreuzfeld.
Wenn die Kviklet-Datenbank dennoch kompromittiert wird, stellt dies ein enormes Sicherheitsrisiko dar, da sie die Datenbank-Anmeldeinformationen für potenziell alle Ihre Produktionsdatenspeicher enthält. Daher können Sie die Verschlüsselung der ruhenden Anmeldeinformationen aktivieren.

Setzen Sie dazu einfach die beiden Umgebungsvariablen.```
ENCRYPTION_ENABLED=true
ENCRYPTION_KEY_CURRENT=some-secret

Kviklet wird beim Start alle Verbindungen neu verschlüsseln, sodass Sie den Container anschließend ohne den vorherigen Schlüssel neu starten können.

## API-Schlüssel

Kviklet unterstützt API-Schlüssel für den programmatischen Zugriff auf das System. Dies ist eine reine Enterprise-Funktion und erfordert eine gültige Lizenz. Sie können API-Schlüssel im Bereich Einstellungen -> API-Schlüssel erstellen.

![API-Schlüssel](https://assets.kitploit.com/production/public/readmes/7140/a11d80c93ef29ead3b8b3bf3b435a782208d10bd2978d80cd2c4edc1fc7bc506.png)
![API-Schlüssel](https://assets.kitploit.com/production/public/readmes/7140/21948bc6a43dbdd88be563befbfc9052a1dd4a99735817c2ff99680c9c32cbd0.png)

Verwenden Sie es wie folgt:```bash
curl --location '[kviklet_host]/api/connections/' \
--header 'Authorization: Bearer your-api-key'

Alternativ können Sie Dateien verwenden:```
PROXY_TLS_CERTIFICATE_SOURCE=file
PROXY_TLS_CERTIFICATE_CERT_FILE=path/to/cert.pem
PROXY_TLS_CERTIFICATE_KEY_FILE=path/to/key.pem