Docker ENTRYPOINT Erklärt: Verwendung, Syntax und bewährte Praktiken

Docker ENTRYPOINT ist eine Dockerfile-Anweisung, die den Standardbefehl definiert und steuert, der beim Start deines Containers ausgeführt wird. Die Beherrschung von ENTRYPOINT vereinfacht die Entwicklung vorhersehbarer, reproduzierbarer und wartbarer Container, die sich wie erwartet verhalten. 

Dieser Leitfaden soll fortgeschrittenen DevOps-Ingenieuren, Backend-Entwicklern und Softwareingenieuren helfen, ENTRYPOINT sicher zu nutzen und häufige Fallstricke zu vermeiden.

Wenn du Docker noch nicht kennst, solltest du dir unser Tutorial Einführung in Docker ansehen, denn dieses Tutorial setzt ein gewisses Maß an Wissen über Docker voraus. Wenn du dich mit Docker vertraut machen willst, besuche unseren Kurs Einführung in Docker. 

Was ist Docker ENTRYPOINT?

ENTRYPOINT definiert den Befehl, der standardmäßig ausgeführt wird, wenn dein Docker-Container gestartet wird. Anders als bei CMD sorgt die Anweisung ENTRYPOINT für Konsistenz, indem sie Befehle bereitstellt, die bei jedem Start des Containers ausgeführt werden.

Wie funktioniert Docker ENTRYPOINT?

ENTRYPOINT in einem Dockerfile definiert den Hauptbefehl, der immer ausgeführt wird, wenn du einen Container aus einem Image startest. Das ist so, als würde man sagen:  "Egal, welche Argumente der Benutzer beim Ausführen dieses Containers angibt, beginne immer mit diesem Befehl."

Mehr über Dockerfiles erfährst du in unserem Tutorial Wie man eine Anwendung mit Docker containerisiert. 

Zum Beispiel in einem Dockerfile:

ENTRYPOINT ["python", "app.py"]

Wenn du jetzt läufst:

docker run myimage

Sie wird immer ausgeführt:

python app.py

Hier ist ein Flussdiagramm, wie ENTRYPOINT funktioniert:

+---------------------------+

|       Dockerfile          |

+---------------------------+

|                           |

|  ENTRYPOINT ["app"]       |

|  CMD ["--default-arg"]    |

+---------------------------+

             |

             v

+---------------------------+

|   Build Docker Image      |

+---------------------------+

             |

             v

+---------------------------+

|    Run Container          |

|   (docker run image)      |

+---------------------------+

             |

             v

+---------------------------+

| Executed Command:         |

|   app --default-arg       |

+---------------------------+

Override CMD at Runtime:

(docker run image --custom-arg)

             |

             v

+---------------------------+

| Executed Command:         |

|   app --custom-arg        |

+---------------------------+

Override ENTRYPOINT at Runtime:

(docker run --entrypoint /bin/bash image)

             |

             v

+---------------------------+

| Executed Command:         |

|   /bin/bash               |

+---------------------------+

Grundlagen von Docker ENTRYPOINT

Wenn du die Grundlagen verstehst, kannst du ENTRYPOINT viel sicherer einsetzen.

Konzeptioneller Rahmen

ENTRYPOINT gibt die ausführbare Datei oder das Skript an, das automatisch ausgeführt wird, wenn dein Container startet. Es ist der Hauptprozess deines Containers, der das Verhalten deines Containers vorhersehbar steuert.

Kernsyntax

Die Dockerfile-Syntax für ENTRYPOINT ist einfach und wird normalerweise zusammen mit CMD verwendet, um Standardargumente oder -parameter bereitzustellen. ENTRYPOINT definiert die ausführbare Datei, während CMD Standardargumente angibt, die ENTRYPOINT verwendet.

Das Verständnis von Docker-Konzepten wie ENTRYPOINT ist wichtig, um in Vorstellungsgesprächen für Data Science zu bestehen. In unseren Top 26 Docker-Interview-Fragen und -Antworten für 2025 erfährst du mehr über häufige Interviewfragen. 

ENTRYPOINT Syntaxformulare

Docker ENTRYPOINT gibt es in zwei verschiedenen Formen: als test-shell und als exec. Wenn du die Unterschiede zwischen diesen Formen kennst, kannst du eine kluge Wahl treffen.

test-shell Form

Beispielsyntax: 

ENTRYPOINT /usr/bin/ping -c 3 localhost

Die test-shell Form ermöglicht die einfache Integration von Shell-Funktionen (Variablenersetzung, Umgebungsmanipulation).

Sie kann jedoch zu einer schlechten Signalverarbeitung führen; sie läuft innerhalb des Zwischenprozesses /bin/sh und nicht direkt als PID 1, was zu Problemen beim Stoppen und Neustarten von Containern führt.

