Creación y Personalización de Imágenes de Docker: Laboratorio Práctico

Introducción

Docker es una herramienta potente para empaquetar y distribuir aplicaciones como contenedores. En el núcleo de este proceso se encuentran las imágenes de Docker, que son paquetes preconstruidos que contienen todo lo necesario para ejecutar una aplicación, incluyendo el código, las dependencias y la configuración. En este laboratorio, aprenderá a crear imágenes de Docker personalizadas que potencian sus aplicaciones al incorporar software, librerías o configuraciones adicionales.

A lo largo de este laboratorio, utilizaremos WebIDE (VS Code) para editar archivos. WebIDE ofrece una interfaz familiar y sencilla para la edición de archivos, facilitando el trabajo con archivos de configuración y código.

Configurar el Entorno del Proyecto

Comencemos creando un directorio para el proyecto y accediendo a él.

Durante este laboratorio, usaremos WebIDE (VS Code) para editar archivos. WebIDE proporciona una interfaz intuitiva para gestionar archivos, lo que facilita la edición de configuraciones.

Abra una terminal en WebIDE. Puede hacerlo haciendo clic en "Terminal" en el menú superior y seleccionando "New Terminal".
En la terminal, ejecute los siguientes comandos:

mkdir -p ~/project/docker
cd ~/project/docker

Terminal mostrando los comandos de creación del directorio del proyecto

Esto crea un nuevo directorio llamado docker dentro de la carpeta ~/project y cambia el directorio de trabajo actual a este.

Verifique que se encuentra en el directorio correcto:

pwd

Debería ver /home/labex/project/docker como resultado.

Explicación de los comandos:

mkdir -p: Este comando crea un directorio. El parámetro -p permite crear directorios padres si no existen.
cd: Este comando cambia el directorio actual.
pwd: Este comando imprime la ruta del directorio de trabajo actual.

Crear una Imagen de Docker Sencilla

Ahora, vamos a crear una imagen de Docker básica que ejecute un servidor web Nginx.

En WebIDE, diríjase al Explorador de Archivos (normalmente el primer icono en la barra lateral izquierda).
Haga clic derecho en el panel del Explorador de Archivos y seleccione "New File". Nómbrelo Dockerfile (con 'D' mayúscula y sin extensión).
Abra el Dockerfile haciendo clic sobre él. Añada el siguiente contenido:

FROM nginx
COPY index.html /usr/share/nginx/html/

Este Dockerfile define una nueva imagen basada en la imagen oficial de Nginx y copia un archivo llamado index.html al directorio raíz de documentos predeterminado de Nginx.

Entendiendo el Dockerfile:

FROM nginx: Esta línea especifica la imagen base desde la que estamos construyendo. En este caso, usamos la imagen oficial de Nginx.
COPY index.html /usr/share/nginx/html/: Esta línea copia nuestro archivo index.html dentro del directorio raíz web del contenedor.

Cree un nuevo archivo llamado index.html en el mismo directorio. Puede hacerlo haciendo clic derecho de nuevo en el Explorador de Archivos y seleccionando "New File".
Abra index.html y añada el siguiente contenido:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Hello Docker!</title>
  </head>
  <body>
    <h1>Hello Docker!</h1>
    <p>This is a custom Docker image.</p>
  </body>
</html>

Esta es una página HTML simple que será servida por nuestro servidor Nginx.

Abra una terminal en WebIDE (Terminal -> New Terminal si cerró la anterior) y construya la imagen de Docker usando el siguiente comando:

docker build -t my-nginx .

Este comando construye una nueva imagen de Docker con la etiqueta my-nginx.

Explicación del comando:

docker build: Es el comando para construir una imagen de Docker.
-t my-nginx: El parámetro -t etiqueta nuestra imagen con el nombre my-nginx.
.: Especifica el contexto de construcción (el directorio que contiene el Dockerfile) como el directorio actual.

Una vez finalizada la construcción, verifique que la imagen se haya creado correctamente:

docker images

Debería ver la imagen my-nginx en la lista de resultados.

Ejecutar y Probar la Imagen Personalizada

Vamos a ejecutar un contenedor basado en nuestra nueva imagen y probarlo.

En la terminal de WebIDE, inicie un contenedor con el siguiente comando:

docker run -d -p 8080:80 --name my-nginx-container my-nginx

Explicación de este comando:

docker run: Crea e inicia un nuevo contenedor.
-d: Ejecuta el contenedor en modo "detached" (en segundo plano).
-p 8080:80: Mapea el puerto 8080 de su máquina anfitriona al puerto 80 del contenedor.
--name my-nginx-container: Asigna un nombre específico a nuestro contenedor.
my-nginx: Es el nombre de la imagen que usamos para crear el contenedor.

Verifique que el contenedor esté en ejecución:

docker ps

Debería ver my-nginx-container en la lista. Este comando muestra todos los contenedores activos.

Para ver el contenido de la página web, use el comando curl:

curl http://localhost:8080

Debería ver el contenido HTML del archivo index.html mostrado en la terminal.

Si tiene curiosidad sobre qué hace curl, es una herramienta para transferir datos desde o hacia un servidor. En este caso, la usamos para obtener el contenido de nuestro servidor web.

También puede dirigirse a la parte superior de la VM de LabEx, hacer clic en el icono "+" para crear un nuevo servidor web e introducir el puerto 8080 para visualizar el contenido en el navegador.

Configuración del puerto del servidor web

