Instalación y configuración de Docker + MySQL

Anexo	Título	Versión
01	*Docker + Mysql*	v 1.0

Introducción

MySQL es un sistema de gestión de bases de datos muy popular y de código abierto. Almacena y organiza datos de manera eficiente, facilitando su acceso.

Docker es una plataforma que permite desarrollar y desplegar aplicaciones en entornos virtuales llamados contenedores. Con una sola imagen, Docker puede iniciar una aplicación con todas sus librerías y dependencias.

En este tutorial, aprenderás a desplegar un contenedor Docker de MySQL y a trabajar con la base de datos en contenedores.

Tutorial sobre Cómo Instalar Contenedores Docker de MySQL

Prerrequisitos

Acceso a una terminal o línea de comandos
Una cuenta de usuario con privilegios de sudo o acceso a la cuenta root
Docker instalado

Si necesitas configurar una base de datos rápidamente y sin usar demasiados recursos, desplegar MySQL en un contenedor es una solución rápida y eficiente. Esto es ideal para aplicaciones pequeñas y medianas. Las aplicaciones grandes pueden necesitar algo más robusto.

Usar Docker para configurar tu base de datos es cada vez más popular para aplicaciones pequeñas. En lugar de tener un servidor separado para la base de datos, puedes desplegar un contenedor de MySQL.

Instalación de un Contenedor Docker de MySQL

Configurar una base de datos en Docker es simplemente construir un contenedor basado en una imagen de MySQL. Sigue estos pasos para poner en marcha tu contenedor MySQL.

Paso 1: Descargar la Imagen Docker de MySQL

Descarga la imagen Docker para MySQL con el siguiente comando:
```
sudo docker pull mysql/mysql-server:latest
```
Si quieres una versión específica de MySQL, reemplaza latest con el número de versión.
Verifica que la imagen esté almacenada localmente listando las imágenes Docker descargadas:
```
sudo docker images
```
Deberías ver mysql/mysql-server en la lista.

Paso 2: Desplegar el Contenedor MySQL

Despliega un nuevo contenedor MySQL con:
```
sudo docker run --name=[nombre_contenedor] -d [nombre_etiqueta_imagen]
```
- Reemplaza [nombre_contenedor] con el nombre que prefieras.
- La opción -d ejecuta el contenedor en segundo plano.
- Reemplaza [nombre_etiqueta_imagen] con el nombre de la imagen descargada en el Paso 1.
Por ejemplo, para crear un contenedor llamado mysql_docker:
```
sudo docker run --name=mysql_docker -d mysql/mysql-server:latest
```

Verifica si el contenedor MySQL está en ejecución:

docker ps

Deberías ver el contenedor recién creado en la lista:

$docker ps
CONTAINER ID   IMAGE                       COMMAND                  CREATED         STATUS                            PORTS                       NAMES
5c5285b91c64   mysql/mysql-server:latest   "/entrypoint.sh mysq…"   7 seconds ago   Up 5 seconds (health: starting)   3306/tcp, 33060-33061/tcp   mysql_docker

Paso 3: Conectar al Contenedor Docker de MySQL

Asegúrate de que el cliente MySQL esté instalado:
```
sudo apt install mysql-client
```
Abre el archivo de registros del contenedor MySQL para encontrar la contraseña root generada:
```
sudo docker logs [nombre_contenedor]
```
Para el contenedor mysql_docker:
```
sudo docker logs mysql_docker
```

Encuentra la línea [Entrypoint] GENERATED ROOT PASSWORD: y copia la contraseña.

...
[Entrypoint] GENERATED ROOT PASSWORD: C6+8Lkq84D.EQ,TO?^:W2W.7a=NY0f0u
...

Conéctate al shell bash del contenedor MySQL:

sudo docker exec -it [nombre_contenedor] bash

Para el contenedor mysql_docker:

sudo docker exec -it mysql_docker bash

Proporciona la contraseña root cuando se te solicite.

Primero nos conectamos al servidor MySQL:
```
mysql -uroot -p
```
Nos pedirá la contraseña que se generó durante la instalación: Introduce la contraseña que copiaste del registro.
```
Enter password:
```
Contraseña

Ojo porque al introducir la contraseña, por seguridad, no se muestra nada en pantalla. Es normal, simplemente escribe la contraseña y pulsa Enter.

Cambia la contraseña root del servidor para mayor seguridad:

mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY '[nuevacontraseña]';

Ejemplo

mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY 'administrador';

El servidor debe contestar con algo así:

Query OK, 0 rows affected (0.01 sec)

Reemplaza [nuevacontraseña] con una contraseña fuerte.

Sal del cliente MySQL escribiendo:
```
mysql> exit;
```
Vuelve a conectar con el servidor MySQL y verifica que la contraseña ha cambiado:
```
mysql -uroot -p
```
Ahora cuando pida la contraseña introduce la nueva contraseña que has configurado.

Si todo ha ido bien, puedes salir del cliente Mysql y del contenedor con exit de ambos.

Configurar el Contenedor MySQL

Configuración

Ahora mismo todos los ficheros de configuración del contendor están dentro del contenedor, por lo que si lo eliminamos perderemos toda la configuración. Para evitar esto, docker nos permite mapear un directorio del host al contenedor, de modo que los ficheros de configuración se mantengan en el host y no se pierdan al eliminar el contenedor.

Carpeta para mapear

Vamos a crear una carpeta en el host para almacenar los ficheros de configuración del contenedor MySQL. Esta carpeta se mapeará al contenedor para que las configuraciones se mantengan incluso si el contenedor se elimina. En este anexo la carpeta estará ubucada en la carpeta principal del usuario, y la llamaremos: docker/docker_mysql. Esta carpeta la usaremos en adelante para almacenar los ficheros de configuración y los datos de la base de datos.

Las opciones de configuración se encuentran en el contenedor en la carpeta /etc/mysql/my.cnf.

Crea un nuevo directorio en la máquina host:

sudo mkdir -p ~/docker/[nombre_contenedor]/conf.d

En nuestro caso:

sudo mkdir -p ~/docker/docker_mysql/conf.d

Crea un archivo de configuración MySQL personalizado:

sudo nano ~/docker/[nombre_contenedor]/conf.d/my-custom.cnf

en nuestro caso:

sudo nano ~/docker/docker_mysql/conf.d/my-custom.cnf

Agrega las configuraciones deseadas. Por ejemplo, para aumentar el número máximo de conexiones a 250:
```
[mysqld]
max_connections=250
```
Guarda y cierra el archivo.
Elimina y vuelve a ejecutar el contenedor MySQL mapeando la ruta del volumen.

Para eliminar el contenedor, primero deténlo:
```
docker stop [nombre_contenedor]
```
Luego elimínalo:
```
docker rm [nombre_contenedor]
```
Ahora ya podemos volver a crear el contenedor con la configuración personalizada. El comando para crear el contenedor sería:
```
docker run \
--detach \
--name=[nombre_contenedor] \
--env="MYSQL_ROOT_PASSWORD=[mi_contraseña]" \
--publish 3306:3306 \
--volume=/carpeta/de/usuario/docker/[nombre_contenedor]/conf.d:/etc/mysql/conf.d \
mysql
```
En nuestro caso, el comando sería:
```
docker run \
--detach \
--name=docker_mysql \
--env="MYSQL_ROOT_PASSWORD=administrador" \
--publish 3306:3306 \
--volume=/carpeta/de/usuario/docker/docker_mysql/conf.d:/etc/mysql/conf.d \
mysql
```
Carpeta de usuario

En el modificador --volume debes poner la ruta completa de la carpeta del usuario donde has creado el directorio docker. Por ejemplo, si tu usuario es alumno, la ruta sería /home/alumno/docker/docker_mysql/conf.d. Pero esto puede cambiar dependiendo de tu sistema operativo. En este modificador no podemos usar la ruta relativa como ~/docker/docker_mysql/conf.d, ya que Docker no la interpretará correctamente.
Verifica si el contenedor cargó la configuración.

