Contenedores ejecutables: ENTRYPOINT vs CMD

Les recomiendo leer esta sección de la documentación de Docker: Best practices for writing Dockerfiles.

Comandos:
$ docker buils -t ping . (construyo la imagen)
$ docker run --name pinger ping <hostname> (ahora le puedo pasar un parámetro, previamente tengo que agregar el ENTRYPOINT en el Dockerfile)

Para reforzar:
https://phoenixnap.com/kb/docker-cmd-vs-entrypoint

FROM ubuntu:trusty
CMD ["/bin/ping", "-c", "3","localhost"]

El parametro que enviamos por linea de comandos sobreescribe
"/bin/ping", "-c", "3","localhost"

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

De esta manera solo se sobreescribe localhost

Contenedores ejecutables: ENTRYPOINT vs CMD

• Vamos a images/docker/avanzado/ping

En docker podemos construir images apartir de un archivo llamado dockerfile

El archivo nos permite ejecutar un comando que se ejecutara una vez inicie nuestro contenedor

¿Qué ocurre al definir un CMD sin definir un ENTRYPOINT?

Si sólo especificas un CMD, entonces Docker ejecutará dicho comando usando el ENTRYPOINT por defecto, que es /bin/sh -c.

Respecto al “entrypoint” (punto de entrada) y “cmd” (comando), puedes sobreescribir ninguno, ambos, o sólo uno de ellos.

Si especificas ambos, entonces:

• El ENTRYPOINT especifica el ejecutable que usará el contenedor,
• y CMD se corresponde con los parámetros a usar con dicho ejecutable.

Ejemplo sin entrypoint

Al no contener el entrypoint toma /bin/ping y toma como parametros los demás elementos "-c", "3", "localhost", sin embargo el argumento localhost es fijo por lo que no podemos hacer ping a otros destinos

  FROM ubuntu:trusty
  CMD ["/bin/ping", "-c", "3", "localhost"]

Ejemplo con entrypoint y cmd

Al usar entry point toma el ejecutable /bin/ping como aplicación de entrada y lo que esta en CMD ["localhost"] de puede cambiar por lo que podemos hacer ping a diferentes destinos

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

Ping a localhost

docker run --name pinger ping

Ping a cualquier otro host

docker run --name pinger ping google.com

Ver más aqui

Note:

Do not confuse RUN with CMD. RUN actually runs a command and commits the result; CMD does not execute anything at build time, but specifies the intended command for the image.

correr un contenedor para que elimine automáticamente cuando termine de ejecutarse

docker run --rm --name pinger ping

There can only be one CMD instruction in a Dockerfile. If you list more than one CMD then only the last CMD will take effect.
The main purpose of a CMD is to provide defaults for an executing container. These defaults can include an executable, or they can omit the executable, in which case you must specify an ENTRYPOINT instruction as well.
If CMD is used to provide default arguments for the ENTRYPOINT instruction, both the CMD and ENTRYPOINT instructions should be specified with the JSON array format.

# Para ejecutar el contener con pámetro en particular.
# Ejecutamos el comando del ENTRYPOINT, con params en CMD
ENTRTPOINT ["command"]
CMD ["params"]

El ENTRYPOINT es el comando que se va a ejecutar por defecto, y en CMD va el parametro del comando.
Este parametro se puede modificar desde el run del contenedor.

¿qué es hacer ping?

Buen tema, me sirvió para algunos contenedores que uso para ejecutar pruebas con dotnet, con esto puedo pasarle parámetros a la ejecución del test sin tener que rebuildear una imagen nueva.

Ejemplo:

FROM build AS testapi
WORKDIR "/src/ApiTest"
ENTRYPOINT [ "dotnet", "test" ]
CMD ["--logger:trx"] 

Y cuando quiero ejecutar el contenedor con modificadores de ejecución, por ejemplo, filtrar los tests:

docker run --rm <container-name> --filter TestCategory=test1

If the user specifies arguments to docker run then they will override the default specified in CMD.

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

cd avanzado/ping

nano Dockerfile 

#######Dockerfile#######
FROM ubuntu:trusty
CMD ["/bin/ping", "-c", "3", "localhost"]
########################

docker build -t ping .

docker run --name pinger ping

– Como hacemos para tener un contenedor ping, acepte parametros por linea de comando y si no recibe algo, haga algo.

hostname

docker run --name pinger ping hostname