PID 1 ist der erste Prozess, der beim Systemstart gestartet wird. In Docker verwaltet der Prozess PID 1 alle anderen Prozesse innerhalb des Containers. 

Ausführungsform

Beispielsyntax: 

ENTRYPOINT ["/usr/bin/ping", "-c", "3"]

Die Exec-Form gewährleistet eine direkte Befehlsausführung als PID 1, was zu einer zuverlässigen Signalverarbeitung und Steuerung führt.

Sie bietet jedoch keine direkte Shell-Unterstützung oder eine automatische Erweiterung der Umgebungsvariablen; für ein Shell-ähnliches Verhalten ist zusätzliches Skripting erforderlich.

ENTRYPOINT vs. CMD: Hauptunterschiede und Anwendungsfälle

Die Unterscheidung zwischen ENTRYPOINT und CMD verhindert Verwirrung und ermöglicht ein vorhersehbares Containerverhalten.

Vorrang der Ausführung

ENTRYPOINT legt die ausführbare Datei fest, die immer ausgeführt wird, während CMD Standardargumente liefert. Wenn sowohl ENTRYPOINT als auch CMD definiert sind, hat ENTRYPOINT Vorrang und wird mit den Werten von CMDals Argumenten ausgeführt, es sei denn, sie werden zur Laufzeit explizit überschrieben.

Einsatzszenarien

ENTRYPOINT sollte verwendet werden, wenn du eine konsistente, erzwungene Ausführung bei jedem Start möchtest, wie z.B. bei Containern mit nur einem Befehl oder bei Wrapper-Skripten für Legacy-Anwendungen. Umgekehrt eignet sich CMD für die Angabe von Standardargumenten, was mehr Flexibilität bei Laufzeitüberschreibungen ermöglicht.

Unsere Top 18 Docker-Befehle zum Erstellen, Ausführen und Verwalten von Containern decken die wichtigsten Docker-Befehle ab, von Container-Grundlagen bis hin zu Volumes und Netzwerken, damit du Anwendungen in verschiedenen Umgebungen sicher verwalten kannst.

Praktisches Beispiel

Eine typische Kombination aus ENTRYPOINT und CMD wird durch dieses Dockerfile veranschaulicht:

FROM ubuntu
ENTRYPOINT ["/usr/bin/ping", "-c", "3"]
CMD ["localhost"]

Dieser Docker-Container sendet standardmäßig immer drei Pings an localhost. Die Benutzer können dieses Standardziel zur Laufzeit mit anderen Hosts überschreiben, ohne dass das vorhersehbare Ausführungsverhalten von ENTRYPOINT beeinträchtigt wird:

docker run ping-container google.com

Mehr über die Bereitstellung von Anwendungen mit Docker erfährst du in unserem Kurs Containerisierung und Virtualisierung mit Docker und Kubernetes. 

Kombination von ENTRYPOINT mit CMD

Die richtige Kombination von ENTRYPOINT mit CMD bietet Flexibilität, ohne die Konsistenz zu beeinträchtigen.

CMD als Standardargumente

Die Einstellung ENTRYPOINT legt den Hauptbefehl zuverlässig fest; CMD liefert Standardparameter, die einfach überschrieben werden können, ohne dass die Bilder neu erstellt werden müssen.

Laufzeitargumente überschreiben

Argumente, die während docker run angegeben werden, überschreiben nur die von CMD definierten Standardwerte. ENTRYPOINT bleibt konsistent und vereinfacht so die Erfahrungen der Benutzer.

ENTRYPOINT zur Laufzeit außer Kraft setzen

Docker erlaubt es, ENTRYPOINT direkt zur Laufzeit zu überschreiben, so dass du Debugging betreiben kannst, ohne dein Dockerfile-Image neu zu erstellen.

Verwendung von Entrypoint-Flags

Docker bietet ein einfaches Flag --entrypoint, das das Verhalten des Containers vorübergehend ändert.

docker run -it --entrypoint /bin/bash my-container

Temporäre Überschreibungen ermöglichen die Fehlersuche mit der test-shell und beheben häufige Startprobleme, ohne dass das Image neu erstellt werden muss oder erhebliche Verzögerungen auftreten.

Anpassen des ENTRYPOINT-Verhaltens

Docker bietet Flexibilität, wenn ENTRYPOINT erweiterte Anpassungen erfordert.

ENTRYPOINT zur Laufzeit außer Kraft setzen

Du kannst den Befehl ENTRYPOINT zur Laufzeit dynamisch überschreiben, indem du docker run --entrypoint zum Debuggen oder zum schnellen Ändern von Kontexten verwendest, ohne dein Dockerfile wiederholt zu ändern.

ENTRYPOINT mit Argumenten

