project-afterlife/docs/deployment.md

# Guia de Despliegue

## Entornos

| Entorno | Compose File | Servicios |
|---------|-------------|-----------|
| **Desarrollo local** | `docker-compose.dev.yml` + `docker-compose.maple2.yml` | Todos |
| **Produccion** | `docker-compose.yml` | Web + CMS + DB + Nginx + SSL |

## Desarrollo Local

### Requisitos
- Docker Engine 24+
- Docker Compose v2+
- 8 GB RAM minimo (16 GB con todos los servidores de juegos)
- 50 GB disco libre

### Levantar todo

```bash
cd docker/

# 1. Stack principal
docker compose -f docker-compose.dev.yml up -d

# 2. MapleStory 2 (requiere setup previo, ver game-servers.md)
docker compose -f docker-compose.maple2.yml up -d

# 3. Verificar
docker ps
```

### Puertos en uso
| Puerto | Servicio |
|--------|---------|
| 3000 | Next.js (frontend) |
| 1337 | Strapi (CMS admin) |
| 5432 | PostgreSQL |
| 9000 | MinIO API |
| 9001 | MinIO Console |
| 23000-23001 | OpenFusion |
| 20001 | MapleStory 2 Login |
| 21001 | MapleStory 2 World |
| 20003 | MapleStory 2 Game |
| 21003 | MapleStory 2 Game gRPC |
| 3307 | MySQL (MapleStory 2) |
| 4000 | MapleStory 2 Web |
| 25565 | Minecraft FTB Evolution |
| 7777 (UDP) | SM64 Coop DX |
| 45000-45004 | N64 Netplay (TCP + UDP) |
| 6262, 6226 (UDP) | Dolphin Traversal (GC/Wii) |

## Acceso Externo (fuera de la red local)

### Requisitos
- Router con acceso al panel de administracion
- Dominio en Cloudflare (consultoria-as.com)
- Token de API de Cloudflare con permisos Zone > DNS > Edit

### 1. Crear token de Cloudflare
1. Ir a https://dash.cloudflare.com/profile/api-tokens
2. Create Token > Edit zone DNS (template)
3. Zone Resources: Include > Specific zone > consultoria-as.com
4. Copiar el token generado a `CF_API_TOKEN` en `docker/.env`

### 2. Configurar variables
En `docker/.env`:
```env
PUBLIC_HOST=play.consultoria-as.com
CF_API_TOKEN=tu-token-aqui
```

En `servers/maple2/.env`:
```env
GAME_IP=play.consultoria-as.com
LOGIN_IP=play.consultoria-as.com
```

### 3. Port forwarding en el router
Abrir estos puertos TCP en el router, apuntando a la IP local del servidor (192.168.10.234):

| Puerto | Servicio | Protocolo |
|--------|----------|-----------|
| 23000 | OpenFusion (login) | TCP |
| 23001 | OpenFusion (shard) | TCP |
| 20001 | MapleStory 2 (login) | TCP |
| 20003 | MapleStory 2 (game) | TCP |
| 25565 | Minecraft FTB Evolution | TCP |
| 7777 | SM64 Coop DX | UDP |
| 45000-45004 | N64 Netplay (Mario Party) | TCP + UDP |
| 6262, 6226 | Dolphin Traversal (GC/Wii) | UDP |

**No forwardear**: PostgreSQL (5432), MinIO (9000/9001), Strapi (1337), Next.js (3000), MySQL (3307). Estos son servicios internos.

### 4. Levantar servicios
```bash
cd docker
docker compose -f docker-compose.dev.yml up -d
docker compose -f docker-compose.maple2.yml up -d
```

El contenedor `cloudflare-ddns` actualizara automaticamente el registro DNS `play.consultoria-as.com` con tu IP publica cada 5 minutos.

### 5. Conexion desde fuera
| Juego | Direccion |
|-------|-----------|
| Minecraft FTB Evolution | `play.consultoria-as.com:25565` |
| OpenFusion (FusionFall) | `play.consultoria-as.com:23000` |
| MapleStory 2 | `play.consultoria-as.com:20001` |
| SM64 Coop DX | `play.consultoria-as.com:7777` (UDP) |
| N64 Netplay (Mario Party) | `play.consultoria-as.com:45000` |
| Dolphin Netplay (GC/Wii) | Traversal Server: `play.consultoria-as.com:6262` |

