17. Usar la imagen de Postgres

 docker --version

Uso de PostgreSQL con Docker para Principiantes

Introducción

Este tutorial te enseñará cómo ejecutar PostgreSQL en Docker y conectarte desde un cliente visual. Usaremos analogías para hacerlo más comprensible.

---

Parte 1: Conceptos Básicos

¿Qué es Docker?

Analogía: Imagina Docker como un sistema de envío de mercancías estandarizado. En lugar de enviar productos sueltos, los pones en contenedores que tienen todo lo necesario para funcionar, independientemente de dónde se abran.

¿Qué es PostgreSQL?

PostgreSQL es un sistema de gestión de bases de datos relacional, similar a MySQL pero con características avanzadas.

---

Parte 2: Ejecutar PostgreSQL en Docker

Paso 1: Ejecutar el contenedor sin exponer puertos

bash

docker run --name mi-postgres -e POSTGRES_PASSWORD=mi_secret_password -d postgres

Diagrama ASCII del contenedor aislado:

text

┌─────────────────────────────────────┐
│         CONTENEDOR POSTGRES         │
│                                     │
│  PostgreSQL en puerto 5432         │
│  (solo accesible dentro del        │
│   contenedor)                      │
│                                     │
└─────────────────────────────────────┘
           ✗ No hay conexión
           ✗ No se puede acceder
           ✗ desde el exterior

Analogía: Es como tener una pelota de boliche dentro de una caja sellada. Sabes que está ahí, pero no puedes agarrarla porque no hay aberturas.

Paso 2: Verificar que el contenedor está ejecutándose

bash

docker container ls

Salida esperada:

text

CONTAINER ID   IMAGE      COMMAND                  CREATED         STATUS         PORTS      NAMES
8d1a2b3c4d5e   postgres   "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   5432/tcp   mi-postgres

Observa que en la columna "PORTS" solo dice 5432/tcp, lo que significa que el puerto está abierto solo internamente en el contenedor.

---

Parte 3: El Problema de la Conexión

Intentando conectar desde TablePlus (o cualquier cliente)

Configuración de conexión:

• Host: localhost

• Puerto: 5432

• Usuario: postgres

• Contraseña: mi_secret_password

Resultado: ¡Fallo de conexión!

¿Por qué falla?

text

EQUIPO HOST (tu computadora)     CONTENEDOR DOCKER
     ┌──────────────┐              ┌──────────────┐
     │              │              │              │
     │ TablePlus    │    ××××××    │ PostgreSQL  │
     │              ├───────────────►  5432/tcp   │
     │ puerto 5432  │   NO HAY     │              │
     │              │   RUTA       │              │
     └──────────────┘              └──────────────┘

Explicación: El puerto 5432 está abierto dentro del contenedor, pero Docker no ha creado un "puente" entre ese puerto y tu computadora.

---

Parte 4: Solución - Exponiendo el Puerto

Paso 1: Eliminar el contenedor anterior

bash

docker container rm -f mi-postgres

Paso 2: Crear un nuevo contenedor con el puerto expuesto

bash

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

Diagrama con puerto expuesto:

text

EQUIPO HOST (tu computadora)     CONTENEDOR DOCKER
     ┌──────────────┐              ┌──────────────┐
     │              │              │              │
     │ TablePlus    │    ────────► │ PostgreSQL  │
     │              │   PUENTE     │  5432/tcp   │
     │ puerto 5432  │   ESTABLECIDO│              │
     │              │              │              │
     └──────────────┘              └──────────────┘
           │                              │
           └─────── puerto 5432:5432 ─────┘
                 (host:contenedor)

Explicación del comando:

• -p 5432:5432 significa: "conecta el puerto 5432 de mi computadora al puerto 5432 del contenedor"

• Formato: -p [PUERTO_HOST]:[PUERTO_CONTENEDOR]

Paso 3: Verificar que el puerto está expuesto

bash

docker container ls

Ahora verás:

text

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

¡Observa la columna PORTS! Ahora dice 0.0.0.0:5432->5432/tcp, lo que confirma que el puente está establecido.

---

Parte 5: Conectarse Correctamente

Configuración en TablePlus (o cualquier cliente):

1. Nombre: PostgreSQL (o cualquier nombre que prefieras)

2. Host: localhost (o 127.0.0.1)

3. Puerto: 5432

4. Usuario: postgres

5. Contraseña: mi_secret_password