Argumente, die in Containern übergeben werden, werden zur Laufzeit zu ENTRYPOINT Parametern; Best Practices empfehlen eine minimale ENTRYPOINT Komplexität neben CMD für maximale Klarheit und Kontrolle.

Wrapper-Skripte

Bash-Skripte, die als ENTRYPOINT Befehle eingeführt werden, können bedingte Startlogik ausführen, auf abhängige Dienste (wie Datenbanken) warten, Einrichtungsaufgaben erledigen und vieles mehr, während sie eine saubere Dockerfile-Syntax beibehalten.

Beispiele und Muster aus der realen Welt

Praktische Anwendungen auf ENTRYPOINT können typische, realistische Verwendungen veranschaulichen. Schauen wir uns einige von ihnen an.

Ein-Befehl-Container 

Für die Einrichtung einer Flask-Anwendung:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]

In der obigen Dockerdatei:

• ENTRYPOINT ["python", "app.py"]  legt die Standardausführungsdatei fest. Das ist das, was läuft, wenn der Container startet.
• CMD ["--port", "8080"]  liefert Standardargumente (--port 8080) für den Befehl ENTRYPOINT.

Der vollständige Standardbefehl wird ausgeführt:

python app.py --port 8080

 Wenn du beim Ausführen des Containers CMD überschreibst (z.B. docker run myimage --port 9090), ersetzt er --port 8080.

Skript als ENTRYPOINT 

Hier kannst du die Logik für die Unterstützung einrichten: 

entrypoint.sh:

#!/bin/sh
until nc -z db_host 5432; do
  echo "Waiting for database to become available."
  sleep 2
done
exec python app.py "$@"

Dockerfile:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--port", "8080"]

In den oben genannten Dateien:

• entrypoint.sh wird verwendet, um auf die Datenbankverbindung zu warten.
• exec python app.py "$@"  ersetzt den aktuellen Prozess der test-shell durch python app.py und übergibt alle zusätzlichen Argumente. "$@" stammt aus den Parametern CMD oder docker run.
• COPY entrypoint.sh  kopiert das Skript entrypoint.sh in das Verzeichnis /app des Containers.
• ENTRYPOINT ["./entrypoint.sh"] legt entrypoint.sh als Standard-Startskript fest, wenn der Container gestartet wird.
• CMD ["--port", "8080"] liefert Standardargumente, die an das Skript entrypoint.sh und schließlich an python app.py übergeben werden. Der endgültig ausgeführte Befehl sieht dann so aus: python app.py --port 8080. 

Signalverarbeitung und PID 1

ENTRYPOINTDie Form von PID 1 hat erhebliche Auswirkungen auf die Fähigkeit von Docker, Signale zu verarbeiten, da PID 1 sehr wichtig ist. Lass uns das genauer untersuchen: 

Ausführungsform und PID 1

Das Exec-Formular führt Befehle direkt als PID 1-Prozess von Docker aus, was die Zuverlässigkeit der Signalweiterleitung und das richtige Verhalten beim Anhalten oder Neustart verbessert.

Grenzen der test-shell Form

Das Shell-Formular fügt einen zwischengeschalteten Shell-Prozess hinzu. Dadurch wird verhindert, dass Beendigungssignale die Anwendungsprozesse erreichen, wodurch die Gefahr besteht, dass Container stecken bleiben oder nicht mehr reagieren.

Debuggen des ENTRYPOINT-Verhaltens

Die Fehlersuche bei entrypoint Konfigurationen ist mit bestimmten Techniken und Tricks einfacher. Entdecken wir sie im Folgenden. 

Verwendung von --entrypoint zur Fehlersuche

Temporäre Überschreibungen ermöglichen interaktive Test-Shells in deinen Containern, ohne dass das Image neu erstellt werden muss. So kannst du verschiedene Dinge in deiner Anwendung testen, ohne das Image neu zu erstellen. 

ENTRYPOINT-Protokolle anzeigen

Das Überprüfen von Ausgabeprotokollen mit docker logs vereinfacht das Nachverfolgen der Ausführungshistorie und das klare und schnelle Auffinden von Konfigurationsproblemen.

Vermeide die Änderung von Dockerdateien für temporäre Tests

Mit den debuggingfreundlichen ENTRYPOINT Überschreibungen zur Laufzeit kannst du Probleme isolieren und beheben, ohne die Container-Images immer wieder zu ändern und neu zu erstellen.

Optimierungstechniken und Best Practices

Im Folgenden werden einige Optimierungen empfohlen, um die Zuverlässigkeit und Wartungsfreundlichkeit von ENTRYPOINT zu verbessern.

Exec-Formular für die Signalverarbeitung verwenden

Bevorzuge immer die Form exec, um die richtigen Abschlusssignale zu erhalten und die Zuverlässigkeit und Verwaltung des Containers insgesamt zu verbessern.

ENTRYPOINT und CMD effektiv kombinieren

Trenne deine ausführbare Datei (ENTRYPOINT) von den Standard-Laufzeitargumenten (CMD) und nutze Laufzeitüberschreibungen für maximale Flexibilität und einfache Verwaltung.

Minimiere die Komplexität in ENTRYPOINT

Halte ENTRYPOINT einfach und delegiere komplexe Startlogik oder Bedingungen in separate Skripte, um die Komplexität zu beherrschen und die Übersichtlichkeit zu erhöhen.

Fortgeschrittene Anwendungsfälle und Patterns

Lass uns einige fortgeschrittene ENTRYPOINT Anwendungsfälle und Muster erkunden.

Mehrstufige Bauten mit ENTRYPOINT

ENTRYPOINT in den letzten Docker-Phasen erzwingt eine zuverlässige Ausführung und sorgt für sauberere Builds, die speziell auf Produktionsaufgaben innerhalb von CI/CD-Workflows zugeschnitten sind.

Dynamische ENTRYPOINT-Skripte

ENTRYPOINT Skripte können ihre Startlogik dynamisch an die bereitgestellten Umgebungsvariablen oder Laufzeitargumente anpassen und sich so nahtlos in verschiedene Anwendungskontexte einfügen.

ENTRYPOINT für CI/CD-Pipelines

Die Nutzung von ENTRYPOINT verbessert die Konsistenz zwischen Test- und Produktionsumgebungen und sorgt für vorhersehbares Laufzeitverhalten und Wiederholbarkeit. Du kannst zum Beispiel ENTRYPOINT für ein Skript einrichten, das Tests automatisch ausführt. 

Andere Anwendungen sind: 

• Eine ENTRYPOINT, die auf die Datenbank wartet, dann Migrationen durchführt und schließlich die app startet.
• Eine ENTRYPOINT, die automatisch Assets kompiliert, Code lintet oder Konfigurationen validiert.
• ENTRYPOINT Skripte können Umgebungen (Dev, Staging, Production) erkennen und die Einstellungen beim Start des Containers entsprechend anpassen. 

Hier ist ein Beispiel für ein Docker-Image, das automatisch Tests durchführt:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["pytest"]

Die .gitlab-ci.yml würde wie folgt aussehen:

build-test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp-test .
    - docker run myapp-test  # <-- No need to specify 'pytest', ENTRYPOINT does it

Wenn docker run ausgeführt wird, löst es automatisch pytest innerhalb des Containers aus. So wird sichergestellt, dass alle Tests gefunden und sofort durchgeführt werden. 

Die Verwendung von ENTRYPOINT in CI/CD hat mehrere Vorteile:

• Jeder Container startet und verhält sich auf dieselbe Weise. 
• Vereinfacht CI/CD-Skripte, weil du nicht jedes Mal vollständige Befehle übergeben musst. 
• Automatisiert Prüfungen vor dem Start, Testläufe und Migrationen und reduziert so menschliche Fehler. 

Häufige Fallstricke und Fehlersuche

ENTRYPOINT hat ein paar Fallstricke, die du in deinen Arbeitsabläufen vermeiden solltest.

Missbräuchliche Verwendung der test-shell Form

Die Test-Shell-Form behindert Signale und Container-Manager; bevorzuge immer die exec Form, um Signale richtig zu behandeln, Container zu verlassen und sauber zu stoppen.

Überkomplizierung ENTRYPOINT

Komplexe Skripte, denen es an Klarheit oder Zuverlässigkeit mangelt, verschlechtern sich bei der Fehlersuche oder der laufenden Wartung weiter. Einfache ENTRYPOINT Setups vereinfachen die Fehlersuche erheblich.

Fazit

Wenn du Docker ENTRYPOINT verstehst und effektiv implementierst, kannst du vorhersehbare, zuverlässige und wartbare Docker-Container für deine Anwendungen erstellen. Richtig eingesetzt, schafft ENTRYPOINT Konsistenz, ohne dass die Flexibilität durch das leistungsstarke Override-System von Docker beeinträchtigt wird. Das sorgfältige Experimentieren mit den ENTRYPOINT Mustern und die Einhaltung der oben beschriebenen Best Practices vereinfacht die Nutzung von Docker erheblich und führt zu reibungsloseren Bereitstellungs- und Verwaltungszyklen in der Produktion.

Schau dir unsere Docker-Kurse an, um weitere Docker-Themen zu erforschen, wie zum Beispiel:

• Einführung in Docker
• Konzepte für Containerisierung und Virtualisierung 
• Containerisierung und Virtualisierung mit Docker und Kubernetes
• Docker für Fortgeschrittene