Wie behandelt man Berechtigungen in Docker?

Einführung

Die Verwaltung von Berechtigungen in Docker ist ein entscheidender Aspekt bei der Verwaltung Ihrer containerisierten Anwendungen. In diesem Tutorial werden Sie Schritt für Schritt durch das Verständnis von Docker-Dateiberechtigungen, das Festlegen von Berechtigungen in Docker-Containern und die Erkundung bewährter Verfahren für die Berechtigungsverwaltung geführt. Am Ende werden Sie über das Wissen verfügen, um Berechtigungen in Ihren Docker-basierten Projekten effektiv zu verwalten.

In diesem Lab (Labor) werden Sie lernen, wie Docker-Container-Berechtigungen funktionieren, wie Sie Nicht-Root-Benutzer in Containern erstellen und nutzen können und wie Sie Berechtigungen verwalten, wenn Sie Daten zwischen dem Host und Containern teilen.

Skills Graph

Verständnis der Standard-Docker-Berechtigungen

In Docker ist das Verständnis, wie Berechtigungen funktionieren, grundlegend für die Sicherung von Containern. Lassen Sie uns beginnen, indem wir die Standard-Berechtigungseinstellungen in Docker-Containern untersuchen.

Prüfen des Standardbenutzers in Docker

Standardmäßig werden Prozesse in Docker-Containern als root-Benutzer ausgeführt. Dies kann zu potenziellen Sicherheitsrisiken führen, wenn der Container kompromittiert wird. Um dieses Verhalten zu sehen, erstellen wir einen einfachen Container und prüfen, welcher Benutzer die Prozesse ausführt.

Zunächst stellen Sie sicher, dass Sie sich in Ihrem Projektverzeichnis befinden:

cd ~/project

Jetzt starten wir einen einfachen Ubuntu-Container und prüfen den aktuellen Benutzer:

docker run -it --rm ubuntu:22.04 whoami

Sie sollten die folgende Ausgabe sehen:

root

Dies bestätigt, dass Docker standardmäßig den root-Benutzer verwendet. Jetzt prüfen wir die Benutzer-ID (UID) und die Gruppen-ID (GID):

docker run -it --rm ubuntu:22.04 id

Die Ausgabe sollte in etwa so aussehen:

uid=0(root) gid=0(root) groups=0(root)

uid=0 und gid=0 zeigen an, dass der Container als root-Benutzer und -Gruppe ausgeführt wird, die uneingeschränkten Zugriff auf alle Ressourcen im Container haben.

Untersuchung von Dateiberechtigungen innerhalb eines Containers

Lassen Sie uns untersuchen, wie Dateiberechtigungen innerhalb eines Docker-Containers funktionieren. Erstellen Sie eine einfache Datei innerhalb eines Containers und prüfen Sie deren Berechtigungen.

Zunächst erstellen wir einen Container, der im Hintergrund läuft:

docker run -d --name permissions-demo ubuntu:22.04 sleep 3600

Jetzt führen wir Befehle innerhalb dieses Containers aus, um eine Datei zu erstellen und deren Berechtigungen zu prüfen:

docker exec permissions-demo touch /test-file
docker exec permissions-demo ls -l /test-file

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

-rw-r--r-- 1 root root 0 May 15 12:34 /test-file

Beachten Sie, dass die Datei vom root-Benutzer und -Gruppe besessen wird. Dies zeigt, dass alle Dateien, die standardmäßig innerhalb eines Docker-Containers erstellt werden, vom root-Benutzer besessen sind.

Lassen Sie uns auch ein Verzeichnis erstellen und dessen Berechtigungen prüfen:

docker exec permissions-demo mkdir /test-directory
docker exec permissions-demo ls -ld /test-directory

Die Ausgabe sollte in etwa so aussehen:

drwxr-xr-x 2 root root 4096 May 15 12:35 /test-directory

Auch hier wird das Verzeichnis vom root-Benutzer und -Gruppe besessen.

Lassen Sie uns den Container bereinigen, bevor wir zum nächsten Schritt gehen:

docker stop permissions-demo
docker rm permissions-demo

Dies zeigt das Standardverhalten von Docker in Bezug auf Benutzerberechtigungen. Im nächsten Schritt werden wir lernen, wie man Nicht-Root-Benutzer in Docker-Containern erstellt und nutzt, um die Sicherheit zu verbessern.

Erstellen und Verwenden von Nicht-Root-Benutzern in Docker

Das Ausführen von Anwendungen als root-Benutzer innerhalb von Docker-Containern birgt Sicherheitsrisiken. Wenn ein Angreifer einen als root laufenden Container kompromittiert, könnte er möglicherweise erhöhte Rechte auf dem Host-System erlangen. In diesem Schritt werden wir lernen, wie man Nicht-Root-Benutzer in Docker-Containern erstellt und nutzt.

Erstellen einer Dockerfile mit einem Nicht-Root-Benutzer

Lassen Sie uns eine Dockerfile erstellen, die einen Nicht-Root-Benutzer definiert und ihn als Standardbenutzer für die Ausführung von Befehlen festlegt.

Zunächst erstellen wir ein neues Verzeichnis für unser Projekt:

mkdir -p ~/project/non-root-user
cd ~/project/non-root-user

Jetzt erstellen wir eine Dockerfile mit dem nano-Texteditor:

nano Dockerfile

Fügen Sie der Dockerfile den folgenden Inhalt hinzu:

FROM ubuntu:22.04

## Create a new user called 'appuser' with user ID 1000
RUN useradd -m -u 1000 appuser

## Create a directory for the application and set ownership
RUN mkdir -p /app && chown -R appuser:appuser /app

## Set the working directory to /app
WORKDIR /app

## Switch to the non-root user
USER appuser

## Create a test file
RUN touch test-file.txt

## Command to run when the container starts
CMD ["bash", "-c", "echo 'Running as user:' && whoami && echo 'File ownership:' && ls -l test-file.txt && tail -f /dev/null"]

Speichern Sie die Datei, indem Sie Strg+O drücken, dann Enter, und verlassen Sie den Editor mit Strg+X.

Diese Dockerfile macht Folgendes:

1. Erstellt einen neuen Benutzer namens appuser mit der UID 1000
2. Erstellt ein Verzeichnis für die Anwendung und gibt die Eigentümerschaft an appuser
3. Setzt das Arbeitsverzeichnis auf /app
4. Wechselt für nachfolgende Befehle zum Nicht-Root-Benutzer
5. Erstellt eine Testdatei, die von appuser besessen wird
6. Setzt einen Befehl, der Informationen über Benutzer und Dateieigentümerschaft anzeigt

Bauen und Ausführen des Containers mit Nicht-Root-Benutzer

Jetzt bauen wir das Docker-Image aus unserer Dockerfile:

docker build -t non-root-image .

Sie sollten eine Ausgabe sehen, die anzeigt, dass Docker das Image baut. Sobald der Bauvorgang abgeschlossen ist, starten Sie einen Container aus diesem Image:

docker run --name non-root-container -d non-root-image

Jetzt prüfen wir die Ausgabe aus unserem Container:

docker logs non-root-container

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Running as user:
appuser
File ownership:
-rw-r--r-- 1 appuser appuser 0 May 15 12:45 test-file.txt

Dies bestätigt, dass der Container als appuser läuft und die Testdatei von appuser besessen wird.

Testen der Berechtigungen des Nicht-Root-Benutzers

Lassen Sie uns uns mit dem laufenden Container verbinden und die Berechtigungen unseres Nicht-Root-Benutzers untersuchen:

docker exec -it non-root-container bash

Jetzt sollten Sie als appuser innerhalb des Containers sein. Lassen Sie uns dies überprüfen:

whoami

Sie sollten sehen:

appuser

Prüfen Sie die Benutzer-ID und die Gruppen-ID:

id

Die Ausgabe sollte in etwa so aussehen:

uid=1000(appuser) gid=1000(appuser) groups=1000(appuser)

Jetzt versuchen Sie, eine Datei im Root-Verzeichnis zu erstellen:

touch /root-test-file

Sie sollten eine Fehlermeldung wegen fehlender Berechtigungen sehen:

touch: cannot touch '/root-test-file': Permission denied