PAra ello primero debemos conectar al contenedor como vimos anteriormente:
```
docker exec -it [nombre_contenedor] bash
```
Y luego ejecutar la siguiente instrucción para ver el número máximo de conexiones:
```
mysql -uroot -p -e 'SHOW GLOBAL VARIABLES LIKE "max_connections";'
```
Deberías ver que el número máximo de conexiones es 250, eso significa que la configuración se ha aplicado correctamente:

+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 250   |
+-----------------+-------+

Gestionar el Almacenamiento de Datos

Por defecto, Docker almacena datos en su volumen interno. Nosotros preferimos almacenar los datos de MySQL en un directorio del host para evitar perderlos si el contenedor se elimina, falla o nos da algun error. Para ello primero tenemos que eliminar el contenedor docker_mysql que hemos creado anteriormente, ya que no tiene mapeado el volumen de datos, y lo ampliaremos con el mapeado del volumen de datos.

Vamos a crear sod volúmnes uno para almacenar los scripts SQL y otro para almacenar los datos de la base de datos. EL primero nos servirá para poder intercambiar scripts SQL entre el host y el contenedor, y el segundo para almacenar los datos de la base de datos.

sudo docker stop [nombre_contenedor]
sudo docker rm [nombre_contenedor]

Siendo el [nombre_contenedor] --> docker_mysql en nuestro caso.

Crea un directorio de datos en el host:
```
sudo mkdir -p ~/docker/[nombre_contendor]/storage/mysql-data
```
En nuestro caso:
```
sudo mkdir -p ~/docker/docker_mysql/storage/mysql-data
```
Permisos del directorio

Recuerda que este directorio debe tener los permisos adecuados para que el contenedor MySQL pueda escribir en él. Docker ejecuta los contenedores con un usuario específico, por lo que es importante asegurarse de que el usuario del contenedor tenga acceso al directorio creado.
```
sudo chmod -R 777 ~/docker/docker_mysql/storage/mysql-data
```
Si docker no tienen permisos para escribir en este directorio, puede que al iniciar el contenedor MySQL nos dé un error de permisos.

Inicia el contenedor nuevamente, montando el directorio creado:

docker run \
--detach \
--name=[nombre_contenedor] \
--env="MYSQL_ROOT_PASSWORD=mi_contraseña" \
--publish 3306:3306 \
--volume=/carpeta/de/usuario/docker/docker_mysql/storage/scripts:/scripts \
--volume=/carpeta/de/usuario/docker/docker_mysql/storage/mysql-data:/var/lib/mysql \
mysql

En nuestro caso, el comando sería:

docker run \
--detach \
--name=docker_mysql \
--env="MYSQL_ROOT_PASSWORD=administrador" \
--publish 3306:3306 \
--volume=/carpeta/de/usuario/docker/docker_mysql/storage/scripts:/scripts \
--volume=/carpeta/de/usuario/docker/docker_mysql/storage/mysql-data:/var/lib/mysql \
mysql

Verifica que el contenedor MySQL almacena sus datos en el sistema host:

Podemos utilizar inspect para ver la configuración del contenedor y verificar que los volúmenes están correctamente mapeados:

sudo docker inspect [nombre_contenedor]

También podemos acceder a la carpeta de datos mysql-data en el host para ver los archivos de la base de datos:

ls ~/docker/[nombre_contenedor]/storage/mysql-data

Inicio automático del contenedor

Si queremos que el contenedor se inicialice automáticamente al arrancar el sistema, podemos hacer dos cosas:

Vover crear el contenedor:

El modificador de docker --restart permite configurar el comportamiento del contenedor al reiniciar el sistema. Si queremos que el contenedor se inicie automáticamente, podemos usar la opción --restart=unless-stopped. Esto significa que el contenedor se reiniciará automáticamente a menos que se detenga manualmente.