### Detener servicios
```bash
docker compose -f docker-compose.dev.yml down
docker compose -f docker-compose.maple2.yml down
```

### Reconstruir imagenes
```bash
docker compose -f docker-compose.dev.yml build --no-cache
docker compose -f docker-compose.maple2.yml build --no-cache
```

## Produccion

### Archivo: docker-compose.yml

El compose de produccion incluye:
- **Nginx** como reverse proxy (puertos 80/443)
- **Certbot** para certificados SSL Let's Encrypt
- Sin servidores de juegos (se configuran aparte segun el VPS)

### Variables de entorno requeridas

```env
# Base de datos
DATABASE_NAME=afterlife
DATABASE_USERNAME=afterlife
DATABASE_PASSWORD=<password-seguro>

# MinIO
MINIO_ROOT_USER=afterlife
MINIO_ROOT_PASSWORD=<password-seguro>

# Strapi keys (generar con: openssl rand -base64 32)
APP_KEYS=<key1>,<key2>,<key3>,<key4>
API_TOKEN_SALT=<salt>
ADMIN_JWT_SECRET=<secret>
TRANSFER_TOKEN_SALT=<salt>
JWT_SECRET=<secret>

# API
STRAPI_API_TOKEN=<token-generado-en-admin>
PUBLIC_STRAPI_URL=https://tu-dominio.com

# Domain
DOMAIN=tu-dominio.com
```

### Deploy manual al VPS

```bash
# En el VPS
cd /opt/project-afterlife
git pull origin main
docker compose build
docker compose up -d
```

### CI/CD Automatico

El archivo `.github/workflows/deploy.yml` automatiza el deploy:

1. **Trigger**: Push a `main`
2. **Accion**: SSH al VPS, pull, build, restart

**Secrets de GitHub requeridos**:
- `VPS_HOST` — Hostname o IP del VPS
- `VPS_USER` — Usuario SSH
- `VPS_SSH_KEY` — Llave privada SSH

### SSL con Certbot

```bash
# Primera vez: obtener certificado
docker compose run --rm certbot certonly \
  --webroot --webroot-path=/var/www/certbot \
  -d tu-dominio.com

# Renovacion automatica (cron)
0 0 * * * docker compose run --rm certbot renew
```

## Backups

### Base de datos CMS (PostgreSQL)
```bash
# Exportar
docker exec docker-postgres-1 pg_dump -U afterlife afterlife > backup_$(date +%Y%m%d).sql

# Importar
cat backup.sql | docker exec -i docker-postgres-1 psql -U afterlife afterlife
```

### Base de datos MapleStory 2 (MySQL)
```bash
# Exportar
docker exec maple2-db mysqldump -u root -pmaplestory --databases maple-data game-server > backup_ms2_$(date +%Y%m%d).sql

# Importar
cat backup_ms2.sql | docker exec -i maple2-db mysql -u root -pmaplestory
```

### Mundo de Minecraft
```bash
# Exportar
docker cp minecraft-ftb:/data/world ./backup_mc_world_$(date +%Y%m%d)/

# Importar
docker cp ./backup_mc_world/ minecraft-ftb:/data/world
docker restart minecraft-ftb
```

### Volumenes Docker (completo)
```bash
# Listar volumenes
docker volume ls | grep afterlife

# Backup de un volumen
docker run --rm -v docker_postgres_data:/data -v $(pwd):/backup \
  alpine tar czf /backup/postgres_data.tar.gz -C /data .
```

## Monitoreo

### Estado de contenedores
```bash
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
```

### Uso de recursos
```bash
docker stats --no-stream
```

### Logs en tiempo real
```bash
docker logs -f --tail 50 <container-name>
```

### Health checks
PostgreSQL y MySQL tienen healthchecks configurados en los compose files. Verificar con:
```bash
docker inspect --format='{{.State.Health.Status}}' docker-postgres-1
docker inspect --format='{{.State.Health.Status}}' maple2-db
```