Cómo usar Dockerfile ONBUILD para ejecutar disparadores en compilaciones posteriores

ONBUILD de Docker instrucción le permite configurar disparadores dentro de una imagen. Tus disparadores se ejecutarán más tarde, cuando la imagen se use como base para otra. Se convertirán en parte del nuevo contexto de imagen descendente y no serán capas del sistema de archivos en su docker build inicial. .

Adición de activadores ONBUILD

ONBUILD es una instrucción que escribe en sus Dockerfiles. Es único ya que acepta otro instrucción como su argumento. Puede especificar cualquier operación de Dockerfile, como COPY o RUN y hacer que se ejecute durante la compilación de una imagen descendente.

ONBUILD RUN example-command

Este ejemplo ejecuta example-command en la imagen secundaria en el momento en que se construye. Aquí hay otro caso en el que un archivo se copia desde el contexto de compilación de la imagen descendente al sistema de archivos:

ONBUILD COPY assets.json /app/assets.json

ONBUILD las instrucciones no tienen ningún efecto en la imagen producida por el Dockerfile en el que están definidas. Construir el Dockerfile anterior no ejecutar example-command o incluya assets.json en la imagen:

# Does not include the extra instructions
docker build -t base-image:latest .

Los activadores se utilizarán cuando escriba otro Dockerfile que utilice el primero como base:

FROM base-image:latest
RUN my-binary

docker build -t downstream-image:latest .

La creación de este Dockerfile ejecutará example-command , copia en assets.json y finalmente ejecuta my-binary . El ONBUILD los disparadores siempre se ejecutan primero, inmediatamente después del FROM instrucción en el Dockerfile descendente.

¿Cómo reconoce Docker los disparadores?

ONBUILD no afecta el sistema de archivos del contenedor base, pero Docker aún sabe que los disparadores están presentes cuando crea una imagen descendente. El proceso de construcción rastrea ONBUILD instrucciones que encuentra y las registra en los metadatos de la imagen.

Docker inspecciona los metadatos de las imágenes a las que se hace referencia en un FROM instrucción. Si la imagen nombrada incluye disparadores en sus metadatos, esas instrucciones de disparador se pegan efectivamente en la parte superior del Dockerfile descendente antes de que comience la compilación.

Los disparadores en realidad se ejecutan como parte del FROM de la compilación. escenario. Se ejecutarán en el orden en que se escribieron en el Dockerfile ascendente. Si un ONBUILD la instrucción falla, Docker cancelará la compilación y se verá como FROM el escenario fue la causa.

Limitaciones

Puede usar cualquier instrucción de Dockerfile como argumento para un ONBUILD disparador con tres excepciones:

• ONBUILD FROM – Esto no está permitido ya que anularía la imagen base utilizada para la compilación. Cada Dockerfile debe heredar de una única base.
• ONBUILD MAINTAINER – El MAINTAINER la instrucción está en desuso y no debe utilizarse; la información de autoría se proporciona mejor como una etiqueta. La LABEL la instrucción es compatible con ONBUILD .
• ONBUILD ONBUILD – Encadenamiento de ONBUILD Las instrucciones no son compatibles. Todos los disparadores se ejecutan en la imagen inmediatamente después de su Dockerfile. No puede definir activadores destinados a ejecutarse en imágenes "nietas" dos o más niveles por debajo del Dockerfile de definición.

Todas las instrucciones se definen de la misma manera que sus usos habituales. Escribiendo un paso ordinario en su Dockerfile, luego prefijándolo con ONBUILD , lo sacará del flujo de compilación normal y lo convertirá en un activador de compilación posterior.

¿Cuándo son útiles los activadores ONBUILD?

ONBUILD se usa más comúnmente dentro de las imágenes de utilidades que automatizan tareas como la compilación de código. Este tipo de procedimiento generalmente requiere que se ejecuten varios pasos en una secuencia específica, con dependencias como su código fuente agregado en un punto particular.

Considere una imagen de compilación que busca el código fuente en un directorio y luego ejecuta un comando para construirlo. No puedes simplemente COPY y RUN dentro del Dockerfile de esa imagen, ya que la fuente del usuario final no existiría dentro de su contexto de compilación de la imagen.

Usando ONBUILD le permite proporcionar un Dockerfile repetitivo que sus usuarios pueden ampliar y docker build sin reinventar la funcionalidad común:

ENV BUILD_ENV=production
RUN init-build.sh

ONBUILD COPY /src /build
ONBUILD RUN compile.sh --destination=/bin

Este ejemplo demuestra cómo una imagen de constructor podría proporcionar un entorno de compilación preconfigurado. Cuando se usa como imagen base, el código se compilaría automáticamente desde el contexto de compilación posterior. Esa imagen podría interactuar con la salida compilada en /bin dentro de sus propias etapas de Dockerfile.

Resumen

ONBUILD Las instrucciones en Dockerfiles le brindan una forma de ejecutar activadores como parte de una compilación posterior. Puede usar cualquier otra instrucción de Dockerfile como ONBUILD disparador, excepto por algunas limitaciones.

Usando ONBUILD le permite proporcionar imágenes genéricas de Docker que definen conjuntos de funcionalidades reutilizables. Esto es más eficiente que hacer que los usuarios copien el texto de los Dockerfiles de ejemplo palabra por palabra y luego agreguen sus propias instrucciones en la parte inferior. Todavía puede modificar y actualizar la imagen base sin requerir ninguna acción por parte de sus usuarios.

Adoptando ONBUILD reduce la repetición y facilita las imágenes base extensibles de Docker. ONBUILD vale la pena tener en cuenta las instrucciones al crear un Dockerfile repetitivo que los usuarios finales deberán personalizar antes de que el entorno final del contenedor se considere completo.