6. Base de datos: (dejar en blanco para conectarse al nivel raíz)

¡Test de conexión exitoso!

Crear una base de datos y tabla:

Una vez conectado, puedes:

1. Crear una nueva base de datos llamada "pruebas"

2. Crear una tabla con una columna "id"

3. Insertar registros

4. Ejecutar consultas SQL

---

Parte 6: Advertencia Importante - Persistencia de Datos

Problema: Si eliminas el contenedor, pierdes todos los datos.

Diagrama de pérdida de datos:

text

┌────────────────────────────────────────────┐
│   CONTENEDOR ELIMINADO = DATOS PERDIDOS    │
│                                            │
│  docker container rm -f mi-postgres        │
│                                            │
│  ┌──────────────┐        ┌──────────────┐ │
│  │              │        │              │ │
│  │ Base de      │   →    │   ¡Nada!     │ │
│  │ datos        │        │              │ │
│  │ Tablas       │        │              │ │
│  │ Registros    │        │              │ │
│  │              │        │              │ │
│  └──────────────┘        └──────────────┘ │
└────────────────────────────────────────────┘

Analogía: Es como tomar apuntes en una pizarra que se limpia cada vez que apagas la luz. Los datos no se guardan automáticamente.

Solución temporal: No elimines el contenedor si quieres conservar los datos.

Solución permanente (que veremos después): Usar volúmenes de Docker para persistir los datos.

---

Parte 7: Tarea Final

Instrucciones:

1. Elimina el contenedor usando el comando apropiado

2. Verifica que se haya eliminado correctamente

Solución:

bash

# Eliminar el contenedor forzosamente
docker container rm -f mi-postgres

# Verificar que ya no aparece en la lista
docker container ls

---

Cuestionario

Pregunta 1:

¿Qué comando ejecutarías para crear un contenedor PostgreSQL con la contraseña "clave123" y exponiendo el puerto 5432?

a) docker run postgres --password clave123 -p 5432
b) docker run --name db -e POSTGRES_PASSWORD=clave123 -p 5432:5432 -d postgres
c) docker create postgres -p 5432 password=clave123
d) docker start postgres --expose 5432 --password clave123

Pregunta 2:

¿Por qué no podemos conectarnos a PostgreSQL cuando ejecutamos el contenedor sin la opción -p?

a) Porque PostgreSQL no inicia correctamente
b) Porque Docker bloquea todas las conexiones por defecto
c) Porque el puerto está abierto solo dentro del contenedor, no en el host
d) Porque necesitamos configurar el firewall primero

Pregunta 3:

En el comando -p 5432:5432, ¿qué representa el primer 5432 y qué representa el segundo?

a) Primer 5432: puerto del contenedor, Segundo 5432: puerto del host
b) Primer 5432: puerto del host, Segundo 5432: puerto del contenedor
c) Ambos son puertos del contenedor
d) Primer 5432: puerto TCP, Segundo 5432: puerto UDP

Pregunta 4:

¿Qué sucede con los datos de la base de datos cuando eliminamos el contenedor?

a) Se guardan automáticamente en Docker Hub
b) Se migran a otro contenedor automáticamente
c) Se pierden permanentemente
d) Se comprimen y archivan en el sistema

Pregunta 5:

¿Cuál es el usuario por defecto en la imagen oficial de PostgreSQL?

a) admin
b) root
c) postgres
d) postgresql

---

Respuestas del Cuestionario

1. b) docker run --name db -e POSTGRES_PASSWORD=clave123 -p 5432:5432 -d postgres

2. c) Porque el puerto está abierto solo dentro del contenedor, no en el host

3. b) Primer 5432: puerto del host, Segundo 5432: puerto del contenedor

4. c) Se pierden permanentemente

5. c) postgres

---

Tutorial Mejorado: Conexión a PostgreSQL en Docker (Versión Clarificada)

¿Problemas para conectar a PostgreSQL en Docker? Te explicamos por qué

El Escenario Común

Has ejecutado PostgreSQL en Docker con este comando:

bash

docker run --name mi-postgres -e POSTGRES_PASSWORD=secreto -d postgres

Todo parece funcionar, pero cuando intentas conectarte con TablePlus, DBeaver o cualquier cliente, obtienes un error de conexión. ¿Por qué?

---

Entendiendo el Problema: Puertos Aislados vs. Puertos Expuestos

Contenedor sin Puerto Expuesto

text

