Creación y personalización de imágenes de Docker: Un laboratorio práctico

Introducción

Docker es una herramienta poderosa para empaquetar y distribuir aplicaciones como contenedores. En el centro 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ás cómo crear imágenes personalizadas de Docker que mejoran tus aplicaciones al incorporar software adicional, bibliotecas o configuraciones.

A lo largo de este laboratorio, usaremos 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 trabajar con archivos de configuración y código.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) linux(("Linux")) -.-> linux/FileandDirectoryManagementGroup(["File and Directory Management"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) linux(("Linux")) -.-> linux/PackagesandSoftwaresGroup(["Packages and Softwares"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ImageOperationsGroup -.-> docker/images("List Images") linux/FileandDirectoryManagementGroup -.-> linux/cd("Directory Changing") linux/FileandDirectoryManagementGroup -.-> linux/mkdir("Directory Creating") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") linux/PackagesandSoftwaresGroup -.-> linux/curl("URL Data Transferring") subgraph Lab Skills docker/run -.-> lab-389185{{"Imágenes personalizadas de Docker"}} docker/exec -.-> lab-389185{{"Imágenes personalizadas de Docker"}} docker/images -.-> lab-389185{{"Imágenes personalizadas de Docker"}} linux/cd -.-> lab-389185{{"Imágenes personalizadas de Docker"}} linux/mkdir -.-> lab-389185{{"Imágenes personalizadas de Docker"}} docker/build -.-> lab-389185{{"Imágenes personalizadas de Docker"}} linux/curl -.-> lab-389185{{"Imágenes personalizadas de Docker"}} end

Configurar el entorno del proyecto

Comencemos creando un directorio de proyecto y navegando hacia él.

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

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

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

Verifique que esté en el directorio correcto:

pwd

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

Comprensión de estos comandos:

mkdir -p: Este comando crea un directorio. La bandera -p permite crear directorios padre si no existen.
cd: Este comando cambia el directorio actual.
pwd: Este comando imprime el directorio de trabajo actual.

Crear una imagen simple de Docker

Ahora, creemos una imagen simple de Docker que ejecute un servidor web Nginx.

En WebIDE, navegue hasta el Explorador de archivos (generalmente el primer icono en la barra lateral izquierda).
Haga clic derecho en el panel del Explorador de archivos y seleccione "Nuevo archivo". Nómbrelo Dockerfile (con 'D' mayúscula y sin extensión de archivo).
Abra el Dockerfile haciendo clic en él en el Explorador de archivos. Agregue 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.

Comprensión del Dockerfile:

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

Cree un nuevo archivo llamado index.html en el mismo directorio. Puede hacer esto haciendo clic derecho nuevamente en el panel del Explorador de archivos y seleccionando "Nuevo archivo".
Abra index.html y agregue 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 -> Nueva 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.

Comprensión del comando:

docker build: Este es el comando para construir una imagen de Docker.
-t my-nginx: La bandera -t etiqueta nuestra imagen con el nombre my-nginx.
.: Esto especifica el contexto de construcción (el directorio que contiene el Dockerfile) como el directorio actual.

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

docker images

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

Ejecutar y probar la imagen personalizada

Ejecutemos un contenedor basado en nuestra nueva imagen y probémoslo.

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

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

Comprensión de este comando:

docker run: Este comando crea e inicia un nuevo contenedor.
-d: Esta bandera ejecuta el contenedor en modo desasociado (en segundo plano).
-p 8080:80: Esto mapea el puerto 8080 de su host al puerto 80 en el contenedor.
--name my-nginx-container: Esto asigna un nombre a nuestro contenedor.
my-nginx: Este es el nombre de la imagen que estamos usando para crear el contenedor.

Verifique que el contenedor esté en ejecución:

docker ps

Debería ver my-nginx-container listado en la salida. Este comando muestra todos los contenedores en ejecución.

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 está curioso sobre lo que 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 puede navegar hasta la parte superior de la máquina virtual (VM) de LabEx y 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

Agregar software personalizado a la imagen

Ahora, modifiquemos nuestra imagen de Docker para incluir software adicional. Agregaremos la utilidad curl como ejemplo.

En WebIDE, abra el Dockerfile. Puede hacer esto haciendo clic en Dockerfile en el panel del Explorador de archivos.
Modifique el contenido del Dockerfile para que sea:

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

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

Comprensión de la nueva línea:

RUN apt-get update && apt-get install -y curl: Esta línea actualiza la lista de paquetes (apt-get update) y luego instala curl (apt-get install -y curl). La bandera -y responde automáticamente "sí" a cualquier solicitud 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 construye una nueva imagen de Docker con la etiqueta my-nginx-curl que incluye la utilidad curl.

Verifique que se haya creado la nueva imagen:

docker images

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

Probar la imagen personalizada con Curl

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

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

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

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

Ejecute una shell bash en el contenedor en ejecución:

docker exec -it curl-container bash

Este comando abre una shell bash interactiva dentro del contenedor en ejecución.

Comprensión de este comando:

docker exec: Esto ejecuta un comando en un contenedor en ejecución.
-it: Estas banderas asignan una pseudo-TTY y mantienen STDIN abierto, lo que le permite interactuar con la shell.
curl-container: Este es el nombre de nuestro contenedor.
bash: Este es el comando que estamos ejecutando en el contenedor (abrir una shell bash).

Ahora debería ver un nuevo prompt, lo que indica que está dentro del contenedor. Dentro del contenedor, pruebe la utilidad curl:

curl http://localhost

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

Salga de la shell bash del contenedor:

exit

Este comando lo devuelve a la shell de su sistema host.

Utilizar variables de entorno en la imagen

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

En WebIDE, abra el Dockerfile nuevamente.
Modifique el contenido del Dockerfile para que sea:

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

Este Dockerfile agrega 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 utilizar este puerto.

Comprensión de las nuevas líneas:

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

Guarde el archivo en WebIDE.
En la terminal de WebIDE, vuelva a construir la imagen de Docker con una nueva etiqueta:

docker build -t my-nginx-env.

Ejecute un contenedor basado en la nueva imagen:

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

Este comando inicia un nuevo contenedor basado en la imagen my-nginx-env, mapea el puerto 9000 del host al puerto 9000 en el contenedor y establece el valor de la variable NGINX_PORT en 9000.

Comprensión de las nuevas partes de este comando:

-e NGINX_PORT=9000: Esto establece la variable de entorno NGINX_PORT en 9000 para esta ejecución específica del contenedor.

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

curl http://localhost:9000

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

Utilizar ENTRYPOINT en el Dockerfile

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

En WebIDE, abra el Dockerfile nuevamente.
Modifique el contenido del Dockerfile para que sea:

FROM nginx
ENV NGINX_PORT 9100
RUN sed -i "s/listen\s*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Este Dockerfile establece NGINX_PORT en 9100 y agrega una instrucción ENTRYPOINT, que especifica el comando a ejecutar cuando el contenedor se inicia.

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

#!/bin/bash
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Este script imprime un mensaje que muestra en qué puerto se ejecutará Nginx antes de iniciar Nginx.

Guarde ambos archivos en WebIDE.
En la terminal de WebIDE, vuelva a construir la imagen de Docker con una nueva etiqueta:

docker build -t my-nginx-entrypoint.

Ejecute un contenedor basado en la nueva imagen:

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

Verifique los registros 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 se esté ejecutando correctamente en el nuevo puerto:

curl http://localhost:9100

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

Resumen

En este laboratorio, has aprendido cómo crear imágenes personalizadas de Docker que agregan valor a tus aplicaciones. Comenzaste creando una imagen simple con un servidor web y luego progresaste a agregar software personalizado y utilizar variables de entorno para la configuración. A lo largo del laboratorio, has utilizado WebIDE (VS Code) para editar archivos, lo que hace el proceso más intuitivo y amigable para el usuario.

A continuación, un resumen de lo que has logrado:

Configuraste un entorno de proyecto y aprendiste comandos básicos de terminal.
Creaste una imagen simple de Docker con Nginx y una página HTML personalizada.
Construiste y ejecutaste contenedores de Docker, aprendiendo sobre mapeo de puertos y nomenclatura de contenedores.
Modificaste una imagen de Docker para incluir software adicional (curl).
Utilizaste docker exec para ejecutar comandos dentro de un contenedor.
Incorporaste variables de entorno en tu imagen de Docker para una configuración más sencilla.