Puntos clave: CMD y ENTRYPOINT de Docker son instrucciones esenciales en Dockerfiles que determinan cómo los contenedores ejecutan comandos al inicio. CMD establece comandos predeterminados que pueden ser anulados, mientras que los comandos ENTRYPOINT son ejecutan incondicionalmente.
- CMD puede ser anulado mediante argumentos de línea de comandos; ENTRYPOINT no.
- Utiliza CMD para los valores predeterminados y ENTRYPOINT para los comandos críticos que siempre deben ejecutarse.
CMD y ENTRYPOINT son dos instrucciones Dockerfile que juntas Define el comando que se ejecuta cuando inicia tu contenedor. te debes utiliza estas instrucciones en tus Dockerfiles para que los usuarios puedan interactuar fácilmente con tus imágenes. Como CMD y ENTRYPOINT trabajan en conjunto, a menudo pueden resultar confusos de entender. Este artículo ayuda a eliminar cualquier posible disparidad en este ámbito.
En una configuración nativa en la nube, los contenedores Docker son elementos esenciales que aseguran que una aplicación funcione eficazmente en diferentes entornos informáticos. Estos contenedores son diseñados para soportar tareas y procesos específicos de un flujo de trabajo de aplicación y son soportados por imágenes Docker.
Las imágenes, en cambio, son ejecutan ejecutando instrucciones Docker a través de un Dockerfile. son Hay tres tipos de instrucciones (comandos) que te utiliza para compilar y ejecutar Dockerfiles:
- RUN. Principalmente utilizado para crear imágenes e instalar aplicaciones y paquetes, RUN construye una nueva capa sobre una imagen existente mediante el commit de los resultados.
- CMD. Establece parámetros predeterminados que pueden ser anulados desde la Interfaz de Línea de Comandos (CLI) de Docker cuando un contenedor está en ejecución.
- ENTRYPOINT. Parámetros predeterminados que no pueden ser anulados cuando los contenedores Docker se ejecutan con parámetros de CLI.
Cualquier imagen Docker debe tener una declaración ENTRYPOINT o CMD para que un contenedor pueda iniciarse. Aunque las instrucciones ENTRYPOINT y CMD puedan parecer similares a primera vista, son diferencias fundamentales en cómo construyen imágenes de contenedores.
(
Formulario de shell vs. formulario ejecutable
Primero, necesitamos entender cómo procesa un Daemon Docker las instrucciones una vez que son pasadas.
Todos los tipos de instrucciones Docker (comandos) pueden especificarse tanto en formato shell como en forma ejecutiva. Vamos a construir un ejemplo de Dockerfile para entender estos dos comandos.
(Explora más comandos Docker.)
Forma de comando de shell
Como su nombre indica, una forma de shell de instrucciones inicia procesos que se ejecutan dentro del shell. Para ejecutarlo, invoca el comando /bin/sh -c <comando>.
Normalmente, cada ejecución mediante un comando de shell requiere que las variables de entorno pasen por validación antes de devolver los resultados.
Las sintaxis de los comandos shell son especificadas en la forma:
<instrucción> <mando>
Ejemplos de comandos shell form incluyen:
RUN yum -y update
RUN yum -y install httpd
COPY ./index.html/var/www/index.html
CMD echo “Hello World”
Un Dockerfile llamado Darwin que utiliza el comando shell tendrá las siguientes especificaciones:
ENV name Darwin
ENTRYPOINT /bin/echo "Welcome, $name"
(Las especificaciones de comandos usadas arriba son como referencia. te puede incluir cualquier otro comando de shell según tus propios requisitos.)
Según la especificación anterior, la salida del comando docker run-it Darwin será:
Bienvenido, Darwin
Este formulario de comandos dirige al shell para que pase por la validación antes de devolver los resultados, lo que a menudo conduce a cuellos de botella en el rendimiento. Como resultado, los formularios de shell no suelen son un método preferido salvo que existan requisitos específicos de validación de comandos o entornos.
Formulario de comando ejecutable
A diferencia del tipo de comando shell, una instrucción escrita en forma ejecutable ejecuta directamente los binarios ejecutables, sin pasar por la validación ni procesamiento del shell.
Las sintaxis de comandos ejecutables son especificadas en la forma:
<instrucciones> ["ejecutable", "parámetro 1", "parámetro 2", ...]
Ejemplos de comandos ejecutables incluyen:
RUN ["yum", "-y", "update"]
CMD ["yum", "-y" "install" "httpd"]
COPY ["./index.html/var/www/index.html"]
Para construir un archivo Dockerfile llamado Darwin en forma ejecutiva:
ENV name Darwin
ENTRYPOINT ["/bin/echo", "Welcome, $name"]
Como esto evita un procesamiento de shell, la salida del comando -it Darwin de docker se devolverá como: Bienvenido, $name.
Esto se está a que la variable de entorno no se están sustituida en el Dockerfile. Para ejecutar bash en forma de ejecutante, especifica /bin/bash como ejecutable, es decir:
ENV name Darwin
ENTRYPOINT ["/bin/bash", “-c” "echo Welcome, $name"]
Esto solicita el procesamiento de shell, así que la salida del archivo Docker será: Bienvenido, Darwin.
Los comandos en una configuración contenedorizada son instrucciones esenciales que son transmitidas al entorno operativo para obtener una salida deseada. Es de suma importancia utilizar el formulario de comandos adecuado para pasar instrucciones con el fin de:
- Devuelve el resultado deseado
- Asegúrate de que te no empujen al entorno a procesos innecesarios, afectando así a la eficiencia operativa
¿Interesado en DevOps empresariales? Conoce más sobre soluciones y herramientas DevOps con BMC. ›
CMD vs. PUNTO DE ENTRADA: Diferencias fundamentales
Las instrucciones CMD y ENTRYPOINT presentan diferencias fundamentales en su funcionamiento, haciendo que cada una sea adecuada para diferentes aplicaciones, entornos y escenarios.
Ambos especifican programas que se ejecutan cuando el contenedor comienza a ejecutarse, pero:
- Los comandos CMD son ignorados por Daemon cuando son parámetros indicados dentro del comando docker run.
- Las instrucciones ENTRYPOINT no son ignoradas, sino que se son añadidas como parámetros de línea de comandos tratándolas como argumentos del comando.
A continuación, echemos un vistazo más de cerca. Vamos a utilizar ambos formularios de comandos para repasar las diferentes etapas de la ejecución de un contenedor Docker.
Docker CMD
Los comandos CMD de Docker son pasados a través de un archivo Docker que consiste en:
- Instrucciones para construir una imagen Docker
- Binarios predeterminados para ejecutar un contenedor sobre la imagen
Con un tipo de instrucción CMD, un comando/programa por defecto se ejecuta incluso si no se está especificado ningún comando en la CLI.
Idealmente, debería haber un único comando CMD dentro de un Dockerfile. Por ejemplo, cuando son múltiples comandos CMD en un Dockerfile, todos excepto el último son ignorados para su ejecución.
Una característica esencial de un comando CMD están su capacidad para ser anulado. Esto permite a los usuarios ejecutar comandos a través de la CLI para anular instrucciones CMD dentro de un archivo Docker.
Una instrucción CMD de Docker puede escribirse tanto en formato Shell como en Exec como:
- Formulario ejecutivo: CMD ["ejecutable", "parameter1", "parameter2"]
- Forma de la carcasa: parámetro de comando CMD1 parámetro2
Etapa 1. Creación de un archivo Docker
Al construir un Dockerfile, la instrucción CMD especifica el programa predeterminado que se ejecutará una vez que el contenedor se ejecute. Un apunte rápido: los comandos CMD solo se utilizarán cuando son falten argumentos de línea de comandos.
Analizaremos un Dockerfile llamado Darwin con instrucciones CMD y analizaremos su comportamiento.
Las especificaciones de Dockerfile para Darwin son:
Etapa 1. Creación de un archivo Docker
FROM centos:7
RUN apt-get update
RUN apt-get -y install python
COPY ./opt/source code
CMD ["echo", "Hello, Darwin"]
La instrucción CMD en el archivo anterior hace eco del mensaje Hola, Darwin cuando el contenedor se está iniciado sin un argumento CLI.
Etapa 2. Construyendo una imagen
Las imágenes Docker son construidas a partir de Dockerfiles usando el comando:
Etapa 2. Construyendo una imagen
$ docker build -t Darwin .
El comando anterior hace dos cosas:
- Le dice al Daemon Docker que construya una imagen
- Establece el nombre de la etiqueta a Darwin ubicado dentro del directorio actual
Fase 3. Ejecutar un contenedor Docker
Para ejecutar un contenedor Docker, utiliza el comando docker run:
Fase 3. Ejecutar un contenedor Docker
$ docker run Darwin
Como esto excluye un argumento de línea de comandos, el contenedor ejecuta la instrucción CMD predeterminada y muestra Hello, Darwin como salida.
Si añadimos un argumento con el comando run, anula la instrucción por defecto, es decir:
$ docker run Darwin hostname
A medida que se sobrescribe un comando por defecto de CMD, el comando anterior ejecutará el contenedor y mostrará el nombre del host, ignorando así la instrucción de eco en el Dockerfile con la siguiente salida:
6e14beead430
que es el nombre de huésped del contenedor Darwin.
Cuándo utilizar CMD
La mejor manera de utilizar una instrucción CMD están especificando programas predeterminados que deberían ejecutarse cuando los usuarios no introducen argumentos en la línea de comandos.
Esta instrucción asegura que el contenedor están en estado de ejecución al iniciar una aplicación tan pronto como se están ejecutada la imagen del contenedor. Al hacerlo, el argumento CMD carga la imagen base tan pronto como el contenedor comienza.
Además, en casos de utiliza específicos, se puede ejecutar un comando de ejecución de docker mediante una CLI para sobrescribir instrucciones especificadas dentro del Dockerfile.
Punto de entrada de Docker
En Dockerfiles, se está utilizando una instrucción ENTRYPOINT para establecer ejecutables que siempre se ejecutarán cuando se están iniciados el contenedor.
A diferencia de los comandos CMD, los comandos ENTRYPOINT no pueden ser ignorados ni anulados, incluso cuando el contenedor se ejecuta con argumentos de línea de comandos indicados.
Una instrucción ENTRYPOINT de Docker puede escribirse tanto en formato shell como ejecutivo:
- Formulario ejecutivo: ENTRYPOINT ["ejecutable", "parameter1", "parameter2"]
- Forma de proyectil: parámetro de comando ENTRYPOINT1 parámetro2
Las instrucciones ENTRYPOINT se son utilizadas para construir Dockerfiles destinados a ejecutar comandos específicos.
Estos son especificaciones de referencia de Dockerfile con un comando Entrypoint:
FROM centos:7
RUN apt-get update
RUN apt-get -y install python
COPY ./opt/source code
ENTRYPOINT ["echo", "Hello, Darwin"]
El archivo Docker anterior utiliza una instrucción ENTRYPOINT que repite Hello, Darwin cuando el contenedor está en ejecución.
El siguiente paso están crear una imagen Docker. Utiliza el comando:
$ docker build -t Darwin .
Al construir esta imagen, el daemon busca la instrucción ENTRYPOINT y la especifica como un programa por defecto que se ejecutará con o sin entrada de línea de comandos.
Al ejecutar un contenedor Docker usando la imagen Darwin sin argumentos de línea de comandos, se ejecutan son las instrucciones ENTRYPOINT por defecto, haciendo eco de Hola, Darwin.
En caso de que se son introducidos argumentos adicionales de línea de comandos a través de la línea de comando, no se está ignorado el ENTRYPOINT. En su lugar, los parámetros de línea de comandos se son añadidos como argumentos para el comando ENTRYPOINT, es decir:
$ docker run Darwin hostname
ejecutará el ENTRYPOINT, repitiendo Hello, Darwin y luego mostrando el nombre del host para devolver la siguiente salida:
Hello, Darwin 6e14beead430
Cuándo utilizar ENTRYPOINT
Las instrucciones ENTRYPOINT son adecuadas tanto para imágenes de propósito único como multimodo donde es necesario que siempre se ejecute un comando específico al iniciar el contenedor.
Uno de sus casos de utiliza populares están la creación de imágenes de contenedores envoltorios que encapsulan programas heredados para la contenedorización, lo que aprovecha una instrucción ENTRYPOINT para asegurar que el programa siempre se ejecute.
Uso conjunto de instrucciones CMD y ENTRYPOINT
Aunque son diferencias fundamentales en sus operaciones, las instrucciones CMD y ENTRYPOINT no son excluyentes. Varios escenarios pueden requerir la utiliza de sus instrucciones combinadas en un Dockerfile.
Un caso de utiliza muy popular para mezclarlos están automatiza tareas de arranque de contenedores. En tal caso, la instrucción ENTRYPOINT puede usarse para Define el ejecutable mientras se utiliza CMD para Define parámetros.
Repasemos esto con Darwin Dockerfile, con sus especificaciones como:
FROM centos:7
RUN apt-get update
RUN apt-get -y install python
COPY ./opt/source code
ENTRYPOINT ["echo", "Hello"]CMD [“Darwin”]
La imagen se está entonces construida con el comando:
$ docker build -t darwin .
Si ejecutamos el contenedor sin parámetros de CLI, hará eco del mensaje Hola, Darwin.
Añadir al comando un parámetro, como Username, sobrescribirá la instrucción CMD y solo ejecutará la instrucción ENTRYPOINT usando los parámetros CLI como argumentos. Por ejemplo, el comando:
$ docker run Darwin User_JDArwin
devolverá la salida:
Hello User_JDArwin
Esto se está a que las instrucciones ENTRYPOINT no pueden ser ignoradas, mientras que con CMD, los argumentos de la línea de comandos anulan la instrucción.
Uso de ENTRYPOINT o CMD
Tanto ENTRYPOINT como CMD son esenciales para construir y ejecutar Dockerfiles; simplemente depende de tu caso de utiliza. Como regla general:
- Utiliza instrucciones ENTRYPOINT al construir una imagen ejecutable en Docker usando comandos que siempre deben ejecutarse.
- Utiliza instrucciones CMD cuando te necesites un conjunto adicional de argumentos que actúen como instrucciones predeterminadas hasta que están usadas explícitamente en línea de comandos cuando se ejecuta un contenedor Docker.
Una imagen de contenedor requiere diferentes elementos, incluyendo instrucciones en tiempo de ejecución, herramientas del sistema y librerías para ejecutar una aplicación. Para Obtén el máximo partido a una configuración Docker, se está encarecidamente recomendable que tus administradores comprendan las distintas funciones, estructuras y aplicaciones de estas instrucciones, ya que son funciones críticas que te ayudan a crear imágenes y ejecutar contenedores de forma eficiente.
Lecturas relacionadas
Guía Docker
Estas publicaciones son mías y no representan necesariamente la posición, estrategias u opinión de BMC.