So verwenden Sie Docker-Build-Secrets: Sensible Daten sicher in Builds übergeben

Docker-Build-Secrets sind eine Funktion von Docker BuildKit, mit der Sie sensible Daten wie API-Schlüssel und Passwörter während des Build-Prozesses sicher übergeben können, ohne sie in das finale Image einzubetten.

Lesen Sie weiter, um mehr über die Verwendung von Build-Secrets zu erfahren, darunter:

1. Was Docker-Build-Secrets sind und warum sie unverzichtbar sind.
2. So erstellen, übergeben und verwenden Sie Secrets in einer Dockerfile.
3. So integrieren Sie Build-Secrets mit Docker Compose in Multi-Service-Anwendungen.
4. So nutzen Sie SSH-Mounts für den sicheren Zugriff auf private Ressourcen.
5. Best Practices zum Schutz sensibler Daten.

Am Ende wissen Sie, wie Sie sensible Daten bereits während der Build-Zeit mit sicheren, temporären Methoden für das Secret-Management in modernen Container-Workflows schützen.

Was sind Docker-Build-Secrets?

Docker-Build-Secrets bieten eine sichere Möglichkeit, während eines Docker-Builds sensible Dateien zu verwenden, ohne sie im finalen Image zu hinterlassen.

Wenn Sie ein Secret verwenden, bindet Docker es vorübergehend in den Build-Container ein. Sobald der Build-Schritt, der das Secret verwendet, abgeschlossen ist, hängt Docker die Datei wieder aus. Das Geheimnis wird weder in den Bildebenen noch in deren Verlauf gespeichert.

Der wichtigste Vorteil gegenüber älteren Methoden wie ARG und ENV ist die Sicherheit. Mit ARG oder ENV übergebene Daten lassen sich mit dem Befehl docker history einsehen, wodurch Ihre Geheimnisse offengelegt werden könnten.

Mit Build-Secrets bleiben die Daten flüchtig und werden nie Teil des Images, wodurch versehentliche Datenlecks verhindert werden.

Welche Arten von Build-Secrets gibt es?

Docker unterstützt beim Umgang mit sensiblen Daten während des Build-Prozesses zwei Arten von Mounts:

• Geheime Mounts. Wird für allgemeine Geheimnisse verwendet, etwa API-Schlüssel, Datenbankpasswörter oder Konfigurationsdateien. Docker begrenzt diese Secret-Dateien auf 500 KB.
• SSH-Mounts. Dient dazu, SSH-Agent-Verbindungen weiterzuleiten und so während des Builds einen sicheren Zugriff auf private Git-Repositories oder andere per SSH geschützte Ressourcen zu ermöglichen.

Docker-Build-Secrets erstellen und übergeben

Die einzelnen Schritte zum Erstellen und Übergeben Ihres ersten Build-Secrets finden Sie unten.

1. Installieren Sie Docker und aktivieren Sie Docker BuildKit

Installieren Sie zunächst Docker auf Ihrem System. Die Schritte unterscheiden sich je nach Betriebssystem. Für dieses Beispiel verwenden wir Docker unter Ubuntu.

Aktivieren Sie als Nächstes Docker BuildKit, da diese Komponente die Funktion für Build-Secrets bereitstellt. Sie können es für einen einzelnen Build oder dauerhaft aktivieren.

Wenn Sie BuildKit für einen einzelnen Build aktivieren möchten, führen Sie den Build-Befehl mit der Umgebungsvariable DOCKER_BUILDKIT=1 aus:

DOCKER_BUILDKIT=1 docker build .

Um BuildKit dauerhaft zu aktivieren, bearbeiten Sie die Docker-Daemon-Konfigurationsdatei unter ~/.docker/config.json und fügen Sie das folgende Feature-Flag hinzu:

{
   "features": {
      "buildkit": true
   }
}

2. Erstellen Sie Ihre geheime Datei

Eine Secret-Datei ist eine Klartextdatei, die die sensiblen Daten enthält, die Sie schützen möchten. Erstellen Sie für dieses Beispiel eine Datei, in der Sie ein Datenbankpasswort speichern.

Erstellen Sie in Ihrem Terminal die geheime Datei:

echo "mydb_password" > mydb-password.txt

Wenn Sie mehrere Secrets haben, speichern Sie jedes einzelne in einer separaten Datei. Damit können Sie deren Berechtigungen verwalten und sie einzeln in den Container einbinden. Zum Beispiel:

echo "my_api_key" > api-key.txt
echo "my_ssh_key" > ssh-key.txt

3. Übergeben Sie das Secret mit dem Flag –secret

Um die geheime Datei an den Build-Prozess zu übergeben, verwenden Sie in Ihrem docker build-Befehl das Flag –secret, und zwar so:

--secret id=mydb_password,src=mydb-password.txt

Hier ist eine Aufschlüsselung der Syntax des Flags:

• –geheim. Das Flag, das BuildKit mitteilt, dass Sie ein Secret übergeben.
• id=mydb_password. Eine eindeutige Kennung für das Secret. Verwenden Sie diese ID, um in Ihrer Dockerfile auf das Secret zu verweisen.
• src=mydb-password.txt. Der Pfad zur geheimen Datei auf Ihrem Host-Rechner.

Dieses Flag verwenden Sie später, nachdem Sie in Ihrer Dockerfile auf das Secret verwiesen haben.

Secrets in Dockerfiles verwenden

Sobald Sie einen geheimen Wert an den Build-Befehl übergeben, können Sie ihn in Ihrer Dockerfile verfügbar machen.

1. Binden Sie Ihr Secret in Ihrem Dockerfile ein

Um ein Secret zu verwenden, binden Sie es innerhalb einer RUN-Anweisung mit dem Flag –mount ein. Der Einhängetyp für Secrets ist type=secret.

Hier ist ein Beispiel für ein Dockerfile, das Ihr Datenbankpasswort als Secret einbindet:

# Ubuntu-Basis-Image verwenden
FROM ubuntu:24.04

# Secret mounten und prüfen, ob es vorhanden ist, ohne den Secret-Wert auszugeben
RUN --mount=type=secret,id=mydb_password \
   ls -l /run/secrets/ && \
   echo "Secret is available and correctly mounted!" || echo "No secret found"

In diesem Beispiel entspricht id=mydb_password der ID, die Sie im Flag –secret angegeben haben. Standardmäßig bindet Docker das Secret unter /run/secrets/ ein, und der Dateiname im Container entspricht der ID des Secrets.

2. Ihr Image aufbauen

Erstellen Sie nun das Image mit dem vollständigen Befehl, einschließlich des Flags –secret. Fügen Sie –no-cache und –progress=plain hinzu, damit die Ausgabe klar angezeigt wird.

docker build --no-cache --progress=plain --secret id=mydb_password,src=mydb-password.txt -t my-image .

Bei Erfolg zeigt die Ausgabe, dass das Secret während dieses RUN -Schritts korrekt im Verzeichnis /run/secrets/ eingebunden wurde.

Sobald der Schritt abgeschlossen ist, wird das Secret nicht gespeichert und ist im finalen Image nicht mehr enthalten.

3. Auf Secrets in Build-Schritten zugreifen

Auf den Inhalt der geheimen Datei können Sie wie auf jede andere Datei zugreifen. Verwenden Sie zum Beispiel während des Builds den cat-Befehl, um den Inhalt zur Fehlerbehebung anzuzeigen.

Aktualisieren Sie Ihre Dockerfile wie folgt:

# Mount a secret and access its content
RUN --mount=type=secret,id=mydb_password \
   cat /run/secrets/mydb_password || echo "No secret found"

Führen Sie dann den Build erneut aus:

docker build --no-cache --progress=plain --secret id=mydb_password,src=mydb-password.txt -t my-image .

Dadurch wird der Inhalt des Secrets in der Konsole ausgegeben. Das ist zwar für Tests nützlich, Sie sollten dies jedoch nicht in Ihren produktiven Dockerfiles belassen, da dadurch Geheimnisse in Ihren Build-Logs offengelegt werden können.

Wenn Sie Apps mit mehreren Diensten erstellen, besteht der nächste Schritt darin, Secrets in Docker Compose zu integrieren.

Build-Secrets in Docker Compose einbinden

Docker Compose ist ein Werkzeug zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern. Build-Secrets können Sie auch direkt in Ihrer Datei docker-compose.yml verwalten. Das vereinfacht die Konfigurationsverwaltung für komplexe Dienste.

Dieser Ansatz eignet sich ideal für die Verwaltung von Anwendungen wie einem Kafka-Cluster auf Docker, bei denen mehrere Komponenten sichere Konfigurationen benötigen.

