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


Este tutorial se concentrará en cómo construir 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.

  • Install Docker and Learn Docker Container Manipulation – Part 1
  • Deploy and Run Applications under Docker Containers – Part 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 = Mandatory as the first instruction in a Docker file. Instructs Docker to pull the base image from which you are building the new image. Use a tag to specify the exact image from which you are building:
Ex: FROM ubuntu:20.04
  1. MAINTAINER = Author of the build image
  2. RUN = This instruction can be used on multiple lines and runs any commands after a Docker image has been created.
  3. CMD = Run any command when the Docker image is started. Use only one CMD instruction in a Dockerfile.
  4. ENTRYPOINT = Same as CMD but used as the main command for the image.
  5. EXPOSE = Instructs the container to listen on network ports when running. The container ports are not reachable from the host by default.
  6. ENV = Set container environment variables.
  7. ADD = Copy resources (files, directories, or files from URLs).

Paso 1: Crear o escribir un 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 construir 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 tenemos que hacer es empezar 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 ejecuta 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 mediante 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. Después de terminar 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: