# Volúmenes y arquitectura Docker — explicación simple

## Qué tienes ahora (y qué es “volumen”)

En tu setup actual:

- **Un Droplet** = una máquina virtual.
- En esa máquina corren **dos contenedores Docker**:
  - **contenedor app** → imagen de tu Next.js (la web).
  - **contenedor db** → imagen de PostgreSQL (la base de datos).

Un **volumen** en Docker es solo “un disco persistente” que le asignas a un contenedor. Si el contenedor se borra o se recrea, lo que está **dentro del volumen** no se pierde.

En tu `docker-compose.yml`:

| Volumen        | Para qué sirve |
|----------------|----------------|
| `postgres_data`| Donde PostgreSQL guarda tablas, usuarios, órdenes, tickets. Sin este volumen, al reiniciar el contenedor `db` perderías toda la base de datos. |
| `uploads_data` | Donde la app guarda las imágenes que subes desde el admin (promos, carrusel, etc.). Sin este volumen, al recrear el contenedor `app` perderías esas fotos. |

Resumen: **una base de datos, dos contenedores (app + db), cada uno con su volumen para no perder datos.** No hay “pods” ni Kubernetes; es Docker Compose en una sola máquina.

---

## “Varios Docker manejados por peticiones” — qué puede significar

- **Opción A — Lo que tienes:**  
  Un solo contenedor de la app que atiende **todas** las peticiones. Las peticiones entran por Nginx al puerto 3000 y las responde ese único proceso Node/Next.js. Simple y suficiente para tráfico normal.

- **Opción B — Varias réplicas de la app (scale):**  
  Varios contenedores de la **misma imagen** de la web, detrás de un balanceador; cada petición la toma uno u otro contenedor. Eso sí es “varios Docker para atender peticiones”.  
  En Docker Compose se hace con `docker compose up -d --scale app=3` (3 copias de `app`). La **base de datos sigue siendo una sola** (un solo contenedor `db`); los 3 contenedores de app se conectan todos a ese mismo PostgreSQL.

- **Opción C — Kubernetes (pods):**  
  “Pods” es un concepto de Kubernetes: un pod puede tener uno o más contenedores. Para una web de sorteo suele ser excesivo; solo tiene sentido si ya piensas en muchos servicios, autoescalado fuerte, etc.

Tu lógica “una base de datos, varios Docker (de la imagen de la app) manejados por peticiones” encaja con la **Opción B**: una DB, N contenedores de app. Los volúmenes siguen siendo:
- **1 volumen para la DB** (asociado al contenedor de PostgreSQL).
- **Volumen de uploads**: aquí hay un detalle. Si tienes 3 contenedores de app y cada uno escribe en “su” disco, las fotos quedarían repartidas. Por eso en arquitecturas con varios contenedores de app lo habitual es que las imágenes **no** se guarden en un volumen local de la app, sino en un almacenamiento compartido (por ejemplo S3/Spaces). Así todos los contenedores ven las mismas imágenes.

---

## Esquema en texto

```
[Internet]
    │
    ▼
[Nginx en el Droplet]
    │
    ▼
[Contenedor app (Next.js)]  ← puede ser 1 o N réplicas (scale)
    │
    ├── lee/escribe ──► [Volumen postgres_data] ◄── [Contenedor db (PostgreSQL)]
    │
    └── sube imágenes ──► [Volumen uploads_data]  (o, con más réplicas, mejor S3/Spaces)
```

- **Una base de datos** = un solo contenedor `db` y un solo volumen `postgres_data`.
- **Varios Docker (de la app)** = varias réplicas del contenedor `app`; todas hablan con la misma DB.
- **Volumen** = “disco persistente” para que, al reiniciar o recrear contenedores, no se pierdan datos (DB o archivos subidos).

---

## ¿Cuánto tráfico soporta la Opción A?

Un solo Droplet con **un contenedor de app + un contenedor de DB** (sin escalar) aguanta aproximadamente esto:

| Droplet (DO) | RAM / vCPU | Peticiones/seg aprox. | Visitas/día aprox. | Notas |
|---------------|------------|------------------------|--------------------|--------|
| Basic $12/mes | 2 GB / 1   | 5–15 req/s             | 20k–50k            | Tráfico bajo–medio. Picos cortos OK. |
| Basic $24/mes | 4 GB / 2   | 15–40 req/s            | 50k–150k           | Cómodo para un sorteo con picos. |
| Basic $48/mes | 8 GB / 4   | 40–80 req/s            | 150k–300k          | Sorteos grandes o muchos usuarios simultáneos. |

**Qué limita:**

- **Node.js** atiende con un solo hilo por proceso: más CPU ayuda, pero no multiplica linealmente.
- Las páginas con **SSR** (home, checkout, admin) hacen consultas a la DB y tardan más que las estáticas.
- **Checkout** (Flow/MP, envío de email) son las rutas más pesadas; muchas compras al mismo tiempo suben la carga.
- **PostgreSQL** en el mismo servidor comparte CPU y RAM con la app; en Droplets pequeños la DB puede ser el cuello de botella antes que Next.js.

**En la práctica**, para un sorteo típico:

- **Opción A (1 app + 1 DB)** suele ser suficiente hasta **varios cientos de compras/día** y **decenas de miles de visitas/día** con un Droplet de 4 GB.
- Si esperas picos muy fuertes (ej. último día del sorteo, mucha gente a la vez), sube a 4–8 GB o pasa a **Opción B** (varias réplicas de la app detrás de un balanceador).

---

## Puntaje de la web

Con los cambios de seguridad y la migración a PostgreSQL + Docker que hicimos, el proyecto está en:

**7,5 / 10**

Para acercarse a 9/10 en producción convendría: rate limiting con Redis, validar tipo real de archivos en uploads (magic bytes) y, si escalas a varios contenedores de app, subir imágenes a S3/Spaces en lugar de volumen local.
