Les recomiendo leer esta sección de la documentación de Docker: Best practices for writing Dockerfiles.
Introducción
Todo lo que aprenderás sobre Docker
Las tres áreas en el desarrollo de software profesional
Virtualización
Preparando tu entorno de trabajo
[Bonus] Play with Docker
Qué es y cómo funciona Docker
Contenedores
Primeros pasos: hola mundo
Conceptos fundamentales de Docker: contenedores
Comprendiendo el estado de Docker
El modo interactivo
Ciclo de vida de un contenedor
Exponiendo contenedores
Datos en Docker
Bind mounts
Volúmenes
Insertar y extraer archivos de un contenedor
Imágenes
Conceptos fundamentales de Docker: imágenes
Construyendo una imagen propia
El sistema de capas
Docker como herramienta de desarrollo
Usando Docker para desarrollar aplicaciones
Aprovechando el caché de capas para estructurar correctamente tus imágenes
Docker networking: colaboración entre contenedores
Docker compose
Docker Compose: la herramienta todo en uno
Subcomandos de Docker Compose
Docker Compose como herramienta de desarrollo
Compose en equipo: override
Docker Avanzado
Administrando tu ambiente de Docker
Deteniendo contenedores correctamente: SHELL vs. EXEC
Contenedores ejecutables: ENTRYPOINT vs CMD
El contexto de build
Multi-stage build
Docker-in-Docker
Cierre
Cierre del curso
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Aportes 31
Preguntas 8
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
El archivo nos permite ejecutar un comando que se ejecutara una vez inicie nuestro contenedor
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:
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"]
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
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
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.
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.
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
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.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.