Dies liegt daran, dass der Nicht-Root-Benutzer keine Schreibberechtigungen im Root-Verzeichnis hat. Unser Benutzer kann jedoch in das /app-Verzeichnis schreiben:

touch /app/user-test-file
ls -l /app/user-test-file

Sie sollten sehen, dass die neue Datei von appuser besessen wird:

-rw-r--r-- 1 appuser appuser 0 May 15 12:50 /app/user-test-file

Verlassen Sie die Container-Shell:

exit

Lassen Sie uns den Container bereinigen, bevor wir zum nächsten Schritt gehen:

docker stop non-root-container
docker rm non-root-container

Dieser Schritt hat gezeigt, wie man einen Nicht-Root-Benutzer in einem Docker-Container erstellt und nutzt. Die Verwendung eines Nicht-Root-Benutzers trägt dazu bei, die Sicherheit Ihrer containerisierten Anwendungen zu verbessern, indem die für die Anwendung verfügbaren Berechtigungen eingeschränkt werden.

Verwaltung von Berechtigungen für Volume-Mounts

Docker-Volumes ermöglichen es Ihnen, Daten zwischen dem Host und Containern zu teilen. Die korrekte Verwaltung von Berechtigungen bei der Verwendung von Volumes ist jedoch wichtig, um Probleme zu vermeiden. In diesem Schritt werden wir lernen, wie man Berechtigungen bei der Verwendung von Volume-Mounts behandelt.

Verständnis von Problemen mit Volume-Mount-Berechtigungen

Die Hauptherausforderung bei Docker-Volume-Mounts besteht darin, dass die Benutzer-IDs (UIDs) innerhalb des Containers möglicherweise nicht mit den Benutzer-IDs auf dem Host-System übereinstimmen. Dies kann zu Berechtigungsproblemen führen, wenn auf Dateien in gemounteten Volumes zugegriffen wird.

Lassen Sie uns dieses Problem anhand eines einfachen Beispiels demonstrieren.

Zunächst erstellen Sie ein neues Verzeichnis auf dem Host, das wir in einen Container mounten werden:

mkdir -p ~/project/host-data
cd ~/project/host-data

Erstellen Sie eine Testdatei in diesem Verzeichnis:

echo "This is a test file created on the host" > host-file.txt

Prüfen Sie die Eigentümerschaft dieser Datei:

ls -l host-file.txt

Sie sollten sehen, dass die Datei vom Benutzer labex (Ihr aktueller Benutzer auf dem Host) besessen wird:

-rw-r--r-- 1 labex labex 39 May 15 13:00 host-file.txt

Jetzt starten wir einen Container, der dieses Verzeichnis mountet, und versuchen, die Datei zu ändern:

docker run -it --rm -v ~/project/host-data:/container-data ubuntu:22.04 bash

Sie befinden sich jetzt innerhalb des Containers. Prüfen wir die Eigentümerschaft der gemounteten Datei:

ls -l /container-data/host-file.txt

Sie können eine Ausgabe ähnlich der folgenden sehen:

-rw-r--r-- 1 1000 1000 39 May 15 13:00 /container-data/host-file.txt

Beachten Sie, dass die Datei numerische IDs anstelle von Benutzernamen anzeigt, da der Container den Benutzer labex vom Host nicht kennt.

Versuchen Sie, eine neue Datei im gemounteten Verzeichnis zu erstellen:

echo "This is a test file created in the container" > /container-data/container-file.txt

Jetzt prüfen wir die Eigentümerschaft dieser neuen Datei:

ls -l /container-data/container-file.txt

Sie sollten sehen:

-rw-r--r-- 1 root root 47 May 15 13:05 /container-data/container-file.txt

Die Datei wird vom Benutzer root innerhalb des Containers besessen (da wir standardmäßig als root laufen).

Verlassen Sie den Container:

exit

Jetzt prüfen Sie die Eigentümerschaft beider Dateien auf dem Host:

ls -l ~/project/host-data/

Sie werden sehen, dass die aus dem Container erstellte Datei auf dem Host von root besessen wird:

-rw-r--r-- 1 root  root  47 May 15 13:05 container-file.txt
-rw-r--r-- 1 labex labex 39 May 15 13:00 host-file.txt

Dies kann zu Berechtigungsproblemen führen, wenn ein Nicht-Root-Benutzer auf dem Host auf diese Dateien zugreifen oder sie ändern muss.

Lösung von Problemen mit Volume-Berechtigungen

Es gibt mehrere Möglichkeiten, Probleme mit Volume-Berechtigungen zu lösen. Lassen Sie uns einige gängige Ansätze untersuchen.

Ansatz 1: Benutzer in Dockerfile so festlegen, dass er mit dem Host-Benutzer übereinstimmt

Erstellen Sie ein neues Verzeichnis für dieses Beispiel:

mkdir -p ~/project/volume-permissions
cd ~/project/volume-permissions

Erstellen Sie eine neue Dockerfile:

nano Dockerfile

Fügen Sie den folgenden Inhalt hinzu:

FROM ubuntu:22.04

## Create a user with the same UID as the host user
RUN useradd -m -u 1000 appuser

## Create app directory and set ownership
RUN mkdir -p /app/data && chown -R appuser:appuser /app

## Set working directory
WORKDIR /app

## Switch to appuser
USER appuser

## Command to run
CMD ["bash", "-c", "echo 'I can write to the mounted volume' > /app/data/test.txt && tail -f /dev/null"]

Speichern Sie die Datei und verlassen Sie den Editor.

Bauen Sie das Image:

docker build -t volume-permissions-image .

Erstellen Sie ein Host-Verzeichnis für Tests:

mkdir -p ~/project/volume-permissions/host-data

Starten Sie einen Container mit dem gemounteten Volume:

docker run -d --name volume-test -v ~/project/volume-permissions/host-data:/app/data volume-permissions-image

Nach einer Weile prüfen Sie die Eigentümerschaft der erstellten Datei auf dem Host:

ls -l ~/project/volume-permissions/host-data/

Sie sollten sehen, dass die Datei von einem Benutzer mit der UID 1000 besessen wird, was mit der UID Ihres Host-Benutzers übereinstimmen sollte:

-rw-r--r-- 1 labex labex 35 May 15 13:15 test.txt

Dieser Ansatz funktioniert, weil wir einen Benutzer im Container mit der gleichen UID wie der Host-Benutzer erstellt haben.

Ansatz 2: Verwendung der --user-Option

Ein anderer Ansatz besteht darin, die --user-Option zu verwenden, um anzugeben, welche Benutzer-ID beim Starten des Containers verwendet werden soll.

Zunächst bereinigen Sie den vorherigen Container:

docker stop volume-test
docker rm volume-test

Jetzt starten Sie einen Container mit der --user-Option:

docker run -d --name user-flag-test --user "$(id -u):$(id -g)" -v ~/project/volume-permissions/host-data:/data ubuntu:22.04 bash -c "echo 'Created with --user flag' > /data/user-flag-test.txt && sleep 3600"

Dieser Befehl startet den Container mit Ihrer aktuellen Benutzer-ID und Gruppen-ID.

Prüfen Sie die Eigentümerschaft der neuen Datei:

ls -l ~/project/volume-permissions/host-data/user-flag-test.txt

Sie sollten sehen, dass die Datei von Ihrem Host-Benutzer besessen wird:

-rw-r--r-- 1 labex labex 23 May 15 13:20 user-flag-test.txt

Lassen Sie uns vor dem nächsten Schritt aufräumen:

docker stop user-flag-test
docker rm user-flag-test

Diese Ansätze zeigen, wie man Berechtigungen bei der Verwendung von Docker-Volumes verwaltet. Indem Sie die Benutzer-IDs zwischen Container und Host übereinstimmen lassen, können Sie Berechtigungsprobleme beim Teilen von Daten zwischen ihnen vermeiden.

Umsetzung von Best Practices für Berechtigungen

Lassen Sie uns alles, was wir gelernt haben, in die Praxis umsetzen, indem wir ein realistischeres Beispiel für einen Docker-Container erstellen, der die Best Practices für Berechtigungen befolgt. Wir werden einen einfachen Web-Applikations-Container erstellen, der die Sicherheits-Best Practices für Berechtigungen beachtet.

Erstellen eines sicheren Web-Applikations-Containers

Zunächst erstellen Sie ein neues Verzeichnis für unser Beispiel:

mkdir -p ~/project/secure-app
cd ~/project/secure-app

Lassen Sie uns eine einfache Web-Applikation erstellen. Zuerst erstellen Sie eine app.py-Datei:

nano app.py

Fügen Sie den folgenden Python-Code hinzu, um einen einfachen Flask-Webserver zu erstellen:

from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from a secure container!'

@app.route('/whoami')
def whoami():
    return os.popen('id').read()

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

Speichern Sie die Datei und verlassen Sie den Editor.

Jetzt erstellen Sie eine requirements.txt-Datei für die Python-Abhängigkeiten:

nano requirements.txt

Fügen Sie den folgenden Inhalt hinzu:

flask==2.0.1

Speichern Sie die Datei und verlassen Sie den Editor.

Jetzt erstellen Sie eine Dockerfile, die die Best Practices für Berechtigungen befolgt:

nano Dockerfile

Fügen Sie den folgenden Inhalt hinzu:

FROM python:3.10-slim

## Create a non-root user to run the application
RUN groupadd -g 1000 appgroup \
  && useradd -u 1000 -g appgroup -s /bin/bash -m appuser

## Set working directory and create necessary directories
WORKDIR /app

## Copy requirements first to leverage Docker cache
COPY requirements.txt .

## Install dependencies as root
RUN pip install --no-cache-dir -r requirements.txt

## Copy application code
COPY app.py .

## Create a data directory that the application can write to
RUN mkdir -p /app/data \
  && chown -R appuser:appgroup /app

## Set proper permissions
RUN chmod -R 755 /app

## Switch to non-root user
USER appuser

## Expose the port the app will run on
EXPOSE 8080

## Command to run the application
CMD ["python", "app.py"]

Speichern Sie die Datei und verlassen Sie den Editor.

Lassen Sie uns das Docker-Image bauen:

docker build -t secure-web-app .

Jetzt starten Sie den Container:

docker run -d --name secure-app -p 8080:8080 secure-web-app

Lassen Sie uns die Applikation testen. Zunächst prüfen Sie, ob der Container läuft:

docker ps

Sie sollten Ihren secure-app-Container in der Liste sehen. Jetzt verwenden Sie curl, um die Applikation zu testen:

curl http://localhost:8080/

Sie sollten sehen:

Hello from a secure container!

Lassen Sie uns prüfen, als welcher Benutzer die Applikation läuft:

curl http://localhost:8080/whoami

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

uid=1000(appuser) gid=1000(appgroup) groups=1000(appgroup)

Dies bestätigt, dass unsere Applikation als Nicht-Root-Benutzer appuser läuft.

Sicherheitsanalyse

Lassen Sie uns die Sicherheitsverbesserungen in unserer Dockerfile analysieren:

1. Nicht-Root-Benutzer: Wir haben einen dedizierten Benutzer (appuser) erstellt, um die Applikation auszuführen, wodurch das Risiko bei einer Kompromittierung des Containers verringert wird.

2. Minimale Berechtigungen: Wir haben nur die notwendigen Berechtigungen festgelegt, die für die Funktionsfähigkeit der Applikation erforderlich sind.

3. Klar definierte Eigentümerschaft: Alle Dateien und Verzeichnisse im Container haben eine klar definierte Eigentümerschaft.

4. Geeignete Verzeichnisstruktur: Wir haben eine dedizierte Verzeichnisstruktur für die Applikation und ihre Daten erstellt.

Diese Praktiken tragen dazu bei, sicherzustellen, dass selbst wenn ein Angreifer es schafft, eine Schwachstelle in der Applikation auszunutzen, er nur eingeschränkten Zugang zum Container und zum Host-System hat.

Umsetzung von Volume-Berechtigungen mit der sicheren Applikation

Lassen Sie uns ein Volume zu unserer sicheren Applikation hinzufügen, um zu zeigen, wie man Berechtigungen bei Volumes richtig behandelt.

Zunächst stoppen und entfernen Sie den vorhandenen Container:

docker stop secure-app
docker rm secure-app

