Bases de Datos en Contenedores: Cómo levantar PostgreSQL y MySQL con Docker en 5 minutos

Si estás empezando un proyecto nuevo o necesitás probar una funcionalidad sin ensuciar tu sistema operativo instalando motores de bases de datos pesados, Docker es tu mejor amigo. Ya no hace falta pasar horas configurando variables de entorno o peleando con los permisos de instalación de Windows o macOS. Con un solo comando, tenés una instancia aislada, lista para usar y, lo más importante, fácil de borrar si algo sale mal.

En este artículo te voy a mostrar paso a paso cómo levantar contenedores de PostgreSQL y MySQL, cómo conectarte a ellos desde tu máquina host y cómo realizar las primeras operaciones básicas para que confirmes que todo está funcionando correctamente. Este tutorial está pensado para desarrolladores que quieren agilizar su flujo de trabajo local.

¿Por qué usar contenedores para bases de datos?

Antes de ir al código, repasemos por qué deberías hacer esto en lugar de instalar el software directamente:

1. Aislamiento: Podés tener una versión 13 de Postgres para un proyecto viejo y una versión 16 para uno nuevo en la misma máquina sin que choquen.
2. Portabilidad: El archivo de configuración que uses hoy es el mismo que usará tu compañero de equipo o el servidor de CI/CD.
3. Limpieza: Cuando terminás el proyecto, borrás el contenedor y la imagen, y tu sistema queda como si nada hubiera pasado.

Parte 1: Levantando PostgreSQL con Docker

PostgreSQL es una de las bases de datos relacionales más robustas y queridas en la industria. Vamos a levantar una instancia rápida.

1. El comando de arranque

Abrí tu terminal y ejecutá el siguiente comando. Prestá atención a las variables de entorno, ya que son fundamentales para el acceso:

docker run --name mi-postgres -e POSTGRES_PASSWORD=mi_password_segura -p 5432:5432 -d postgres

Desglose del comando:

• --name mi-postgres: Le ponemos un nombre al contenedor para no tener que usar el ID aleatorio que asigna Docker.
• -e POSTGRES_PASSWORD=mi_password_segura: Definimos la contraseña del superusuario postgres mediante una variable de entorno.
• -p 5432:5432: Mapeamos el puerto 5432 del contenedor al puerto 5432 de tu máquina host. Esto es lo que te permite conectarte desde afuera.
• -d postgres: Corremos el contenedor en modo detached (en segundo plano) usando la imagen oficial de Postgres.

2. Verificando que el contenedor está vivo

Ejecutá docker ps y deberías ver algo así:

CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                    NAMES
a1b2c3d4e5f6   postgres  "docker-entrypoint.s…"   10 seconds ago   Up 8 seconds   0.0.0.0:5432->5432/tcp   mi-postgres

3. Conectándose y creando una tabla

Tenés dos opciones: usar un cliente gráfico (como pgAdmin o DBeaver) o entrar directo por consola. Vamos con la consola para que veas el proceso real.

Primero, entramos al contenedor y ejecutamos psql:

docker exec -it mi-postgres psql -U postgres

