Docker-Sicherheit: Best Practices für Dockerfiles und Docker Compose

Docker hat die Art und Weise, wie wir Anwendungen entwickeln, verpacken und bereitstellen, revolutioniert. Die Containerisierungstechnologie bietet zahlreiche Vorteile wie Portabilität, Skalierbarkeit und Isolierung. Doch mit zunehmender Verbreitung von Docker-Containern wird auch die Sicherheit zu einem immer wichtigeren Thema. Ein unzureichend abgesicherter Container kann ein erhebliches Sicherheitsrisiko darstellen und die gesamte Infrastruktur gefährden.

In diesem umfassenden Leitfaden erfährst du, welche Best Practices für die Sicherheit von Dockerfiles und Docker Compose existieren, wie du deine Container-Umgebung effektiv absichern kannst und welche Maßnahmen besonders wichtig sind. Ob du ein Anfänger im Bereich Docker bist oder bereits fortgeschrittene Kenntnisse hast – dieser Artikel bietet dir wertvolle Hinweise, um deine Docker-Umgebung sicherer zu gestalten.

Inhaltsverzeichnis

1. Einführung in Docker-Sicherheit
2. Best Practices für Dockerfile-Sicherheit
3. Reduzierung der Angriffsfläche in Dockerfiles
4. Best Practices für Docker Compose
5. Container-Laufzeitsicherheit
6. Docker-Umgebung absichern
7. Implementierung von Sicherheitskontrollen
8. Sicherheitsüberwachung und Incident Response
9. Fazit: Sichere Docker-Umgebungen aufbauen
10. FAQs zur Docker-Sicherheit

Einführung in Docker-Sicherheit

Warum ist Docker-Sicherheit wichtig?

In einer Zeit, in der sich der Trend der Unternehmen weiterhin stark in Richtung Cloud bewegt, gewinnen Container immer mehr an Bedeutung. Es ist daher von höchster Relevanz, diese containerisierten Anwendungen mit Best Practices abzusichern, um ein angemessenes Maß an Grundsicherheit zu erreichen. Die Sicherheit von Docker-Containern betrifft einerseits die Sicherheit der Dockerfiles selbst, also Docker-Base-Images und potenziell fehlerhafte Sicherheitseinstellungen. Andererseits sind auch Sicherheitsbelange der Docker-Container während der Laufzeit, wie Netzwerk-Ports, Benutzerberechtigungen und der Zugriff auf gemountete Dateisysteme von großer Bedeutung.

Docker wirkt beinahe wie ein Magnet für Angriffe aus dem Cyberspace. Das Absichern einer Docker-Umgebung erfordert sowohl eine gehörige Dosis gesunden Menschenverstands als auch eine Menge administrativer Kleinarbeit. Hacker zielen besonders gerne auf Docker-Server ab, die durch Konfigurationsfehler "glänzen". Eine aktuelle Kampagne, die sich durch Crypto-Mining mit Hilfe der kompromittierten Systeme finanziert, wurde von Forschern untersucht.

Die Angreifer missbrauchen häufig die REST-API von Docker, um eigene Container auf einem verwundbaren Server einzurichten. Der betroffene Host bezieht ein bösartiges Docker-Image von Docker Hub und initialisiert damit einen neuen Container, der dann verschiedene schädliche Aktivitäten ausführt.

Die Sicherheitsgrundlagen in Docker verstehen

Bevor wir in die spezifischen Best Practices eintauchen, ist es wichtig, die grundlegenden Sicherheitsaspekte von Docker zu verstehen. Docker's Sicherheitsmodell basiert auf verschiedenen Technologien:

• Kernel Namespaces: Docker nutzt Kernel-Namespaces zur Prozessisolierung. Jeder Container arbeitet in seinem eigenen Namespace und isoliert seine Prozesse und Systemressourcen von anderen Containern und dem Host.
• Control Groups (Cgroups): Cgroups spielen eine wichtige Rolle bei der Verwaltung und Begrenzung der Container-Ressourcennutzung. Sie helfen, Denial-of-Service-Angriffe zu verhindern, indem sie Ressourcen fair unter den Containern aufteilen.
• Docker Daemon: Der Docker-Daemon ist das Herzstück der Docker-Architektur und muss besonders gut abgesichert werden, da jeder mit Zugriff auf den Daemon Docker-Befehle auf deinem Host ausführen kann.

Best Practices für Dockerfile-Sicherheit

Vertrauenswürdige Basis-Images verwenden

Eine der wichtigsten Best Practices für die Sicherheit deiner Docker-Container ist die Verwendung vertrauenswürdiger Basis-Images. Offizielle Docker-Images, die speziell für deine Technologie entwickelt wurden, sollten immer die erste Wahl sein. Diese Images werden von Millionen von Benutzern getestet und optimiert, was ihre Zuverlässigkeit und Sicherheit erhöht.

Es ist wichtig, spezifische Image-Tags zu verwenden, anstatt auf "latest" zurückzugreifen. Die Verwendung eines bestimmten Tags oder einer bestimmten Version für dein Image gibt deinem Image Rückverfolgbarkeit. Bei der Fehlerbehebung des laufenden Containers wird das genaue Image offensichtlich sein.

# Gut
FROM nginx:1.23.1

# Vermeiden
FROM nginx:latest

Zudem solltest du bei der Auswahl der Basis-Images auf minimale Varianten setzen. Je mehr Software dein Container enthält, desto größer ist die potenzielle Angriffsfläche. Das Prinzip sollte daher immer sein, nur das absolute Minimum einzubeziehen, das deine Anwendung benötigt, um zu funktionieren.

Images und Abhängigkeiten aktuell halten

Regelmäßige Updates sind ein wesentlicher Bestandteil jeder Sicherheitsstrategie. Die Aufrechterhaltung einer hochmodernen Webhosting-Umgebung mit Docker erfordert ständige Wachsamkeit. Um deine Container sicher zu halten, solltest du die Docker-Engine und ihre Abhängigkeiten regelmäßig aktualisieren.

Um gegen bekannte Container-Escape-Schwachstellen wie Leaky Vessels zu schützen, die typischerweise dazu führen, dass der Angreifer Root-Zugriff auf den Host erhält, ist es wichtig, sowohl den Host als auch Docker auf dem neuesten Stand zu halten. Dies umfasst regelmäßige Updates des Host-Kernels sowie der Docker Engine.

Container teilen den Kernel des Hosts. Wenn der Kernel des Hosts anfällig ist, sind auch die Container anfällig. Ein proaktiver Sicherheitsansatz, bei dem Updates und Patches zeitnah angewendet werden, hilft dir, eine robuste Webhosting-Umgebung aufzubauen und den Bedrohungen voraus zu sein.

Die Größe der Images minimieren

Ein häufiges Problem in Bezug auf die Sicherheit von Docker-Containern ist, dass man oft mit übergroßen Images für die Docker-Container endet. Im Allgemeinen gilt: Je mehr Software dein Container hat, desto größer ist die potenzielle Angriffsfläche.

Um die Größe deiner Images zu minimieren, solltest du folgende Praktiken anwenden:

• Minimalistische Basis-Images verwenden: Leichtgewichtige Images wie alpine sind kleiner, schneller herunterzuladen und reduzieren die Angriffsfläche.
• Schichten minimieren: Kombiniere Befehle, um die Anzahl der Schichten in deinem Dockerfile zu minimieren (z.B. verwende &&, um Befehle in einer einzigen RUN-Anweisung zu verketten).
• Cache löschen: Entferne Paketmanager und Caches nach der Installation (z.B. apt-get clean für Ubuntu).

# Gut - Minimale Schichten und Aufräumen nach Installation
RUN apt-get update && \
    apt-get install -y package1 package2 && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Vermeiden - Mehrere Schichten und kein Aufräumen
RUN apt-get update
RUN apt-get install -y package1
RUN apt-get install -y package2

Multi-Stage Builds verwenden

Multi-Stage Builds sind eine effektive Methode, um Docker-Images zu optimieren und gleichzeitig die Sicherheit zu verbessern. Mit dieser Technik kannst du Build-Abhängigkeiten von der Laufzeitumgebung trennen, was zu schlankeren Produktions-Images führt.

So funktioniert ein Multi-Stage Build:

# Build-Stage
FROM node:14 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Produktions-Stage
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

In diesem Beispiel wird das Build-Image verwendet, um die Anwendung zu kompilieren, und nur die kompilierten Dateien werden in das endgültige Produktions-Image kopiert. Dies reduziert die Größe des endgültigen Images erheblich und minimiert die Angriffsfläche, da Build-Tools und -Abhängigkeiten nicht im Produktions-Image enthalten sind.

Die richtige Benutzerberechtigungen einrichten

Für Sicherheitszwecke solltest du immer sicherstellen, dass deine Images als Nicht-Root ausgeführt werden, indem du USER in deinem Dockerfile definierst. Zusätzlich solltest du die Berechtigungen für die Dateien und Verzeichnisse für den Benutzer festlegen.

Da der Docker-Daemon als Root ausgeführt wird, werden Docker-Images standardmäßig als Root ausgeführt. Das bedeutet, wenn ein Prozess im Container kompromittiert wird, hat der Angreifer Root-Zugriff auf den Container.

# Einen nicht-root Benutzer erstellen
RUN groupadd -r appgroup && useradd -r -g appgroup appuser

# Verzeichnisberechtigungen setzen
RUN chown -R appuser:appgroup /app

# Als nicht-root Benutzer ausführen
USER appuser

CMD ["./app"]

Vermeide es, deine Umgebung als Root auszuführen. Openshift und einige Kubernetes-Cluster werden standardmäßig restriktive Richtlinien anwenden, die Root-Container am Ausführen hindern. Widerstehe der Versuchung, als Root zu arbeiten, um Berechtigungs- oder Eigentumsprobleme zu umgehen, und behebe stattdessen das eigentliche Problem.

Reduzierung der Angriffsfläche in Dockerfiles

Unnötige Pakete und Abhängigkeiten vermeiden

Es ist eine Dockerfile-Best-Practice, die Images minimal zu halten. Vermeide die Einbeziehung unnötiger Pakete oder das Freilegen von Ports, um die Angriffsfläche zu reduzieren. Je mehr Komponenten du in einem Container einschließt, desto exponierter ist dein System und desto schwieriger ist es zu warten, besonders für Komponenten, die nicht unter deiner Kontrolle stehen.

Einige Tipps zur Minimierung der Abhängigkeiten:

• Verwende immer die neueste Version eines Basis-Images. Diese Version sollte die neuesten verfügbaren Sicherheitspatches enthalten, wenn das Basis-Image erstellt wird.
• Führe Schwachstellenscans durch. Scanne ein Basis- oder Anwendungs-Image, um zu bestätigen, dass es keine bekannten Sicherheitslücken enthält.
• Wähle Basis-Images ohne unnötige Pakete. Verwende spezialisierte, schlanke Basis-Images, die nur die für deine Anwendung notwendigen Komponenten enthalten.

Ports richtig absichern

Die Absicherung von Ports ist ein wichtiger Aspekt der Docker-Sicherheit. Exponiere nur die notwendigen Ports und achte darauf, wie du sie konfigurierst:

• Exponiere nur die Ports, die deine Anwendung wirklich benötigt.
• Wenn möglich, binde Ports an die lokale Schnittstelle (127.0.0.1) anstatt an alle Schnittstellen (0.0.0.0).
• Verwende nicht-privilegierte Ports (über 1024), es sei denn, es ist absolut notwendig.

In Docker Compose kann das so aussehen:

services:
  webapp:
    image: my-webapp
    ports:
      # Bindet an localhost:8080, nicht an alle Schnittstellen
      - "127.0.0.1:8080:8080"

Mit .dockerignore vertrauliche Dateien ausschließen

Um zu vermeiden, dass unnötige Dateien in das Image kopiert werden, erstelle eine .dockerignore-Datei, ähnlich wie .gitignore. Dies ist besonders wichtig, um zu verhindern, dass sensible Informationen wie Konfigurationsdateien, Zertifikate oder Umgebungsvariablen versehentlich in dein Docker-Image gelangen.

Eine typische .dockerignore-Datei könnte so aussehen:

# Versionskontrolle
.git
.gitignore

# Build-Artefakte
node_modules
npm-debug.log
build
dist

# Sensible Dateien
.env
*.pem
*.key
secrets/

Security Scanning für Images einrichten

Die Verwendung von Security-Scanning-Tools ist unerlässlich, um potenzielle Sicherheitslücken in deinen Docker-Images zu identifizieren. Mit Lintern wie hadolint oder dockle gewährleistest du die Sicherheit deiner Dockerfile-Konfiguration. Außerdem solltest du deine Container-Images scannen, um Schwachstellen zu erkennen.

Einige empfohlene Tools für das Security-Scanning sind:

• Snyk: Findet und behebt Schwachstellen in Abhängigkeiten und Container-Images.
• Docker Bench for Security: Überprüft Docker-Konfigurationen anhand der CIS Docker Benchmark.
• Trivy: Ein einfacher, umfassender Scanner für Schwachstellen in Container-Images.

Regelmäßiges Scannen deiner Images sollte Teil deines CI/CD-Prozesses sein, um sicherzustellen, dass keine bekannten Sicherheitslücken in die Produktion gelangen.

Best Practices für Docker Compose

Sicherheitsaspekte bei der Netzwerkkonfiguration

Docker Compose unterstützt die Netzwerksegmentierung deiner Container. Du kannst private Netzwerke erstellen, in denen deine Container miteinander kommunizieren, isoliert von anderen Netzwerken. Dies ist ein wichtiger Aspekt für die Sicherheit, da es die Angriffsfläche deiner Anwendung reduziert.

Ein Beispiel für eine sichere Netzwerkkonfiguration in Docker Compose:

services:
  webapp:
    image: my-webapp
    networks:
      - frontend

  api:
    image: my-api
    networks:
      - frontend
      - backend

  database:
    image: postgres
    networks:
      - backend

networks:
  frontend:
  backend:
    internal: true  # Kein direkter Zugriff von außen möglich

In diesem Beispiel kann die Datenbank nur vom API-Service erreicht werden, der wiederum mit dem Webapp-Service kommuniziert. Die Datenbank ist vom Internet isoliert, was die Sicherheit erhöht.

Umgang mit sensiblen Daten in Docker Compose

Für sensible Daten wie Passwörter, API-Schlüssel oder Zertifikate solltest du Umgebungsvariablen oder Docker Secrets verwenden, anstatt sie direkt in deine Docker Compose-Datei einzubetten.

Hier ein Beispiel für die Verwendung von Umgebungsvariablen:

services:
  webapp:
    image: my-webapp
    environment:
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}

Noch sicherer ist die Verwendung von Docker Secrets, besonders in Produktionsumgebungen:

services:
  webapp:
    image: my-webapp
    secrets:
      - db_password

secrets:
  db_password:
    file: ./secrets/db_password.txt

Auf diese Weise werden sensible Daten niemals direkt im Docker Compose-File oder im Image gespeichert, was das Risiko von Datenlecks erheblich reduziert.

Volume-Berechtigungen richtig konfigurieren

Volumes sind die bevorzugte Methode, um persistente Daten in Docker zu speichern. Sie ermöglichen es dir, Daten unabhängig vom Lebenszyklus eines Containers zu speichern. Allerdings ist es wichtig, die Berechtigungen für diese Volumes korrekt zu konfigurieren, um unbefugten Zugriff zu verhindern.

Achte darauf, dass die Volumes die richtigen Berechtigungen haben und nur für die Benutzer zugänglich sind, die sie benötigen. Wenn möglich, verwende read-only Volumes für Container, die keine Schreibrechte benötigen:

services:
  webapp:
    image: my-webapp
    volumes:
      - ./config:/app/config:ro  # Read-only Volume
      - data:/app/data

volumes:
  data:

Ressourcenbegrenzungen festlegen

Um Denial-of-Service-Angriffe zu verhindern und eine faire Ressourcenverteilung zu gewährleisten, solltest du Ressourcenbegrenzungen für deine Container festlegen. Dies kann in Docker Compose mit der deploy-Sektion erfolgen:

services:
  webapp:
    image: my-webapp
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

Diese Konfiguration stellt sicher, dass der Container nicht mehr als 0,5 CPU-Kerne und 512 MB RAM verwenden kann, was verhindert, dass ein kompromittierter oder fehlerhafter Container den Host vollständig auslastet.

Container-Laufzeitsicherheit

Nicht als Root-Benutzer ausführen

Eine der wichtigsten Sicherheitsmaßnahmen für Docker-Container ist, sie nicht als Root-Benutzer auszuführen. Dies ist besonders wichtig, da ein Angreifer, der Zugriff auf einen Container erlangt, der als Root läuft, leichter auf den Host-System zugreifen kann.

Führe deine Docker-Images immer mit --security-opt=no-new-privileges aus, um Privilege Escalation zu verhindern. Dies verhindert, dass der Container neue Privilegien erlangt, z.B. durch Ausführung von setuid-Binärdateien.

docker run --security-opt=no-new-privileges -it my-image

In Docker Compose kannst du das so konfigurieren:

services:
  webapp:
    image: my-webapp
    security_opt:
      - no-new-privileges:true

Container-Berechtigungen beschränken

Auch in der Ausführung kannst du die Anwendungsberechtigungen auf den minimal erforderlichen Satz beschränken, indem du --cap-drop in Docker oder securityContext.capabilities.drop in Kubernetes verwendest. Auf diese Weise ist im Falle einer Kompromittierung deines Containers der Handlungsspielraum für einen Angreifer begrenzt.

docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE my-image

Dieses Beispiel entfernt alle Capabilities und fügt nur die eine hinzu, die benötigt wird, damit die Anwendung an einen Port unter 1024 binden kann.

Zusätzlich kannst du AppArmor und Seccomp als weitere Mechanismen zur Einschränkung von Container-Privilegien einsetzen.

Health und Liveness Checks implementieren

Wenn du Docker oder Docker Swarm verwendest, solltest du eine HEALTHCHECK-Anweisung in dein Dockerfile aufnehmen, wann immer es möglich ist. Dies ist entscheidend für lang laufende oder persistente Dienste, um sicherzustellen, dass sie gesund sind, und das Neustarten des Dienstes zu verwalten, falls dies nicht der Fall ist.

HEALTHCHECK --interval=5m --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

Wenn du deine Images in Kubernetes ausführst, verwende stattdessen die livenessProbe-Konfiguration innerhalb der Container-Definitionen, da die Docker-HEALTHCHECK-Anweisung nicht angewendet wird.

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 3
  periodSeconds: 3

Container-Isolation sicherstellen

Docker bietet standardmäßig eine gewisse Isolation zwischen Containern und dem Host-System. Dennoch gibt es zusätzliche Maßnahmen, die du ergreifen kannst, um die Isolation zu verbessern:

• Verwende benutzerdefinierte Netzwerke, um Container zu segmentieren und den Netzwerkverkehr zwischen ihnen zu kontrollieren.
• Setze --pid=host und --network=host nur ein, wenn es absolut notwendig ist, da diese Flags die Isolation verringern.
• Vermeide die Verwendung von privilegierten Containern (--privileged), da sie vollen Zugriff auf das Host-System haben.

Ein Beispiel für die Verwendung eines benutzerdefinierten Netzwerks:

docker network create app-network
docker run --network=app-network --name=webapp my-webapp
docker run --network=app-network --name=api my-api

Docker-Umgebung absichern

Docker Daemon richtig konfigurieren

Der Docker-Daemon ist normalerweise über einen Unix-Socket unter /var/run/docker.sock verfügbar. Es besteht die Möglichkeit, den Daemon optional so zu konfigurieren, dass er auch auf einen TCP-Socket hört, was Remote-Verbindungen zum Docker-Host von einer anderen Maschine aus ermöglicht.

Dies sollte vermieden werden, da es einen zusätzlichen Angriffsvektor darstellt. Wenn du versehentlich den TCP-Socket in deinem öffentlichen Netzwerk freigibst, kann jeder Befehle an die Docker-API senden, ohne vorher physischen Zugriff auf deinen Host zu benötigen. Lasse TCP deaktiviert, es sei denn, dein Anwendungsfall erfordert Fernzugriff.

Wenn es keine Alternative zur Verwendung von TCP gibt, ist es unerlässlich, den Socket mit TLS zu schützen. Dadurch wird sichergestellt, dass der Zugriff nur Clients gewährt wird, die den richtigen Zertifikatsschlüssel vorlegen.

Setze niemals den Docker-Daemon-Socket (auch nicht für die Container) frei. Der Docker-Socket /var/run/docker.sock ist der UNIX-Socket, auf den Docker hört. Dies ist der primäre Eintrittspunkt für die Docker-API. Der Eigentümer dieses Sockets ist Root. Jemandem Zugriff darauf zu geben, entspricht der Gewährung uneingeschränkten Root-Zugriffs auf deinen Host.

Docker-Host aktuell halten

Das Aktuellhalten des Docker-Hosts ist genauso wichtig wie das Aktuellhalten der Docker-Engine selbst. Regelmäßige Sicherheitsupdates für das Betriebssystem und den Kernel sind entscheidend, um bekannte Sicherheitslücken zu schließen.

Einige wichtige Punkte:

• Führe regelmäßig System-Updates durch (apt update && apt upgrade in Debian/Ubuntu, yum update in CentOS/RHEL).
• Halte den Kernel auf dem neuesten Stand, besonders wenn Sicherheitspatches verfügbar sind.
• Verwende bewährte Sicherheitspraktiken für dein Betriebssystem, wie das Deaktivieren nicht benötigter Dienste und das Einrichten einer Firewall.

Netzwerksicherheit für Docker-Umgebungen

Die Netzwerksicherheit ist ein kritischer Aspekt bei der Absicherung deiner Docker-Umgebung. Hier sind einige Best Practices:

• Verwende Docker-Netzwerke, um Container zu segmentieren und den Netzwerkverkehr zwischen ihnen zu kontrollieren.
• Verwende Firewalls, um den Zugriff auf Docker-Host-Ports zu beschränken und nur die notwendigen Ports zu öffnen.
• Nutze TLS für die sichere Kommunikation zwischen Containern und externen Diensten.

Ein Beispiel für die Einrichtung von Netzwerksegmentierung:

# Erstelle separate Netzwerke für verschiedene Anwendungsteile
docker network create frontend
docker network create backend

# Verbinde Container mit den entsprechenden Netzwerken
docker run --network=frontend --name=webapp my-webapp
docker run --network=backend --name=database my-database

# Verbinde Container, die mit beiden Netzwerken kommunizieren müssen
docker network connect backend webapp

Logging und Monitoring für Sicherheitszwecke einrichten

Die Überwachung und Protokollierung deiner Docker-Umgebung ist entscheidend, um Sicherheitsvorfälle zu erkennen und darauf zu reagieren. Folgende Maßnahmen können dir dabei helfen:

• Richte ein zentrales Logging-System ein, um Container-Logs zu sammeln und zu analysieren.
• Implementiere Monitoring-Tools, die ungewöhnliche Aktivitäten in deiner Docker-Umgebung erkennen können.
• Verwende Tools wie Falco, um verdächtige Aktivitäten in Echtzeit zu erkennen.

Eine einfache Konfiguration für das Logging in Docker Compose könnte so aussehen:

services:
  webapp:
    image: my-webapp
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Für fortgeschrittenere Anforderungen könntest du einen Logging-Treiber wie Fluentd oder Logstash konfigurieren, um Logs an ein zentrales Log-Management-System wie Elasticsearch zu senden.

Implementierung von Sicherheitskontrollen

Vulnerability Scanning in CI/CD-Pipelines

Das Integrieren von Vulnerability Scanning in deine CI/CD-Pipelines ist ein wesentlicher Schritt, um zu verhindern, dass Container mit bekannten Schwachstellen in die Produktion gelangen. Tools wie Trivy, Snyk oder Clair können automatisch in deine Pipelines integriert werden, um Images auf Schwachstellen zu überprüfen, bevor sie bereitgestellt werden.

Hier ist ein Beispiel für die Integration von Trivy in eine GitLab CI/CD-Pipeline:

stages:
  - build
  - scan
  - deploy

build:
  stage: build
  script:
    - docker build -t my-app:$CI_COMMIT_SHA .

scan:
  stage: scan
  script:
    - trivy image my-app:$CI_COMMIT_SHA
  only:
    - main

deploy:
  stage: deploy
  script:
    - docker push my-app:$CI_COMMIT_SHA
  only:
    - main
  dependencies:
    - scan

Secrets Management in Docker-Umgebungen

Das sichere Verwalten von Geheimnissen (Secrets) wie Passwörtern, API-Schlüsseln und Zertifikaten ist entscheidend für die Sicherheit deiner Docker-Umgebung. Anstatt diese Informationen direkt in deine Dockerfiles oder Docker Compose-Dateien einzubetten, solltest du dedizierte Lösungen für das Secrets Management verwenden.

Einige Möglichkeiten:

• Docker Secrets: Für Docker Swarm-Umgebungen bietet Docker eine integrierte Lösung für das Secrets Management.
• Kubernetes Secrets: Wenn du Kubernetes verwendest, kannst du dessen Secrets-Management-Funktionen nutzen.
• Hashicorp Vault: Eine fortgeschrittene Lösung für das Verwalten von Geheimnissen, die sich gut in Docker-Umgebungen integrieren lässt.

Ein Beispiel für die Verwendung von Docker Secrets in einer Docker Compose-Datei:

services:
  webapp:
    image: my-webapp
    secrets:
      - db_password
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password

secrets:
  db_password:
    external: true

Runtime Security Controls

Die Absicherung von Containern zur Laufzeit ist ein wichtiger Aspekt der Docker-Sicherheit. Hier sind einige Best Practices:

• Seccomp-Profile: Begrenzen der Systemaufrufe, die Container verwenden können.
• AppArmor/SELinux: Mandatory Access Control (MAC) für Container einrichten.
• Auditd: System-Calls auf dem Host überwachen, um verdächtige Aktivitäten zu erkennen.

Ein Beispiel für die Verwendung eines Seccomp-Profils:

docker run --security-opt seccomp=/path/to/seccomp-profile.json my-image

Oder in Docker Compose:

services:
  webapp:
    image: my-webapp
    security_opt:
      - seccomp:/path/to/seccomp-profile.json

Sicherheitsüberwachung und Incident Response

Container-Überwachung und -Anomalieerkennung

Die kontinuierliche Überwachung deiner Container-Umgebung ist entscheidend, um Sicherheitsvorfälle frühzeitig zu erkennen. Tools und Praktiken, die dir dabei helfen können:

• Prometheus und Grafana: Für die Überwachung von Container-Metriken und die Erstellung von Dashboards.
• Falco: Ein Open-Source-Tool zur Erkennung von Container-Anomalien in Echtzeit.
• ELK-Stack: Für die zentrale Sammlung und Analyse von Container-Logs.

Einrichten von Alarmen für ungewöhnliche Aktivitäten wie:

• Unerwartete Zugriffe auf sensible Dateien oder Verzeichnisse
• Unerwartete Netzwerkverbindungen oder erhöhter Netzwerkverkehr
• Plötzliche Änderungen im Ressourcenverbrauch (CPU, RAM)

Incident Response für Container-Umgebungen

Ein gut definierter Incident-Response-Plan ist unerlässlich, um effektiv auf Sicherheitsvorfälle in deiner Docker-Umgebung reagieren zu können. Einige wichtige Aspekte:

• Isolation: Verfahren zur Isolierung kompromittierter Container vom Rest der Umgebung.
• Forensik: Tools und Prozesse für die forensische Untersuchung von Containern.
• Wiederherstellung: Strategien für die schnelle Wiederherstellung betroffener Dienste.

Ein einfacher Incident-Response-Workflow könnte so aussehen:

1. Erkennen des Vorfalls (durch Monitoring oder Alerts)
2. Isolieren des betroffenen Containers
3. Sammeln von Beweisen (Container-Logs, Images)
4. Analysieren des Vorfalls
5. Eindämmen und beseitigen der Bedrohung
6. Wiederherstellen des Normalbetriebs
7. Dokumentieren und lernen aus dem Vorfall

Fazit: Sichere Docker-Umgebungen aufbauen

Die wichtigsten Sicherheitsmaßnahmen im Überblick

Die Sicherheit von Docker-Containern ist ein komplexes und kritisches Thema, das einfach nicht ignoriert werden kann, bis es mit schrecklichen Konsequenzen explodiert. In diesem Artikel haben wir zahlreiche Best Practices für die Sicherheit von Dockerfiles und Docker Compose vorgestellt.

Zu den wichtigsten Maßnahmen gehören:

1. Vertrauenswürdige Basis-Images verwenden: Offizielle und minimale Docker-Images nutzen, um die Angriffsfläche zu reduzieren.
2. Host und Docker aktuell halten: Regelmäßige Updates durchführen, um gegen bekannte Sicherheitslücken geschützt zu sein.
3. Nicht als Root ausführen: Container als nicht-privilegierte Benutzer ausführen, um das Risiko von Privilege-Escalation-Angriffen zu reduzieren.
4. Container-Berechtigungen beschränken: Capabilities und Ressourcen begrenzen, um den Schaden bei einer Kompromittierung zu minimieren.
5. Security Scanning implementieren: Images auf Schwachstellen scannen, bevor sie in Produktion gehen.
6. Sichere Netzwerkkonfiguration: Container segmentieren und nur notwendige Ports öffnen.
7. Secrets sicher verwalten: Sensible Daten niemals im Dockerfile oder Docker Compose-File speichern.

Weiterführende Werkzeuge für Docker-Sicherheit

Es gibt zahlreiche Tools, die dir bei der Absicherung deiner Docker-Umgebung helfen können:

• DockerBench for Security: Überprüft deine Docker-Installation auf Best Practices.
• Clair: Ein Open-Source-Projekt zur statischen Analyse von Schwachstellen in Container-Images.
• Anchore Engine: Ein Tool für die tiefgehende Inspektion von Docker-Images.
• Notary: Ein Tool für die Überprüfung der Integrität und Authentizität von Container-Images.
• Docker Content Trust (DCT): Eine Funktion von Docker zur Signaturverifizierung von Images.

Indem du diese Best Practices und Tools in deine Docker-Workflow integrierst, kannst du eine deutlich sicherere Container-Umgebung schaffen und das Risiko von Sicherheitsvorfällen erheblich reduzieren.

---

Häufig gestellte Fragen