Ahora ya controlas tanto la gestión de imágenes como la de contentedores. Has levantado tus primeros contenedores para realizar las mas diversas tareas. Sin embargo, hasta el momento, solo estás aprovechando lo que otros han desarrollado o construido. Pero, esto no es mas que la punta del iceberg, porque todavía es posible llegar mas lejos. Y no solo llegar mas lejos, sino también sacarle todo el potencial a los contenedores. Me refiero a crear tus propias imágenes con Podman.

Pero, ¿para que crear tus propias imágenes con Podman? Son muchas las razones para crear tus propias imágenes con Podman, pero sin lugar a dudas, a mi la que se me viene la primera a la cabeza es desplegar una aplicación en cualquier sitio en cuestión de segundos. Ya sea que tengas un VPS, o una Raspberry, o en el portátil, si quieres tener una aplicación implementada por ti, corriendo en cuestión de segundos, tan solo tienes que tener esa imagen disponible para ti en cualquier repositorio.

Crear imágenes con Podman

Como crear tus imágenes con Podman

Construir tu propia imagen con Podman es tremendamente sencillo, solo tienes que ejecutar la siguiente instrucción,

podman build <opciones> [path | url]

Normalmente, todo lo que necesito lo tengo en el mismo directorio en el que construyo la imagen, incluido el Dockerfile, por supuesto. De esta manera, esta instrucción se convierte, por regla general en,

podman build -t atareao/nombre .

No es necesario que te diga que tendrás que reemplazar atareao/nombre, por el nombre que le quieras asignar a tu imagen. Por otro lado, indicarte que esto, lo que hace es añadir :latest, al final. De forma, que el nombre de la imagen finalmente quedará como atareao/nombre:latest.

Un ejemplo rápido

Para que veas lo sencillo que es crear tu primera imagen con Podman, crearás una sencilla imagen, con la bienvenida al maravilloso mundo de Podman. Para esto ejecuta las siguientes instrucciones en un terminal,

echo 'echo "Bienvenido a Podman!!!"' > hola.sh
cat <<EOF> Dockerfile
FROM alpine
COPY hola.sh /
ENTRYPOINT ["/bin/sh"]
CMD ["/hola.sh"]
EOF
podman build -t atareao/test .

Con estas sencillas líneas, ya has construido tu primera imagen que podrás utilizar para levantar ese primer contenedor. Para esto, para levantar tu primer contenedor, simplemente ejecuta la siguiente instrucción, como ya viste en capítulos anteriores del tutorial,

podman run -name test atareao/test:latest

Si te fijas en las instrucciones que te he indicado mas arriba, has creado un archivo llamado Dockerfile, con el siguiente contenido,

FROM alpine
COPY hola.sh /
ENTRYPOINT ["/bin/sh"]
CMD ["/hola.sh"]

Esto lo puedes entender como una receta de cocina, donde indicas los pasos que se tienen que seguir para crear esa imagen. Pero, siguiendo con los símiles alimentarios, también deberías entenderlo como una cebolla, en la que cada una de las líneas de esa receta son capas de la cebolla.

Esto de las capas de la cebolla es mas importante de lo que puedas imaginar. Esto es así, porque una vez construida tu imagen, en el caso de que tengas que reconstruirla, por la razón que sea, no necesitarás reconstruir las primeras capas que no hayas modificado, sino que solo tendrás que reconstruir a partir de aquella capa que cambiaste.

Dockerfile

Evidentemente la parte mas importante de todo esto es la creación del Dockerfile. El comando de construcción, es mas o menos sencillo, no tiene mucha miga. Por recordarte, las distintas instrucciones que tienes para crear esa receta,

• FROM indica la imagen desde la que parte para construir tu versión personalizada.
• COPY y ADD para copiar archivos. Aunque aparentemente son iguales, ADD permite que el origen sea una url, y en el caso de un archivo comprimido del tipo tar.gz o similar, este se desempaqueta en un directorio. Esto lo tienes que tener en cuenta. De cualquier forma, la recomendación es utilizar COPY, siempre que no sea necesario utilizar las habilidades especiales de ADD.
• RUN te permite ejecutar cualquier instrucción.
• VOLUME crea un volumen que es compartido con otros contenedores y con el host.
• USER define el usuario por defecto del contenedor.
• WORKDIR establece el directorio de trabajo.
• ENTRYPOINT es el comando que se ejecuta cada vez que inicias el contenedor.
• CMD el argumento que pasas por defecto al contenedor.
• ENV te permite definir variables de entorno en el contenedor.
• EXPOSE abre un puerto del contenedor.

Con el ejemplo anterior, es lo mas sencillo que puedes hacer, simplemente tienes que seguir la secuencia,

1. FROM alpine partes de una imagen de alpine
2. COPY hola.sh / copias el script que hiciste previamente en el directorio raíz.
3. ENTRYPOINT ["/bin/sh"] defines la instrucción que se ejecutará al levantar el contenedor.
4. CMD ["/hola.sh"] es el argumento que pasas por defecto al ejecutable.

Imaginación al poder

A partir de aquí, puedes hacer cualquier cosa que se te pase por la cabeza, con la increíble ventaja que este contenedor funcionará en cualquier máquina que tenga la misma arquitectura de la original. Esto es una increíble ventaja. De esta manera, te olvidas de versiones, de dependencias y prácticamente de todas las incomodidades que normalmente rodean la distribución de aplicaciones.

Por ejemplo, hace unos días cree un contenedor para trabajar con ffmpeg, que me permitiera hacer distintas operaciones que no se pueden hacer con la versión de esta herramienta que por defecto está en alpine. Esto, lo puedes hacer de la siguiente forma,

FROM alpine

COPY --from=mwader/static-ffmpeg:4.4.0 /ffmpeg /usr/local/bin/
COPY --from=mwader/static-ffmpeg:4.4.0 /ffprobe /usr/local/bin/
COPY --from=mwader/static-ffmpeg:4.4.0 /qt-faststart /usr/local/bin/

ENTRYPOINT ["/usr/local/bin/ffmpeg"]

Con esto tendrías tu propio contenedor con ffmpeg para hacer todo lo que consideres, sin que te tengas que preocupar de si funcionará o no en tu equipo. Simplemente te tienes que preocupar de que la arquitectura sea la misma.

---

Imagen de portada de Annie Spratt en Unsplash