# Nota: Streamlit eliminado

> El panel Streamlit fue eliminado en esta rama; las instrucciones que mencionan Streamlit se mantienen solo como referencia histórica. Usa la API (main.py) para operaciones actuales.

# 🐳 Guía de Uso con Docker - TubeScript-API

## 🎯 Descripción

Esta guía te ayudará a ejecutar TubeScript-API con Docker, incluyendo tanto la API FastAPI como el panel web Streamlit.

---

## 📋 Prerequisitos

### 1. Instalar Docker

**macOS:**
```bash
brew install --cask docker
```

O descarga desde: https://www.docker.com/products/docker-desktop

**Linux:**
```bash
# Ubuntu/Debian
sudo apt-get update
sudo apt-get install docker.io docker-compose

# Fedora
sudo dnf install docker docker-compose
```

**Windows:**
Descarga Docker Desktop desde: https://www.docker.com/products/docker-desktop

### 2. Verificar Instalación

```bash
docker --version
docker-compose --version
```

---

## 🚀 Inicio Rápido

### Opción 1: Script Automático (Recomendado)

```bash
# Dar permisos de ejecución
chmod +x docker-start.sh

# Iniciar todo
./docker-start.sh
```

Este script:
- ✅ Verifica que Docker esté instalado
- ✅ Crea archivos de configuración si no existen
- ✅ Construye las imágenes Docker
- ✅ Inicia los servicios
- ✅ Muestra los logs iniciales

### Opción 2: Manual

```bash
# 1. Construir las imágenes
docker-compose build

# 2. Iniciar los servicios
docker-compose up -d

# 3. Ver los logs
docker-compose logs -f
```

---

## 🌐 Acceder a los Servicios

Una vez iniciados los contenedores:

### API FastAPI (Backend)
```
http://localhost:8080
```

### Documentación API (Swagger)
```
http://localhost:8080/docs
```

---

## 📊 Arquitectura Docker

```
┌─────────────────────────────────────────────────────┐
│              Docker Network: tubescript-network      │
├─────────────────────────────────────────────────────┤
│                                                      │
│  ┌──────────────────┐      ┌──────────────────┐   │
│  │  FastAPI Backend │   ◄──│  Streamlit Panel │   │
│  │  (Puerto 8000)   │      │  (Puerto 8501)   │   │
│  │  tubescript_api  │      │  streamlit_panel │   │
│  └──────────────────┘      └──────────────────┘   │
│           │                         │               │
│           └─────────┬───────────────┘               │
│                     │                               │
│              ┌──────▼──────┐                       │
│              │  Volúmenes  │                       │
│              │  Compartidos│                       │
│              └─────────────┘                       │
│                                                      │
└─────────────────────────────────────────────────────┘
         │                    │
    Puerto 8501          Puerto 8080
         │                    │
    ┌────▼────────────────────▼────┐
    │      Tu Navegador             │
    └───────────────────────────────┘
```

---

## 📂 Volúmenes Compartidos

Los siguientes archivos/directorios se comparten entre el host y los contenedores:

| Archivo/Directorio | Descripción | Modo |
|-------------------|-------------|------|
| `cookies.txt` | Cookies de YouTube | Solo lectura |
| `stream_config.json` | Configuración RTMP | Lectura/Escritura |
| `streams_state.json` | Estado de transmisiones | Lectura/Escritura |
| `data/` | Datos persistentes | Lectura/Escritura |

---

## 🛠️ Comandos Útiles

### Ver Estado de Servicios

```bash
docker-compose ps
```

### Ver Logs en Tiempo Real

```bash
# Todos los servicios
docker-compose logs -f

# O usar el script
./docker-logs.sh

# Solo la API
docker-compose logs -f tubescript-api
```

### Detener Servicios

```bash
docker-compose down

# O usar el script
./docker-stop.sh
```

### Reiniciar Servicios

```bash
# Reiniciar todos
docker-compose restart

# Reiniciar uno específico
docker-compose restart tubescript-api
```

### Reconstruir Imágenes

Si cambias código o dependencias:

```bash
# Reconstruir sin caché
docker-compose build --no-cache

# Reiniciar con nueva imagen
docker-compose up -d --build
```

### Acceder al Contenedor

```bash
# Acceder al shell del contenedor
docker exec -it tubescript_api bash

# Ejecutar comando en el contenedor
docker exec tubescript_api ls -la
```

### Limpiar Todo

```bash
# Detener y eliminar contenedores, redes
docker-compose down

# Detener, eliminar contenedores, redes y volúmenes
docker-compose down -v

# Eliminar imágenes también
docker-compose down --rmi all
```

---

## ⚙️ Configuración

### Variables de Entorno

Puedes configurar variables de entorno en `docker-compose.yml`:

```yaml
environment:
  - PYTHONUNBUFFERED=1
  - API_URL=http://tubescript-api:8000
  - MAX_UPLOAD_SIZE=100
```

