Imagen base propia para Docker

En el servidor dockerhost descrito anteriormente vamos a crear nuestras imágenes propias de Centos 7 para Docker.

Imagen base de CentOS 7

Primero definimos un directorio para la instalación de CentOS 7.

mkdir -p ~/Docker_Images/CentOS7
export centos_root=~/Docker_Images/CentOS7
cd ~/Docker_Images

Luego inicializamos la base de datos rpm.

rpm --root $centos_root --initdb

Descargamos e instalamos el paquete centos-release.

sudo yum reinstall --downloadonly --downloaddir . centos-release

sudo rpm --root $centos_root -ivh centos-release*.rpm

sudo rpm --root $centos_root --import  $centos_root/etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-7

Instalamos yum sin documentación y sólo en inglés.

sudo yum -y --installroot=$centos_root --setopt=tsflags='nodocs' --setopt=override_install_langs=en_US.utf8 install yum

Modificamos la configuración de yum para evitar la instalación de documentación y archivos en otro idioma que no sea inglés.

sudo sed -i "/distroverpkg=centos-release/a override_install_langs=en_US.utf8\ntsflags=nodocs" $centos_root/etc/yum.conf

Creamos un entorno "enjaulado" con chroot y procedemos a instalar algunos paquetes útiles.

sudo cp /etc/resolv.conf $centos_root/etc

sudo chroot $centos_root /bin/bash <<EOF
yum install -y procps-ng iputils net-tools vim lsof wget git initscripts passwd
yum clean all
EOF

sudo rm -f $centos_root/etc/resolv.conf

Cambiamos la contraseña del usuario root.

sudo chroot $centos_root /bin/bash

En el entorno chroot (bash-4.2# indica que nos encontramos dentro del entorno enjaulado) ejecutamos el comando passwd

bash-4.2# passwd

bash-4.2# exit

Imagen base de CentOS 7 para Docker

Creamos ahora la imagen base de CentOS 7 para Docker. Todos los comandos serán ejecutados con los privilegios del usuario root, por eso vamos a omitir el sudo en cada línea.

export centos_root=/home/dockero/Docker_Images/CentOS7

tar -C $centos_root -c . | docker import - dockero/centos7

Comprobamos la creación de la imagen.

docker images

REPOSITORY           TAG                 IMAGE ID                CREATED                SIZE
dockero/centos7      latest            3e4dba68901g        11 seconds ago      267.3 MB 

 

Podemos ahora inicializar la imagen "dockero/centos7".

docker run -t -i dockero/centos7 /bin/bash

En el contenedor (bash-4.2# indica que nos encontramos dentro del contenedor) ejecutemos el comando cat /etc/centos-release

bash-4.2# cat /etc/centos-release

CentOS Linux release 7.4.1708 (Core)

 

Abrimos ahora otra terminal en el servidor dockerhost y ejecutamos el comando docker ps para ver lo que hemos creado.

docker ps -a

CONTAINER ID      IMAGE                   COMMAND           CREATED           STATUS          PORTS     NAMES
g588a5f01f63      dockero/centos7    "/bin/bash"       9 minutes ago     Up 9 minutes                clever_golick

 

Exportemos el contenedor ("clever_golick" es el nombre aleatorio asignado por Docker al contenedor).

docker export --output=centos7base-container.tar clever_golick

En la terminal del contenedor ejecutamos el comando exit para salir.

bash-4.2# exit

Finalmente, podemos eliminar el contenedor inactivo.

docker ps -a

CONTAINER ID      IMAGE                   COMMAND           CREATED           STATUS                                PORTS     NAMES
g588a5f01f63      dockero/centos7    "/bin/bash"       35 minutes ago     Exited (0) 42 seconds ago                 clever_golick

 

Con el comando docker rm eliminamos el contenedor.

docker rm clever_golick

Subir la imagen a un registro de Docker

Podemos subir la imagen a un registro de Docker para compartirla con nuestro equipo. En este ejemplo usamos el registro de Docker en GitLab.

Primero necesitamos saber la identificación de la imagen (Image ID).

docker images

REPOSITORY           TAG                 IMAGE ID                CREATED                SIZE
dockero/centos7      latest            3e4dba68901g        35 minutes ago      267.3 MB

 

Ahora tenemos que etiquetar la imagen para especificar el destino del registro de Docker en GitLab.

docker tag 3e4dba68901g registry.gitlab.com/<namespace>/<project>/centos7

Finalmente iniciamos una sesión en GitLab y subimos la imagen.

docker login registry.gitlab.com
docker push registry.gitlab.com/<namespace>/<project>/centos7

Image propia de MySQL para Docker

Vamos a crear una imagen propia de MySQL usando la imagen base de CentOS7. Todos los comandos serán ejecutados con los privilegios del usuario root, por eso vamos a omitir el sudo en cada línea.

docker run -t -i --cap-add=SYS_ADMIN -e "container=docker" -v /sys/fs/cgroup:/sys/fs/cgroup --name mysql-container dockero/centos7:latest /usr/sbin/init

Veremos al final unas líneas similares a las que se muestran abajo.

CentOS Linux 7 (Core)
Kernel 3.10.0-693.11.6.el7.x86_64 on an x86_64

541r8gf47d43 login:

 

Podemos iniciar nuestra sesión usando la contraseña del usuario root que ya hemos definido anteriormente en la imagen de Centos7. En los siguientes comandos, "bash-4.2#" indica que nos encontramos dentro del contenedor.

bash-4.2# yum update

bash-4.2# yum install mariadb-server

bash-4.2# systemctl enable mariadb.service

bash-4.2# systemctl start mariadb.service

bash-4.2# mysql_secure_installation

bash-4.2# yum clean all

Con la contraseña del usuario root de MySQL ejecutamos los siguientes comandos.

bash-4.2# mysql -u root -p
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '***' WITH GRANT OPTION;

Necesitamos ahora crear un servicio que realize operaciones (init script) en la base de datos cada vez que la imagen de MySQL sea inicializada.

bash-4.2# touch /etc/systemd/system/docker-entrypoint-initdb.service

bash-4.2# chmod 644 /etc/systemd/system/docker-entrypoint-initdb.service

bash-4.2# touch /opt/docker-entrypoint-initdb.sh

bash-4.2# chmod 744 /opt/docker-entrypoint-initdb.sh

Contenido del archivo: /etc/systemd/system/docker-entrypoint-initdb.service

[Unit]
After=mariadb.service

[Service]
ExecStart=/opt/docker-entrypoint-initdb.sh

[Install]
WantedBy=default.target

Contenido del archivo: /opt/docker-entrypoint-initdb.sh

#!/bin/bash

for sqlfile in /docker-entrypoint-initdb.d/*.sql
do
  mysql -uroot -pMySQLrooPassword -hlocalhost < $sqlfile
done

Ahora sólo falta activar el nuevo servicio.

bash-4.2# systemctl daemon-reload

bash-4.2# systemctl enable docker-entrypoint-initdb.service

Exportemos el contenedor "mysql-container".

docker export --output=centos7mysql-container.tar mysql-container

FInalmente creamos una nueva imagen de MySQL para Docker.

bash-4.2# poweroff
docker commit -a "Dockero" -m "Imagen propia de MySQL" mysql-container dockero/centos7mysql
docker rm mysql-container

Y subimos la imagen nueva a GitLab.

docker images | grep centos7mysql
docker tag 6ed78a6380p8 registry.gitlab.com/<namespace>/<project>/centos7mysql
docker login registry.gitlab.com
docker push registry.gitlab.com/<namespace>/<project>/centos7mysql

Image propia de Apache para Docker

En esta última sección vamos a crear una imagen propia de Apache. Todos los comandos serán ejecutados con los privilegios del usuario root, por eso vamos a omitir el sudo en cada línea.

docker run -t -i -p 80:80 --cap-add=SYS_ADMIN -e "container=docker" -v /sys/fs/cgroup:/sys/fs/cgroup --name apache-container dockero/centos7:latest /usr/sbin/init

Iniciamos una sesión y ejecutamos los siguientes comandos (bash-4.2# indica que nos encontramos dentro del contenedor).

bash-4.2# yum update

bash-4.2# yum install httpd php php-pear php-mysql php-gd

bash-4.2# yum install epel-release

bash-4.2# yum install phpmyadmin

bash-4.2# yum clean all

bash-4.2# mv /etc/httpd/conf.d/phpMyAdmin.conf  /etc/httpd/conf.d/phpMyAdmin.conf.disabled

Extracto del archivo: /etc/php.ini

error_reporting = E_ALL

display_errors = On

 Continuamos ejecutando los siguientes comandos.

bash-4.2# systemctl enable httpd.service

bash-4.2# cd /var/www/html/

bash-4.2# ln -s /usr/share/phpMyAdmin phpmyadmin

bash-4.2# systemctl start httpd.service

En un navegador como Firefox probamos el funcionamiento del servicio de Apache. En este ejemplo, la dirección IP del servidor dockerhost es 192.168.56.110.

http://192.168.56.110/

http://192.168.56.110/phpmyadmin/

Podemos copiar directo los archivos de configuración de Apache y phpMyAdmin del contenedor al servidor dockerhost (PID es el número del proceso Apache en dockerhost).

cp /proc/<PID>/root/etc/httpd/conf/httpd.conf .
cp /proc/<PID>/root/etc/phpMyAdmin/config.inc.php .

Exportemos el contenedor "apache-container".

docker export --output=centos7apache-container.tar apache-container

FInalmente creamos una nueva imagen de Apache para Docker y la subimos a GitLab.

bash-4.2# poweroff
docker commit -a "Dockero" -m "Apache base image" apache-container dockero/centos7apache
docker rm apache-container
docker images | grep centos7apache
docker tag 2ds64g2915d4 registry.gitlab.com/<namespace>/<project>/centos7apache
docker login registry.gitlab.com
docker push registry.gitlab.com/<namespace>/<project>/centos7apache

 

Tags