Añadir Software Personalizado a la Imagen

Ahora, vamos a modificar nuestra imagen de Docker para incluir software adicional. Añadiremos la utilidad curl como ejemplo.

En WebIDE, abra el archivo Dockerfile.
Modifique el contenido del Dockerfile por el siguiente:

FROM nginx
RUN apt-get update && apt-get install -y curl
COPY index.html /usr/share/nginx/html/

Este Dockerfile añade una nueva instrucción RUN que actualiza el índice de paquetes e instala la utilidad curl utilizando el gestor de paquetes apt-get.

Explicación de la nueva línea:

RUN apt-get update && apt-get install -y curl: Esta línea actualiza la lista de paquetes y luego instala curl. El parámetro -y responde automáticamente "sí" a cualquier pregunta durante la instalación.

Guarde el archivo en WebIDE presionando Ctrl+S (o Cmd+S en Mac).
En la terminal de WebIDE, vuelva a construir la imagen de Docker con una nueva etiqueta:

docker build -t my-nginx-curl .

Este comando crea una nueva imagen llamada my-nginx-curl que ya incluye la herramienta curl.

Verifique que la nueva imagen se haya creado:

docker images

Debería ver my-nginx-curl en la lista.

Probar la Imagen Personalizada con Curl

Ejecutemos un contenedor basado en nuestra nueva imagen y probemos la utilidad curl desde dentro.

En la terminal de WebIDE, inicie un nuevo contenedor:

docker run -d --name curl-container my-nginx-curl

Este comando inicia un contenedor basado en la imagen my-nginx-curl y lo nombra curl-container.

Ejecute un shell bash dentro del contenedor en funcionamiento:

docker exec -it curl-container bash

Este comando abre una terminal interactiva dentro del contenedor.

Explicación de este comando:

docker exec: Ejecuta un comando en un contenedor que ya está corriendo.
-it: Estos parámetros asignan un pseudo-TTY y mantienen la entrada estándar (STDIN) abierta, permitiéndole interactuar con el shell.
curl-container: El nombre de nuestro contenedor.
bash: El comando que queremos ejecutar (abrir el shell bash).

Ahora verá un nuevo símbolo de sistema (prompt), lo que indica que está dentro del contenedor. Pruebe la utilidad curl internamente:

curl http://localhost

Debería ver el contenido HTML del archivo index.html.

Salga del shell del contenedor:

exit

Este comando le devuelve al shell de su sistema anfitrión.

Usar Variables de Entorno en la Imagen

En este paso, modificaremos nuestra imagen de Docker para utilizar variables de entorno para su personalización.

En WebIDE, abra de nuevo el Dockerfile.
Modifique el contenido del Dockerfile por el siguiente:

FROM nginx
ENV NGINX_PORT 9000
RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/

Este Dockerfile añade una instrucción ENV que establece la variable NGINX_PORT a 9000. También incluye una instrucción RUN que modifica la configuración de Nginx para usar este puerto.

Explicación de las nuevas líneas:

ENV NGINX_PORT 9000: Define una variable de entorno llamada NGINX_PORT con el valor 9000.
RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf: Utiliza el comando sed para reemplazar el puerto predeterminado (80) por nuestra variable de entorno en el archivo de configuración de Nginx.

Guarde el archivo en WebIDE.
En la terminal, construya la imagen con una nueva etiqueta:

docker build -t my-nginx-env .

Ejecute un contenedor basado en la nueva imagen:

docker run -d -p 9000:9000 --name env-container my-nginx-env

Este comando inicia el contenedor y mapea el puerto 9000 del anfitrión al 9000 del contenedor. Como la variable de entorno ya está definida en el Dockerfile, no es necesario volver a indicarla en el comando docker run.

Verifique que el servidor web esté funcionando en el puerto especificado:

curl http://localhost:9000

Debería ver el contenido HTML de index.html.

Usar ENTRYPOINT en el Dockerfile

En este paso, aprenderemos a usar la instrucción ENTRYPOINT y a configurar un puerto diferente (9100) mediante un script de inicio.

En WebIDE, abra el Dockerfile una vez más.
Modifique el contenido del Dockerfile por el siguiente:

FROM nginx
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Este Dockerfile elimina la variable de entorno fija y el comando sed directo. En su lugar, gestionaremos la configuración en tiempo de ejecución mediante un script ENTRYPOINT. Esto hace que nuestra imagen sea mucho más flexible.

Cree un nuevo archivo llamado start.sh en el mismo directorio con el siguiente contenido:

#!/bin/bash
## Set a default port if NGINX_PORT is not set
export NGINX_PORT=${NGINX_PORT:-9100}
## Replace the port in the nginx configuration
sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Este script establece un puerto por defecto, modifica la configuración de Nginx al arrancar el contenedor, imprime un mensaje informativo y finalmente inicia Nginx.

Guarde ambos archivos en WebIDE.
En la terminal, construya la imagen con una nueva etiqueta:

docker build -t my-nginx-entrypoint .

Ejecute un contenedor basado en la nueva imagen. Estableceremos el puerto a 9100 usando una variable de entorno en el comando de ejecución.

docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint

Revise los registros (logs) del contenedor para ver el mensaje de inicio:

docker logs entrypoint-container

Debería ver el mensaje "Starting Nginx on port 9100" en la salida.

Verifique que el servidor web responda correctamente en el nuevo puerto:

curl http://localhost:9100