Docker ENTRYPOINT Explicado: Uso, sintaxis y buenas prácticas

Docker ENTRYPOINT es una instrucción de Dockerfile que define y controla el comando por defecto que se ejecuta cada vez que se inicia tu contenedor. Dominar ENTRYPOINT simplifica el desarrollo de contenedores predecibles, reproducibles y mantenibles que se comportan como se espera de ellos. 

Esta guía pretende ayudar a los ingenieros de DevOps intermedios, programadores de backend e ingenieros de software a utilizar con confianza ENTRYPOINT y evitar los errores más comunes.

Si eres nuevo en Docker, consulta nuestro tutorial de introducción a Docker, ya que este tutorial asume cierto nivel de comprensión de Docker. Para ponerte manos a la obra con Docker, consulta nuestro curso Introducción a Docker. 

¿Qué es Docker ENTRYPOINT?

ENTRYPOINT define el comando que se ejecuta por defecto cada vez que se inicia tu contenedor Docker. A diferencia del uso de CMD, la instrucción ENTRYPOINT garantiza la coherencia proporcionando comandos que se ejecutan cada vez que se inicia el contenedor.

¿Cómo funciona Docker ENTRYPOINT?

ENTRYPOINT en un Dockerfile define el comando principal que siempre se ejecuta cuando inicias un contenedor desde una imagen. Es como decir:  "Independientemente de los argumentos que pase el usuario al ejecutar este contenedor, empieza siempre con este comando".

Profundizamos en los archivos Docker en nuestro tutorial Cómo contenerizar una aplicación utilizando Docker. 

Por ejemplo, en un archivo Dockerfile:

ENTRYPOINT ["python", "app.py"]

Ahora, cuando corras:

docker run myimage

Siempre se ejecutará:

python app.py

Aquí tienes un diagrama de flujo de cómo funciona ENTRYPOINT:

+---------------------------+

|       Dockerfile          |

+---------------------------+

|                           |

|  ENTRYPOINT ["app"]       |

|  CMD ["--default-arg"]    |

+---------------------------+

             |

             v

+---------------------------+

|   Build Docker Image      |

+---------------------------+

             |

             v

+---------------------------+

|    Run Container          |

|   (docker run image)      |

+---------------------------+

             |

             v

+---------------------------+

| Executed Command:         |

|   app --default-arg       |

+---------------------------+

Override CMD at Runtime:

(docker run image --custom-arg)

             |

             v

+---------------------------+

| Executed Command:         |

|   app --custom-arg        |

+---------------------------+

Override ENTRYPOINT at Runtime:

(docker run --entrypoint /bin/bash image)

             |

             v

+---------------------------+

| Executed Command:         |

|   /bin/bash               |

+---------------------------+

Fundamentos de Docker ENTRYPOINT

Comprender los fundamentos aumentará significativamente tu confianza para utilizar ENTRYPOINT con eficacia.

Marco conceptual

ENTRYPOINT especifica el ejecutable o script que se ejecuta automáticamente cuando se inicia tu contenedor. Es el proceso principal de tu contenedor, que dirige su comportamiento de forma predecible.

Sintaxis básica

La sintaxis de Dockerfile para ENTRYPOINT es sencilla y suele utilizarse junto a CMD para proporcionar argumentos o parámetros por defecto. ENTRYPOINT define el ejecutable, mientras que CMD especifica argumentos por defecto que utiliza ENTRYPOINT.

Comprender conceptos de Docker como ENTRYPOINT es vital para superar con éxito las entrevistas de ciencia de datos. Explora las preguntas más comunes de las entrevistas en nuestras 26 mejores preguntas y respuestas de entrevistas sobre Docker para 2025. 

Formularios de sintaxis ENTRYPOINT

Docker ENTRYPOINT se presenta en dos formas distintas: forma de terminal y forma de ejecución. Conocer las diferencias entre estas formas puede ayudarte a elegir sabiamente.

Terminal

Ejemplo de sintaxis: 

ENTRYPOINT /usr/bin/ping -c 3 localhost

La forma de terminal garantiza una fácil integración de las funciones de la shell (sustitución de variables, manipulación del entorno).

Sin embargo, puede dar lugar a una mala gestión de las señales; se ejecuta dentro del proceso intermedio /bin/sh en lugar de directamente como PID 1, lo que provoca problemas al detener y reiniciar los contenedores.