TU COMPUTADORA                CONTENEDOR DOCKER
┌─────────────────┐          ┌─────────────────┐
│                 │          │                 │
│  Cliente BD     │  =×××=>  │  PostgreSQL     │
│  (TablePlus)    │   NO     │  puerto 5432    │
│  puerto 5432    │   HAY    │                 │
│                 │   RUTA   │                 │
└─────────────────┘          └─────────────────┘

Explicación simple: El contenedor tiene PostgreSQL ejecutándose en su puerto 5432 interno, pero no hay un "túnel" que conecte ese puerto con tu computadora.

Contenedor con Puerto Expuesto

text

TU COMPUTADORA                CONTENEDOR DOCKER
┌─────────────────┐          ┌─────────────────┐
│                 │          │                 │
│  Cliente BD     │  ========│  PostgreSQL     │
│  (TablePlus)    │   TÚNEL  │  puerto 5432    │
│  puerto 5432    │   ACTIVO │                 │
│                 │          │                 │
└─────────────────┘          └─────────────────┘
        ↓                             ↓
        └───── -p 5432:5432 ──────────┘

---

Solución Paso a Paso

Paso 1: Eliminar el contenedor existente (si aplica)

bash

docker rm -f mi-postgres

Paso 2: Crear contenedor CON exposición de puerto

bash

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

Desglose del comando:

• --name mi-postgres → Nombre fácil para referenciarlo

• -e POSTGRES_PASSWORD=secreto → Establece la contraseña

• -p 5432:5432 → ¡LA CLAVE! Conecta tu puerto 5432 al puerto 5432 del contenedor

• -d → Ejecuta en segundo plano

• postgres → Nombre de la imagen

Paso 3: Verificar que el puerto está expuesto

bash

docker ps

Busca esta línea en la salida:

text

0.0.0.0:5432->5432/tcp

Esto confirma que el túnel está establecido.

---

Configuración del Cliente de Base de Datos

Para TablePlus/DBeaver/pgAdmin/otro cliente:

Parámetro	Valor	Notas
Tipo	PostgreSQL
Host	localhost	O 127.0.0.1
Puerto	5432	El mismo que usaste en -p
Usuario	postgres	Usuario por defecto, no cambia
Contraseña	secreto	La que estableciste en POSTGRES_PASSWORD
Database	(vacío)	Déjalo vacío para conectar al nivel raíz

---

⚠️ Advertencia Crítica: Los Datos NO Persisten

IMPORTANTE: Los datos dentro del contenedor son efímeros. Si ejecutas:

bash

docker rm -f mi-postgres

¡Todos los datos desaparecen! Bases de datos, tablas, registros... todo.

Por ahora: Si quieres conservar datos, no elimines el contenedor.

En el futuro: Aprenderemos a usar volúmenes Docker para guardar datos permanentemente.

---

Resumen Visual del Flujo

text

  [COMANDO INCORRECTO]              [COMANDO CORRECTO]
      ↓                                   ↓
docker run postgres            docker run -p 5432:5432 postgres
      ↓                                   ↓
  ┌─────────┐                        ┌─────────┐
  │ AISLADO │                        │ CONECTADO│
  │  5432   │                        │ 5432↔5432│
  └─────────┘                        └─────────┘
      ↓                                   ↓
  × Conexión                          ✓ Conexión
  × TablePlus                         ✓ TablePlus
  × Acceso externo                    ✓ Acceso externo

---

Tu Tarea Práctica

Objetivo:

Practicar el ciclo completo: crear, conectar y eliminar.

Pasos:

1. Crea el contenedor con puerto expuesto

2. Conéctate con TablePlus

3. Crea una base de datos "ejercicio"

4. Crea una tabla "usuarios"

5. Elimina el contenedor

6. Verifica que los datos se perdieron (¡es parte del aprendizaje!)

Comandos de referencia:

bash

# Crear
docker run --name practica -e POSTGRES_PASSWORD=abc123 -p 5432:5432 -d postgres

# Conectar (usando TablePlus u otro cliente)
# Configuración: localhost:5432, usuario: postgres, contraseña: abc123

# Eliminar
docker rm -f practica

---

Puntos Clave para Recordar

1. Sin -p = Sin conexión externa

2. -p HOST:CONTENEDOR crea el túnel

3. Usuario siempre es postgres (por defecto)

4. Los datos son temporales sin volúmenes

5. Verifica con docker ps que el puerto está mapeado

¡Ahora estás listo para trabajar con PostgreSQL en Docker!