LabEx
EntrarÚnete

Imágenes de Docker personalizadas

DockerBeginner
Practicar Ahora

Introducción

Docker es una herramienta potente para empaquetar y distribuir aplicaciones como contenedores. El núcleo de este proceso son las imágenes de Docker, que son paquetes preconfigurados que contienen todo lo necesario para ejecutar una aplicación, incluyendo el código, las dependencias y la configuración. En este laboratorio, aprenderás a crear imágenes de Docker personalizadas que mejoren tus aplicaciones incorporando software, bibliotecas o configuraciones adicionales.

A lo largo de este laboratorio, utilizaremos WebIDE (VS Code) para editar archivos. WebIDE proporciona una interfaz familiar y fácil de usar para la edición de archivos, lo que facilita 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.

A lo largo de este laboratorio, utilizaremos WebIDE (VS Code) para editar archivos. WebIDE proporciona una interfaz familiar y fácil de usar para la edición de archivos, lo que facilita el trabajo con archivos de configuración y código.

  1. Abre una terminal en WebIDE. Puedes hacerlo haciendo clic en "Terminal" en el menú superior y seleccionando "New Terminal".
  2. En la terminal, ejecuta 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 en la carpeta ~/project y cambia el directorio de trabajo actual a este.

  1. Verifica que te encuentras en el directorio correcto:
pwd

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

Entendiendo estos comandos:

  • mkdir -p: Este comando crea un directorio. El flag -p permite crear directorios padres si no existen.
  • cd: Este comando cambia el directorio actual.
  • pwd: Este comando imprime el directorio de trabajo actual.

Crear una imagen de Docker sencilla

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

  1. En WebIDE, navega al Explorador de archivos (generalmente el primer icono en la barra lateral izquierda).
  2. Haz clic derecho en el panel del Explorador de archivos y selecciona "New File". Asígnale el nombre Dockerfile (con una 'D' mayúscula y sin extensión de archivo).
  3. Abre el Dockerfile haciendo clic en él en el Explorador de archivos. Añade 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 predeterminado de Nginx.

Entendiendo el Dockerfile:

  • FROM nginx: Esta línea especifica la imagen base sobre la cual 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 en el directorio raíz web del contenedor.
  1. Crea un nuevo archivo llamado index.html en el mismo directorio. Puedes hacerlo haciendo clic derecho en el panel del Explorador de archivos y seleccionando "New File".
  2. Abre index.html y añade 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 sencilla que será servida por nuestro servidor Nginx.

  1. Abre una terminal en WebIDE (Terminal -> New Terminal si cerraste la anterior) y construye 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.

Entendiendo el comando:

  • docker build: Es el comando para construir una imagen de Docker.
  • -t my-nginx: El flag -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.
  1. Una vez completada la construcción, verifica que la imagen se haya creado correctamente:
docker images

Deberías ver la imagen my-nginx listada en el resultado.

Ejecutar y probar la imagen personalizada

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

  1. En la terminal de WebIDE, inicia un contenedor usando el siguiente comando:
docker run -d -p 8080:80 --name my-nginx-container my-nginx

Entendiendo este comando:

  • docker run: Este comando crea e inicia un nuevo contenedor.
  • -d: Este flag ejecuta el contenedor en modo "detached" (en segundo plano).
  • -p 8080:80: Esto mapea el puerto 8080 de tu host al puerto 80 en el contenedor.
  • --name my-nginx-container: Esto asigna un nombre a nuestro contenedor.
  • my-nginx: Es el nombre de la imagen que estamos usando para crear el contenedor.
  1. Verifica que el contenedor se esté ejecutando:
docker ps

Deberías ver my-nginx-container listado en el resultado. Este comando muestra todos los contenedores en ejecución.

  1. Para ver el contenido de la página web, usa el comando curl:
curl http://localhost:8080

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

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

También puedes navegar a la parte superior de la máquina virtual de LabEx, hacer clic en + para crear un nuevo servidor web y luego ingresar el puerto 8080 para ver el contenido.

Configuración del puerto del servidor web

Añadir software personalizado a la imagen

En este paso, modificarás tu imagen de Docker para incluir software adicional. Añadiremos el editor de texto nano como ejemplo, ya que no está incluido en la imagen base de nginx.

  1. En WebIDE, abre el Dockerfile. Puedes hacerlo haciendo clic en Dockerfile en el panel del Explorador de archivos.
  2. Modifica el contenido del Dockerfile a:
FROM nginx
RUN apt-get update && apt-get install -y nano
COPY index.html /usr/share/nginx/html/

Este Dockerfile añade una nueva instrucción RUN que actualiza el índice de paquetes e instala el paquete nano usando el gestor de paquetes apt-get.

Entendiendo la nueva línea:

  • RUN apt-get update && apt-get install -y nano: Esta línea actualiza la lista de paquetes (apt-get update) y luego instala nano (apt-get install -y nano). El flag -y responde automáticamente "sí" a cualquier solicitud durante la instalación.
  1. Guarda el archivo en WebIDE presionando Ctrl+S (o Cmd+S en Mac).
  2. En la terminal de WebIDE, reconstruye la imagen de Docker con una nueva etiqueta:
docker build -t my-nginx-nano .

Este comando construye una nueva imagen de Docker con la etiqueta my-nginx-nano que incluye el editor nano.

  1. Verifica que la nueva imagen se haya creado:
docker images

Deberías ver la imagen my-nginx-nano listada en el resultado.

Probar la imagen personalizada con Nano

En este paso, ejecutarás un contenedor basado en tu nueva imagen y confirmarás que el paquete nano está disponible dentro de él.

  1. En la terminal de WebIDE, inicia un nuevo contenedor usando el siguiente comando:
docker run -d --name nano-container my-nginx-nano

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

  1. Ejecuta el siguiente comando para verificar la versión instalada de nano dentro del contenedor:
docker exec nano-container nano --version

Este comando ejecuta nano --version dentro del contenedor en ejecución para que puedas confirmar que el paquete está instalado.

Entendiendo este comando:

  • docker exec: Ejecuta un comando en un contenedor en ejecución.
  • nano-container: Es el nombre de nuestro contenedor.
  • nano --version: Imprime la versión de nano instalada desde dentro del contenedor.
  1. Deberías ver un resultado que comienza con GNU nano, lo que confirma que la imagen personalizada ahora incluye el editor.

Usar variables de entorno en la imagen

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

  1. En WebIDE, abre el Dockerfile de nuevo.

  2. Modifica el contenido del Dockerfile a:

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 en 9000. También incluye una instrucción RUN que modifica la configuración de Nginx para usar este puerto.

Entendiendo las nuevas líneas:

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

  1. Guarda el archivo en WebIDE.

  2. En la terminal de WebIDE, reconstruye la imagen de Docker con una nueva etiqueta:

docker build -t my-nginx-env .
  1. Ejecuta un contenedor basado en la nueva imagen:
docker run -d -p 9000:9000 --name env-container my-nginx-env

Este comando inicia un nuevo contenedor basado en la imagen my-nginx-env y mapea el puerto 9000 en el host al puerto 9000 en el contenedor. Ten en cuenta que la variable de entorno ya está establecida en el Dockerfile, por lo que no es necesario volver a establecerla en el comando docker run.

  1. Verifica que el servidor web se esté ejecutando en el puerto especificado:
curl http://localhost:9000

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

Usar ENTRYPOINT en el Dockerfile

En este paso, aprenderemos a usar la instrucción ENTRYPOINT en un Dockerfile y a utilizar un puerto diferente (9100).

  1. En WebIDE, abre el Dockerfile de nuevo.

  2. Modifica el contenido del Dockerfile a:

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 y el comando sed. En su lugar, manejaremos la configuración en tiempo de ejecución usando un script ENTRYPOINT. Esto hace que nuestra imagen sea más flexible.

  1. Crea 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 predeterminado, modifica la configuración de Nginx al iniciar el contenedor, imprime un mensaje mostrando en qué puerto se ejecutará Nginx y luego inicia Nginx.

  1. Guarda ambos archivos en WebIDE.

  2. En la terminal de WebIDE, reconstruye la imagen de Docker con una nueva etiqueta:

docker build -t my-nginx-entrypoint .
  1. Ejecuta un contenedor basado en la nueva imagen. Estableceremos el puerto en 9100 usando una variable de entorno.
docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint
  1. Revisa los registros (logs) del contenedor para ver el mensaje de inicio:
docker logs entrypoint-container

Deberías ver el mensaje "Starting Nginx on port 9100" en el resultado.

  1. Verifica que el servidor web se esté ejecutando correctamente en el nuevo puerto:
curl http://localhost:9100

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

Resumen

En este laboratorio, has aprendido a crear imágenes de Docker personalizadas que añaden valor a tus aplicaciones. Comenzaste creando una imagen sencilla con un servidor web, luego progresaste añadiendo software personalizado y utilizando variables de entorno para la configuración. A lo largo del laboratorio, has utilizado WebIDE (VS Code) para editar archivos, haciendo el proceso más intuitivo y fácil de usar.

Aquí tienes un resumen de lo que has logrado:

  1. Configurar un entorno de proyecto y aprender comandos básicos de terminal.
  2. Crear una imagen de Docker sencilla con Nginx y una página HTML personalizada.
  3. Construir y ejecutar contenedores Docker, aprendiendo sobre mapeo de puertos y nombres de contenedores.
  4. Modificar una imagen de Docker para incluir software adicional (curl).
  5. Usar docker exec para ejecutar comandos dentro de un contenedor.
  6. Incorporar variables de entorno en tu imagen de Docker para una configuración más sencilla.
Relacionado Docker Cursos
Docker para Principiantes

Docker para Principiantes

dockerdevops
Desafíos de Práctica de Docker

Desafíos de Práctica de Docker

dockerdevops
Laboratorios Prácticos de Docker

Laboratorios Prácticos de Docker

dockerdevops