cesarmendivil 8e6df294dc Add Docker management scripts for TubeScript API

2026-02-21 12:19:08 -07:00

8.2 KiB

Raw Blame History

🐳 TubeScript API - Guía de Comandos Docker Separados

Esta guía te muestra cómo ejecutar los servicios de TubeScript API por separado, permitiéndote iniciar solo el API FastAPI o solo el panel Streamlit de forma independiente.

📦 Requisitos Previos

Asegúrate de tener instalado:

Docker (versión 20.10 o superior)
Docker Compose (opcional, solo para uso conjunto)

Verifica la instalación:

docker --version
docker-compose --version

⚙️ Configuración Inicial

1. Crear la Red de Docker

Primero, crea la red compartida entre servicios:

./docker-create-network.sh

O manualmente:

docker network create tubescript-network

2. Configurar Variables de Entorno

Copia el archivo de ejemplo y edita según tu configuración:

cp .env.example .env
nano .env

Configuraciones importantes:

# Para servicios en el mismo servidor (Docker)
API_URL=http://tubescript-api:8000

# Para desarrollo local (sin Docker)
API_URL=http://localhost:8080

# Para producción con dominio
API_URL=https://api.tudominio.com

🚀 Comandos Disponibles

1️⃣ Iniciar solo FastAPI

./docker-start-api.sh

Características:

Puerto: 8080 (host) → 8000 (contenedor)
Documentación: http://localhost:8080/docs
Endpoint de prueba: http://localhost:8080/stream/VIDEO_ID

Ver logs:

docker logs -f tubescript_api

Detener:

docker stop tubescript_api

2️⃣ Iniciar solo Streamlit

./docker-start-streamlit.sh

Características:

Puerto: 8501 (host) → 8501 (contenedor)
Panel web: http://localhost:8501
Se conecta automáticamente al API usando API_URL del archivo .env

Ver logs:

docker logs -f streamlit_panel

Detener:

docker stop streamlit_panel

3️⃣ Ver Logs

Usa el script de logs para ver la salida de los servicios:

# Ver logs de FastAPI
./docker-logs-separate.sh api

# Ver logs de Streamlit
./docker-logs-separate.sh streamlit

# Ver logs de ambos (requiere docker-compose)
./docker-logs-separate.sh both

O directamente con Docker:

docker logs -f tubescript_api
docker logs -f streamlit_panel

4️⃣ Detener Todos los Servicios

./docker-stop-all.sh

O manualmente:

docker stop tubescript_api streamlit_panel
docker rm tubescript_api streamlit_panel

🎯 Uso Individual de Servicios

Escenario 1: Solo API (Backend)

Si solo necesitas el API para integraciones o pruebas:

# 1. Crear red
./docker-create-network.sh

# 2. Iniciar API
./docker-start-api.sh

# 3. Probar endpoint
curl http://localhost:8080/stream/VIDEO_ID

Escenario 2: Solo Streamlit (Frontend)

Si ya tienes el API corriendo en otro servidor:

# 1. Configurar URL del API remoto
echo "API_URL=https://api.tudominio.com" > .env

# 2. Iniciar Streamlit
./docker-start-streamlit.sh

# 3. Abrir navegador
open http://localhost:8501

Escenario 3: Ambos Servicios Separados

Para desarrollo o testing:

# 1. Crear red compartida
./docker-create-network.sh

# 2. Iniciar API
./docker-start-api.sh

# 3. Esperar que API esté listo (verificar logs)
docker logs -f tubescript_api
# Presiona Ctrl+C cuando veas "Application startup complete"

# 4. Iniciar Streamlit
./docker-start-streamlit.sh

# 5. Verificar ambos servicios
curl http://localhost:8080/docs
open http://localhost:8501

Escenario 4: Usar Docker Compose (Recomendado)

Para producción, usa docker-compose:

# Iniciar ambos servicios
docker-compose up -d

# Ver logs
docker-compose logs -f

# Detener
docker-compose down

🔧 Comandos Docker Manuales

FastAPI

Construir imagen:

docker build -t tubescript-api .

Ejecutar contenedor:

docker run -d \
  --name tubescript_api \
  --network tubescript-network \
  -p 8080:8000 \
  -v "$(pwd)/cookies.txt:/app/cookies.txt:ro" \
  -v "$(pwd)/stream_config.json:/app/stream_config.json" \
  -v "$(pwd)/streams_state.json:/app/streams_state.json" \
  -v "$(pwd)/data:/app/data" \
  -e PYTHONUNBUFFERED=1 \
  tubescript-api \
  uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Streamlit

Ejecutar contenedor:

docker run -d \
  --name streamlit_panel \
  --network tubescript-network \
  -p 8501:8501 \
  -v "$(pwd)/cookies.txt:/app/cookies.txt:ro" \
  -v "$(pwd)/stream_config.json:/app/stream_config.json" \
  -v "$(pwd)/streams_state.json:/app/streams_state.json" \
  -v "$(pwd)/data:/app/data" \
  -e PYTHONUNBUFFERED=1 \
  -e API_URL=http://tubescript-api:8000 \
  tubescript-api \
  streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0 --server.headless=true --browser.gatherUsageStats=false

🔍 Verificar Estado de Servicios

Listar contenedores activos:

docker ps

Verificar red:

docker network inspect tubescript-network

Ver recursos utilizados:

docker stats tubescript_api streamlit_panel

🛠️ Solución de Problemas

Problema: "Red no existe"

Solución:

./docker-create-network.sh

Problema: "Puerto ya en uso"

Identificar proceso:

lsof -i :8080  # Para FastAPI
lsof -i :8501  # Para Streamlit

Cambiar puerto en docker-compose.yml:

ports:
  - "8081:8000"  # Cambiar 8080 por 8081

Problema: "Streamlit no se conecta al API"

Verificar API_URL:

docker exec streamlit_panel env | grep API_URL

Probar conectividad:

docker exec streamlit_panel curl http://tubescript-api:8000/docs

Problema: "Error al obtener stream m3u8"

Actualizar yt-dlp:

docker exec tubescript_api pip install --upgrade yt-dlp
docker exec streamlit_panel pip install --upgrade yt-dlp

O reconstruir contenedores:

docker-compose down
docker-compose build --no-cache
docker-compose up -d

Problema: "Contenedor se detiene inmediatamente"

Ver logs completos:

docker logs tubescript_api
docker logs streamlit_panel

Ejecutar en modo interactivo para debugging:

docker run -it --rm \
  --network tubescript-network \
  -p 8080:8000 \
  tubescript-api \
  uvicorn main:app --host 0.0.0.0 --port 8000

📊 Monitoreo y Mantenimiento

Ver logs en tiempo real:

# Todos los contenedores
docker logs -f tubescript_api
docker logs -f streamlit_panel

# Con marca de tiempo
docker logs -f --timestamps tubescript_api

Limpiar recursos no utilizados:

# Eliminar contenedores detenidos
docker container prune

# Eliminar imágenes sin usar
docker image prune -a

# Limpiar todo (cuidado)
docker system prune -a --volumes

Actualizar servicios:

# Detener servicios
./docker-stop-all.sh

# Reconstruir con últimos cambios
docker-compose build --no-cache

# Reiniciar
docker-compose up -d

📝 Resumen de Comandos Rápidos

# Iniciar servicios individuales
./docker-create-network.sh     # Crear red (solo primera vez)
./docker-start-api.sh          # Iniciar FastAPI
./docker-start-streamlit.sh    # Iniciar Streamlit

# Ver logs
./docker-logs-separate.sh api       # Logs de API
./docker-logs-separate.sh streamlit # Logs de Streamlit

# Detener servicios
./docker-stop-all.sh           # Detener todos

# Docker Compose (alternativa)
docker-compose up -d           # Iniciar ambos
docker-compose logs -f         # Ver logs
docker-compose down            # Detener ambos

🌐 URLs de Acceso

Servicio	URL	Descripción
FastAPI	http://localhost:8080	API principal
FastAPI Docs	http://localhost:8080/docs	Documentación interactiva
Streamlit	http://localhost:8501	Panel de control web

📚 Documentación Adicional

README.md - Guía general del proyecto
DOCKER_GUIDE.md - Guía completa de Docker
API_URL_CONFIG.md - Configuración de URL del API

8.2 KiB Raw Blame History Unescape Escape