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)
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
Aún no tienes acceso a esta clase
Crea una cuenta y continúa viendo este curso
Aportes 26
Preguntas 5
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)
Les recomiendo leer esta sección de la documentación de Docker: Best practices for writing Dockerfiles.
Para reforzar:
https://phoenixnap.com/kb/docker-cmd-vs-entrypoint
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
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
# Para ejecutar el contener con pámetro en particular.
# Ejecutamos el comando del ENTRYPOINT, con params en CMD
ENTRTPOINT ["command"]
CMD ["params"]
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.
¿qué es hacer ping?
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
Entrypoint es el comando por defecto que se va a correr en el contenedor, pasando como parámetro lo que se especifique en CMD
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
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.
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 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
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
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? Crea una cuenta o inicia sesión.