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!
