Seleccione su idioma

Durante un tiempo construí mis imágenes UBI encadenando Dockerfiles. Cada herramienta tenía su propia receta y un script se encargaba de pasar el resultado de una construcción a la siguiente. Con make build obtenía una imagen lista para usar en CI, con todas las herramientas instaladas en el orden que había elegido.

El sistema funcionaba. Cuando quise que las propias recetas declarasen qué necesitaban y que varias compartieran una dependencia, probé Dev Container Features. Finalmente mantuve la composición a nivel de imagen con CEKit y publiqué el resultado como CEKit UBI Modules.

Los ejemplos del sistema anterior están simplificados y usan nombres y etiquetas ficticios.

Cómo componía las imágenes antes

El repositorio que ensamblaba la imagen incorporaba las recetas de las herramientas como submódulos Git. Cada pieza tenía su Dockerfile y su Makefile. El Dockerfile aceptaba SOURCE_IMAGE como argumento de construcción y lo usaba en el FROM.

ARG SOURCE_IMAGE
FROM ${SOURCE_IMAGE}

RUN microdnf install -y jq && microdnf clean all

Eso permitía usar el mismo Dockerfile sobre la base habitual o sobre una imagen intermedia que ya traía otras herramientas. El Makefile de cada pieza hacía, en esencia, esto.

buildah build --layers \
  --build-arg "SOURCE_IMAGE=$SOURCE_IMAGE" \
  --tag "$LOCAL_IMAGE" .

La composición estaba en build.sh. El script leía los valores de cada pieza, pasaba al Makefile la imagen anterior mediante SOURCE_IMAGE y asignaba una etiqueta local al resultado. Esa etiqueta se convertía en la entrada del siguiente build. La primera pieza podía venir ya construida. Las siguientes se montaban sobre ella, una detrás de otra.

Por ejemplo, podía partir de una UBI con repositorios adicionales, añadir primero las herramientas de construcción de contenedores, después las de inspección de imágenes y, al final, las utilidades de CI. El orden se veía en el script y podía cambiarlo sin tocar los Dockerfiles de cada herramienta.

Dónde aparece el rombo

La cadena funciona bien cuando quien escribe build.sh conoce todas las piezas y controla su orden. El problema cambia cuando cada pieza empieza a declarar sus propias dependencias. Imaginemos una receta que necesita Git y Python y que ambas herramientas requieren el mismo mecanismo de arranque.

  • Imagen de trabajo → Git → Arranque común
  • Imagen de trabajo → Python → Arranque común

Con el sistema anterior, podía resolver ese caso a mano. Ponía primero el arranque común, después Git y después Python, pasando el resultado de cada build al siguiente FROM. El rombo quedaba convertido en una secuencia válida. Si cambiaba una dependencia, me correspondía ajustar la lista de la imagen que la consumía.

El FROM parametrizado ya me daba una forma de componer. Lo que faltaba era que las recetas expresaran sus dependencias y que el constructor dedujera de ellas el orden y qué piezas compartidas había que instalar una sola vez.

Lo que probé con Dev Container Features

Probé a empaquetar las piezas como Features. Separé el certificado de confianza, el arranque y Python. En aquel prototipo, Python declaraba dependencias sobre las otras dos Features. Llegué a construir una imagen intermedia en Podman con la CLI de Dev Containers y a usarla como base de otra construcción con Buildah.

El primer comando parte de un .devcontainer/devcontainer.json preparado y el segundo de un Dockerfile final con ARG BASE_IMAGE y FROM ${BASE_IMAGE}.

devcontainer build --workspace-folder . \
  --docker-path podman --buildkit never \
  --image-name localhost/demo/ubi-features:local

buildah build \
  --build-arg BASE_IMAGE=localhost/demo/ubi-features:local \
  --tag localhost/demo/ubi-final:local .

Las Features tienen resolución transitiva. Con dependsOn, cada rama puede pedir una dependencia y pasarle opciones. La especificación distingue dos solicitudes de la misma Feature si llevan opciones diferentes. installsAfter solo ordena las Features que ya se van a instalar. En un rombo donde la pieza común debe tener una sola configuración, sigue haciendo falta decidir qué opciones reciben las dos ramas y dónde se fijan. Especificación de Dev Container Features.

El prototipo además tenía un ciclo propio de construcción, pruebas, empaquetado y publicación para las Features. Mi objetivo diario seguía siendo construir imágenes UBI para distintos usos, así que busqué una forma de declarar directamente qué debía contener cada imagen y revisar el Containerfile resultante.

La composición final con CEKit

Con CEKit, cada pieza tiene un module.yaml y los scripts o ficheros que necesita. La imagen declara su base y los módulos que quiere instalar. Buildah sigue construyendo la imagen a partir del contexto que genera CEKit.

El rombo de Git y Python se puede probar con los módulos del proyecto público. Ambos dependen de entrypoint porque ambos pueden aportar hooks que se ejecutan al arrancar el contenedor. Aunque se llega a entrypoint por dos caminos, CEKit lo incorpora una sola vez.

Este image.yaml se puede guardar en un directorio de prueba vacío. Usa el repositorio público como catálogo de módulos.

schema_version: 1
name: localhost/demo/ubi-tools
version: local
from: docker.io/redhat/ubi10-minimal:latest

modules:
  repositories:
    - git:
        url: https://github.com/guillermomolina/cekit-ubi-modules.git
        ref: main
  install:
    - name: git
    - name: python

run:
  cmd: ["/bin/sh"]

Con Python 3.12 o posterior, Git, Buildah y Podman disponibles, primero se puede generar e inspeccionar el Containerfile. Después se puede construir y comprobar que las dos herramientas arrancan.

python3 -m venv .venv
. .venv/bin/activate
python -m pip install 'cekit==4.16.0'

cekit build --dry-run buildah
find target -name Containerfile -print

cekit build buildah --tag localhost/demo/ubi-tools:local --no-squash

podman run --rm localhost/demo/ubi-tools:local \
  /bin/sh -c 'git --version && python3 --version'

El --dry-run permite revisar el orden de los instaladores y comprobar que el de entrypoint aparece una sola vez. El último comando verifica el resultado en ejecución. El repositorio también incluye ejemplos y un make check que valida la sintaxis de los scripts y genera los Containerfile de ejemplo. Para fijar la selección de módulos en CI, el ref: main del ejemplo puede sustituirse por un commit revisado.

Una decisión de la migración fue sacar la CA personalizada de las dependencias de Python. Ahora hay un módulo opcional de CA y la imagen que lo necesita aporta su certificado. Del mismo modo, cada consumidor aporta su configuración de servicios y las credenciales se suministran en ejecución. Así el catálogo público se puede usar con una UBI estándar.

Sigo usando FROM y sigo construyendo imágenes con Buildah. El cambio está en lo que escribo cuando necesito una variante nueva. Antes tenía que ordenar una cadena de construcciones y pasar sus etiquetas de una a otra. Ahora declaro la base y los módulos en image.yaml, y sus dependencias determinan qué se instala y en qué orden.

Código, módulos y ejemplos en GitHub