# Usar bases de datos contenedorizadas El uso de una base de datos local contenedorizada ofrece flexibilidad y facilidad de configuración, lo que te permite reflejar fielmente los entornos de producción sin la sobrecarga de las instalaciones de bases de datos tradicionales. Docker simplifica este proceso, permitiéndote desplegar, gestionar y escalar bases de datos en contenedores aislados con solo unos pocos comandos. En esta guía, aprenderás a: - Ejecutar una base de datos local contenedorizada - Acceder a la shell de una base de datos contenedorizada - Conectarte a una base de datos contenedorizada desde tu host - Conectarte a una base de datos contenedorizada desde otro contenedor - Persistir los datos de la base de datos en un volumen - Compilar una imagen de base de datos personalizada - Usar Docker Compose para ejecutar una base de datos Esta guía utiliza la imagen de MySQL para los ejemplos, pero los conceptos se pueden aplicar a otras imágenes de bases de datos. ## Prerrequisitos Para seguir esta guía, debes tener Docker instalado. Para instalar Docker, consulta [Obtener Docker](/get-started/get-docker/). ## Ejecutar una base de datos local contenedorizada La mayoría de los sistemas de bases de datos más populares, incluidos MySQL, PostgreSQL y MongoDB, tienen una imagen oficial de Docker disponible en Docker Hub. Estas imágenes son un conjunto curado de imágenes que siguen las mejores prácticas, lo que garantiza que tengas acceso a las últimas funciones y actualizaciones de seguridad. Para comenzar, visita [Docker Hub](https://hub.docker.com) y busca la base de datos que te interese. La página de cada imagen proporciona instrucciones detalladas sobre cómo ejecutar el contenedor, personalizar tu configuración y configurar la base de datos según tus necesidades. Para obtener más información sobre la imagen de MySQL utilizada en esta guía, consulta la página de la [imagen de MySQL](https://hub.docker.com/_/mysql) en Docker Hub. Para ejecutar un contenedor de base de datos, puedes usar la interfaz gráfica (GUI) de Docker Desktop o la interfaz de línea de comandos (CLI). **CLI** Para ejecutar un contenedor usando la CLI, ejecuta el siguiente comando en una terminal: ```console $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb -d mysql:latest ``` En este comando: - `--name my-mysql` asigna el nombre `my-mysql` a tu contenedor para facilitar la referencia. - `-e MYSQL_ROOT_PASSWORD=my-secret-pw` establece la contraseña raíz (root) de MySQL en `my-secret-pw`. Reemplaza `my-secret-pw` con una contraseña segura de tu elección. - `-e MYSQL_DATABASE=mydb` crea opcionalmente una base de datos llamada `mydb`. Puedes cambiar `mydb` por el nombre de base de datos que desees. - `-d` ejecuta el contenedor en modo detached (segundo plano). - `mysql:latest` especifica que deseas utilizar la última versión de la imagen de MySQL. Para verificar que tu contenedor se está ejecutando, ejecuta `docker ps` en una terminal. **GUI** Para ejecutar un contenedor usando la interfaz gráfica (GUI): 1. En el Panel de control (Dashboard) de Docker Desktop, selecciona la búsqueda global en la parte superior de la ventana. 2. Escribe `mysql` en el cuadro de búsqueda y selecciona la pestaña **Images** si no está seleccionada. 3. Pasa el cursor sobre la imagen `mysql` y selecciona **Run**. Aparecerá el cuadro de diálogo **Run a new container**. 4. Despliega **Optional settings**. 5. En la configuración opcional, especifica lo siguiente: - **Container name**: `my-mysql` - **Environment variables**: - `MYSQL_ROOT_PASSWORD`:`my-secret-pw` - `MYSQL_DATABASE`:`mydb` ![The optional settings screen with the options specified.](/guides/databases/images/databases-1.webp) 6. Selecciona **Run**. 7. Abre la vista **Containers** en el Dashboard de Docker Desktop para verificar que tu contenedor se esté ejecutando. ## Acceder a la shell de una base de datos contenedorizada Cuando tienes una base de datos ejecutándose dentro de un contenedor Docker, es posible que necesites acceder a su shell para gestionar la base de datos, ejecutar comandos o realizar tareas administrativas. Docker proporciona una forma sencilla de hacer esto usando el comando `docker exec`. Además, si prefieres una interfaz gráfica, puedes usar la interfaz de Docker Desktop. Si aún no tienes un contenedor de base de datos ejecutándose, consulta [Ejecutar una base de datos local contenedorizada](#run-a-local-containerized-database). **CLI** Para acceder a la terminal de un contenedor MySQL usando la CLI, puedes usar el siguiente comando `docker exec`: ```console $ docker exec -it my-mysql bash ``` En este comando: - `docker exec` le indica a Docker que deseas ejecutar un comando en un contenedor en ejecución. - `-it` asegura que la terminal a la que accedes sea interactiva, de modo que puedas escribir comandos en ella. - `my-mysql` es el nombre de tu contenedor MySQL. Si le diste un nombre diferente cuando lo ejecutaste, usa ese nombre en su lugar. - `bash` es el comando que deseas ejecutar dentro del contenedor. Abre una shell de bash que te permite interactuar con el sistema de archivos del contenedor y las aplicaciones instaladas. Después de ejecutar este comando, tendrás acceso a la shell de bash dentro de tu contenedor MySQL, desde la cual podrás administrar tu servidor MySQL directamente. Puedes ejecutar `exit` para regresar a tu terminal. **GUI** 1. Abre el Dashboard de Docker Desktop y selecciona la vista **Containers**. 2. En la columna **Actions** de tu contenedor, selecciona **Show container actions** y luego **Open in terminal**. En esta terminal puedes acceder a la shell dentro de tu contenedor MySQL, desde la cual podrás administrar tu servidor MySQL directamente. Una vez que hayas accedido a la terminal del contenedor, puedes ejecutar cualquier herramienta disponible en ese contenedor. El siguiente ejemplo muestra el uso de `mysql` en el contenedor para listar las bases de datos. ```console # mysql -u root -p Enter password: my-secret-pw mysql> SHOW DATABASES; +--------------------+ | Database | +--------------------+ | information_schema | | mydb | | mysql | | performance_schema | | sys | +--------------------+ 5 rows in set (0.00 sec) ``` ## Conectarse a una base de datos contenedorizada desde tu host Conectarse a una base de datos contenedorizada desde tu máquina host implica mapear un puerto dentro del contenedor a un puerto en tu máquina host. Este proceso garantiza que la base de datos dentro del contenedor sea accesible a través de la red de la máquina host. Para MySQL, el puerto por defecto es el 3306. Al exponer este puerto, puedes utilizar varias herramientas o aplicaciones de gestión de bases de datos en tu máquina host para interactuar con tu base de datos MySQL. Antes de comenzar, debes eliminar cualquier contenedor que hayas ejecutado previamente para esta guía. Para detener y eliminar un contenedor, puedes hacer lo siguiente: - En una terminal, ejecuta `docker rm --force my-mysql` para eliminar el contenedor llamado `my-mysql`. - O, en el Dashboard de Docker Desktop, selecciona el icono **Delete** junto a tu contenedor en la vista **Containers**. A continuación, puedes utilizar la interfaz gráfica (GUI) de Docker Desktop o la CLI para ejecutar el contenedor con el puerto mapeado. **CLI** Ejecuta el siguiente comando en una terminal. ```console $ docker run -p 3307:3306 --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb -d mysql:latest ``` En este comando, `-p 3307:3306` mapea el puerto 3307 del host al puerto 3306 del contenedor. Para verificar que el puerto esté mapeado, ejecuta el siguiente comando. ```console $ docker ps ``` Deberías ver una salida como la siguiente. ```console CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 6eb776cfd73c mysql:latest "docker-entrypoint.s…" 17 minutes ago Up 17 minutes 33060/tcp, 0.0.0.0:3307->3306/tcp my-mysql ``` **GUI** Para ejecutar un contenedor usando la GUI: 1. En el Dashboard de Docker Desktop, selecciona la búsqueda global en la parte superior de la ventana. 2. Escribe `mysql` en el cuadro de búsqueda y selecciona la pestaña **Images** si no está seleccionada. 3. Pasa el cursor sobre la imagen `mysql` y selecciona **Run**. Aparecerá el cuadro de diálogo **Run a new container**. 4. Despliega **Optional settings**. 5. En la configuración opcional, especifica lo siguiente: - **Container name**: `my-mysql` - **Host port** para el puerto **3306/tcp**: `3307` - **Environment variables**: - `MYSQL_ROOT_PASSWORD`:`my-secret-pw` - `MYSQL_DATABASE`:`mydb` ![The optional settings screen with the options specified.](/guides/databases/images/databases-2.webp) 6. Selecciona **Run**. 7. En la vista **Containers**, verifica que el puerto esté mapeado en la columna **Port(s)**. Deberías ver **3307:3306** para el contenedor **my-mysql**. En este punto, cualquier aplicación que se ejecute en tu host puede acceder al servicio MySQL en el contenedor en `localhost:3307`. ## Conectarse a una base de datos contenedorizada desde otro contenedor Conectarse a una base de datos contenedorizada desde otro contenedor es un escenario común en arquitecturas de microservicios y durante los procesos de desarrollo. Las capacidades de red de Docker facilitan el establecimiento de esta conexión sin tener que exponer la base de datos a la red del host. Esto se logra colocando tanto el contenedor de la base de datos como el contenedor que necesita acceder a ella en la misma red de Docker. Antes de comenzar, debes eliminar cualquier contenedor que hayas ejecutado previamente para esta guía. Para detener y eliminar un contenedor, puedes hacer lo siguiente: - En una terminal, ejecuta `docker rm --force my-mysql` para eliminar el contenedor llamado `my-mysql`. - O, en el Dashboard de Docker Desktop, selecciona el icono **Delete** junto a tu contenedor en la vista **Containers**. Para crear una red y ejecutar contenedores en ella: 1. Ejecuta el siguiente comando para crear una red de Docker llamada `my-network`. ```console $ docker network create my-network ``` 2. Ejecuta tu contenedor de base de datos y especifica la red usando la opción `--network`. Esto ejecuta el contenedor en la red `my-network`. ```console $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb --network my-network -d mysql:latest ``` 3. Ejecuta tus otros contenedores y especifica la red usando la opción `--network`. Para este ejemplo, ejecutarás un contenedor phpMyAdmin que puede conectarse a tu base de datos. 1. Ejecuta un contenedor phpMyAdmin. Utiliza la opción `--network` para especificar la red, la opción `-p` para permitirte acceder al contenedor desde tu máquina host, y la opción `-e` para especificar una variable de entorno requerida para esta imagen. ```console $ docker run --name my-phpmyadmin -d --network my-network -p 8080:80 -e PMA_HOST=my-mysql phpmyadmin ``` 4. Verifica que los contenedores se puedan comunicar. Para este ejemplo, accederás a phpMyAdmin y verificarás que se conecta a la base de datos. 1. Abre [http://localhost:8080](http://localhost:8080) para acceder a tu contenedor de phpMyAdmin. 2. Inicia sesión usando `root` como usuario y `my-secret-pw` como contraseña. Deberías conectarte al servidor MySQL y ver tu base de datos listada. En este punto, cualquier aplicación que se ejecute en tu red de contenedores `my-network` puede acceder al servicio MySQL en el contenedor en `my-mysql:3306`. ## Persistir los datos de la base de datos en un volumen Persistir los datos de la base de datos en un volumen de Docker es necesario para garantizar que tus datos sobrevivan a los reinicios y eliminaciones de los contenedores. Un volumen de Docker te permite almacenar archivos de base de datos fuera de la capa escribible del contenedor, lo que hace posible actualizar el contenedor, cambiar de base y compartir datos sin perderlos. A continuación, se muestra cómo puedes adjuntar un volumen a tu contenedor de base de datos utilizando la CLI de Docker o la interfaz gráfica de Docker Desktop. Antes de comenzar, debes eliminar cualquier contenedor que hayas ejecutado previamente para esta guía. Para detener y eliminar un contenedor, puedes hacer lo siguiente: - En una terminal, ejecuta `docker rm --force my-mysql` para eliminar el contenedor llamado `my-mysql`. - O, en el Dashboard de Docker Desktop, selecciona el icono **Delete** junto a tu contenedor en la vista **Containers**. A continuación, puedes utilizar la interfaz gráfica (GUI) de Docker Desktop o la CLI para ejecutar el contenedor con un volumen. **CLI** Para ejecutar tu contenedor de base de datos con un volumen adjunto, incluye la opción `-v` con tu comando `docker run`, especificando un nombre de volumen y la ruta donde la base de datos almacena sus datos dentro del contenedor. Si el volumen no existe, Docker lo creará automáticamente por ti. Para ejecutar un contenedor de base de datos con un volumen adjunto y luego verificar que los datos persisten: 1. Ejecuta el contenedor y adjunta el volumen. ```console $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -e MYSQL_DATABASE=mydb -v my-db-volume:/var/lib/mysql -d mysql:latest ``` Este comando monta el volumen llamado `my-db-volume` en el directorio `/var/lib/mysql` dentro del contenedor. 2. Crea algunos datos en la base de datos. Utiliza el comando `docker exec` para ejecutar `mysql` dentro del contenedor y crear una tabla. ```console $ docker exec my-mysql mysql -u root -pmy-secret-pw -e "CREATE TABLE IF NOT EXISTS mydb.mytable (column_name VARCHAR(255)); INSERT INTO mydb.mytable (column_name) VALUES ('value');" ``` Este comando utiliza la herramienta `mysql` en el contenedor para crear una tabla llamada `mytable` con una columna llamada `column_name`, y finalmente inserta el valor `'value'`. 3. Detén y elimina el contenedor. Sin un volumen, la tabla que creaste se perdería al eliminar el contenedor. ```console $ docker rm --force my-mysql ``` 4. Inicia un nuevo contenedor con el volumen adjunto. Esta vez, no necesitas especificar ninguna variable de entorno ya que la configuración se guarda en el volumen. ```console $ docker run --name my-mysql -v my-db-volume:/var/lib/mysql -d mysql:latest ``` 5. Verifica que la tabla que creaste todavía exista. Usa el comando `docker exec` nuevamente para ejecutar `mysql` dentro del contenedor. ```console $ docker exec my-mysql mysql -u root -pmy-secret-pw -e "SELECT * FROM mydb.mytable;" ``` Este comando utiliza la herramienta `mysql` en el contenedor para seleccionar todos los registros de la tabla `mytable`. Deberías ver una salida como la siguiente. ```console column_name value ``` **GUI** Para ejecutar un contenedor de base de datos con un volumen adjunto y luego verificar que los datos persisten usando la GUI: 1. Ejecuta un contenedor con un volumen adjunto. 1. En el Dashboard de Docker Desktop, selecciona la búsqueda global en la parte superior de la ventana. 2. Escribe `mysql` en el cuadro de búsqueda y selecciona la pestaña **Images** si no está seleccionada. 3. Pasa el cursor sobre la imagen **mysql** y selecciona **Run**. Aparecerá el cuadro de diálogo **Run a new container**. 4. Despliega **Optional settings**. 5. En la configuración opcional, especifica lo siguiente: - **Container name**: `my-mysql` - **Environment variables**: - `MYSQL_ROOT_PASSWORD`:`my-secret-pw` - `MYSQL_DATABASE`:`mydb` - **Volumes**: - `my-db-volume`:`/var/lib/mysql` ![The optional settings screen with the options specified.](/guides/databases/images/databases-3.webp) Aquí, el nombre del volumen es `my-db-volume` y está montado en el contenedor en `/var/lib/mysql`. 6. Selecciona **Run**. 2. Crea algunos datos en la base de datos. 1. En la vista **Containers**, junto a tu contenedor selecciona el icono **Show container actions** y luego selecciona **Open in terminal**. 2. Ejecuta el siguiente comando en la terminal del contenedor para agregar una tabla. ```console # mysql -u root -pmy-secret-pw -e "CREATE TABLE IF NOT EXISTS mydb.mytable (column_name VARCHAR(255)); INSERT INTO mydb.mytable (column_name) VALUES ('value');" ``` Este comando utiliza la herramienta `mysql` en el contenedor para crear una tabla llamada `mytable` con una columna llamada `column_name`, y finalmente inserta el valor `'value'`. 3. En la vista **Containers**, selecciona el icono **Delete** junto a tu contenedor y luego selecciona **Delete forever**. Sin un volumen, la tabla que creaste se perdería al eliminar el contenedor. 4. Ejecuta un contenedor con un volumen adjunto. 1. En el Dashboard de Docker Desktop, selecciona la búsqueda global en la parte superior de la ventana. 2. Escribe `mysql` en el cuadro de búsqueda y selecciona la pestaña **Images** si no está seleccionada. 3. Pasa el cursor sobre la imagen **mysql** y selecciona **Run**. Aparecerá el cuadro de diálogo **Run a new container**. 4. Despliega **Optional settings**. 5. En la configuración opcional, especifica lo siguiente: - **Container name**: `my-mysql` - **Environment variables**: - `MYSQL_ROOT_PASSWORD`:`my-secret-pw` - `MYSQL_DATABASE`:`mydb` - **Volumes**: - `my-db-volume`:`/var/lib/mysql` ![The optional settings screen with the options specified.](/guides/databases/images/databases-3.webp) 6. Selecciona **Run**. 5. Verifica que la tabla que creaste todavía exista. 1. En la vista **Containers**, junto a tu contenedor selecciona el icono **Show container actions** y luego selecciona **Open in terminal**. 2. Ejecuta el siguiente comando en la terminal del contenedor para verificar que la tabla que creaste todavía existe. ```console # mysql -u root -pmy-secret-pw -e "SELECT * FROM mydb.mytable;" ``` Este comando utiliza la herramienta `mysql` en el contenedor para seleccionar todos los registros de la tabla `mytable`. Deberías ver una salida como la siguiente. ```console column_name value ``` En este punto, cualquier contenedor MySQL que monte el volumen `my-db-volume` podrá acceder y guardar datos persistentes. ## Compilar una imagen de base de datos personalizada Personalizar tu imagen de base de datos te permite incluir configuración adicional, scripts o herramientas junto con el servidor de base de datos base. Esto es particularmente útil para crear una imagen de Docker que coincida con las necesidades específicas de tu entorno de desarrollo o producción. El siguiente ejemplo describe cómo compilar y ejecutar una imagen de MySQL personalizada que incluye un script de inicialización de tablas. Antes de comenzar, debes eliminar cualquier contenedor que hayas ejecutado previamente para esta guía. Para detener y eliminar un contenedor, puedes hacer lo siguiente: - En una terminal, ejecuta `docker rm --force my-mysql` para eliminar el contenedor llamado `my-mysql`. - O, en el Dashboard de Docker Desktop, selecciona el icono **Delete** junto a tu contenedor en la vista **Containers**. Para compilar y ejecutar tu imagen personalizada: 1. Crea un Dockerfile. 1. Crea un archivo llamado `Dockerfile` en el directorio de tu proyecto. Para este ejemplo, puedes crear el `Dockerfile` en un directorio vacío de tu elección. Este archivo definirá cómo compilar tu imagen MySQL personalizada. 2. Añade el siguiente contenido al `Dockerfile`. ```dockerfile # syntax=docker/dockerfile:1 # Use the base image mysql:latest FROM mysql:latest # Set environment variables ENV MYSQL_DATABASE mydb # Copy custom scripts or configuration files from your host to the container COPY ./scripts/ /docker-entrypoint-initdb.d/ ``` En este Dockerfile, has establecido la variable de entorno para el nombre de la base de datos MySQL. También puedes usar la instrucción `COPY` para agregar archivos de configuración o scripts personalizados al contenedor. En este ejemplo, los archivos del directorio `./scripts/` de tu host se copian en el directorio `/docker-entrypoint-initdb.d/` del contenedor. En este directorio, los scripts `.sh`, `.sql` y `.sql.gz` se ejecutan cuando el contenedor se inicia por primera vez. Para obtener más detalles sobre los Dockerfiles, consulta la [Referencia de Dockerfile](/reference/dockerfile/). 3. Crea un archivo de script para inicializar una tabla en la base de datos. En el directorio donde se encuentra tu `Dockerfile`, crea un subdirectorio llamado `scripts` y luego crea un archivo llamado `create_table.sql` con el siguiente contenido. ```text CREATE TABLE IF NOT EXISTS mydb.myothertable ( column_name VARCHAR(255) ); INSERT INTO mydb.myothertable (column_name) VALUES ('other_value'); ``` Ahora deberías tener la siguiente estructura de directorios. ```text ├── your-project-directory/ │ ├── scripts/ │ │ └── create_table.sql │ └── Dockerfile ``` 2. Compila tu imagen. 1. En una terminal, cambia de directorio al directorio donde se encuentra tu `Dockerfile`. 2. Ejecuta el siguiente comando para compilar la imagen. ```console $ docker build -t my-custom-mysql . ``` En este comando, `-t my-custom-mysql` etiqueta (nombra) tu nueva imagen como `my-custom-mysql`. El punto (.) al final del comando especifica el directorio actual como el contexto para la compilación, donde Docker busca el Dockerfile y cualquier otro archivo necesario para la compilación. 3. Ejecuta tu imagen como lo hiciste en [Ejecutar una base de datos local contenedorizada](#run-a-local-containerized-database). Esta vez, especifica el nombre de tu imagen en lugar de `mysql:latest`. Además, ya no necesitas especificar la variable de entorno `MYSQL_DATABASE`, ya que ahora está definida por tu Dockerfile. ```console $ docker run --name my-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d my-custom-mysql ``` 4. Verifica que tu contenedor se esté ejecutando con el siguiente comando. ```console $ docker ps ``` Deberías ver una salida como la siguiente. ```console CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES f74dcfdb0e59 my-custom-mysql "docker-entrypoint.s…" 2 hours ago Up 51 minutes 3306/tcp, 33060/tcp my-mysql ``` 5. Verifica que se haya ejecutado tu script de inicialización. Ejecuta el siguiente comando en una terminal para mostrar el contenido de la tabla `myothertable`. ```console $ docker exec my-mysql mysql -u root -pmy-secret-pw -e "SELECT * FROM mydb.myothertable;" ``` Deberías ver una salida como la siguiente. ```console column_name other_value ``` Cualquier contenedor que se ejecute utilizando tu imagen `my-custom-mysql` tendrá la tabla inicializada cuando se inicie por primera vez. ## Usar Docker Compose para ejecutar una base de datos Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker de múltiples contenedores. Con un solo comando, puedes configurar todos los servicios de tu aplicación (como bases de datos, aplicaciones web, etc.) y administrarlos. En este ejemplo, crearás un archivo Compose y lo utilizarás para ejecutar un contenedor de base de datos MySQL y un contenedor phpMyAdmin. Para ejecutar tus contenedores con Docker Compose: 1. Crea un archivo de Docker Compose. 1. Crea un archivo llamado `compose.yaml` en el directorio de tu proyecto. Este archivo definirá los servicios, redes y volúmenes. 2. Añade el siguiente contenido al archivo `compose.yaml`. ```yaml services: db: image: mysql:latest environment: MYSQL_ROOT_PASSWORD: my-secret-pw MYSQL_DATABASE: mydb ports: - 3307:3306 volumes: - my-db-volume:/var/lib/mysql phpmyadmin: image: phpmyadmin/phpmyadmin:latest environment: PMA_HOST: db PMA_PORT: 3306 MYSQL_ROOT_PASSWORD: my-secret-pw ports: - 8080:80 depends_on: - db volumes: my-db-volume: ``` Para el servicio de base de datos: - `db` es el nombre del servicio. - `image: mysql:latest` especifica que el servicio utiliza la última imagen de MySQL de Docker Hub. - `environment` enumera las variables de entorno utilizadas por MySQL para inicializar la base de datos, como la contraseña raíz y el nombre de la base de datos. - `ports` mapea el puerto 3307 del host al puerto 3306 del contenedor, lo que te permite conectarte a la base de datos desde tu máquina host. - `volumes` monta `my-db-volume` en `/var/lib/mysql` dentro del contenedor para persistir los datos de la base de datos. Además del servicio de base de datos, hay un servicio phpMyAdmin. Por defecto, Compose configura una única red para tu aplicación. Cada contenedor de un servicio se une a la red predeterminada y es accesible por otros contenedores en esa red, además de ser reconocible por el nombre del servicio. Por lo tanto, en la variable de entorno `PMA_HOST`, puedes especificar el nombre del servicio, `db`, para conectarte al servicio de base de datos. Para obtener más detalles sobre Compose, consulta la [Referencia del archivo Compose](/reference/compose-file/). 2. Ejecuta Docker Compose. 1. Abre una terminal y cambia de directorio al directorio donde se encuentra tu archivo `compose.yaml`. 2. Ejecuta Docker Compose usando el siguiente comando. ```console $ docker compose up ``` Ahora puedes acceder a phpMyAdmin en [http://localhost:8080](http://localhost:8080) y conectarte a tu base de datos usando `root` como usuario y `my-secret-pw` como contraseña. 3. Para detener los contenedores, presiona `Ctrl`+`C` en la terminal. Ahora, con Docker Compose puedes iniciar tu base de datos y tu aplicación, montar volúmenes, configurar redes y más, todo con un solo comando. ## Resumen Esta guía te introdujo a los aspectos esenciales del uso de bases de datos contenedorizadas, centrándose específicamente en MySQL, para mejorar la flexibilidad, la facilidad de configuración y la consistencia en tus entornos de desarrollo. Los casos de uso cubiertos en esta guía no solo simplifican tus flujos de trabajo de desarrollo, sino que también te preparan para escenarios más avanzados de administración y despliegue de bases de datos, garantizando que tus aplicaciones basadas en datos sigan siendo robustas y escalables. Información relacionada: - [Imágenes de bases de datos de Docker Hub](https://hub.docker.com/search?q=database&type=image) - [Referencia de Dockerfile](/reference/dockerfile/) - [Referencia del archivo Compose](/reference/compose-file/) - [Referencia de la CLI](/reference/cli/docker/) - [Muestras de bases de datos](/../reference/samples/#databases)