Um Build-Secrets mit Docker Compose zu verwenden, definieren Sie diese im obersten Abschnitt secrets Ihrer Datei docker-compose.yml und weisen Sie sie anschließend den entsprechenden Services zu.

Hier ist ein Beispiel mit einem PostgreSQL-Datenbankdienst:

version: "3.8"
services:
   db:
      image: postgres
      environment:
         POSTGRES_PASSWORD_FILE: /run/secrets/mydb_password
      secrets:
         - mydb_password
secrets:
   mydb_password:
      file: ./mydb-password.txt

In dieser Datei:

• Der Secrets-Schlüssel auf oberster Ebene definiert ein Secret mit dem Namen mydb_password und weist Compose an, es aus der Datei ./mydb-password.txt zu beziehen.
• Der db-Dienst greift auf dieses Secret zu und macht es im Container verfügbar.
• Die Umgebungsvariable POSTGRES_PASSWORD_FILE weist das PostgreSQL-Image an, das Datenbankpasswort aus dem angegebenen Dateipfad innerhalb des Containers zu lesen, der standardmäßig /run/secrets/mydb_password ist.

Um Ihre App zu starten, führen Sie docker-compose up aus. Compose liest die geheime Datei von Ihrem Host und bindet sie sicher in den laufenden Container ein, ohne sie in der Service-Definition offenzulegen.

Bitte beachten Sie, dass Docker Compose zwar gut für die Verwaltung von App-Geheimnissen wie Passwörtern geeignet ist, Sie jedoch häufig Authentifizierungsgeheimnisse verwalten müssen. Hier können SSH-Mounts helfen.

SSH-Mounts für den sicheren Zugriff verwenden

SSH-Mounts sind eine spezielle Art von Build-Geheimnissen, die SSH-Schlüssel weiterleiten. Sie sind nützlich, wenn Sie während eines Builds ein privates Git-Repository klonen oder auf andere durch SSH geschützte Ressourcen zugreifen müssen.

Wie normale Secrets ist auch der SSH-Schlüssel nur während des RUN-Schritts vorübergehend verfügbar und wird niemals in das endgültige Image eingebettet.

In automatisierten CI/CD-Pipelines, in denen Sie möglicherweise Tools wie Ansible zur Installation und Konfiguration von Docker verwenden, bieten SSH-Mounts einen sicheren Kanal für diese Build-Schritte.

Um ein SSH-Mount zu verwenden, laden Sie Ihren SSH-Schlüssel in Ihren lokalen SSH-Agenten.

Starten Sie zunächst den SSH-Agenten, falls er noch nicht ausgeführt wird:

eval $(ssh-agent)

Fügen Sie dann Ihren privaten Schlüssel zum Agenten hinzu:

ssh-add ~/.ssh/id_rsa

Überprüfen Sie, ob der Schlüssel geladen ist:

ssh-add -l

Verweisen Sie als Nächstes in Ihrer Dockerfile auf das SSH-Mount. Der Mount-Typ für SSH ist type=ssh.

Unten finden Sie ein Beispiel, das ein privates Git-Repository klont:

FROM ubuntu:24.04
# Git- und SSH-Abhängigkeiten installieren
RUN apt update && apt install -y git ssh-client

# SSH-Schlüssel von GitHub zu known_hosts hinzufügen, um Abfragen zur Host-Verifizierung zu vermeiden
RUN mkdir -p -m 0700 ~/.ssh && \
    ssh-keyscan github.com >> ~/.ssh/known_hosts

# Privates Git-Repository mit dem gemounteten SSH-Schlüssel klonen
RUN --mount=type=ssh git clone git@github.com:your-org/your-private-repo.git /myproject

Abschließend erstellen Sie das Image mit dem Flag `–ssh`. Dieses Flag weist Docker an, den Socket des SSH-Agenten an den Build weiterzuleiten:

docker build --ssh default -t my-image .

Nachdem Sie nun wissen, wie Sie sowohl dateibasierte Secrets mit Docker Compose als auch SSH-Schlüssel mit SSH-Mounts handhaben, sehen wir uns als Nächstes bewährte Methoden an, mit denen Sie Ihre Builds sicher halten.

Was sind bewährte Methoden für die Verwaltung von Docker-Build-Secrets?

