Sono confuso circa quando dovrei usare CMDvs RUN. Ad esempio, per eseguire i comandi bash / shell (cioè ls -la) userei sempre CMDo c'è una situazione in cui userei RUN? Cercare di capire le migliori pratiche su queste due Dockerfiledirettive simili .

RUN è una fase di creazione dell'immagine, lo stato del contenitore dopo che un RUNcomando verrà assegnato all'immagine del contenitore. Un file Docker può avere molti RUNpassaggi che si sovrappongono l'uno sull'altro per creare l'immagine.

CMD è il comando che il contenitore esegue per impostazione predefinita all'avvio dell'immagine creata. Un file Docker utilizzerà solo il finale CMDdefinito. È CMDpossibile eseguire l'override all'avvio di un contenitore con docker run $image $other_command.

ENTRYPOINT è anche strettamente correlato CMDe può modificare il modo in cui un contenitore avvia un'immagine.

RUN - Il comando si innesca mentre costruiamo l'immagine docker.

CMD - Il comando si innesca mentre lanciamo l'immagine della finestra mobile creata.

Ho trovato questo articolo molto utile per capire la differenza tra loro:

RUN : le istruzioni RUN consentono di installare l'applicazione e i pacchetti necessari per esso. Esegue qualsiasi comando sull'immagine corrente e crea un nuovo livello eseguendo il commit dei risultati. Spesso troverai più istruzioni RUN in un file Docker.

CMD - L'istruzione CMD consente di impostare un comando predefinito, che verrà eseguito solo quando si esegue il contenitore senza specificare un comando. Se il contenitore Docker viene eseguito con un comando, il comando predefinito verrà ignorato. Se Dockerfile ha più di un'istruzione CMD, tutte le
istruzioni CMD tranne l'ultima vengono ignorate.

RUN - Installa Python, il tuo contenitore ora ha Python masterizzato nella sua immagine
CMD - python hello.py, esegui il tuo script preferito

Comando RUN: il comando RUN fondamentalmente eseguirà il comando predefinito quando costruiamo l'immagine. Commetterà anche le modifiche dell'immagine per il passaggio successivo.

Possono esserci più di 1 comando RUN, per facilitare il processo di creazione di una nuova immagine.

Comando CMD: i comandi CMD imposteranno semplicemente il comando predefinito per il nuovo contenitore. Questo non verrà eseguito al momento della creazione.

Se un file docker ha più di 1 comandi CMD, tutti vengono ignorati tranne l'ultimo. Poiché questo comando non eseguirà nulla, ma semplicemente imposterà il comando predefinito.

Nota: non confondere RUN con CMD. RUN esegue effettivamente un comando e commette il risultato; CMD non esegue nulla al momento della creazione, ma specifica il comando previsto per l'immagine.

dal riferimento al file docker

https://docs.docker.com/engine/reference/builder/#cmd

RUN : può essere molti e viene utilizzato nel processo di compilazione , ad esempio l'installazione di più librerie

CMD : può avere solo 1, che è il punto iniziale di esecuzione (ad es ["npm", "start"]. ["node", "app.js"])

Le risposte esistenti coprono la maggior parte di ciò di cui chiunque avrebbe bisogno a questa domanda. Quindi tratterò solo alcune aree di nicchia per CMD e RUN.

CMD: i duplicati sono consentiti ma dispendiosi

GingerBeer fa un punto importante: non otterrai errori se inserisci più di un CMD - ma è inutile farlo. Vorrei elaborare con un esempio:

FROM busybox
CMD echo "Executing CMD"
CMD echo "Executing CMD 2"

Se lo costruisci in un'immagine ed esegui un contenitore in questa immagine, come afferma GingerBeer, verrà ascoltato solo l'ultimo CMD. Quindi l'output di quel contenitore sarà:

Esecuzione di CMD 2

Il modo in cui ci penso è che "CMD" sta impostando una singola variabile globale per l'intera immagine che viene costruita, quindi le istruzioni "CMD" successive semplicemente sovrascrivono qualsiasi scrittura precedente a quella variabile globale e nell'immagine finale che ha creato il l'ultimo a scrivere vince. Poiché un Dockerfile viene eseguito in ordine dall'alto verso il basso, sappiamo che il CMD più in basso è quello che ottiene questa "scrittura" finale (metaforicamente parlando).

ESEGUI: i comandi non possono essere eseguiti se le immagini sono memorizzate nella cache

Un punto sottile da notare su RUN è che viene trattato come una funzione pura anche se ci sono effetti collaterali, e quindi viene memorizzato nella cache. Ciò significa che se RUN ha avuto alcuni effetti collaterali che non cambiano l'immagine risultante e quell'immagine è già stata memorizzata nella cache, il RUN non verrà eseguito di nuovo e quindi gli effetti collaterali non si verificheranno nelle build successive. Ad esempio, prendi questo Dockerfile:

FROM busybox
RUN echo "Just echo while you work"

La prima volta che lo esegui, otterrai un output come questo, con diversi ID alfanumerici:

docker build -t example/run-echo .
Sending build context to Docker daemon  9.216kB
Step 1/2 : FROM busybox
 ---> be5888e67be6
Step 2/2 : RUN echo "Just echo while you work"
 ---> Running in ed37d558c505
Just echo while you work
Removing intermediate container ed37d558c505
 ---> 6f46f7a393d8
Successfully built 6f46f7a393d8
Successfully tagged example/run-echo:latest

Si noti che l'istruzione echo è stata eseguita in quanto sopra. La seconda volta che lo esegui, utilizza la cache e non vedrai alcun eco nell'output della build:

docker build -t example/run-echo .
Sending build context to Docker daemon  9.216kB
Step 1/2 : FROM busybox
 ---> be5888e67be6
Step 2/2 : RUN echo "Just echo while you work"
 ---> Using cache
 ---> 6f46f7a393d8
Successfully built 6f46f7a393d8
Successfully tagged example/run-echo:latest

Ci sono state abbastanza risposte su RUN e CMD . Voglio solo aggiungere qualche parola su ENTRYPOINT . Gli argomenti CMD possono essere sovrascritti dagli argomenti della riga di comando, mentre gli argomenti ENTRYPOINT vengono sempre utilizzati.

Questo articolo è una buona fonte di informazioni.