El PID 1 es el primer proceso que se inicia durante el arranque del sistema. En Docker, el proceso PID 1 gestiona todos los demás procesos dentro del contenedor. 

Formulario de ejecución

Ejemplo de sintaxis: 

ENTRYPOINT ["/usr/bin/ping", "-c", "3"]

La forma Exec garantiza la ejecución directa de órdenes como PID 1, lo que conduce a un manejo y control fiables de las señales.

Sin embargo, no es compatible directamente con el terminal ni expande automáticamente las variables de entorno; requiere una secuencia de comandos adicional para obtener un comportamiento similar al del terminal.

PUNTO DE ENTRADA vs CMD: Diferencias clave y casos de uso

Distinguir ENTRYPOINT de CMD evita confusiones y permite un comportamiento predecible del contenedor.

Precedencia de ejecución

ENTRYPOINT establece el ejecutable que siempre se ejecuta, mientras que CMD proporciona argumentos por defecto. Si se definen tanto ENTRYPOINT como CMD, ENTRYPOINT tiene prioridad y se ejecuta utilizando los valores de CMDcomo argumentos, a menos que se anulen explícitamente en tiempo de ejecución.

Casos prácticos

ENTRYPOINT debe utilizarse cuando quieras una ejecución coherente y forzada en cada lanzamiento, como en el caso de contenedores de un solo comando o scripts envolventes de aplicaciones heredadas. Por el contrario, CMD es adecuado para especificar argumentos por defecto, lo que permite más flexibilidad con las anulaciones en tiempo de ejecución.

Nuestros 18 mejores comandos Docker para crear, ejecutar y gestionar contenedores cubren los comandos Docker esenciales, desde los fundamentos de los contenedores hasta los volúmenes y las redes, para que puedas gestionar con confianza las aplicaciones en distintos entornos.

Ejemplo práctico

Una combinación típica de ENTRYPOINT y CMD se ilustra en este Dockerfile:

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

Este contenedor Docker siempre emite tres pings por defecto contra localhost. Los usuarios pueden anular este objetivo predeterminado en tiempo de ejecución con otros hosts fácilmente, conservando el comportamiento de ejecución predecible de ENTRYPOINT:

docker run ping-container google.com

Puedes obtener más información sobre el despliegue de aplicaciones con Docker en nuestro curso Containerización y virtualización con Docker y Kubernetes. 

Combinar ENTRYPOINT con CMD

Combinar adecuadamente ENTRYPOINT con CMD ofrece flexibilidad sin sacrificar la coherencia.

CMD como argumentos por defecto

Configurar ENTRYPOINT define el comando principal de forma fiable; CMD proporciona parámetros por defecto para anularlos fácilmente sin reconstruir las imágenes.

Anulación de argumentos en tiempo de ejecución

Los argumentos especificados durante docker run sólo sobrescriben los predeterminados definidos por CMD. ENTRYPOINT mantiene la coherencia, simplificando así la experiencia de los usuarios.

Anulación de ENTRYPOINT en tiempo de ejecución

Docker permite anular ENTRYPOINT directamente en tiempo de ejecución, lo que permite depurar sin reconstruir tu imagen Dockerfile.

Uso de la bandera del punto de entrada

Docker proporciona una sencilla bandera --entrypoint que cambia el comportamiento del contenedor temporalmente.

docker run -it --entrypoint /bin/bash my-container

Las anulaciones temporales permiten solucionar problemas utilizando el terminal, resolviendo problemas comunes de inicio sin reconstrucciones de imagen ni retrasos sustanciales.

Personalizar el comportamiento de ENTRYPOINT

Docker ofrece flexibilidad cuando ENTRYPOINT requiere una personalización más avanzada.

Anulación de ENTRYPOINT en tiempo de ejecución

Puedes anular el comando ENTRYPOINT dinámicamente en tiempo de ejecución utilizando docker run --entrypoint para depurar o cambiar de contexto rápidamente sin modificar tu Dockerfile repetidamente.

PUNTO DE ENTRADA con argumentos

Los argumentos pasados a los contenedores se convierten en parámetros de ENTRYPOINT en tiempo de ejecución; las mejores prácticas sugieren tener una complejidad mínima de ENTRYPOINT junto a CMD para obtener la máxima claridad y control.

Guiones de envoltura

Los scripts Bash introducidos como comandos de ENTRYPOINT pueden ejecutar lógica de inicio condicional, esperar servicios dependientes (como bases de datos), gestionar tareas de configuración y mucho más, manteniendo una sintaxis limpia de Dockerfile.

Ejemplos y patrones del mundo real

Las aplicaciones prácticas de ENTRYPOINT pueden ilustrar usos típicos y realistas. Veamos algunas de ellas.

Contenedores monocomando 

Para configurar una aplicación Flask:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["python", "app.py"]
CMD ["--port", "8080"]

En el archivo Dockerfile anterior:

• ENTRYPOINT ["python", "app.py"]  establece el ejecutable por defecto. Esto es lo que se ejecuta cuando se inicia el contenedor.
• CMD ["--port", "8080"]  proporciona argumentos por defecto (--port 8080) al comando ENTRYPOINT.

El comando completo ejecutado por defecto será

python app.py --port 8080

 Si anulas CMD al ejecutar el contenedor (por ejemplo, docker run myimage --port 9090), sustituirá a --port 8080.

Guión como PUNTO DE ENTRADA 

Sirve para configurar la lógica condicional de apoyo: 

entrypoint.sh:

#!/bin/sh
until nc -z db_host 5432; do
  echo "Waiting for database to become available."
  sleep 2
done
exec python app.py "$@"

Dockerfile:

FROM python:3.11-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
COPY entrypoint.sh .
RUN chmod +x entrypoint.sh
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--port", "8080"]

En los archivos anteriores:

• entrypoint.sh se utiliza para esperar la conexión a la base de datos.
• exec python app.py "$@"  sustituye el proceso actual de la terminal por python app.py, pasando cualquier argumento adicional. "$@" procede de los parámetros CMD o docker run.
• COPY entrypoint.sh  copia el script entrypoint.sh en el directorio /app del contenedor.
• ENTRYPOINT ["./entrypoint.sh"] establece entrypoint.sh como script de inicio por defecto cuando se ejecuta el contenedor.
• CMD ["--port", "8080"] proporciona argumentos por defecto que se pasarán al script entrypoint.sh y finalmente a python app.py. El comando final ejecutado tendrá el siguiente aspecto python app.py --port 8080. 

Manejo de señales y PID 1

ENTRYPOINTafecta significativamente a la capacidad de Docker para gestionar señales debido a la importancia del PID 1. Exploremos esto con más detalle: 

Formulario de ejecución y PID 1

El formulario Ejecutar ejecuta comandos como proceso PID 1 de Docker directamente, lo que mejora la fiabilidad del reenvío de señales y el comportamiento adecuado de parada o reinicio.

Limitaciones del formulario del terminal

La forma shell añade un proceso shell intermedio. Esto impide que las señales de terminación lleguen a los procesos de aplicación, creando el riesgo de que los contenedores se atasquen o no respondan.

Depurar el comportamiento de ENTRYPOINT

Resolver los problemas de configuración de entrypoint es más fácil utilizando ciertas técnicas y trucos. Descubrámoslos a continuación. 

Utilizar --entrypoint para depurar

Las anulaciones temporales habilitan rápidamente terminales de depuración interactivas dentro de tus contenedores sin necesidad de reconstruir la imagen. Esto te permite probar diferentes cosas en tu aplicación sin reconstruir la imagen. 

Visualización de los registros de ENTRYPOINT

Comprobar los registros de salida con docker logs simplifica el seguimiento del historial de ejecución y la localización de problemas de configuración de forma clara y rápida.

Evita modificar Dockerfile para pruebas temporales

Las anulaciones de ENTRYPOINT en tiempo de ejecución, fáciles de depurar, te permiten aislar y corregir problemas sin tener que modificar y reconstruir repetidamente las imágenes de los contenedores.

Técnicas de optimización y buenas prácticas

A continuación encontrarás varias optimizaciones recomendadas para mejorar la fiabilidad y mantenibilidad de ENTRYPOINT.

Utiliza el formulario exec para la gestión de señales

Prefiere siempre la forma exec para obtener señales de terminación adecuadas y una mejor fiabilidad y gestión general del contenedor.

Combinar ENTRYPOINT y CMD eficazmente

Separa tu ejecutable (ENTRYPOINT) de los argumentos predeterminados en tiempo de ejecución (CMD) y utiliza las anulaciones en tiempo de ejecución para obtener la máxima flexibilidad y facilidad de gestión.

Minimizar la complejidad en ENTRYPOINT

Mantén ENTRYPOINT simple, delegando la lógica de inicio compleja o las condiciones en scripts separados para garantizar una gestión adecuada de la complejidad y mejorar la claridad.

Casos de uso y modelos avanzados

Exploremos algunos casos de uso y patrones avanzados de ENTRYPOINT.

Construcciones multietapa con ENTRYPOINT

ENTRYPOINT en las etapas finales de Docker refuerza la ejecución fiable, proporcionando compilaciones más limpias adaptadas específicamente a las tareas de producción dentro de los flujos de trabajo CI/CD.

Guiones dinámicos ENTRYPOINT

ENTRYPOINT Los scripts pueden ajustar dinámicamente su lógica de inicio en función de las variables de entorno o los argumentos de ejecución proporcionados, adaptándose sin problemas a diferentes contextos de aplicación.

ENTRYPOINT para pipelines CI/CD

Aprovechar ENTRYPOINT mejora la coherencia entre los entornos de prueba y producción, garantizando comportamientos predecibles en tiempo de ejecución y repetibilidad. Por ejemplo, puedes configurar ENTRYPOINT para un script que ejecute pruebas automáticamente. 

Otras aplicaciones son: 

• Un ENTRYPOINT que espera la base de datos, luego ejecuta las migraciones y, por último, inicia el app.
• Un ENTRYPOINT que compila activos, enlaza código o valida configuraciones automáticamente.
• ENTRYPOINT pueden detectar entornos (desarrollo, ensayo, producción) y ajustar la configuración en consecuencia al iniciar el contenedor. 

Aquí tienes un ejemplo de imagen Docker que ejecuta pruebas automáticamente:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
ENTRYPOINT ["pytest"]

El .gitlab-ci.yml tendría este aspecto:

build-test:
  image: docker:latest
  services:
    - docker:dind
  script:
    - docker build -t myapp-test .
    - docker run myapp-test  # <-- No need to specify 'pytest', ENTRYPOINT does it

Cuando se ejecuta docker run, se activa automáticamente pytest dentro del contenedor. Esto garantizará que todas las pruebas se encuentren y se ejecuten inmediatamente. 

Utilizar ENTRYPOINT en CI/CD tiene varias ventajas:

• Todos los contenedores se inician y se comportan de la misma manera. 
• Simplifica los scripts CI/CD porque no tienes que pasar comandos completos cada vez. 
• Automatiza las comprobaciones previas al arranque, las ejecuciones de prueba y las migraciones, reduciendo los errores humanos. 

Errores comunes y solución de problemas

ENTRYPOINT tiene algunos escollos que merece la pena evitar en tus flujos de trabajo.

Uso incorrecto del formulario del terminal

La forma de terminal entorpece las señales y la gestión de los contenedores; prefiere siempre la forma exec para una correcta gestión de las señales, salidas de contenedores y paradas limpias.

Complicar en exceso el PUNTO DE ENTRADA

Los scripts complejos que carecen de claridad o fiabilidad se deterioran aún más durante la depuración o el mantenimiento continuo. Las sencillas configuraciones de ENTRYPOINT simplifican considerablemente la resolución de problemas.

Conclusión

Comprender e implementar eficazmente Docker ENTRYPOINT permite construir contenedores Docker predecibles, fiables y mantenibles para tus aplicaciones. Si se utiliza correctamente, ENTRYPOINT crea coherencia sin sacrificar la flexibilidad gracias al potente sistema de anulación de Docker. Experimentar cuidadosamente con los patrones de ENTRYPOINT, siguiendo las mejores prácticas descritas anteriormente, simplifica significativamente el uso de Docker y conduce a ciclos de despliegue y gestión más fluidos en producción.

Consulta nuestros cursos de Docker para explorar más temas de Docker, como:

• Introducción a Docker
• Conceptos de contenedorización y virtualización 
• Containerización y virtualización con Docker y Kubernetes
• Docker intermedio