Cómo crear y configurar automáticamente imágenes de Docker personalizadas con Dockerfile - Parte 3


Este tutorial se concentrará en cómo crear una imagen Docker personalizada basada en Ubuntu con el servicio Apache instalado. Todo el proceso se automatizará mediante un Dockerfile.

Las imágenes de Docker se pueden crear automáticamente a partir de archivos de texto, denominados Dockerfiles. Un archivo de Docker contiene instrucciones o comandos ordenados paso a paso que se utilizan para crear y configurar una imagen de Docker.

  • Instale Docker y aprenda a manipular contenedores de Docker - Parte 1
  • Implementar y ejecutar aplicaciones en contenedores Docker - Parte 2

Básicamente, un archivo Docker contiene varias instrucciones para crear y configurar un contenedor específico según sus requisitos. Las siguientes instrucciones son las más utilizadas, siendo algunas de ellas obligatorias:

  1. FROM u003d Obligatorio como la primera instrucción en un archivo Docker. Indica a Docker que extraiga la imagen base a partir de la cual está creando la nueva imagen. Use una etiqueta para especificar la imagen exacta a partir de la cual está construyendo:

Ex: FROM ubuntu:20.04

  1. MAINTAINER u003d Autor de la imagen de compilación
  2. RUN u003d Esta instrucción se puede utilizar en varias líneas y ejecuta cualquier comando después de que se haya creado una imagen de Docker.
  3. CMD u003d Ejecute cualquier comando cuando se inicie la imagen de Docker. Use solo una instrucción CMD en un Dockerfile.
  4. ENTRYPOINT u003d Igual que CMD pero utilizado como comando principal para la imagen.
  5. EXPOSE u003d Indica al contenedor que escuche en los puertos de red cuando se esté ejecutando. Los puertos del contenedor no son accesibles desde el host de forma predeterminada.
  6. ENV u003d Establecer variables de entorno del contenedor.
  7. ADD u003d Copie recursos (archivos, directorios o archivos de URL).

Paso 1: creación o escritura del repositorio de Dockerfile

1. Primero, creemos algún tipo de repositorios de Dockerfile para reutilizar archivos en el futuro para crear otras imágenes. Cree un directorio vacío en algún lugar de la partición /var donde crearemos el archivo con las instrucciones que se utilizarán para construir la nueva imagen de Docker.

# mkdir -p /var/docker/ubuntu/apache
# touch /var/docker/ubuntu/apache/Dockerfile

2. A continuación, comience a editar el archivo con las siguientes instrucciones:

# vi /var/docker/ubuntu/apache/Dockerfile

Extracto de Dokerfile:

FROM ubuntu
MAINTAINER  your_name  <[email protected]>
RUN apt-get -y install apache2
RUN echo “Hello Apache server on Ubuntu Docker” > /var/www/html/index.html
EXPOSE 80
CMD /usr/sbin/apache2ctl -D FOREGROUND

Ahora, repasemos las instrucciones del archivo:

La primera línea nos dice que estamos construyendo a partir de una imagen de Ubuntu. Si no se envía ninguna etiqueta, digamos 14:10, por ejemplo, se utiliza la última imagen de Docker Hub.

En la segunda línea, agregamos el nombre y el correo electrónico del creador de la imagen. Las siguientes dos líneas RUN se ejecutarán en el contenedor al compilar la imagen e instalarán el demonio Apache y harán eco de algo de texto en la página web predeterminada de Apache.

La línea EXPOSE indicará al contenedor Docker que escuche en el puerto 80, pero el puerto no estará disponible para el exterior. La última línea indica al contenedor que ejecute el servicio Apache en primer plano después de que se inicie el contenedor.

3. Lo último que debemos hacer es comenzar a crear la imagen emitiendo el siguiente comando, que creará localmente una nueva imagen de Docker llamada ubuntu-apache basada en el Dockerfile creado anteriormente, como se muestra en este ejemplo:

# docker build -t ubuntu-apache /var/docker/ubuntu/apache/

4. Una vez que Docker haya creado la imagen, puede enumerar todas las imágenes disponibles e identificar su imagen emitiendo el siguiente comando:

# docker images

Paso 2: Ejecute el contenedor y acceda a Apache desde LAN

5. Para ejecutar el contenedor continuamente (en segundo plano) y acceder a los servicios expuestos al contenedor (puertos) desde el host u otra máquina remota en su LAN, ejecute el siguiente comando en el indicador de su terminal host:

# docker run -d -p 81:80 ubuntu-apache

Aquí, la opción -d ejecuta el contenedor ubuntu-apache en segundo plano (como un demonio) y la opción -p mapea el puerto del contenedor 80 a su puerto localhost 81. El acceso LAN externo al servicio Apache se puede alcanzar a través del puerto 81 solamente.

El comando Netstat le dará una idea de qué puertos está escuchando el host.

Una vez iniciado el contenedor, también puede ejecutar el comando docker ps para ver el estado del contenedor en ejecución.

6. La página web se puede mostrar en su host desde la línea de comando usando la utilidad curl contra la dirección IP de su máquina, localhost o interfaz de red acoplable en el puerto 81. Use la línea de comando IP para mostrar las direcciones IP de la interfaz de red.

# ip addr               [List nework interfaces]
# curl ip-address:81    [System Docker IP Address]
# curl localhost:81     [Localhost]

7. Para visitar la página web del contenedor desde su red, abra un navegador en una ubicación remota y use el protocolo HTTP, la dirección IP de la máquina donde se está ejecutando el contenedor, seguida del puerto 81 como se ilustra en la imagen de abajo.

http://ip-address:81

8. Para obtener una visión interna de los procesos que se están ejecutando dentro del contenedor, emita el siguiente comando:

# docker ps
# docker top <name or ID of the container>

9. Para detener el contenedor, emita el comando docker stop seguido del ID o nombre del contenedor.

# docker stop <name or ID of the container>
# docker ps

10. En caso de que desee asignar un nombre descriptivo para el contenedor, utilice la opción --name como se muestra en el siguiente ejemplo:

# docker run --name my-www -d -p 81:80 ubuntu-apache
# docker ps

Ahora puede hacer referencia al contenedor para la manipulación (inicio, parada, inicio, estadísticas, etc.) solo con el nombre asignado.

# docker stats my-www

Paso 3: crear un archivo de configuración de todo el sistema para el contenedor Docker

11. En CentOS/RHEL puede crear un archivo de configuración systemd y administrar el contenedor como lo hace normalmente para cualquier otro servicio local.

Por ejemplo, cree un nuevo archivo systemd llamado, digamos, apache-docker.service usando el siguiente comando:

# vi /etc/systemd/system/apache-docker.service

Extracto del archivo apache-docker.service:

[Unit]
Description=apache container
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/bin/docker start -a my-www
ExecStop=/usr/bin/docker stop -t 2 my-www

[Install]
WantedBy=local.target

12. Una vez que termine de editar el archivo, ciérrelo, vuelva a cargar el demonio systemd para reflejar los cambios e inicie el contenedor emitiendo los siguientes comandos:

# systemctl daemon-reload
# systemctl start apache-docker.service
# systemctl status apache-docker.service

Este fue solo un ejemplo simple de lo que puede hacer con un simple Dockerfile, pero puede preconstruir algunas aplicaciones bastante sofisticadas que puede iniciar en cuestión de segundos con un mínimo de recursos y esfuerzo.

Otras lecturas: