Was ist der Unterschied zwischen CMD und ENTRYPOINT in einer Docker-Datei?

In Dockerfiles gibt es zwei Befehle, die mir ähnlich sehen: CMDund ENTRYPOINT. Aber ich denke, dass es einen (subtilen?) Unterschied zwischen ihnen gibt - sonst wäre es nicht sinnvoll, zwei Befehle für genau dasselbe zu haben.

In der Dokumentation heißt es für CMD

Der Hauptzweck einer CMD besteht darin, Standardeinstellungen für einen ausführenden Container bereitzustellen.

und für ENTRYPOINT:

Mit ENTRYPOINT können Sie einen Container konfigurieren, den Sie als ausführbare Datei ausführen können.

Was ist der Unterschied zwischen diesen beiden Befehlen?

Docker verfügt über einen Standardeinstiegspunkt, der /bin/sh -cjedoch keinen Standardbefehl enthält.

Wenn Sie Docker wie docker run -i -t ubuntu bash folgt ausführen : Der Einstiegspunkt ist der Standardwert /bin/sh -c, das Image ist ubuntuund der Befehl ist bash.

Der Befehl wird über den Einstiegspunkt ausgeführt. dh die eigentliche Sache, die ausgeführt wird, ist /bin/sh -c bash. Dadurch konnte Docker RUNschnell implementieren , indem er sich auf den Parser der Shell stützte.

Später fragten die Leute, ob sie dies anpassen könnten, ENTRYPOINTund --entrypointwurden vorgestellt.

Alles nach ubuntudem obigen Beispiel ist der Befehl und wird an den Einstiegspunkt übergeben. Wenn Sie die CMDAnweisung verwenden, ist es genau so, als ob Sie es tun würden docker run -i -t ubuntu <cmd>. <cmd>wird der Parameter des Einstiegspunkts sein.

Sie erhalten das gleiche Ergebnis auch, wenn Sie stattdessen diesen Befehl eingeben docker run -i -t ubuntu. Sie werden weiterhin eine Bash-Shell im Container starten, da die Ubuntu-Docker-Datei eine Standard-CMD angegeben hat:CMD ["bash"]

Da alles an den Einstiegspunkt übergeben wird, können Sie Ihre Bilder sehr gut verhalten. @Jiri Beispiel ist gut, es zeigt, wie man ein Bild als "binär" verwendet. Wenn Sie ["/bin/cat"]als Einstiegspunkt verwenden und dann tun docker run img /etc/passwd, erhalten Sie es, /etc/passwdist der Befehl und wird an den Einstiegspunkt übergeben, so dass die Ausführung des Endergebnisses einfach ist /bin/cat /etc/passwd.

Ein anderes Beispiel wäre, einen beliebigen Cli als Einstiegspunkt zu haben. Wenn Sie beispielsweise ein Redis-Image haben, anstatt es auszuführen docker run redisimg redis -H something -u toto get key, können Sie es einfach haben ENTRYPOINT ["redis", "-H", "something", "-u", "toto"]und dann wie folgt ausführen, um dasselbe Ergebnis zu erzielen : docker run redisimg get key.

Das ENTRYPOINTgibt einen Befehl an, der immer ausgeführt wird, wenn der Container gestartet wird.

Das CMDgibt Argumente an, die dem zugeführt werden ENTRYPOINT.

Wenn Sie ein Bild für einen bestimmten Befehl erstellen möchten, verwenden Sie ENTRYPOINT ["/path/dedicated_command"]

Wenn Sie andernfalls ein Bild für allgemeine Zwecke erstellen möchten, können Sie es ENTRYPOINTnicht angeben und verwenden, CMD ["/path/dedicated_command"]da Sie die Einstellung überschreiben können, indem Sie Argumente an angeben docker run.

Zum Beispiel, wenn Ihre Docker-Datei:

FROM debian:wheezy
ENTRYPOINT ["/bin/ping"]
CMD ["localhost"]

Wenn Sie das Image ohne Argument ausführen, wird ein Ping an den lokalen Host gesendet:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.096 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.088 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.088 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.088/0.091/0.096/0.000 ms

Wenn Sie das Bild jetzt mit einem Argument ausführen, wird das Argument gepingt:

$ docker run -it test google.com
PING google.com (173.194.45.70): 48 data bytes
56 bytes from 173.194.45.70: icmp_seq=0 ttl=55 time=32.583 ms
56 bytes from 173.194.45.70: icmp_seq=2 ttl=55 time=30.327 ms
56 bytes from 173.194.45.70: icmp_seq=4 ttl=55 time=46.379 ms
^C--- google.com ping statistics ---
5 packets transmitted, 3 packets received, 40% packet loss
round-trip min/avg/max/stddev = 30.327/36.430/46.379/7.095 ms

Zum Vergleich, wenn Ihre Docker-Datei:

FROM debian:wheezy
CMD ["/bin/ping", "localhost"]

Wenn Sie das Image ohne Argument ausführen, wird ein Ping an den lokalen Host gesendet:

$ docker run -it test
PING localhost (127.0.0.1): 48 data bytes
56 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.076 ms
56 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.087 ms
56 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.090 ms
^C--- localhost ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.076/0.084/0.090/0.000 ms

Wenn Sie das Image jedoch mit einem Argument ausführen, wird das folgende Argument ausgeführt:

docker run -it test bash
root@e8bb7249b843:/#

Weitere Informationen finden Sie in diesem Artikel von Brian DeHamer: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

Laut Docker docs ,

Sowohl CMD- als auch ENTRYPOINT-Anweisungen definieren, welcher Befehl beim Ausführen eines Containers ausgeführt wird. Es gibt nur wenige Regeln, die ihre Zusammenarbeit beschreiben.

1. Dockerfile sollte mindestens einen CMDoder mehrere ENTRYPOINTBefehle angeben .
2. ENTRYPOINT sollte definiert werden, wenn der Container als ausführbare Datei verwendet wird.
3. CMDsollte verwendet werden, um Standardargumente für einen ENTRYPOINTBefehl zu definieren oder um einen Ad-hoc-Befehl in einem Container auszuführen.
4. CMD wird überschrieben, wenn der Container mit alternativen Argumenten ausgeführt wird.

Die folgende Tabelle zeigt, welcher Befehl für verschiedene ENTRYPOINT/ CMDKombinationen ausgeführt wird :

- - No ENTRYPOINT

╔════════════════════════════╦═════════════════════════════╗
║ No CMD                     ║ error, not allowed          ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════╝

- - ENTRYPOINT exec_entry p1_entry

╔════════════════════════════╦══════════════════════════════════╗
║ No CMD                     ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ /bin/sh -c exec_entry p1_entry   ║
╟────────────────────────────╫──────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_entry p1_entry   ║
╚════════════════════════════╩══════════════════════════════════╝

- - ENTRYPOINT [“exec_entry”, “p1_entry”]

╔════════════════════════════╦═════════════════════════════════════════════════╗
║ No CMD                     ║ exec_entry p1_entry                             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“exec_cmd”, “p1_cmd”] ║ exec_entry p1_entry exec_cmd p1_cmd             ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ exec_entry p1_entry p1_cmd p2_cmd               ║
╟────────────────────────────╫─────────────────────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd  ║
╚════════════════════════════╩═════════════════════════════════════════════════╝

Ja, das ist eine gute Frage. Ich verstehe es noch nicht ganz, aber:

Ich verstehe, dass dies ENTRYPOINTdie Binärdatei ist, die ausgeführt wird. Sie können den Einstiegspunkt mit --entrypoint = "" überschreiben.

docker run -t -i --entrypoint="/bin/bash" ubuntu

CMD ist das Standardargument für Container. Ohne Einstiegspunkt ist das Standardargument der Befehl, der ausgeführt wird. Beim Einstiegspunkt wird cmd als Argument an den Einstiegspunkt übergeben. Sie können einen Befehl mit Einstiegspunkt emulieren.

# no entrypoint
docker run ubuntu /bin/cat /etc/passwd

# with entry point, emulating cat command
docker run --entrypoint="/bin/cat" ubuntu /etc/passwd

Der Hauptvorteil besteht also darin, dass Sie mit dem Einstiegspunkt Argumente (cmd) an Ihren Container übergeben können. Um dies zu erreichen, müssen Sie beide verwenden:

# Dockerfile
FROM ubuntu
ENTRYPOINT ["/bin/cat"]

und

docker build -t=cat .

dann können Sie verwenden:

docker run cat /etc/passwd
#              ^^^^^^^^^^^
#                   CMD
#          ^^^      
#          image (tag)- using the default ENTRYPOINT

Unterschied zwischen CMD und ENTRYPOINT durch Intuition :

• ENTRYPOINT: Befehl, der ausgeführt wird, wenn der Container gestartet wird.
• CMD: Befehl, der ausgeführt werden soll, wenn der Container gestartet wird, oder Argumente für ENTRYPOINT, falls angegeben.

Ja, es ist durcheinander.

Sie können jeden von ihnen überschreiben, wenn Sie Docker ausführen.

Unterschied zwischen CMD und ENTRYPOINT am Beispiel :

