Was ist der Unterschied zwischen CMD und ENTRYPOINT in einer Dockerfile?

In Dockerfiles es gibt zwei Befehle, die ähnlich Aussehen wie ich: CMD und ENTRYPOINT. Aber ich denke, dass es eine (subtile?) der Unterschied zwischen Ihnen - sonst würde es keinen Sinn machen, zwei Befehle für die sehr gleiche Sache.

Gibt die Dokumentation für CMD

Den Hauptzweck einer CMD ist die Bereitstellung von Vorgaben für die Ausführung Behälter.

und für ENTRYPOINT:

Einen ENTRYPOINT unterstützt Sie bei der Konfiguration eines Containers, dass Sie ausgeführt werden kann als eine ausführbare Datei.

So, was ist der Unterschied zwischen diesen beiden Befehlen?

InformationsquelleAutor der Frage Golo Roden | 2014-02-04

docker

Docker hat eine Standard entrypoint, die /bin/sh -c aber nicht über eine default-Befehl.

Beim ausführen von docker wie diese:
docker run -i -t ubuntu bash
der entrypoint ist der Standard -/bin/sh -c, das Bild ist ubuntu den Befehl bash.

Ausführen des Befehls über den entrypoint. d.h., die eigentliche Sache und ausgeführt wird, ist /bin/sh -c bash. Dies erlaubt Andockfenster zu implementieren RUN schnell, indem Sie sich auf der shell-parser.

Später, bat die Leute, um in der Lage sein, dies anzupassen, so ENTRYPOINT und --entrypoint eingeführt wurden.

Alles nach ubuntu im Beispiel oben ist die Befehls-und übergeben, entrypoint. Bei der Verwendung der CMD Unterricht, es ist genau so, als ob Sie Taten docker run -i -t ubuntu <cmd>. <cmd> werden die parameter der entrypoint.

Erhalten Sie auch das gleiche Ergebnis, wenn Sie statt dessen diesen Befehl eingeben docker run -i -t ubuntu. Werden Sie noch starten Sie eine bash-shell in die container, weil der ubuntu Dockerfile angegebenen Standardwert CMD: CMD ["bash"]

Als alles, was übergeben wird, der entrypoint ist, können Sie ein sehr schönes Verhalten von Ihren Bildern. @Jiri Beispiel ist gut, er zeigt, wie man ein Bild als "binary". Bei der Verwendung von ["/bin/cat"] als entrypoint und dann tut docker run img /etc/passwd Sie es bekommen, /etc/passwd ist der Befehl und wird an den entrypoint, so das Ergebnis der Ausführung ist einfach /bin/cat /etc/passwd.

Anderes Beispiel wäre es, alle cli als entrypoint. Zum Beispiel, wenn Sie einen redis-Bild, anstatt zu laufen docker run redisimg redis -H something -u toto get key können Sie einfach ENTRYPOINT ["redis", "-H", "something", "-u", "toto"] und dann ausführen, wie dies für das gleiche Ergebnis: docker run redisimg get key.

InformationsquelleAutor der Antwort creack

248

Den ENTRYPOINT gibt einen Befehl an, der immer ausgeführt werden, wenn der container gestartet wird.

Den CMD gibt Argumente, die zugeführt wird, um die ENTRYPOINT.

Wenn Sie möchten, ein Bild zu machen, einen eigenen Befehl, den Sie verwenden ENTRYPOINT ["/path/dedicated_command"]

Andernfalls, wenn Sie möchten, um ein Bild für den Allgemeinen Zweck, lassen Sie ENTRYPOINT unbestimmten und verwenden CMD ["/path/dedicated_command"] wie können Sie die Einstellung außer Kraft setzen, indem Sie liefern Argumente, um docker run.

Zum Beispiel, wenn Ihr Dockerfile ist:

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

Läuft das Bild ohne argument wird die ping localhost:

$ 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

Jetzt läuft das Bild mit einem argument, mit dem die ping-argument:

$ 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 Ihr Dockerfile ist:

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

Läuft das Bild ohne argument wird die ping localhost:

$ 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

Aber läuft das Bild mit einem argument ausgeführt, das argument:

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

Finden Sie in diesem Artikel von Brian DeHamer für noch mehr details:
https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

InformationsquelleAutor der Antwort Daishi

135

Ja, das ist eine gute Frage. Ich verstehe es zwar nicht vollständig, aber:

Ich verstehe, dass ENTRYPOINT ist die binäre, der ausgeführt wird. Sie können diesen entrypoint-entrypoint="".
```
docker run -t -i --entrypoint="/bin/bash" ubuntu
```
CMD ist die Standard-argument, um den Behälter. Ohne entrypoint, Standard-argument ist der Befehl, der ausgeführt wird. Mit entrypoint, cmd übergeben wird, entrypoint als argument. Können Sie emulieren Sie den Befehl mit entrypoint.
```
# no entrypoint
docker run ubuntu /bin/cat /etc/passwd

# with entry point, emulating cat command
docker run --entrypoint="/bin/cat" ubuntu /etc/passwd
```
So, der Hauptvorteil ist, dass mit entrypoint können Sie Argumente übergeben (cmd) auf den container. Um dies zu erreichen, müssen Sie verwenden beide:
```
# 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
```
InformationsquelleAutor der Antwort Jiri

104

Laut Andockfenster docs,

Beide CMD und ENTRYPOINT Anweisungen definieren, was Befehl ausgeführt
wenn ein container. Es gibt nur wenige Regeln, die beschreiben, Ihre
Zusammenarbeit.

Dockerfile sollten geben Sie mindestens eine der CMD oder ENTRYPOINT Befehle.

ENTRYPOINT sollten definiert werden, wenn der container als eine ausführbare Datei.

CMD sollte verwendet werden, als eine Möglichkeit der Definition von Standard-Argumente, die für einen ENTRYPOINT Befehls oder zur Ausführung einer ad-hoc-Befehl in einer
container.

CMD werden, überschrieben werden, wenn die Ausführung des Containers mit alternativen Argumenten.

Den nachstehenden Tabellen zeigt welcher Befehl ausgeführt wird, für verschiedene ENTRYPOINT /CMD Kombinationen:

-- 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 exec_cmd p1_cmd            ║
╟────────────────────────────╫───────────────────────────────────────────────────────────╢
║ CMD [“p1_cmd”, “p2_cmd”]   ║ /bin/sh -c exec_entry p1_entry p1_cmd p2_cmd              ║
╟────────────────────────────╫───────────────────────────────────────────────────────────╢
║ CMD exec_cmd p1_cmd        ║ /bin/sh -c exec_entry p1_entry /bin/sh -c exec_cmd p1_cmd ║
╚════════════════════════════╩═══════════════════════════════════════════════════════════╝

-- 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  ║
╚════════════════════════════╩═════════════════════════════════════════════════╝

InformationsquelleAutor der Antwort Rafaf Tahsin

24

Kurz gesagt:
- CMD setzt default-Befehl und/oder Parameter, die überschrieben werden kann von der Befehl Linie, wenn docker-container läuft.
- ENTRYPOINT Befehl und Parameter werden nicht überschrieben, das von der Kommandozeile aus. Stattdessen werden alle Kommandozeilen-Argumente werden addiert, nachdem ENTRYPOINT Parameter.
Wenn Sie weitere Einzelheiten benötigen oder möchten, um zu sehen Unterschied auf Beispiel, es ist ein blog-post, die umfassend vergleichen Sie CMD ein und ENTRYPOINT mit vielen Beispielen - http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/

InformationsquelleAutor der Antwort upitau
14

Unterschied zwischen CMD und ENTRYPOINT durch intuition:
- ENTRYPOINT: Befehl ausgeführt werden, wenn der container gestartet wird.
- CMD: Befehl ausgeführt werden, wenn der container gestartet wird oder Argumente zu ENTRYPOINT, wenn angegeben.
Ja, es ist die Vermischung.

Können Sie überschreiben alle von Ihnen beim ausführen von docker laufen.

Unterschied zwischen CMD und ENTRYPOINT von 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 auf den Unterschied zwischen CMD und ENTRYPOINT:

Argument docker run wie /bin/bash überschreibt alle CMD-Befehl, den wir schrieb im Dockerfile.

ENTRYPOINT kann nicht überschrieben werden, die zur Laufzeit mit normalen Befehle wie docker run [args]. Die args am Ende docker run [args] vorgesehen sind, die als Argumente an ENTRYPOINT. Auf diese Weise können wir eine container die wie eine normale binäre wie ls.

Also CMD als default-Parameter zu ENTRYPOINT, und dann können wir überschreiben die CMD args [args].

ENTRYPOINT überschrieben werden können mit --entrypoint.

InformationsquelleAutor der Antwort Tomer Ben David
7

Die akzeptierte Antwort ist Fabelhaft, die die Geschichte erklären. Ich finde diese Tabelle erklären es sehr gut aus offizielle doc ', wie Sie CMD ein und ENTRYPOINT interagieren':

InformationsquelleAutor der Antwort Xiao Peng - ZenUML.com
5

Kommentare auf EntryPoint-Funktion in code

//ENTRYPOINT /usr/sbin/nginx.

//Entrypoint (standardmäßig sh -c) /usr/sbin/nginx.

//Nimmt die CMD als Argumente zu /usr/sbin/nginx.

Andere Referenz von Dokumenten

Können Sie die exec-form der ENTRYPOINT zu setzen relativ stabil Standard-Befehle und Argumente und dann CMD verwenden, um zusätzliche Standards, die eher geändert werden.

Beispiel:
```
FROM ubuntu:14.04.3
ENTRYPOINT ["/bin/ping"]
CMD ["localhost", "-c", "2"]
```
Bauen: 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
```
p.s:
In Anwesenheit von EntryPoint, CMD halten wird, Argumente an die fed zu EntryPoint.
In Abwesenheit von EntryPoint, CMD wird der Befehl, welcher ausgeführt werden soll.

InformationsquelleAutor der Antwort Tahir Rauf
1

CMD:
- CMD ["executable","param1","param2"]: ["executable","param1","param2"] ist der erste Prozess.
- CMD command param1 param2: /bin/sh -c CMD command param1 param2 ist der erste Prozess. CMD command param1 param2 ist entstanden aus dem ersten Prozess.
- CMD ["param1","param2"]: Dieses Formular wird verwendet, um default-Argumente für ENTRYPOINT.
ENTRYPOINT (Die folgende Liste erhebt nicht den Fall betrachten, wo Sie CMD ein und ENTRYPOINT sind, zusammen verwendet):
- ENTRYPOINT ["executable", "param1", "param2"]: ["executable", "param1", "param2"] ist der erste Prozess.
- ENTRYPOINT command param1 param2: /bin/sh -c command param1 param2 ist der erste Prozess. command param1 param2 ist entstanden aus dem ersten Prozess.
Als creack sagte, CMD wurde zuerst entwickelt. Dann ENTRYPOINT wurde entwickelt für mehr Anpassung. Da Sie nicht gemeinsam entworfen, es gibt einige Funktionen, die überschneidungen zwischen CMD und ENTRYPOINT, die oft verwirren die Menschen.

InformationsquelleAutor der Antwort Jingguo Yao
-2

Dies ist wahrscheinlich die beste Beschreibung, die ich gefunden habe:
Dockerfile: ENTRYPOINT vs CMD

Hatte ich eine Zusammenfassung hier, aber die Leute gehalten downvoting ohne Angabe von Gründen, also habe ich es gelöscht.

InformationsquelleAutor der Antwort Ondra Žižka

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.