---
title: "Cómo instalar MySQL en Docker"
slug: "how-to-install-mysql-on-docker"
published_at: "2022-10-22T17:57:36.000Z"
categories: "Tutoriales de MySQL, Tutoriales de SQL, Tutoriales de SQL para principiantes"
tags: "Docker, Docker Compose, imagen, instalar, MySQL"
---

# Cómo instalar MySQL en Docker

> MySQL es una de las bases de datos SQL más populares y quizás la más usada en la web. Hoy vamos a aprender a instalar MySQL en un contenedor de Docker.

MySQL es una de las bases de datos SQL más populares y quizás la más usada en la web. A veces, necesitamos crear un entorno de pruebas o quizás queremos crear nuestra página web en nuestro propio servidor en la nube. Una de las mejores formas de lograr esto es usando contenedores de [Docker](https://www.docker.com/). Hoy vamos a aprender a instalar el servidor de [MySQL](https://www.mysql.com/) en un contenedor de Docker.

![](/blog/creating-a-stored-procedure-in-mysql/image-30.png)

## Pre-requisitos

Si estás usando windows, deberías tener Docker y WSL instalados en la máquina donde vas a hacer la implementación.

Ya escribimos sobre esto [en un post anterior](/es/install-sql-server-in-docker-quick-guide). Te recomiendo leerlo e instalar tu entorno en la plataforma que quieras usar.

## Instalando la imagen de MySQL

Antes que nada, vamos a crear un archivo llamado _**deploy_mysql.yml**_.

El archivo debería estar ubicado en su propia carpeta y contener el siguiente código:

```sql
version: '3.8'
services:
  db:
    image: mysql:8.0
    cap_add:
      - SYS_NICE
    restart: always
    environment:
      - MYSQL_DATABASE=main_database
      - MYSQL_ROOT_PASSWORD=[YOUR PASSWORD]
    ports:
      - '3306:3306'
    volumes:
      - db:/var/lib/mysql
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
    container_name: mysql-server
  adminer:
    image: adminer
    restart: always
    ports:
      - 8080:8080
volumes:
  db:
    driver: local
```

### Entendiendo nuestro archivo docker-compose

Analicemos línea por línea lo que estamos haciendo acá (las tabulaciones son muy importantes para Docker-Compose):

#### Versionado de docker-compose

**version: ‘3.8’**: antes que nada estamos declarando la [versión del archivo docker-compose](https://docs.docker.com/compose/compose-file/compose-versioning/) que vamos a usar.

#### Servicios de docker-compose

-   **services**: estamos declarando qué servicios va a tener el contenedor

-   **db**: nuestro contenedor va a contener una base de datos
-   **image**: la imagen que vamos a usar para nuestra base de datos

-   **cap_add**: vamos a agregar las siguientes capacidades al contenedor
-   **SYS_NICE**: le otorga al contenedor la capacidad `CAP_SYS_NICE`, que le permite subir los valores `nice` de los procesos, establecer políticas de scheduling en tiempo real, definir afinidad de CPU, y otras operaciones.
-   **restart: always**: va a reiniciar nuestra base de datos y contenedor cada vez que ejecutemos el Docker Compose.
-   **environment:** de acá en más, vamos a declarar variables predefinidas para nuestro entorno de MySQL.
-   **– MYSQL_DATABASE=main_database**: estamos declarando que nuestro contenedor va a tener al inicio una base de datos llamada main_database
-   **– MYSQL_ROOT_PASSWORD=[YOUR PASSWORD]**: declaramos nuestra contraseña de root.
-   **ports:** ¿cuáles van a ser los puertos que va a usar nuestra base de datos?
-   **– ‘3306:3306’**: acá definimos que nuestra base de datos va a estar externamente (primer valor del puerto) en el 3306 e internamente en el 3306. Si querés cambiar el puerto de escucha de tu implementación, podrías usar, por ejemplo, **3307:3306** y tu base de datos va a escuchar en el puerto 3307.
-   **volumes**: dónde se va a guardar nuestra base de datos
-   **– db:/var/lib/mysql**: dónde va a estar el almacenamiento de nuestra base de datos dentro de nuestro contenedor.
-   **– ./db/init.sql:/docker-entrypoint-initdb.d/init.sql**: esto va a crear una subcarpeta y un archivo /db/init.sql en nuestra carpeta (fuera del entorno) que va a estar en la raíz de nuestro contenedor (podemos modificar este archivo y se va a modificar en nuestro contenedor)
-   **container_name: mysql-server**: el nombre que le vamos a poner al contenedor.
-   **adminer:** consola de administración para nuestra base de datos
-   **image: adminer:** va a usar la imagen llamada adminer
-   **restart: always**: como dijimos antes, va a reiniciar nuestra implementación cada vez que ejecutemos el Docker Compose, en este caso para el adminer.
-   **ports:** puertos donde va a escuchar el adminer
-   **– 8080:8080**: lo mismo que 3306:3306 pero para adminer ahora

#### Volúmenes de docker-compose

-   **volumes:** volumen donde se va a guardar la información. Para más información sobre esto, acá tenés algo de [documentación.](https://docs.docker.com/storage/volumes/)
-   **db:** volumen para la db
-   **driver: local**: esto significa “dentro del contenedor”

## Iniciando nuestro contenedor con Docker-Compose

¡Y eso es todo! Ya estamos listos para correr nuestro contenedor de docker con docker-compose.

Solo abrí tu consola favorita, navegá hasta la carpeta donde está guardado el YML y ejecutá:

```sql
docker-compose -f deploy_mysql.yml -d up
```

Esto va a ejecutar nuestro archivo en docker-compose y -d significa que va a estar en modo detach (va a correr en segundo plano)

**¡Ya tenés tu contenedor de docker levantado y funcionando!**

**Esta implementación es una instancia lista para usar en docker, sin embargo, hay otras formas de instalar nuestro MySQL en Docker.**

## Otras formas de instalar nuestro contenedor

Empecemos creando una red bridged

```sql
docker network create my-network-1
```

Ahora descarguemos la imagen

```bash
docker pull mysql/mysql-server:latest
```

Ahora vamos a correr nuestro contenedor con esta imagen descargada

```bash
docker run --network my-network-1 --publish 3306:3306 --name=mysql-server -d mysql/mysql-server:latest 
```

Una vez que la imagen está lista, podemos ver los logs, y necesitamos encontrar esta línea:

```sql
docker logs mysql-server
GENERATED ROOT PASSWORD: Axegh3kAJyDLa1NRuBemecis&EShOs1sabr
```

### Conectándonos a nuestra instancia

Ahora vamos a conectarnos a nuestra instancia y cambiar la contraseña de root

```bash
docker exec -it mysql-server mysql -uroot -p
# Esto te va a pedir la contraseña que obtuviste del archivo de log.
mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY '[YOUR_NEW_PASSWORD]';
```

**¡Y listo! ¡Ya podés conectarte a tu nueva instancia de docker!**

## Actualizando tu instancia de docker de MySQL

Si necesitás actualizar tu instancia de docker de SQL tenés que ejecutar este pequeño comando (con el contenedor de docker corriendo).

```bash
docker exec -it mysql-server mysql_upgrade -uroot -p
```

Después de hacer esto deberías reiniciar tu contenedor

```sql
docker restart mysql-server
```

## Iniciando y deteniendo la instancia de docker de MySQL

Para iniciar tu instancia de docker de MySQL:

```sql
docker start mysql-server
```

Para detener tu instancia de docker de MySQL:

```sql
docker stop mysql-server
```

## Eliminando tu instancia de docker

Podés eliminar tu instancia desde la interfaz de Docker Desktop después de detenerla, o con el siguiente comando

```sql
docker rm mysql-server
```

## Conclusión

Instalar una instancia de MySQL para entornos de desarrollo o servidores dockerizados es una forma hermosa de tener tus datos organizados sin necesidad de instalar una VM que va a requerir más recursos y te va a traer más problemas.

Si necesitás hacer troubleshooting, acá tenés algunos [docs de MySQL](https://dev.mysql.com/doc/mysql-installation-excerpt/8.0/en/linux-installation-docker.html) que te van a ayudar.

¡Nos vemos en el próximo!

