Qual è la differenza tra CMD e ENTRYPOINT in un Dockerfile?


Answers

ENTRYPOINT specifica un comando che verrà sempre eseguito all'avvio del contenitore.

Il CMD specifica gli argomenti che verranno ENTRYPOINT a ENTRYPOINT .

Se vuoi creare un'immagine dedicata a un comando specifico, utilizzerai ENTRYPOINT ["/path/dedicated_command"] comando ENTRYPOINT ["/path/dedicated_command"]

Altrimenti, se si desidera creare un'immagine per scopi generali, è possibile lasciare ENTRYPOINT non specificato e utilizzare CMD ["/path/dedicated_command"] ENTRYPOINT CMD ["/path/dedicated_command"] quanto sarà possibile sovrascrivere l'impostazione fornendo argomenti docker run .

Ad esempio, se il tuo Dockerfile è:

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

L'esecuzione dell'immagine senza alcun argomento eseguirà il ping dell'host locale:

$ 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

Ora, l'esecuzione dell'immagine con un argomento eseguirà il ping dell'argomento:

$ 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

Per confronto, se il tuo Dockerfile è:

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

L'esecuzione dell'immagine senza alcun argomento eseguirà il ping dell'host locale:

$ 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

Ma l'esecuzione dell'immagine con un argomento eseguirà l'argomento:

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

Vedi questo articolo di Brian DeHamer per ulteriori dettagli: https://www.ctl.io/developers/blog/post/dockerfile-entrypoint-vs-cmd/

Question

In Dockerfiles ci sono due comandi che mi assomigliano: CMD e ENTRYPOINT . Ma immagino che ci sia una (sottile?) Differenza tra loro - altrimenti non avrebbe senso avere due comandi per la stessa cosa.

La documentazione indica per CMD

Lo scopo principale di un CMD è di fornire i valori predefiniti per un contenitore in esecuzione.

e per ENTRYPOINT :

Un ENTRYPOINT ti aiuta a configurare un contenitore che puoi eseguire come un eseguibile.

Quindi, qual è la differenza tra questi due comandi?




Commenti sulla funzione EntryPoint nel code

// ENTRYPOINT / usr / sbin / nginx.

// Imposta il punto di accesso (che di default è sh -c) in / usr / sbin / nginx.

// Accetterà il CMD come argomenti per / usr / sbin / nginx.

Un altro riferimento da documenti

È possibile utilizzare il modulo exec di ENTRYPOINT per impostare comandi e argomenti predefiniti piuttosto stabili e quindi utilizzare CMD per impostare valori predefiniti aggiuntivi che è più probabile che vengano modificati.

Esempio:

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: In presenza di EntryPoint, CMD terrà argomenti da alimentare a EntryPoint. In assenza di EntryPoint, CMD sarà il comando che verrà eseguito.







Differenza tra CMD e ENTRYPOINT per intuizione :

  • ENTRYPOINT: comando da eseguire all'avvio del contenitore.
  • CMD: comando da eseguire all'avvio del contenitore o argomenti su ENTRYPOINT se specificato.

Sì, si sta mescolando.

È possibile sovrascriverli quando si esegue la finestra mobile.

Differenza tra CMD e ENTRYPOINT con l'esempio :

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

Maggiori informazioni sulla differenza tra CMD e ENTRYPOINT :

L'argomento su docker run come / bin / bash sovrascrive qualsiasi comando CMD che abbiamo scritto nel Dockerfile.

ENTRYPOINT non può essere cancellato in fase di esecuzione con normali comandi come la docker run [args] . Gli args alla fine della docker run [args] sono forniti come argomenti per ENTRYPOINT. In questo modo possiamo creare un container che è come un normale binario come ls .

Quindi CMD può agire come parametri di default su ENTRYPOINT e quindi possiamo sovrascrivere gli argomenti CMD da [argomenti].

ENTRYPOINT può essere ignorato con --entrypoint .




Secondo i documenti del docker ,

Entrambe le istruzioni CMD e ENTRYPOINT definiscono quale comando viene eseguito durante l'esecuzione di un contenitore. Ci sono poche regole che descrivono la loro cooperazione.

  1. Dockerfile dovrebbe specificare almeno uno dei comandi CMD o ENTRYPOINT .
  2. ENTRYPOINT deve essere definito quando si utilizza il contenitore come eseguibile.
  3. CMD dovrebbe essere usata come un modo per definire gli argomenti predefiniti per un comando ENTRYPOINT o per eseguire un comando ad-hoc in un contenitore.
  4. CMD verrà sovrascritto durante l'esecuzione del contenitore con argomenti alternativi.

Le tabelle seguenti mostrano quale comando viene eseguito per le diverse combinazioni ENTRYPOINT / CMD :

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



Links



Tags

docker docker