Una vez adentro del prompt de PostgreSQL (postgres=#), vamos a crear una base de datos, una tabla y cargar un dato:

-- Crear la base de datos
CREATE DATABASE tienda_db;
\c tienda_db;

-- Crear una tabla de productos
CREATE TABLE productos (
    id SERIAL PRIMARY KEY,
    nombre VARCHAR(100) NOT NULL,
    precio DECIMAL(10, 2) NOT NULL,
    stock INTEGER DEFAULT 0
);

-- Insertar un registro de prueba
INSERT INTO productos (nombre, precio, stock) 
VALUES ('Teclado Mecánico', 8500.50, 15);

-- Consultar los datos
SELECT * FROM productos;

Salida esperada:

 id |      nombre       | precio | stock 
----+-------------------+--------+-------
   1 | Teclado Mecánico | 8500.50|    15 
(1 row)

Parte 2: Levantando MySQL con Docker

Si tu stack es más orientado a PHP o preferís MySQL/MariaDB, el proceso es muy similar pero cambian las variables de entorno.

1. El comando de arranque

Ejecutá esto en tu terminal:

docker run --name mi-mysql -e MYSQL_ROOT_PASSWORD=root_password -e MYSQL_DATABASE=app_db -p 3306:3306 -d mysql:latest

Diferencias clave aquí:

• -e MYSQL_ROOT_PASSWORD: Es obligatoria para el usuario root.
• -e MYSQL_DATABASE=app_db: A diferencia de Postgres, MySQL te permite crear una base de datos automáticamente al iniciar el contenedor.

2. Verificando la ejecución

Nuevamente, chequeamos con docker ps:

CONTAINER ID   IMAGE    COMMAND                  CREATED         STATUS         PORTS                    NAMES
z9y8x7w6v5u4   mysql    "docker-entrypoint.s…"   20 seconds ago   Up 15 seconds   0.0.0.0:3306->3306/tcp   mi-mysql

3. Conectándose y creando una tabla

Entramos al shell de MySQL dentro del contenedor:

docker exec -it mi-mysql mysql -u root -p

(El sistema te pedirá la contraseña: escribí root_password)

Ahora, operamos sobre la base de datos que creamos al inicio:

USE app_db;

CREATE TABLE usuarios (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) UNIQUE NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO usuarios (username, email) 
VALUES ('dev_rioplatense', 'hola@ejemplo.com');

SELECT * FROM usuarios;

Salida esperada:

+----+------------------+-------------------+---------------------+
| id | username         | email             | created_at           |
+----+------------------+-------------------+---------------------+
|  1 | dev_rioplatense  | hola@ejemplo.com   | 2023-10-27 10:00:00 |
+----+------------------+-------------------+---------------------+
1 row in set (0.00 sec)

Conectando desde el Host (Tu aplicación)

Cuando configures tu archivo .env o tu cadena de conexión en el código, recordá que el host ya no es localhost dentro del contenedor, sino que es localhost desde tu máquina porque hicimos el mapeo de puertos.

Ejemplo para PostgreSQL:

• Host: localhost
• Puerto: 5432
• Usuario: postgres
• Password: mi_password_segura
• DB: tienda_db

Ejemplo para MySQL:

• Host: localhost
• Puerto: 3306
• Usuario: root
• Password: root_password
• DB: app_db

Buenas prácticas y errores comunes

1. El problema de la persistencia (¡Cuidado acá!)

Si borrás el contenedor con docker rm -f mi-postgres, perdés todos tus datos. Los contenedores son efímeros por naturaleza. Para evitar esto, tenés que usar volúmenes.

Modificá tu comando así:

docker run --name mi-postgres -v pgdata:/var/lib/postgresql/data -e POSTGRES_PASSWORD=pass -p 5432:5432 -d postgres

Con -v pgdata:/var/lib/postgresql/data, Docker crea un volumen llamado pgdata en tu disco duro que sobrevive aunque borres el contenedor.

2. Conflictos de puertos

Si ya tenés instalado Postgres o MySQL nativamente en tu PC, el comando docker run te va a tirar un error: Bind for 0.0.0.0:5432 failed: port is already allocated.

Solución: Cambiá el puerto del host. Por ejemplo, usá -p 5433:5432. Ahora te conectarías a través del puerto 5433.

3. Seguridad

Nunca uses contraseñas simples como 1234 o root en entornos que no sean puramente locales. Aunque el contenedor esté aislado, si exponés el puerto al mundo, cualquiera puede intentar entrar.

Conclusión

Levantar una base de datos con Docker es la forma más eficiente de trabajar hoy en día. Te permite iterar rápido, probar diferentes versiones de motores de búsqueda y mantener tu sistema operativo limpio.

Resumen de lo que aprendimos:

• Cómo usar docker run con variables de entorno para configurar credenciales.
• El mapeo de puertos (-p) para acceder desde el host.
• Cómo entrar al contenedor con docker exec para ejecutar comandos SQL.
• La importancia de los volúmenes (-v) para no perder la data.

Como próximo paso, te recomiendo investigar Docker Compose. En lugar de escribir comandos largos en la terminal, podés definir todo tu stack (App + DB + Redis) en un archivo .yml y levantarlo todo con un simple docker-compose up -d. ¡A darle átomos!