nano Dockerfile 

#######Dockerfile#######
FROM ubuntu:trusty
ENTRYPOINT ["/bin/ping", "-c", "3"]
CMD ["localhost"]
########################

docker build -t ping .

docker run --name pinger ping

docker rm pinger

docker run --name pinger google.com

Para los que tienen problemas dónde el contenedor sustituye correctamente los parámetros del CMD pero no hace conexión con ping, basta con reiniciar Docker y se soluciona el problema.

Entrypoint es el comando por defecto que se va a correr en el contenedor, pasando como parámetro lo que se especifique en CMD

Como llama a la imagen ping, igual que el nombre del comando se puede prestar a confusión cuando hace

docker run --name pinger ping google

ping hace referencia a la imagen ping y no al comando ping

Si quieren ver el comando completo cuando hacen docker ps, pueden usar ese comando así:

docker ps -l --no-trunc

Understand how CMD and ENTRYPOINT interact

El ENTRYPOINT es el comando por defecto que va a correr el contenedor, usando el cmd del docker file como parámetro.

ENTRYPOINT por defecto → /bin/sh -c.

En ocaciones queremos que el contenedor funcione como un ejecutable al que queremos darle unos parametros para realizar una tarea.

Sin Entrypoint (CMD)

Al no usar entrypoint y solo CMD en el dockerfile, al agregar un comando al final del docker run <app> <command>, este se ejecutara en lugar del pre-establecido.

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

docker run app google.com
# exec: google.com

Sin ejecutar el ping. Porque remplaza al CMD.

Con Entrypoing (Entrypoint+CMD)

El comando entregado al entrypoint sera el que se ejecute siempre y al que se le puede agregar con CMD o agregando el comando al docker run <app> <command>.

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

docker run app google.com
# exec: /bin/ping -c 3 google.com

Ejecutando asi el ping. Porque remplaza solo al CMD y mantiene el entrypoint. Si no se agrega nada, se mantiene el CMD ejecutando: /bin/ping -c 3 localhost

Tips:

• Usar CMD y entrypoint en solo un tipo de formato: Solo EXEC o solo SHELL FORM.

Contenedores ejecutables: ENTRYPOINT vs CMD

Best practices for writing Dockerfiles

El ENTRYPOINT es el comando por defecto que va a correr en el contenedor (a menos que se lo especifiquemos de otra manera).

Entrypoint: Es el comando por defecto que se va a correr siempre y va utilizar lo que diga CMD como parámetro.

Contenedores ejecutables: ENTRYPOINT vs CMD
Comandos:
$ docker buils -t ping . (construyo la imagen)
$ docker run --name pinger ping <hostname> (ahora le puedo pasar un parámetro, previamente tengo que agregar el ENTRYPOINT en el Dockerfile)

Y pueden revisar el siguiente enlace:
https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

excelente explicacion del porque usar de esta forma.

DOCKERFILE

#Usar imagen ubuntu
FROM ubuntu:trusty

#Enviar comando
ENTRYPOINT ["/bin/ping", "-c", "3"]

#Recibir parámetro
CMD ["localhost"]

DOCKER COMANDO

#Enviar parametro
docker run --name <container> <image> <parametro>

entrypoint comando por defecto que deja paras informacion como parametro

Entrypoint es el comando por defecto que se va a correr a menos que lo especifiquemos de otra manera.

😎

Excelente

Recordando:
El ENTRYPOINT permite ejecutar la configuración de un container que podrá correr como un ejecutable.
Que contiene dos formas, exec form:

ENTRYPOINT ["executable", "param1", "param2"]

shell form:

ENTRYPOINT command param1 param2

El CMD son instrucciones dentro del Dockerfile que si se llega a colocar más de uno tomará el ultimo y ese se hará efecto en la ejecución.
Contiene tres formas de aplicación, exec form:

CMD ["executable","param1","param2"]

Como parametro del ENTRYPOINT:

CMD ["param1","param2"]

Shell form:

CMD command param1 param2

Importante:
Al tener en cuenta que el CMD son tomados como parámetros en a segunda forma, estos se pueden sobre escribir con el Overrinding durante su ejecución, pero si se aplica como en el primera y tercera forma se debe tener cuidado los cambios que se realicen, porque podría causar fallos durante la ejecución. Caso, que no sucede si executable o command entra en el ENTRYPOINT, porque esté no se ve afectado con el Overrinding.