DockerFile: Crear imagen personalizada con Docker

La otra vez veíamos en este impresionante post, como descargar una imagen, crear un contenedor, modificarlo y luego subir la imagen a Docker Hub para poder descargarla desde cualquier maquina del planeta tierra, y desde otras galaxias también (siempre que tengan el motor de Docker instalado).

Bueno, mucha gente me paró por la calle y me dijo "¿hay alguna forma de automatizar todo esto de manera que sean solo 2 clicks?". A lo que yo respondí: "No uso mouse, no hago clicks... y para tener tu contenedor con todo listo, solo tenes que ejecutar este comando":

sudo docker run --name VirtualArdillas -it ardillasenlared/ubuntu:ardillas /bin/bash

- Con esto te bajas la imagen de Ubuntu que subí la otra vez a Docker Hub y ya tenes todo listo para usar, no necesitas DockerFile, ¿para que lo queres? ¬¬
- Bueno, perdón que te contradiga, o mejor dicho, que me contradiga, pero si quiero personalizar esa imagen que está subida voy a tardar mas tiempo, porque esa imagen solo me sirve si busco lo que ya tiene instalado, de lo contrario una imagen a partir de un DockerFile seria mas útil.
- ¿Por que? ¿Que es DockerFile?.
- Dockerfile es un documento de texto que contiene todos los comandos que un usuario quiere ejecutar para crear una imagen. Docker puede construir imágenes automáticamente leyendo las instrucciones de Dockerfile. Usando docker build los usuarios pueden crear una compilación automatizada que ejecuta varios comandos y que nos sirve para instalar programas y/o realizar configuraciones que formaran parte de una imagen de manera simple y rápida.
- Que bien, ganaste. Me convenciste con eso del Docker Fail.
- DockerFile.
- Eso, y aprende a pronunciar.

En este DockerFile vamos a hacer lo mismo que la otra vez pero a partir de un archivo, repasemos:

1. Actualizar los repos:

apt-get update

También hicimos una actualización del sistema operativo con apt-get upgrade pero en este caso tenemos que evitar el RUN apt-get upgrade y dist-upgrade ya que hay muchos paquetes que pueden no actualizarse dentro de un contenedor sin privilegios. Podemos ejecutarlo manualmente luego.

2. Crear el usuario ardillasenlared

adduser ardillasenlared

3. Instalar nano, sudo, iputils-ping, net-tools, ssh:

apt-get install nano
apt-get install sudo
apt-get install iputils-ping
apt-get install net-tools
apt-get install ssh
apt-get install nmap (este en realidad no estaba, pero va de yapa)

4. Dar permisos de sudo al usuario ardillasenlared:

En el post hicimos esto:

nano /etc/sudoers

Y agregar lo siguiente:

ardillasenlared ALL=(ALL:ALL) ALL

Pero en el Dockerfile vamos a agregarlo al grupo sudo, el resultado es el mismo.

5. Y por ultimo corregir el error:

sudo: setrlimit(RLIMIT_CORE): Operation not permitted

Para ello teníamos que crear el archivo /etc/sudo.conf con la siguiente linea:

Set disable_coredump false

¿Como hacemos todo esto con un DockerFile? Así:

#Bajar la imagen base de Ubuntu 20.04
FROM ubuntu:20.04

#Actualizar repos e instalar iputils-ping, net-tools, ssh y nmap
RUN apt-get update && \
      apt-get -y install sudo nano iputils-ping net-tools ssh nmap

#Crear el usuario ardillasenlared con contraseña password y agregarlo a sudoers
RUN useradd -m ardillasenlared && echo "ardillasenlared:password" | chpasswd && adduser ardillasenlared sudo

#Crear archivo sudo.conf con la linea Set disable_coredump false para que no aparezca el error
RUN touch /etc/sudo.conf && echo "Set disable_coredump false" > /etc/sudo.conf

#Iniciar shell bash al levantar le contenedor con el usuario ardillasenlared
USER ardillasenlared
CMD /bin/bash

A la hora de crear nuestro Dockerfile siempre tenemos que tener en cuenta que su ejecución no tiene interacción, con lo cual tenemos que armarlo de manera que no tengamos que hacer absolutamente nada (por ejemplo, cuando hace un apt-get install programa siempre te pregunta si queres instalar las dependencias y demás, con el parametro "-y" le estamos diciendo que le diga que si a todo sin preguntar).

Una vez creado el archivo con ese código, pasamos a crear la imagen con todo lo que definimos en el Dockerfile. Para eso ejecutamos:

sudo docker build -t ubuntuardillas:1.0 . (hay un punto al final)

Si hacemos un sudo docker images vamos a ver una nueva llamada ubuntuardillas.

Luego levantamos un contenedor a partir de la imagen recién creada:

sudo docker run --name ardillas1.0 -it ubuntuardillas:1.0

Vemos que directamente nos da una shell de bash, como configuramos en el Dockerfile, y ademas nos loguea con el usuario ardillasenlared creado en el mismo procedimiento.

Vamos a probar un ping, nmap y luego a instalar algo con sudo:

Cuando me solicita la contraseña de sudo ingreso password que es la que configuramos en el Dockerfile.
Vemos que todo responde según lo esperado, y que el nmap a 192.168.2.106 nos indica que el puerto 22 esta abierto, entonces aprovecho y pruebo el ssh contra esa virtual:

Y vemos que tiene ssh instalado también.

En caso de querer cambiar la contraseña del usuario ardillasenlared tenes que ejecutar:

passwd ardillasenlared

Te va a solicitar primero la contraseña actual (password) y luego una nueva.

Para crear otro usuario podes seguir los siguientes pasos.

Con esto ya creamos nuestra imagen personalizada a partir de lo que definimos en el archivo Dockerfile.

Espero que le haya servido!

COMPARTAN, dejen de guardarse el conocimiento para uds, no sean egoístas!

Bye!