Wie Sie docker container run zum Starten und Anpassen von Containern verwenden
Docker führt Anwendungen innerhalb von Containern aus – schlanken, isolierten Umgebungen, die Software zusammen mit allen benötigten Abhängigkeiten und Konfigurationen bündeln. Im Gegensatz zu klassischen virtuellen Maschinen benötigen Container kein eigenes Gastbetriebssystem; stattdessen greifen sie auf den Kernel des Hostsystems zu. Dadurch starten sie deutlich schneller und verbrauchen weniger Ressourcen. Der Befehl docker container run ist das zentrale Werkzeug, um Container aus Images zu starten, Laufzeiteinstellungen anzuwenden und isolierte Prozesse bereitzustellen.
Dieser Leitfaden beschreibt, wie Sie docker container run mit individuellen Parametern einsetzen – darunter das Benennen von Containern, der Betrieb im Hintergrundmodus, das Freigeben von Ports, das Einbinden von Volumes sowie das automatische Entfernen von Containern über --rm. Zusätzlich enthält der Text Referenztabellen zu wichtigen Flags rund um Netzwerk, Speicher, Ressourcen und Health-Checks von Containern.
Kurzfassung
# Container interaktiv aus einem Image starten
$ docker container run -it ubuntu
# Container im Hintergrund ausführen
$ docker container run -d nginx
# Container mit Namen starten
$ docker container run --name myapp alpine
# Port 80 des Containers auf Port 8080 des Hosts veröffentlichen
$ docker container run -p 8080:80 nginx
# Volume in Container einbinden
$ docker container run -v $(pwd):/data alpine
# Container nach Beendigung automatisch löschen
$ docker container run --rm busybox echo "done"
Jedes Beispiel illustriert einen grundlegenden Anwendungsfall von docker container run – darunter Namensvergabe, Netzwerkkonfiguration, Volume-Handling, interaktive Nutzung und automatisches Aufräumen.
Allgemeine Optionen für docker container run
| Option | Beschreibung | Beispiel |
|---|---|---|
| -d, –detach | Startet den Container im Hintergrund. | -d |
| –name | Weist dem Container einen benutzerdefinierten Namen zu. | –name my-nginx |
| –rm | Entfernt den Container nach seiner Beendigung. | –rm |
| -e, –env | Setzt eine Umgebungsvariable. | -e NODE_ENV=production |
| –env-file | Lädt Variablen aus Datei. | –env-file ./env.list |
| –entrypoint | Überschreibt das vorgegebene Entrypoint-Skript. | –entrypoint /bin/sh |
| -t, –tty | Aktiviert eine TTY-Sitzung. | -it |
| -i, –interactive | Hält STDIN offen. | -it |
| –workdir, -w | Setzt das Arbeitsverzeichnis im Container. | –workdir /usr/src/app |
Netzwerkoptionen für docker container run
| Option | Beschreibung | Beispiel |
|---|---|---|
| -p, –publish | Veröffentlicht Ports vom Container zum Host. | -p 8080:80 |
| -P, –publish-all | Veröffentlicht alle Ports automatisch. | -P |
| –network | Verbindet Container mit benutzerdefiniertem Docker-Netzwerk. | –network backend-net |
| –add-host | Erweitert /etc/hosts um einen Eintrag. |
–add-host db.local:10.0.0.5 |
| –dns | Legt DNS-Server für Container fest. | –dns 1.1.1.1 |
Speicheroptionen
| Option | Beschreibung | Beispiel |
|---|---|---|
| -v, –volume | Bindet ein Host-Verzeichnis oder Volume ein. | -v /data:/app/data |
| –mount | Strukturierter Mount-Syntax. | –mount type=bind,src=/data,dst=/app |
| –tmpfs | Erstellt ein temporäres In-Memory-FS. | –tmpfs /app/cache |
| –read-only | Container-Dateisystem wird schreibgeschützt. | –read-only |
Ressourcenverwaltung
| Option | Beschreibung | Beispiel |
|---|---|---|
| –cpus | Begrenzt CPU-Kerne. | –cpus 2 |
| –memory, -m | Setzt ein Speicherlimit. | -m 512m |
| –memory-swap | Speicher+Swap-Limit festlegen. | –memory-swap 1g |
| –oom-kill-disable | Verhindert OOM-Kills. | –oom-kill-disable |
| –pids-limit | Beschränkt maximale Prozessanzahl. | –pids-limit 100 |
Sicherheitsoptionen
| Option | Beschreibung | Beispiel |
|---|---|---|
| –user | Führt den Container unter bestimmter UID/GID aus. | –user 1000:1000 |
| –cap-add / –cap-drop | Fügt Kernel-Capabilities hinzu oder entfernt sie. | –cap-drop NET_RAW |
| –security-opt | Setzt Sicherheitsprofile wie seccomp oder AppArmor. | –security-opt seccomp=./profile.json |
| –privileged | Gewährt umfassenden Hostzugriff. | –privileged |
Optionen für Container-Gesundheitsprüfungen
| Option | Beschreibung | Beispiel |
|---|---|---|
| –health-cmd | Führt einen Befehl zur Zustandsprüfung aus. | –health-cmd „curl -f http://127.0.0.1/“ |
| –health-interval | Intervall zwischen Prüfungen. | –health-interval 30s |
| –health-retries | Fehleranzahl bis „unhealthy“. | –health-retries 3 |
| –no-healthcheck | Deaktiviert im Image hinterlegte Prüfroutinen. | –no-healthcheck |
Weitere Optionen
| Option | Beschreibung | Beispiel |
|---|---|---|
| –restart | Legt Neustartverhalten fest. | –restart always |
| –log-driver | Definiert Log-Backend. | –log-driver json-file |
| –pull | Legt fest, wann Images nachgeladen werden. | –pull always |
Container mit benutzerdefiniertem Namen starten
Mit dem Flag --name können Sie Containern eindeutige Namen geben. Das erleichtert Verwaltung, Automatisierung und Log-Analysen. Ohne Angabe weist Docker zufällige Namen wie frosty_morse zu.
Controllernamen müssen mit einem alphanumerischen Zeichen beginnen und dürfen Buchstaben, Zahlen, Unterstriche, Punkte und Bindestriche enthalten.
Befehlssyntax
docker container run --name <container-name> [IMAGE]
--name <container-name>: Setzt den Containernamen.[IMAGE]: Das zu startende Docker-Image.
Befehlsbeispiele
BusyBox-Container mit dem Namen busybox_test erstellen:
$ docker container run --name busybox_test busybox
Nginx-Container mit dem Namen web-server starten:
$ docker container run --name web-server nginx
Ubuntu-Container mit dem Namen linux starten:
$ docker container run --name linux ubuntu
Einen Container namens my-nginx im Hintergrundmodus starten:
$ docker container run --name my-nginx -d nginx
Aktive Container anzeigen:
$ docker container ls
Logs des Containers my-nginx anzeigen:
$ docker container logs my-nginx
my-nginx zu my-nginx-2 umbenennen:
$ docker container rename my-nginx my-nginx-2
Containerliste erneut anzeigen:
$ docker container ls
Output:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
dbbe80f32d93 nginx „/docker-entrypoint.…“ 20 seconds ago Up 20 seconds 80/tcp my-nginx-2
Container im Hintergrund betreiben (Detached Mode)
Standardmäßig laufen Container im Vordergrund und geben ihre Ausgabe direkt im Terminal aus. Mit dem Flag -d lassen sich Container im Hintergrund starten. Dies eignet sich besonders für Dienste wie Webserver oder Background-Worker.
Befehlssyntax
docker container run -d [IMAGE]
Befehlsbeispiele
Nginx im Hintergrundmodus starten:
$ docker container run --name nginx-bg -d nginx
Live-Logs anzeigen:
$ docker container logs -f nginx-bg
Shell im Container öffnen:
$ docker container exec -it nginx-bg bash
Kommando im Container ausführen:
root@<container_id>:/# date
Output:
Fri Jun 27 11:22:47 UTC 2025
Shell beenden:
root@<container_id>:/# exit
Container starten und Ports veröffentlichen
Mit -p oder --publish können interne Container-Ports für den Host verfügbar gemacht werden. Dadurch sind Webserver, APIs oder ähnliche Dienste extern erreichbar.
Für ein-gehende Verbindungen ist Portfreigabe erforderlich, für ausgehende nicht.
Befehlssyntax
docker container run -p [IP:]<host_port>:<container_port> [IMAGE]
Befehlsbeispiele
Port 80 auf 8080 veröffentlichen:
$ docker container run -p 8080:80 nginx
UDP-Portzuordnung:
$ docker container run -p 8080:1234/udp busybox
Zugriff nur lokal erlauben:
$ docker container run -p 127.0.0.1:8080:80 nginx
HTTP und HTTPS freigeben:
$ docker container run -p 80:80 -p 443:443 nginx
Praxiseinsatz
Nginx öffentlich auf Port 8080 bereitstellen:
$ docker container run -d -p 8080:80 nginx
Extern testen (SERVER-IP ersetzen):
$ curl http://<SERVER-IP>:8080
Nur lokal erreichbar starten:
$ docker container run -d -p 127.0.0.1:8081:80 nginx
Lokaler Zugriff erfolgreich:
$ curl http://127.0.0.1:8081
Externer Zugriff scheitert wie erwartet:
$ curl http://<SERVER-IP>:8081
Container mit Host-Volume starten
Standardmäßig sind Container vom Host-Dateisystem isoliert. Über -v lassen sich jedoch Host-Pfade einbinden – etwa für Konfigurationen, statische Dateien oder persistente Daten.
Befehlssyntax
docker container run -v <host_path>:<container_path>[:options] [IMAGE]
Befehlsbeispiele
Host-Verzeichnis mit Lese-/Schreibrechten mounten:
$ docker container run -v /home/linuxuser/data:/data busybox
Gleiches Verzeichnis schreibgeschützt mounten:
$ docker container run -v /home/linuxuser/data:/data:ro busybox
Praxiseinsatz
Ein einfaches statisches Webprojekt über Nginx hosten:
Webverzeichnis anlegen:
$ mkdir /home/linuxuser/webdata
In das Verzeichnis wechseln:
$ cd /home/linuxuser/webdata
HTML-Datei erstellen:
$ cat < index.html
Greetings from centron
EOF
Nginx-Container mit eingebundenem Verzeichnis starten:
$ docker container run -d -p 8082:80 -v /home/linuxuser/webdata:/usr/share/nginx/html:ro nginx
Seite testen:
$ curl http://127.0.0.1:8082
Output:
<!DOCTYPE html>
<html>
<head><title>centron Greeting</title></head>
<body><h1>Greetings from centron</h1></body>
</html>
Eingebundene Verzeichnisse bleiben auch nach dem Entfernen des Containers erhalten. Änderungen im Container spiegeln sich direkt im Host-Verzeichnis wider.
Container starten und nach Beendigung automatisch entfernen
Normalerweise bleiben Container nach ihrer Ausführung bestehen, selbst wenn sie beendet sind. Mit dem Flag --rm sorgt Docker dafür, dass der Container direkt nach seinem Ende gelöscht wird. Dies ist ideal für Kurzläufer, Tests oder einmalige Kommandos.
Befehlssyntax
docker container run --rm [IMAGE] [COMMAND]
--rm: Entfernt den Container nach seinem Ende.[IMAGE]: Das zu startende Container-Image.[COMMAND]: Der im Container auszuführende Befehl.
Befehlsbeispiele
„Hello, world“ ausgeben und Container danach löschen:
$ docker container run --rm busybox echo "Hello, world"
Fünf Sekunden schlafen und sich danach automatisch entfernen:
$ docker container run --rm busybox sleep 5
Ubuntu-Container: Ausgabe erzeugen und dann entfernen:
$ docker container run --rm ubuntu bash -c "echo Done && date"
Praxiseinsatz
So verhindert --rm das Anhäufen veralteter Container:
Temporären BusyBox-Container starten:
$ docker container run --name busybox --rm busybox echo "Temporary container"
Überprüfen, ob er noch existiert:
$ docker container ls -a
Der Container erscheint nicht mehr – er wurde automatisch gelöscht.
Gleiches Beispiel ohne --rm:
$ docker container run --name busybox busybox echo "Persistent container"
Containerliste erneut anzeigen:
$ docker container ls -a
Output:
CONTAINER ID IMAGE COMMAND CREATED STATUS NAMES
9f5d3cc7bb3e busybox „echo ‚Persistent co…’“ 5 seconds ago Exited (0) 5 seconds ago busybox
Dieser Container bleibt bestehen und muss manuell gelöscht werden (z. B. docker container rm).
Fazit
Dieser Artikel hat erläutert, wie Container mit docker container run gestartet werden können. Dabei wurden Themen wie benutzerdefinierte Namen, Hintergrundbetrieb, Portfreigaben, Volume-Mounts und automatische Bereinigung mit --rm behandelt. Zudem wurden wichtige Flags zu Netzwerk, Speicherverwaltung, Ressourcenlimits, Sicherheit und Gesundheitsprüfungen vorgestellt.
Diese Funktionen bilden die Grundlage für flexible, reproduzierbare und portable Container-Workflows. Für weiterführende Beispiele und umfassendere Details empfiehlt sich die offizielle Docker-Dokumentation.
