Uso de las instrucciones ENTRYPOINT y CMD de Dockerfile

Si alguna vez ha necesitado ejecutar uno o dos comandos en su contenedor Docker al inicio, este tutorial es para usted. Usando el Dockerfile ENTRYPOINT y CMD instrucciones, puede ejecutar tantos comandos de inicio como desee.

En este tutorial, aprenderá a usar el ENTRYPOINT y CMD instrucciones para ejecutar comandos de inicio en un Dockerfile y comprender las diferencias entre ellos.

Requisitos

Dado que este tutorial será una demostración práctica, asegúrese de contar con lo siguiente:

• En este tutorial se usó una PC con Windows 10:Windows 10 v10.0.19042.
• Docker Desktop:este tutorial utiliza Docker Desktop v3.3.1.

Creación de un Dockerfile

Antes de poder ejecutar los comandos de inicio del contenedor Docker, primero debe crear un Dockerfile. Un Dockerfile es un documento de texto que contiene una lista de comandos para crear contenedores, imágenes de Docker y determina cómo se crea una imagen de Docker.

1. Primero, abra PowerShell como administrador.

2. Cree una nueva carpeta para almacenar el Dockerfile y todos los archivos asociados que usará este tutorial y cambie a ese directorio. Este tutorial usa ~/docker .

mkdir ~/docker
cd docker

3. Ahora, cree un archivo de texto en blanco llamado Dockerfile con el siguiente comando.

cd > Dockerfile

Como alternativa, puede crear un Dockerfile con el siguiente comando si está en Linux o Mac OS.

touch Dockerfile

4. Finalmente, agregue el siguiente contenido en el Dockerfile

FROM ubuntu:20.04

¡Ahora ha creado un Dockerfile que pronto será!

Creación de una imagen de Docker

Ahora que ha creado su Dockerfile, debe crear una imagen de Docker para ejecutar los comandos escritos en las instrucciones ENTRYPOINT y CMD de su Dockerfile. Una forma de construir una imagen es usando build comando.

Mientras está en ~/docker directorio, ejecute el siguiente comando. El siguiente comando crea una imagen Docker llamada demo (-t demo ) del Dockerfile en ~/docker especificando el directorio de trabajo actual (. ).

docker build -t demo .

Ejecución de un contenedor Docker

Una vez que haya creado la imagen de Docker, necesitará un contenedor para ejecutar la imagen de Docker que ejecutará los comandos de las instrucciones ENTRYPOINT y CMD de Dockerfile.

Para ejecutar un contenedor Docker, invoque run comando para crear una capa de contenedor grabable sobre la imagen de Docker (demo ). El siguiente ejemplo está usando -it parámetro para conectarse de forma interactiva al contenedor para que pueda ver la salida de muestra.

docker run -it demo

Exec vs. Formulario Shell

Cuando comience a trabajar con un Dockerfile y descubra cómo ejecutar los comandos de inicio, puede encontrar dos métodos diferentes para definir estos comandos. Cada método invocará comandos pero lo hará de forma un poco diferente.

Cuando Docker ejecuta comandos, puede hacerlo directamente llamado exec o vaya a través del caparazón del contenedor (/bin/sh -c en Linux o cmd /S /C en Windows) llamado shell .

Notarás comandos ejecutados a través de exec tener una instrucción seguida de los ejecutables para invocar seguidos de uno o más argumentos de la línea de comandos, como se muestra a continuación.

ENTRYPOINT ["executables", "parameter1", "parameter2", ...]
CMD ["executables", "parameter1", "parameter2:, ...]

Escribir comandos en shell El formulario, por otro lado, no requiere envolver comandos entre corchetes, como se muestra a continuación.

ENTRYPOINT <command> "parameter1"
CMD <command> "parameter1"

Si no especifica un argumento para CMD , Docker siempre ejecutará el comando en forma exec, p. CMD <command> .

Si recién está comenzando, diferenciar entre estas dos invocaciones de comandos no importará demasiado, pero a medida que avance, pronto verá las ventajas y desventajas de cada una.

Ejecución de comandos de inicio

Ahora entremos en el meollo de este tutorial y ensuciémonos las manos recorriendo algunos ejemplos de ejecución de comandos de inicio dentro de un Dockerfile ENTRYPOINT e instrucciones CMD.

1. Abra el Dockerfile que creó anteriormente en su editor de texto preferido.

2. Copie y pegue el contenido del Dockerfile de ejemplo en su Dockerfile, como se muestra a continuación, y guárdelo.

Este Dockerfile crea una capa utilizando ubuntu:20.04 como imagen base. Luego le dice a Docker que invoque el echo comando pasándole el Hello world argumento para el Dockerfile CMD y ENTRYPOINT instrucciones usando exec y shell forma.

FROM ubuntu:20.04
# CMD Instruction
CMD ["echo", "Hello world"] # Exec Form
CMD echo "Hello world"      # Shell Form
# ENTRYPOINT Instruction
ENTRYPOINT ["echo", "Hello world"] # Exec Form
ENTRYPOINT echo "Hello world"      # Shell Form

3. Mientras está en ~/docker directorio, cree la nueva imagen ejecutando docker build y llámalo demo . El comando debajo de etiquetas la imagen como demo y busca un Dockerfile en el directorio de trabajo actual (. ).

docker build -t demo .

4. Ahora, ejecute un contenedor usando la imagen y luego ejecute un contenedor Docker basado en la imagen Docker creada anteriormente. Ahora verá que el contenedor devuelve Hello world que vino del CMD instrucciones proporcionadas en el Dockerfile.

docker run -it demo

Uso de variables en un Dockerfile

A veces, es posible que no sepa los argumentos exactos de la línea de comandos para pasar al comando con anticipación. Los argumentos que necesita pasar a un comando se exponen solo en tiempo de ejecución. En lugar de asignar argumentos de comando de forma estática, puede capturar y pasar esos argumentos a comandos con variables.

Solo puede usar variables Dockerfile en shell forma. Docker no admite variables en el comando invocado a través de exec formulario.

Abra el Dockerfile en su editor de texto preferido nuevamente, reemplace todo lo que contiene con la siguiente serie de comandos y guárdelo.

Notarás que esta vez, el Dockerfile usa variables de entorno y se muestra usando ENV . En el siguiente ejemplo, Dockerfile define una variable de entorno llamada name con un valor de friend . Una vez creada, se hace referencia a esta variable de entorno a través de $name .

Cuando Docker ejecuta un contenedor basado en este Dockerfile, invocará el echo comando y pasar el argumento de Welcome, friend .

FROM ubuntu:20.04
ENV name friend

CMD echo "Welcome, $name"
# or
## ENTRYPOINT echo "Welcome, $name"

Ahora, cree la imagen de Docker y ejecute el contenedor nuevamente proporcionando opcionalmente un nombre de etiqueta de shellform . Notarás que Docker invocó el echo comando y devolvió el resultado esperado.

Combinar las instrucciones de ENTRYPOINT y CMD de Dockerfile

La mayor parte del tiempo, invocará comandos de inicio en la instrucción CMD o ENTRYPOINT. Después de todo, puede invocar tantos comandos como desee con cada método. Pero también puede invocar un solo comando y "construir sobre él" usando ambas instrucciones.

Sobre la base de los ejemplos anteriores, quizás tenga un Dockerfile que se parece al siguiente ejemplo. Tal como está, si crea una imagen y ejecuta un contenedor a partir de esa imagen, Docker invocaría el echo comando y devuelve Hello .

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]

Tal vez tenga otro argumento que le gustaría pasar al echo comando, pero no de inmediato. Tal vez le gustaría hacer eso más abajo en el Dockerfile. Llamando al CMD instrucción sin un comando, puede hacerlo.

Cuando especifica un comando para ejecutar a través del ENTRYPOINT instrucción seguida del CMD instrucción, Docker asume automáticamente el valor pasado a CMD es un argumento; no es un comando.

Ahora, agregue un CMD referencia de instrucción sin un comando, solo un argumento llamado world , como se muestra a continuación.

FROM ubuntu:20.04
ENTRYPOINT ["echo", "Hello"]
CMD ["world"]

Las instrucciones combinadas siempre deben escribirse en formato ejecutivo debido a su comportamiento "similar a una matriz" de especificar valores individualmente separados por comas frente a todo en una cadena.

Después de construir la imagen y ejecutar el contenedor desde la imagen, puede ver que en lugar de dos líneas de salida (Hello y world ), Docker solo devuelve uno, lo que significa solo un único echo invocación de comando.

Conclusión

Ahora debería tener una buena comprensión de cómo ejecutar los comandos de inicio del contenedor Docker a través de CMD y ENTRYPOINT Instrucciones del archivo Docker. Cada instrucción es un poco diferente pero realiza la misma tarea e incluso se pueden usar juntas.

¿Puedes pensar en un escenario en el que preferirías usar CMD? sobre ENTRYPOINT ejecutar un comando de inicio?