docker run -it --rm yourcontainer /bin/bash            <-- /bin/bash overrides CMD
                                                       <-- /bin/bash does not override ENTRYPOINT
docker run -it --rm --entrypoint ls yourcontainer      <-- overrides ENTRYPOINT with ls
docker run -it --rm --entrypoint ls yourcontainer  -la  <-- overrides ENTRYPOINT with ls and overrides CMD with -la

Mehr zum Unterschied zwischen CMDund ENTRYPOINT:

Argumente docker runwie / bin / bash überschreiben alle CMD-Befehle, die wir in Dockerfile geschrieben haben.

ENTRYPOINT kann zur Laufzeit nicht mit normalen Befehlen wie z docker run [args]. Die argsam Ende von docker run [args]werden als Argumente für ENTRYPOINT bereitgestellt. Auf diese Weise können wir eine erstellen, containerdie einer normalen Binärdatei wie z ls.

CMD kann also als Standardparameter für ENTRYPOINT fungieren, und dann können wir die CMD-Argumente von [Argumente] überschreiben.

ENTRYPOINT kann mit überschrieben werden --entrypoint.

In einer Nussschale:

• CMD legt Standardbefehle und / oder -parameter fest, die über die Befehlszeile überschrieben werden können, wenn der Docker-Container ausgeführt wird.
• Der Befehl und die Parameter ENTRYPOINT werden nicht über die Befehlszeile überschrieben. Stattdessen werden alle Befehlszeilenargumente nach den Parametern ENTRYPOINT hinzugefügt.

Wenn Sie weitere Details benötigen oder einen Unterschied zum Beispiel sehen möchten, gibt es einen Blog-Beitrag, in dem CMD und ENTRYPOINT umfassend mit vielen Beispielen verglichen werden - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/

Ich werde meine Antwort als Beispiel ¹ hinzufügen , um Ihnen zu helfen, den Unterschied besser zu verstehen.

Angenommen, wir möchten ein Image erstellen, das beim Start immer einen Schlafbefehl ausführt. Wir erstellen unser eigenes Image und geben einen neuen Befehl an:

FROM ubuntu
CMD sleep 10

Jetzt bauen wir das Bild:

docker build -t custom_sleep .
docker run custom_sleep
# sleeps for 10 seconds and exits

Was ist, wenn wir die Anzahl der Sekunden ändern möchten? Wir müssten das ändern, Dockerfileda der Wert dort fest codiert ist, oder den Befehl überschreiben, indem wir einen anderen angeben:

docker run custom_sleep sleep 20

Dies funktioniert zwar, ist aber keine gute Lösung, da wir einen redundanten "Schlaf" -Befehl haben (der Zweck des Containers besteht darin, zu schlafen , daher sleepist es keine gute Praxis , den Befehl explizit anzugeben ).

Versuchen wir nun, die ENTRYPOINTAnweisung zu verwenden:

FROM ubuntu
ENTRYPOINT sleep

Diese Anweisung gibt das Programm an, das beim Starten des Containers ausgeführt wird .

Jetzt können wir laufen:

docker run custom_sleep 20

Was ist mit einem Standardwert? Nun, Sie haben es richtig erraten:

FROM ubuntu
ENTRYPOINT ["sleep"]
CMD ["10"]

Das ENTRYPOINTist das Programm, das ausgeführt wird, und der an den Container übergebene Wert wird an diesen angehängt.

Das ENTRYPOINTkann durch Angabe eines --entrypointFlags überschrieben werden , gefolgt von dem neuen Einstiegspunkt, den Sie verwenden möchten.

^{Nicht meins, ich habe mir einmal ein Tutorial angesehen, das dieses Beispiel lieferte}

Die akzeptierte Antwort ist fabelhaft in der Erklärung der Geschichte. Ich finde, diese Tabelle erklärt es sehr gut aus dem offiziellen Dokument über die Interaktion von CMD und ENTRYPOINT :

Kommentare zur EntryPoint-Funktion im Code

// ENTRYPOINT / usr / sbin / nginx.

// Setze den Einstiegspunkt (standardmäßig sh -c) auf / usr / sbin / nginx.

// Akzeptiert die CMD als Argumente für / usr / sbin / nginx.

Ein weiterer Hinweis aus Dokumenten

Sie können die Exec-Form von ENTRYPOINT verwenden, um ziemlich stabile Standardbefehle und -argumente festzulegen, und dann CMD verwenden, um zusätzliche Standardeinstellungen festzulegen , die mit größerer Wahrscheinlichkeit geändert werden.

Beispiel:

FROM ubuntu:14.04.3
ENTRYPOINT ["/bin/ping"]
CMD ["localhost", "-c", "2"]

Build : sudo docker build -t ent_cmd.

CMD arguments are easy to override.

NO argument (sudo docker -it ent_cmd)                :  ping localhost 
argument    (sudo docker run -it ent_cmd google.com) :  ping google.com

.

To override EntryPoint argument, you need to supply entrypoint
sudo docker run -it --entrypoint="/bin/bash" ent_cmdd

ps: Bei Vorhandensein von EntryPoint enthält CMD Argumente, die an EntryPoint weitergeleitet werden sollen. In Abwesenheit von EntryPoint ist CMD der Befehl, der ausgeführt wird.

CMDDer in der DockerfileDatei erwähnte Befehl kann über den docker runBefehl überschrieben werden, während ENTRYPOINTdies nicht möglich ist.

Ich habe alle Antworten gelesen und möchte zum besseren Verständnis auf den ersten Blick Folgendes zusammenfassen:

Erstens besteht der gesamte Befehl, der im Container ausgeführt wird, aus zwei Teilen: dem Befehl und den Argumenten

• ENTRYPOINT definiert die ausführbare Datei, die beim Starten des Containers aufgerufen wird (für Befehl)

• CMD gibt die Argumente an, die an ENTRYPOINT übergeben werden (für Argumente).

Im Kubernetes In Action- Buch wird ein wichtiger Hinweis dazu gegeben. (Kapitel 7)

Obwohl Sie die CMD- Anweisung verwenden können, um den Befehl anzugeben, den Sie ausführen möchten, wenn das Image ausgeführt wird, besteht die richtige Methode darin, die Anweisung ENTRYPOINT zu verwenden und die CMD nur anzugeben, wenn Sie die Standardargumente definieren möchten.

Sie können diesen Artikel auch auf einfache Weise lesen, um eine gute Erklärung zu erhalten

CMD:

• CMD ["executable","param1","param2"]: ["executable","param1","param2"]ist der erste Prozess.
• CMD command param1 param2: /bin/sh -c CMD command param1 param2ist der erste Prozess. CMD command param1 param2wird vom ersten Prozess gegabelt.
• CMD ["param1","param2"]: Dieses Formular wird verwendet, um Standardargumente für bereitzustellen ENTRYPOINT.

ENTRYPOINT (In der folgenden Liste wird der Fall nicht berücksichtigt, in dem CMD und ENTRYPOINT zusammen verwendet werden):

• ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"]ist der erste Prozess.
• ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2ist der erste Prozess. command param1 param2wird vom ersten Prozess gegabelt.

Wie Creack sagte, wurde CMD zuerst entwickelt. Dann wurde ENTRYPOINT für weitere Anpassungen entwickelt. Da sie nicht zusammen entworfen wurden, gibt es einige Funktionsüberschneidungen zwischen CMD und ENTRYPOINT, die Menschen oft verwirren.

Die meisten Leute erklären es hier perfekt, deshalb werde ich nicht alle Antworten wiederholen. Aber um ein gutes Gefühl zu bekommen, würde ich vorschlagen, es selbst zu testen, indem Sie sich die Prozesse im Container ansehen.

Erstellen Sie eine winzige Docker-Datei des Formulars:

FROM ubuntu:latest
CMD /bin/bash

Erstellen Sie es, führen Sie es mit aus docker run -it theimageund führen Sie es ps -eo ppid,pid,argsim Container aus. Vergleichen Sie diese Ausgabe mit der Ausgabe, die Sie von ps erhalten, wenn Sie Folgendes verwenden:

• docker run -it theimage bash
• Erstellen Sie das Image neu, aber mit ENTRYPOINT /bin/bashund führen Sie es auf beide Arten aus
• Verwenden von CMD ["/bin/bash"]
• ...

Auf diese Weise können Sie die Unterschiede zwischen allen möglichen Methoden leicht selbst erkennen.

Die offizielle Dokumentation der Best Practices von Dockerfile erklärt die Unterschiede hervorragend. Best Practices für Dockerfile

CMD:

Die CMD-Anweisung sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit allen Argumenten auszuführen. CMD sollte fast immer in Form von verwendet werden CMD ["executable", "param1", "param2"…]. Wenn das Image also für einen Dienst wie Apache und Rails bestimmt ist, würden Sie so etwas wie ausführen CMD ["apache2","-DFOREGROUND"]. In der Tat wird diese Form der Anweisung für jedes service-basierte Image empfohlen.

EINSTIEGSPUNKT:

Die beste Verwendung für ENTRYPOINT besteht darin, den Hauptbefehl des Bildes festzulegen, sodass das Bild so ausgeführt werden kann, als wäre es dieser Befehl (und dann CMD als Standardflags verwenden).