Die Einhaltung bewährter Verfahren hilft, sensible Daten in Docker-Containern während des gesamten Entwicklungszyklus zu schützen. Im Folgenden finden Sie einige allgemeingültige Richtlinien:

• Verwenden Sie ARG oder ENV niemals für sensible Daten. Diese Anweisungen machen Werte über den Befehl docker history sichtbar und ermöglichen es Angreifern, sie aus Image-Layern zu extrahieren. Verwenden Sie stattdessen immer Mounts mit –secret oder –ssh.
• Verwenden Sie für jede Umgebung separate Secrets. Verwenden Sie für Entwicklung, Staging und Produktion keine gemeinsamen Zugangsdaten. Dadurch wird die Auswirkung begrenzt, falls ein Geheimnis aus einer Umgebung kompromittiert wird.
• Schließen Sie Geheimnisse von der Versionsverwaltung aus. Fügen Sie vertrauliche Dateien und Verzeichnisse Ihrer .gitignore-Datei hinzu, damit sie nicht in Ihr Repository eingecheckt werden.
• Verwenden Sie die Verwaltung von Secrets zur Build-Zeit in CI/CD. Plattformen wie GitHub Actions oder Jenkins bieten sichere Möglichkeiten, Secrets während des Build-Prozesses einzuschleusen. Verwenden Sie stattdessen diese Funktionen, anstatt Geheimnisse in Ihrem Repository zu speichern.
• Rotieren Sie Secrets regelmäßig. Passwörter, API-Schlüssel und andere Zugangsdaten regelmäßig ändern. Verwenden Sie Automatisierungstools wie HashiCorp Vault, um diesen Prozess effizient zu verwalten.
• Überprüfen Sie Ihre Dockerfiles regelmäßig. Überprüfen Sie Dockerfiles auf unsichere Praktiken, etwa fest codierte Zugangsdaten oder ENV-Anweisungen mit sensiblen Daten, die versehentlich hinzugefügt worden sein könnten.

Die wichtigsten Erkenntnisse

Der Einsatz von Docker-Build-Secrets ist eine grundlegende Maßnahme, um containerisierte Anwendungen abzusichern. Es verhindert, dass sensible Daten wie API-Schlüssel, Token und Zugangsdaten versehentlich in Ihren finalen Docker-Images offengelegt werden.

Hier sind die wichtigsten Punkte, die Sie sich merken sollten:

• Verwenden Sie immer das Secret-Management von BuildKit. Verwenden Sie für Dateien das Flag –secret und für SSH-Schlüssel das Flag –ssh, um sensible Daten während des Builds vorübergehend bereitzustellen.
• Hinterlegen Sie Geheimnisse niemals fest im Code. Verwenden Sie für sensible Daten keine ARG– oder ENV-Anweisungen, da diese unsicher sind und sich leicht offenlegen lassen.
• Integrieren Sie Secrets in Ihre Workflows. Verwenden Sie die Secrets-Funktion von Docker Compose, um Konfigurationen für Multi-Container-Apps sauber und sicher zu verwalten.
• Achten Sie auf eine konsequente Sicherheitsdisziplin. Halten Sie geheime Dateien mit .gitignore aus der Versionsverwaltung heraus, wechseln Sie Geheimnisse regelmäßig aus und verwenden Sie für jede Umgebung separate Zugangsdaten.

Als Nächstes erhöhen Sie die Sicherheit Ihrer Docker-Umgebung, indem Sie eine private Docker-Registry einrichten, um den Zugriff auf Images zu steuern und sensible Workloads zu schützen.

Dieser Ansatz schützt Images, verringert das Risiko unbefugter Zugriffe und gibt Ihnen die volle Kontrolle über Ihre Deployment-Pipeline.

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Faradilla Ayunindya

Faradilla, auch bekannt als Ninda, ist Content Marketing Specialist bei Hostinger mit über fünf Jahren Erfahrung und einem zehnjährigen Hintergrund als Linguistin. Sie möchte Technologie für alle zugänglich machen, indem sie komplexe Anleitungen in klare und leicht verständliche Schritt-für-Schritt-Guides verwandelt. In ihrer Freizeit interessiert sie sich für Biowissenschaften oder schaut gerne lustige Tiervideos. Vernetzen Sie sich mit ihr auf LinkedIn.

Mehr von Faradilla Ayunindya