Si tenemos el contendor creado debemos detenerlo y eliminarlo como hemos visto anteriormente, y luego volver a crearlo con el modificador --restart=unless-stopped.

Por tanto el comando completo teniendo en cuenta lo visto anteriormente sería:
```
    docker run \
    --detach \
    --name=docker_mysql \
    --env="MYSQL_ROOT_PASSWORD=administrador" \
    --publish 3306:3306 \
    --volume=/carpeta/de/usuario/docker/docker_mysql/storage/scripts:/scripts \
    --volume=/carpeta/de/usuario/docker/docker_mysql/storage/mysql-data:/var/lib/mysql \
    --restart=unless-stopped \
    -d mysql/mysql-server:latest
```
Modificar el contenedor:

Si el contenedor ya está creado, podemos modificarlo con el siguiente comando:
```
sudo docker update --restart=always [nombre_contenedor]
```
La opción --restart admite las siguientes opciones:
- no: No reiniciar el contenedor si se detiene.
- on-failure: Reiniciar el contenedor si se detiene con un código de error.
- always: Reiniciar el contenedor siempre que se detenga.
- unless-stopped: Reiniciar el contenedor siempre que se detenga, excepto si se detiene manualmente.
En nuestro caso recomendamos usar la opción unless-stopped.
```
sudo docker update --restart=unless-stopped mysql_docker
```

Iniciar, Detener y Reiniciar el Contenedor MySQL

Para iniciar el contenedor MySQL:

sudo docker start [nombre_contenedor]

Para detener el contenedor MySQL:

sudo docker stop [nombre_contenedor]

Para reiniciar el contenedor MySQL:

sudo docker restart [nombre_contenedor]

Eliminar el Contenedor MySQL

Antes de eliminar un contenedor MySQL, asegúrate de detenerlo primero.

Luego, elimina el contenedor docker con:

sudo docker rm [nombre_contenedor]

Instrucciones para Windows 11

Configuración de Docker, MySQL y Visual Studio Code en Windows 11

Prerequisitos

¿Debería utilizar Hyper-V o WSL?

La funcionalidad de Docker Desktop se mantiene constante tanto en WSL como en Hyper-V, sin preferencia por ninguna de las dos arquitecturas. Hyper-V y WSL tienen sus propias ventajas y desventajas, según su configuración específica y el caso de uso planificado.

Hay dos versiones de bakend para Docker Desktop en Windows: Hyper-V y WSL 2. La elección de uno u otro depende de tus necesidades, preferencis y versiones de Windows. Para Windows 11 Home, WSL 2 es la única opción disponible.

¿Como instalar WSL 2 en Windows 11?

wsl --install

Podemos instalar la imagen de Ubuntu en WSL 2:

wsl --install -d Ubuntu

Nos pedirá reiniciar el equipo para completar la instalación.

Una vez instalado WSL 2, podemos pasar a la instalación de Docker Desktop.

1. Instalar Docker Desktop

Descarga Docker Desktop desde su página oficial:
https://www.docker.com/products/docker-desktop
Ejecuta el instalador y sigue los pasos:
Acepta los términos de la licencia.
Habilita el uso de contenedores WSL 2 (opción recomendada durante la instalación).
Reinicia tu equipo si es necesario después de la instalación.
Verifica la instalación abriendo un terminal y ejecutando:
```
docker --version
```

2. Configurar arranque automático

Abre Docker Desktop.
Ve a Settings > General.
Activa la opción "Start Docker Desktop when you log in" para habilitar el arranque automático al iniciar Windows.

Seguir los pasos anteriores

Una vez que Docker Desktop esté instalado y configurado, puedes seguir los pasos anteriores para instalar y configurar MySQL en un contenedor Docker. Los comandos son prácticamente los mismos que en Linux, pero asegúrate de ejecutar el terminal de Docker Desktop o PowerShell con permisos de administrador.

Tutorial sobre Cómo Instalar Contenedores Docker de MySQL