Sicherheitsrichtlinien für Container und Images

In Kubernetes werden Container aus Images gestartet. Daher überschneiden sich viele Sicherheitsüberlegungen zwischen Container- und Image-Sicherheitsrichtlinien. In diesem Leitfaden werden bewährte Verfahren für die Container- und Image-Sicherheit beschrieben, um eine robuste und sichere Umgebung zu gewährleisten.

Unveränderlichkeit von Containern

Sobald ein Image gestartet und zu einem Container geworden ist, sollte es unveränderlich bleiben. Das bedeutet, dass nach dem Start des Containers nichts mehr in den Container eingefügt, verändert oder gelöscht werden darf. Dieser Grundsatz trägt zur Wahrung der Konsistenz und Sicherheit bei.

Terminologie

Container-Images: Eigenständige, ausführbare Softwarepakete, die alles enthalten, was zur Ausführung eines Dienstes benötigt wird - Code, Laufzeit, Systemwerkzeuge, Systembibliotheken und Einstellungen.
Übergeordnete Images: Die Basis-Images, die in einem Dockerfile mit dem FROM-Befehl angegeben werden. Beispielsweise gibt FROM ubuntu ein Ubuntu-Betriebssystem als übergeordnetes Abbild an.
Basis-Images: Spezielle Container-Images, die keine übergeordneten Images haben und in der Regel mit FROM scratch in ihren Dockerfiles beginnen.

Container-Image-Richtlinien

1. User Management

Non-Root User: Es wird empfohlen, Container nicht als root auszuführen. Erstellen Sie einen Benutzer in der Dockerdatei und wechseln Sie zu diesem Benutzer.
```
RUN useradd -d /home/appuser -m -s /bin/bash appuser USER appuser
```
User Context Enforcement: Stellen Sie sicher, dass der Container nicht als ein Benutzer ausgeführt wird, der auf dem Host-Rechner existiert.

2. Use of Trusted Images

Official Repositories: Verwenden Sie Container-Images aus vertrauenswürdigen Quellen und verifizieren Sie diese mit Prüfsummen.
Image Scanners: Verwenden Sie Image-scanner, um Images aus weniger vertrauenswürdigen Quellen auf Schwachstellen zu überprüfen.

3. Housekeeping of Images

Vulnerability Scanning: Scannen Sie Images regelmäßig auf Schwachstellen und bauen Sie sie mit dem --no-cache-Flag neu auf, um die Verwendung von zwischengespeicherten Bildern zu verhindern.
```
docker build --no-cache -t myimage:latest .
```
Avoid Package Manager Commands: Führen Sie keine Paketmanager-Befehle wie apt-get update in Dockerdateien aus. Verwenden Sie stattdessen aktualisierte Basis-Images.
```
RUN apt-get install --no-install-recommends -y <package>
```

4. COPY vs. ADD

COPY Command: Bevorzugen Sie COPY gegenüber ADD in Dockerdateien, um potenzielle Sicherheitsrisiken im Zusammenhang mit ADD zu vermeiden.
```
COPY ./localfile /containerfile
```
Check for ADD Usage: Identify the use of ADD in images.
```
docker history <ImageID> --no-trunc | grep ADD
```

5. Package Managers

Remove Package Managers: Remove package managers from the container image after use to prevent installations within running containers.
```
RUN apt-get install -y <package> && apt-get purge -y <package-manager>
```

6. Versioning

Specify Versions: Always specify the versions of parent images and dependencies to ensure reproducibility and security.
```
FROM ubuntu:20.04
```

7. Privileged Containers

Avoid Privileged Containers: Verwenden Sie nicht das --privileged-Flag, da es dem Container umfangreiche Rechte auf dem Host gewährt.
```
docker/crictl run --privileged <image> # Avoid this
```

8. Einbettung sensibler Daten

Vermeiden Sie das Einbinden von Host-Verzeichnissen: Hängen Sie keine sensiblen Host-Verzeichnisse in Container ein. Verwenden Sie Kubernetes ConfigMaps und Secrets für Konfigurationsdateien und sensible Daten.
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  config.yaml: |
    key: value
```

9. Eine Anwendung pro Container

Microservices-Prinzip: Jeder Container sollte eine einzige Anwendung oder einen einzigen Prozess ausführen, um der Microservices-Architektur zu folgen.

10. Schreibgeschütztes Dateisystem

Read-Only Containers: Konfigurieren Sie Container so, dass sie mit einem schreibgeschützten Dateisystem laufen und gewähren Sie Schreibrechte nur für notwendige Verzeichnisse.
```
RUN chmod 0444 /* RUN chmod 0755 /writable-dir
```

11. Persistenz und Verwaltung von Daten

External Storage: Speichern Sie Benutzerdaten, Konfigurationsdateien und andere dauerhafte Daten außerhalb des Containers mit Hilfe von persistenten Volumes.
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```

Beispiel Secure Dockerfile

FROM ubuntu:20.04

# Create a user and switch to it
RUN useradd -d /home/appuser -m -s /bin/bash appuser
USER appuser

# Install necessary packages without recommendations
RUN apt-get update && apt-get install --no-install-recommends -y \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Copy application files
COPY ./app /home/appuser/app

# Set the file system to read-only and allow write access to specific directories
RUN chmod 0444 /* && chmod 0755 /home/appuser/app

CMD ["./home/appuser/app/start.sh"]

Schlussfolgerung

Die Umsetzung dieser Container- und Image-Sicherheitsrichtlinien stellt sicher, dass Ihre Kubernetes-Umgebung sicher und konform mit den Best Practices bleibt. Wenn Sie diese Richtlinien befolgen, können Sie die mit dem Betrieb von Containern verbundenen Risiken mindern und eine solide Sicherheitslage in Ihren Kubernetes-Clustern aufrechterhalten. Überprüfen und aktualisieren Sie diese Praktiken regelmäßig, um sie an die sich entwickelnden Sicherheitsbedrohungen und Fortschritte bei Container-Technologien anzupassen.

Risiken