Volúmenes y redes: persistir datos y comunicar contenedores

Imagina esto: levantas PostgreSQL con Docker, creas tablas, insertas 10.000 filas de datos de ventas del último mes. Todo perfecto. Luego haces docker compose down y... tus datos han DESAPARECIDO. Completamente. Cuando vuelves a hacer docker compose up, PostgreSQL arranca limpio como el primer día. ¿Qué ha pasado? Bienvenido al concepto más importante (y más doloroso de aprender) de Docker: la EFÍMERA naturaleza de los contenedores.

Los contenedores son EFÍMEROS por diseño. Eso significa que no están pensados para guardar datos permanentes. Cuando un contenedor se borra, todo lo que había dentro desaparece con él. Es como una pizarra que se borra cada vez que alguien sale de la sala. Esto es una FEATURE, no un bug — los contenedores deben poder crearse y destruirse sin miedo. Pero entonces... ¿dónde guardamos los datos que SÍ queremos mantener?

### Volúmenes: la memoria permanente de Docker

La respuesta son los VOLÚMENES. Un volumen es como un disco duro externo que conectas al contenedor. El contenedor puede morir, borrarse, recrearse — pero el disco externo (el volumen) sigue ahí con tus datos intactos. Cuando creas un contenedor nuevo, simplemente vuelves a conectar el mismo disco externo y tus datos están donde los dejaste.

### Tipos de volúmenes

Docker tiene dos tipos principales de volúmenes. Ambos logran el mismo objetivo (persistir datos), pero de formas diferentes:

• ▹Named volumes (volúmenes con nombre): Docker los gestiona internamente. Tú solo les das un nombre y Docker decide dónde guardarlos en tu disco. Son ideales para bases de datos.
• ▹Bind mounts (montaje directo): Tú eliges exactamente qué carpeta de tu ordenador se conecta al contenedor. Son ideales para desarrollo — editas código en tu PC y el contenedor lo ve al instante.

1# docker-compose.yml con NAMED VOLUME para PostgreSQL
2services:
3  db:
4    image: postgres:16
5    environment:
6      POSTGRES_PASSWORD: secreto123
7    ports:
8      - "5432:5432"
9    volumes:
10      - pgdata:/var/lib/postgresql/data  # Named volume
11
12volumes:
13  pgdata:  # Declara el volumen con nombre

1# docker-compose.yml con BIND MOUNT para desarrollo
2services:
3  app:
4    build: .
5    volumes:
6      - ./src:/app/src  # Tu carpeta local → dentro del contenedor
7    ports:
8      - "8000:8000"

### Redes Docker: cómo se comunican los contenedores

docker-compose crea automáticamente una red interna para tus servicios — por eso en la lección anterior pudimos usar "db" como hostname. Pero a veces necesitas más control: separar servicios en redes diferentes, o conectar contenedores de diferentes docker-compose.yml. Para eso existen las redes explícitas.

1# docker-compose.yml con redes explícitas
2services:
3  db:
4    image: postgres:16
5    environment:
6      POSTGRES_PASSWORD: secreto123
7    networks:
8      - backend  # Solo accesible desde la red "backend"
9
10  redis:
11    image: redis:7-alpine
12    networks:
13      - backend  # Solo accesible desde la red "backend"
14
15  app:
16    build: .
17    networks:
18      - backend   # Puede hablar con db y redis
19      - frontend  # También expuesta al frontend
20    ports:
21      - "8000:8000"
22
23  web:
24    image: nginx:alpine
25    networks:
26      - frontend  # Solo puede hablar con app, NO con db directamente
27    ports:
28      - "80:80"
29
30networks:
31  backend:
32  frontend:

Para data engineering, las redes explícitas son menos comunes (normalmente todos tus servicios necesitan hablar entre sí), pero es importante entender el concepto. La red por defecto que docker-compose crea es perfecta para el 90% de los casos.

### Gestionar volúmenes desde la terminal

1# Listar todos los volúmenes
2docker volume ls
3
4# Inspeccionar un volumen (ver dónde está en tu disco)
5docker volume inspect pgdata
6
7# Borrar un volumen específico
8docker volume rm pgdata
9
10# Borrar TODOS los volúmenes no usados (¡cuidado!)
11docker volume prune

### Patrón profesional: desarrollo con hot-reload

En desarrollo, el patrón más común es usar un bind mount para tu código + un named volume para la base de datos. Así puedes editar tu código en VS Code y el contenedor lo ejecuta al instante, sin necesidad de reconstruir la imagen:

1# docker-compose.yml — patrón de desarrollo profesional
2services:
3  db:
4    image: postgres:16
5    environment:
6      POSTGRES_PASSWORD: secreto123
7      POSTGRES_DB: dev
8    ports:
9      - "5432:5432"
10    volumes:
11      - pgdata:/var/lib/postgresql/data    # Datos persistentes
12
13  app:
14    build: .
15    volumes:
16      - ./src:/app/src                     # Código en hot-reload
17      - ./data:/app/data                   # Datasets locales
18    environment:
19      DATABASE_URL: postgresql://postgres:secreto123@db:5432/dev
20    depends_on:
21      - db
22    ports:
23      - "8000:8000"
24
25volumes:
26  pgdata: