Creación de imagenes usando un Dockerfile

  • Enviado por: administrador

Creación de imágenes usando un dockerfile

Siguiendo con nuestras entregas en este Blog acerca de contenedores paso a paso, hoy vamos a ver cómo crear imágenes usando un archivo de configuración denominado Dockerfile.

El resultado final es esencialmente el mismo que con una imagen binaria estática, pero con un archivo Docker estamos suministrando las instrucciones para construir la imagen, en lugar de simplemente los archivos binarios en bruto. Esto es útil porque así es mucho más fácil administrar los cambios, especialmente a medida que las imágenes se hacen más grandes y más complejas.

Por ejemplo, si se lanza una nueva versión de figlet (https://ubunlog.com/figlet-banners-ascii-terminal/ ), tendríamos que volver a crear nuestra imagen desde cero o ejecutar nuestra imagen y actualizar la versión instalada de figlet. En cambio, si usamos un Dockerfile dicho archivo incluiría los comandos apt-get que usamos para instalar figlet, de modo que cualquier persona que use nuestro archivo Dockerfile, simplemente recomponga la imagen usando las instrucciones que contiene ese archivo.

Los archivos del tipo Dockerfile son muy poderosos porque nos permiten administrar cómo se construye una imagen, en lugar de sólo administrar archivos binarios. En la práctica, un Dockerfile se puede comportar de la misma manera que se podría comportar el código fuente: es un archivo de texto, por lo que casi cualquier sistema de control de versiones se puede usar para administrar un conjunto de archivos Docker a lo largo del tiempo.

Ahora voy a usar un ejemplo de una aplicación “Hola Mundo” basada en Node.js

Aclaro que no soy programador de Node.js, pero para efectos de nuestro ejercicio no es necesario saber de programación en Node.js.

El siguiente es el contenido de un archivo denominado index.js que se debe crear con cualquier editor de texto de su preferencia, lo puede crear en cualquier ruta de disco de su máquina, recuerde que debe tener extensión .js

var os = require(«os»);

var hostname = os.hostname();

console.log(«Hola mundo desde » + hostname);

Este archivo genera el famoso “Hola mundo” y se le agrega el hostname, es decir desde donde se generó el mensaje.

Vamos a ejecutar esta aplicación usando Docker y para ello creamos un Dockerfile. Usaremos alpine Linux como la imagen del sistema operativo base, y agregaremos un runtime de Node.js y luego copiaremos nuestro código fuente en el contenedor. También especificaremos el comando predeterminado que se ejecutará al crear el contenedor.

Ahora es necesario crear un archivo que se denomine Dockerfile en la misma ruta en donde creamos nuestro anterior archivo index.js, para efectos prácticos haré mi ejercicio en la ruta C:\tmp\Docker de mi máquina Windows

Contenido del archivo Dockerfile:

FROM alpine

RUN apk update && apk add nodejs

COPY . /app

WORKDIR /app

CMD [«node»,»index.js»]

Así quedaron mis archivos dentro de mi carpeta C:\tmp\Docker

No nos queda sino construir nuestra imagen con el siguiente comando:

docker image build -t hola:v0.1 .

Observen los pasos que deben suceder, que son 5 en total, en la siguiente imagen se muestran los dos primeros pasos:

Como pueden ver, hay que descargar la imagen de alpine Linux y agregarle Node.js

Y en los pasos del 3 al 5 se configura la ruta /app, como se especificó en el Dockerfile y se especifica que se va a ejecutar index.js dentro del Node.js que está en el contenedor.

Como estoy ejecutando Docker para Windows también hay una advertencia de seguridad en cuanto a los permisos de archivo, la cual por ahora podemos omitir.

¡Y listo! Ya tengo mi contenedor.

Miren lo que pasó en realidad

(Imagen tomada de https://training.play-with-docker.com/ops-s1-images/ )

Ahora ya podemos verificar el funcionamiento de nuestro contenedor con el siguiente comando:

docker container run hola:v0.1

Y en efecto, se ejecutó lo esperado.

¿Qué hicimos? Creamos dos archivos: nuestro código de la aplicación (index.js) que es un simple código de JavaScript que muestra en pantalla un mensaje. Y además creamos un Dockerfile con las instrucciones para que el motor Docker creara nuestro contenedor personalizado. Este Dockerfile hace lo siguiente:

  1. Especifica una imagen base para jalar (FROM) – la imagen de Linux alpine
  2. Luego ejecuta dos comandos (apk update y apk add) dentro de ese contenedor, que instalan el servidor js.
  3. Luego se le especifica que se haga una copia (COPY) de archivos de nuestro directorio de trabajo en el contenedor. El único archivo que tenemos ahora es nuestro index.js.
  4. A continuación, especificamos el WORKDIR (Directorio de trabajo)- es decir el directorio que el contenedor debería usar cuando se inicia
  5. Y finalmente, se le indica al contenedor un comando (CMD) para que se ejecute cuando el contenedor comience.

Con un Dockerfile podemos especificar los comandos que se deben ejecutar cuando cualquier usuario use o ejecute el contenedor. Una vez se ha puesto el contenedor en un repositorio, otros usuarios no tienen que construir el contenedor ellos mismos sino simplemente usar el que ya creamos. Tampoco deben saber qué comandos usamos en dicho contenedor. Este archivo Dockerfile nos permite especificar cómo construir un contenedor para que podamos repetir esos pasos de forma precisa cada vez y podemos especificar qué debe hacer el contenedor cuando se ejecuta.

Entre otras ventajas tenemos el hecho de disminuir los errores que se podrían cometer en la construcción de nuestras aplicaciones debido a que tenemos un archivo que nos permite repetir el proceso con certeza, además de que podemos ser más ágiles en el despliegue de aplicaciones y servicios.

Este tema es muy interesante para mí y espero que para ustedes también lo sea.

¡No se pierdan la próxima entrega! Un abrazo para todos.

Autor: administrador