### Cambiar Puertos

Edita `docker-compose.yml`:

```yaml
services:
  tubescript-api:
    ports:
      - "9091:8000"  # Cambiar puerto del host a 9091
```

---

## 🔍 Health Checks

Los servicios tienen health checks configurados:

- **FastAPI**: Verifica `/docs` cada 30 segundos

Ver estado de salud:

```bash
docker-compose ps
# ESTADO: healthy (verde) = funcionando correctamente
```

---

## 🐛 Solución de Problemas

### Problema: Puertos ya en uso

**Error:**
```
Error starting userland proxy: listen tcp4 0.0.0.0:8501: bind: address already in use
```

**Solución:**
```bash
# Ver qué proceso usa el puerto
lsof -i :8501
lsof -i :8080

# Matar el proceso
kill -9 <PID>

# O cambiar puertos en docker-compose.yml
```

### Problema: Contenedor no inicia

```bash
# Ver logs detallados
docker-compose logs streamlit-panel

# Ver eventos de Docker
docker events

# Reiniciar Docker Desktop (macOS/Windows)
```

### Problema: No se puede construir la imagen

```bash
# Limpiar cache de Docker
docker system prune -a

# Reconstruir sin cache
docker-compose build --no-cache
```

### Problema: Volúmenes no se actualizan

```bash
# Detener servicios
docker-compose down

# Eliminar volúmenes
docker volume prune

# Reiniciar
docker-compose up -d
```

### Problema: FFmpeg no funciona en Docker

```bash
# Verificar que FFmpeg esté en la imagen
docker exec streamlit_panel ffmpeg -version

# Si no está, reconstruir la imagen
docker-compose build --no-cache
```

---

## 📊 Monitoreo

### Ver Recursos Usados

```bash
# Ver uso de CPU, memoria, red
docker stats

# Ver solo los contenedores de TubeScript
docker stats streamlit_panel tubescript_api
```

### Ver Procesos Dentro del Contenedor

```bash
docker exec streamlit_panel ps aux
docker exec tubescript_api ps aux
```

---

## 🚀 Producción

### Consideraciones para Producción

1. **Usar un proxy reverso (Nginx)**

```yaml
# docker-compose.yml
services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - streamlit-panel
      - tubescript-api
```

2. **Configurar HTTPS**

3. **Usar secretos para Stream Keys**

```yaml
secrets:
  stream_keys:
    file: ./secrets/stream_keys.json
```

4. **Limitar recursos**

```yaml
services:
  streamlit-panel:
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
        reservations:
          cpus: '0.5'
          memory: 256M
```

5. **Configurar logs**

```yaml
services:
  streamlit-panel:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
```

---

## 📝 Archivos de Configuración

### docker-compose.yml

Define los servicios, puertos, volúmenes y redes.

### Dockerfile

Define cómo construir la imagen con Python, FFmpeg y dependencias.

### .dockerignore

Lista de archivos a ignorar al construir la imagen.

---

## 🎯 Flujo de Trabajo Completo

### Primera Vez

```bash
# 1. Clonar repositorio o navegar al directorio
cd TubeScript-API

# 2. Dar permisos a scripts
chmod +x docker-start.sh docker-stop.sh docker-logs.sh

# 3. Iniciar servicios
./docker-start.sh

# 4. Abrir en navegador
# http://localhost:8501
```

### Uso Diario

```bash
# Iniciar
docker-compose up -d

# Trabajar en el panel web
# http://localhost:8501

# Ver logs si hay problemas
./docker-logs.sh

# Detener al terminar
docker-compose down
```

### Actualizar Código

```bash
# 1. Detener servicios
docker-compose down

# 2. Actualizar código
git pull  # o editar archivos

# 3. Reconstruir
docker-compose build

# 4. Reiniciar
docker-compose up -d
```

---

## 📋 Checklist de Inicio

- [ ] Docker Desktop instalado y corriendo
- [ ] Archivos `stream_config.json` y `streams_state.json` creados
- [ ] `cookies.txt` creado (vacío está bien)
- [ ] Permisos de ejecución dados a scripts `.sh`
- [ ] Puertos 8501 y 8080 disponibles
- [ ] Ejecutar `./docker-start.sh`
- [ ] Verificar acceso a http://localhost:8501
- [ ] Verificar acceso a http://localhost:8080/docs

---

## 🎉 ¡Listo!

Tu stack completo de TubeScript-API está corriendo en Docker:

- **Frontend Streamlit**: http://localhost:8501
- **Backend FastAPI**: http://localhost:8080
- **Documentación API**: http://localhost:8080/docs

Para detener: `./docker-stop.sh`

Para ver logs: `./docker-logs.sh`

**¡Disfruta transmitiendo a múltiples plataformas! 📺🚀**