Erstellen Sie ein Datenverzeichnis auf dem Host:

mkdir -p ~/project/secure-app/host-data

Setzen Sie die richtigen Berechtigungen auf dem Host-Verzeichnis:

sudo chown 1000:1000 ~/project/secure-app/host-data

Jetzt starten Sie den Container mit dem gemounteten Volume:

docker run -d --name secure-app-with-volume \
  -p 8080:8080 \
  -v ~/project/secure-app/host-data:/app/data \
  secure-web-app

Lassen Sie uns uns mit dem Container verbinden und eine Datei im gemounteten Volume erstellen:

docker exec -it secure-app-with-volume bash

Jetzt erstellen Sie innerhalb des Containers eine Testdatei im gemounteten Volume:

echo "Test file created from inside the container" > /app/data/container-file.txt

Prüfen Sie die Dateieigentümerschaft:

ls -l /app/data/container-file.txt

Sie sollten sehen, dass die Datei von appuser besessen wird:

-rw-r--r-- 1 appuser appgroup 43 May 15 13:30 /app/data/container-file.txt

Verlassen Sie den Container:

exit

Jetzt prüfen Sie die Dateieigentümerschaft auf dem Host:

ls -l ~/project/secure-app/host-data/container-file.txt

Sie sollten sehen, dass die Datei von der UID 1000 besessen wird (was Ihrem Host-Benutzer entspricht):

-rw-r--r-- 1 labex labex 43 May 15 13:30 container-file.txt

Dies zeigt, dass bei richtiger Berechtigungskonfiguration Dateien, die innerhalb des Containers in einem gemounteten Volume erstellt werden, die richtige Eigentümerschaft auf dem Host haben.

Lassen Sie uns vor Abschluss aufräumen:

docker stop secure-app-with-volume
docker rm secure-app-with-volume

Indem Sie diese Best Practices für Docker-Berechtigungen befolgen, können Sie sichere, zuverlässige containerisierte Applikationen erstellen, die Dateiberechtigungen sowohl innerhalb des Containers als auch beim Teilen von Daten mit dem Host-System richtig verwalten.

Zusammenfassung

In diesem Lab haben Sie essentielle Techniken zur Verwaltung von Berechtigungen in Docker-Containern gelernt:

1. Verständnis der Standard-Docker-Berechtigungen: Sie haben untersucht, wie Docker-Container standardmäßig als root laufen und wie dies zu potenziellen Sicherheitsrisiken führen kann.

2. Erstellen und Verwenden von Nicht-Root-Benutzern: Sie haben gelernt, wie man benutzerdefinierte Nicht-Root-Benutzer in Docker-Containern erstellt, was eine kritische Sicherheits-Best Practice ist.

3. Verwaltung von Volume-Mount-Berechtigungen: Sie haben entdeckt, wie man Berechtigungen behandelt, wenn man Daten zwischen dem Host und Containern mithilfe von Volumes teilt, und haben damit häufige Berechtigungsprobleme angegangen.

4. Umsetzung von Best Practices für Berechtigungen: Sie haben all diese Konzepte angewendet, um einen sicheren Web-Applikations-Container zu erstellen, der die Best Practices für Docker-Berechtigungen befolgt.

Indem Sie diese Techniken in Ihren Docker-Projekten anwenden, können Sie die Sicherheit und Zuverlässigkeit Ihrer containerisierten Applikationen erheblich verbessern. Denken Sie daran, dass das Ausführen von Containern mit den geringstmöglichen erforderlichen Rechten ein grundlegendes Sicherheitsgrundprinzip ist, das immer befolgt werden sollte.

Einige wichtige Erkenntnisse:

• Verwenden Sie immer Nicht-Root-Benutzer in Ihren Containern.
• Stimmen Sie die Benutzer-IDs zwischen Host und Container überein, wenn Sie Volumes verwenden.
• Legen Sie die richtigen Datei- und Verzeichnisberechtigungen fest.
• Befolgen Sie das Prinzip der geringsten Privilegien.

Diese Praktiken werden Ihnen helfen, sicherere Docker-Container zu erstellen und häufige berechtigungsbezogene Probleme zu vermeiden.