581 lines
12 KiB
Markdown
581 lines
12 KiB
Markdown
# Nota importante: El frontend Streamlit ha sido eliminado
|
||
|
||
> Se ha eliminado el panel Streamlit en esta rama/proyecto. Las instrucciones a continuación permanecen para referencia histórica, pero el flujo operativo actual es usar únicamente la API (FastAPI) y los comandos de Docker relacionados con el servicio `api`.
|
||
|
||
|
||
# 🐳 Comandos Docker - Ejecución por Separado
|
||
|
||
## 📋 Índice
|
||
|
||
1. [Ejecutar Servicios por Separado](#ejecutar-servicios-por-separado)
|
||
2. [Uso del Endpoint /stream/](#uso-del-endpoint-stream)
|
||
3. [Comandos FFmpeg con RTMP](#comandos-ffmpeg-con-rtmp)
|
||
4. [Flujo Completo](#flujo-completo)
|
||
|
||
---
|
||
|
||
## 🚀 Ejecutar Servicios por Separado
|
||
|
||
### 1️⃣ Solo API FastAPI (Backend)
|
||
|
||
```bash
|
||
# Construir imagen
|
||
docker build -t tubescript-api .
|
||
|
||
# Ejecutar solo la API
|
||
docker run -d \
|
||
--name tubescript_api \
|
||
-p 8080:8000 \
|
||
-v $(pwd)/cookies.txt:/app/cookies.txt:ro \
|
||
tubescript-api
|
||
|
||
# Ver logs
|
||
docker logs -f tubescript_api
|
||
|
||
# Detener
|
||
docker stop tubescript_api
|
||
docker rm tubescript_api
|
||
```
|
||
|
||
**Acceder:**
|
||
- API: http://localhost:8080
|
||
- Docs: http://localhost:8080/docs
|
||
- Endpoint stream: http://localhost:8080/stream/VIDEO_ID
|
||
|
||
---
|
||
|
||
### 2️⃣ Solo Panel Streamlit (Frontend)
|
||
|
||
```bash
|
||
# Construir imagen (si no está construida)
|
||
docker build -t tubescript-streamlit .
|
||
|
||
# Ejecutar solo Streamlit
|
||
docker run -d \
|
||
--name streamlit_panel \
|
||
-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 \
|
||
-e API_URL=http://host.docker.internal:8080 \
|
||
streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0 --server.headless=true
|
||
|
||
# Ver logs
|
||
docker logs -f streamlit_panel
|
||
|
||
# Detener
|
||
docker stop streamlit_panel
|
||
docker rm streamlit_panel
|
||
```
|
||
|
||
**Acceder:**
|
||
- Panel: http://localhost:8501
|
||
|
||
**Nota:** Usa `host.docker.internal` para que Streamlit pueda conectarse a la API si ambos corren por separado.
|
||
|
||
---
|
||
|
||
### 3️⃣ Ambos Servicios (con docker-compose)
|
||
|
||
```bash
|
||
# Construir
|
||
docker-compose build
|
||
|
||
# Iniciar ambos
|
||
docker-compose up -d
|
||
|
||
# Ver logs de ambos
|
||
docker-compose logs -f
|
||
|
||
# Ver logs de uno solo
|
||
docker-compose logs -f streamlit-panel
|
||
docker-compose logs -f tubescript-api
|
||
|
||
# Detener ambos
|
||
docker-compose down
|
||
```
|
||
|
||
---
|
||
|
||
## 📡 Uso del Endpoint /stream/
|
||
|
||
### Obtener URL m3u8 de un Video en Vivo
|
||
|
||
#### Método 1: cURL
|
||
|
||
```bash
|
||
# Obtener stream URL
|
||
curl http://localhost:8080/stream/VIDEO_ID
|
||
|
||
# Ejemplo con video real
|
||
curl http://localhost:8080/stream/dQw4w9WgXcQ
|
||
```
|
||
|
||
**Respuesta:**
|
||
```json
|
||
{
|
||
"video_id": "dQw4w9WgXcQ",
|
||
"stream_url": "https://manifest.googlevideo.com/api/manifest/hls_playlist/...",
|
||
"url_type": "m3u8/hls",
|
||
"youtube_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
|
||
"ffmpeg_example": "ffmpeg -re -i \"URL\" -c copy -f flv rtmp://destino/stream_key",
|
||
"usage": {
|
||
"description": "Usa stream_url con FFmpeg para retransmitir",
|
||
"command_template": "ffmpeg -re -i \"{stream_url}\" -c copy -f flv {rtmp_url}/{stream_key}",
|
||
"platforms": {
|
||
"youtube": "rtmp://a.rtmp.youtube.com/live2/YOUR_STREAM_KEY",
|
||
"facebook": "rtmps://live-api-s.facebook.com:443/rtmp/YOUR_STREAM_KEY",
|
||
...
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
#### Método 2: Python
|
||
|
||
```python
|
||
import requests
|
||
|
||
# Obtener stream URL
|
||
video_id = "VIDEO_ID"
|
||
response = requests.get(f"http://localhost:8080/stream/{video_id}")
|
||
data = response.json()
|
||
|
||
stream_url = data["stream_url"]
|
||
print(f"URL m3u8: {stream_url}")
|
||
```
|
||
|
||
#### Método 3: JavaScript/Node.js
|
||
|
||
```javascript
|
||
// Obtener stream URL
|
||
const videoId = "VIDEO_ID";
|
||
const response = await fetch(`http://localhost:8080/stream/${videoId}`);
|
||
const data = await response.json();
|
||
|
||
console.log("URL m3u8:", data.stream_url);
|
||
```
|
||
|
||
---
|
||
|
||
## 🎬 Comandos FFmpeg con RTMP
|
||
|
||
### Flujo Básico
|
||
|
||
1. **Obtener URL m3u8** desde el endpoint `/stream/`
|
||
2. **Usar FFmpeg** para retransmitir a RTMP
|
||
|
||
### Template General
|
||
|
||
```bash
|
||
ffmpeg -re \
|
||
-i "URL_M3U8_DEL_ENDPOINT" \
|
||
-c copy \
|
||
-f flv \
|
||
RTMP_URL/STREAM_KEY
|
||
```
|
||
|
||
---
|
||
|
||
### Ejemplo 1: Transmitir a YouTube
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8
|
||
VIDEO_ID="dQw4w9WgXcQ"
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
# 2. Transmitir a YouTube
|
||
ffmpeg -re \
|
||
-i "$STREAM_URL" \
|
||
-c copy \
|
||
-f flv \
|
||
rtmp://a.rtmp.youtube.com/live2/TU_STREAM_KEY_YOUTUBE
|
||
```
|
||
|
||
---
|
||
|
||
### Ejemplo 2: Transmitir a Facebook
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
# 2. Transmitir a Facebook
|
||
ffmpeg -re \
|
||
-i "$STREAM_URL" \
|
||
-c copy \
|
||
-f flv \
|
||
rtmps://live-api-s.facebook.com:443/rtmp/TU_STREAM_KEY_FACEBOOK
|
||
```
|
||
|
||
---
|
||
|
||
### Ejemplo 3: Transmitir a Twitch
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
# 2. Transmitir a Twitch
|
||
ffmpeg -re \
|
||
-i "$STREAM_URL" \
|
||
-c copy \
|
||
-f flv \
|
||
rtmp://live.twitch.tv/app/TU_STREAM_KEY_TWITCH
|
||
```
|
||
|
||
---
|
||
|
||
### Ejemplo 4: Transmitir a X (Twitter)
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
# 2. Transmitir a Twitter/X
|
||
ffmpeg -re \
|
||
-i "$STREAM_URL" \
|
||
-c copy \
|
||
-f flv \
|
||
rtmps://fa.contribute.live-video.net/app/TU_STREAM_KEY_TWITTER
|
||
```
|
||
|
||
---
|
||
|
||
### Ejemplo 5: Transmitir a Múltiples Plataformas Simultáneamente
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
# 2. Transmitir a YouTube
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmp://a.rtmp.youtube.com/live2/YOUTUBE_KEY &
|
||
|
||
# 3. Transmitir a Facebook
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmps://live-api-s.facebook.com:443/rtmp/FACEBOOK_KEY &
|
||
|
||
# 4. Transmitir a Twitch
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmp://live.twitch.tv/app/TWITCH_KEY &
|
||
|
||
# Esperar a que todos terminen
|
||
wait
|
||
```
|
||
|
||
---
|
||
|
||
## 🔄 Flujo Completo
|
||
|
||
### Opción A: Usando la API Manualmente
|
||
|
||
```bash
|
||
# 1. Iniciar solo la API
|
||
docker run -d --name tubescript_api -p 8080:8000 \
|
||
-v $(pwd)/cookies.txt:/app/cookies.txt:ro \
|
||
tubescript-api
|
||
|
||
# 2. Obtener URL m3u8 de un video en vivo
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
curl http://localhost:8080/stream/$VIDEO_ID > stream_data.json
|
||
|
||
# 3. Extraer la URL
|
||
STREAM_URL=$(cat stream_data.json | jq -r '.stream_url')
|
||
echo "URL m3u8: $STREAM_URL"
|
||
|
||
# 4. Transmitir con FFmpeg a YouTube
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmp://a.rtmp.youtube.com/live2/TU_STREAM_KEY
|
||
|
||
# 5. Detener API cuando termines
|
||
docker stop tubescript_api
|
||
```
|
||
|
||
---
|
||
|
||
### Opción B: Usando el Panel Streamlit
|
||
|
||
```bash
|
||
# 1. Iniciar API
|
||
docker run -d --name tubescript_api -p 8080:8000 \
|
||
-v $(pwd)/cookies.txt:/app/cookies.txt:ro \
|
||
tubescript-api
|
||
|
||
# 2. Iniciar Streamlit
|
||
docker run -d --name streamlit_panel -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 \
|
||
-e API_URL=http://host.docker.internal:8080 \
|
||
tubescript-streamlit \
|
||
streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0
|
||
|
||
# 3. Abrir panel
|
||
open http://localhost:8501
|
||
|
||
# 4. Usar la interfaz gráfica para configurar y transmitir
|
||
|
||
# 5. Detener cuando termines
|
||
docker stop streamlit_panel tubescript_api
|
||
```
|
||
|
||
---
|
||
|
||
### Opción C: Usando docker-compose
|
||
|
||
```bash
|
||
# 1. Iniciar ambos servicios
|
||
docker-compose up -d
|
||
|
||
# 2. Opción A: Usar el panel web
|
||
open http://localhost:8501
|
||
|
||
# 2. Opción B: Usar la API directamente
|
||
curl http://localhost:8080/stream/VIDEO_ID
|
||
|
||
# 3. Detener
|
||
docker-compose down
|
||
```
|
||
|
||
---
|
||
|
||
## 🧪 Testing Individual
|
||
|
||
### Test 1: Probar Solo la API
|
||
|
||
```bash
|
||
# Iniciar API
|
||
docker run -d --name test_api -p 8080:8000 tubescript-api
|
||
|
||
# Probar endpoint de salud
|
||
curl http://localhost:8080/
|
||
|
||
# Probar endpoint de stream
|
||
curl http://localhost:8080/stream/dQw4w9WgXcQ
|
||
|
||
# Ver logs
|
||
docker logs test_api
|
||
|
||
# Limpiar
|
||
docker stop test_api && docker rm test_api
|
||
```
|
||
|
||
---
|
||
|
||
### Test 2: Probar Solo Streamlit
|
||
|
||
```bash
|
||
# Iniciar Streamlit (sin API)
|
||
docker run -d --name test_streamlit -p 8501:8501 \
|
||
tubescript-streamlit \
|
||
streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0
|
||
|
||
# Abrir en navegador
|
||
open http://localhost:8501
|
||
|
||
# Ver logs
|
||
docker logs test_streamlit
|
||
|
||
# Limpiar
|
||
docker stop test_streamlit && docker rm test_streamlit
|
||
```
|
||
|
||
---
|
||
|
||
### Test 3: Probar FFmpeg Localmente (Sin Docker)
|
||
|
||
```bash
|
||
# 1. Obtener URL m3u8 manualmente
|
||
yt-dlp -g -f best "https://www.youtube.com/watch?v=VIDEO_EN_VIVO"
|
||
|
||
# 2. Copiar la URL obtenida
|
||
|
||
# 3. Probar transmisión de 10 segundos a YouTube
|
||
ffmpeg -re -t 10 \
|
||
-i "URL_M3U8_COPIADA" \
|
||
-c copy \
|
||
-f flv \
|
||
rtmp://a.rtmp.youtube.com/live2/TU_STREAM_KEY
|
||
```
|
||
|
||
---
|
||
|
||
## 📊 Resumen de Puertos
|
||
|
||
| Servicio | Puerto Host | Puerto Container | URL |
|
||
|----------|-------------|------------------|-----|
|
||
| FastAPI | 8080 | 8000 | http://localhost:8080 |
|
||
| Streamlit | 8501 | 8501 | http://localhost:8501 |
|
||
|
||
---
|
||
|
||
## 🔧 Variables de Entorno
|
||
|
||
### Para Streamlit:
|
||
|
||
```bash
|
||
-e API_URL=http://host.docker.internal:8080 # Conectar a API en host
|
||
-e API_URL=http://tubescript-api:8000 # Conectar a API en Docker network
|
||
```
|
||
|
||
### Para API:
|
||
|
||
```bash
|
||
-e PYTHONUNBUFFERED=1 # Logs en tiempo real
|
||
-e PYTHONIOENCODING=utf-8 # Encoding correcto
|
||
```
|
||
|
||
---
|
||
|
||
## 🎯 Casos de Uso Prácticos
|
||
|
||
### Caso 1: Desarrollo Local de la API
|
||
|
||
```bash
|
||
# Solo API para desarrollo
|
||
docker run -d --name dev_api -p 8080:8000 \
|
||
-v $(pwd):/app \
|
||
-v $(pwd)/cookies.txt:/app/cookies.txt:ro \
|
||
tubescript-api
|
||
|
||
# Hacer cambios en main.py localmente
|
||
# Reiniciar para ver cambios
|
||
docker restart dev_api
|
||
```
|
||
|
||
---
|
||
|
||
### Caso 2: Testing de Streamlit con API Externa
|
||
|
||
```bash
|
||
# Streamlit apuntando a API en producción
|
||
docker run -d --name test_streamlit -p 8501:8501 \
|
||
-e API_URL=https://api-produccion.com \
|
||
tubescript-streamlit \
|
||
streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0
|
||
```
|
||
|
||
---
|
||
|
||
### Caso 3: Transmisión Automática con Script
|
||
|
||
```bash
|
||
#!/bin/bash
|
||
# script-transmision.sh
|
||
|
||
VIDEO_ID="VIDEO_EN_VIVO"
|
||
YOUTUBE_KEY="tu_stream_key_youtube"
|
||
FACEBOOK_KEY="tu_stream_key_facebook"
|
||
|
||
# Obtener URL m3u8
|
||
echo "Obteniendo URL m3u8..."
|
||
STREAM_URL=$(curl -s http://localhost:8080/stream/$VIDEO_ID | jq -r '.stream_url')
|
||
|
||
if [ -z "$STREAM_URL" ]; then
|
||
echo "Error: No se pudo obtener la URL"
|
||
exit 1
|
||
fi
|
||
|
||
echo "URL obtenida: $STREAM_URL"
|
||
|
||
# Transmitir a YouTube
|
||
echo "Iniciando transmisión a YouTube..."
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmp://a.rtmp.youtube.com/live2/$YOUTUBE_KEY &
|
||
|
||
# Transmitir a Facebook
|
||
echo "Iniciando transmisión a Facebook..."
|
||
ffmpeg -re -i "$STREAM_URL" -c copy -f flv \
|
||
rtmps://live-api-s.facebook.com:443/rtmp/$FACEBOOK_KEY &
|
||
|
||
echo "Transmisiones iniciadas. Presiona Ctrl+C para detener."
|
||
wait
|
||
```
|
||
|
||
---
|
||
|
||
## 📚 Documentación de la API
|
||
|
||
### GET /
|
||
|
||
Endpoint de salud.
|
||
|
||
**Respuesta:**
|
||
```json
|
||
{
|
||
"message": "TubeScript API Pro is running!"
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### GET /stream/{video_id}
|
||
|
||
Obtiene la URL m3u8 de un video en vivo de YouTube.
|
||
|
||
**Parámetros:**
|
||
- `video_id` (path): ID del video de YouTube
|
||
|
||
**Respuesta exitosa (200):**
|
||
```json
|
||
{
|
||
"video_id": "dQw4w9WgXcQ",
|
||
"stream_url": "https://manifest.googlevideo.com/...",
|
||
"url_type": "m3u8/hls",
|
||
"youtube_url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
|
||
"ffmpeg_example": "ffmpeg -re -i \"URL\" -c copy -f flv rtmp://destino/key",
|
||
"usage": { ... }
|
||
}
|
||
```
|
||
|
||
**Respuesta de error (400):**
|
||
```json
|
||
{
|
||
"detail": "Error de yt-dlp: ..."
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
### GET /transcript/{video_id}
|
||
|
||
Obtiene la transcripción de un video.
|
||
|
||
**Parámetros:**
|
||
- `video_id` (path): ID del video
|
||
- `lang` (query, opcional): Idioma (default: "es")
|
||
|
||
---
|
||
|
||
## 🎉 Resumen
|
||
|
||
### Comandos Esenciales:
|
||
|
||
```bash
|
||
# Solo API
|
||
docker run -d --name api -p 8080:8000 tubescript-api
|
||
|
||
# Solo Streamlit
|
||
docker run -d --name panel -p 8501:8501 \
|
||
-e API_URL=http://host.docker.internal:8080 \
|
||
tubescript-streamlit streamlit run streamlit_app.py --server.port=8501 --server.address=0.0.0.0
|
||
|
||
# Ambos (docker-compose)
|
||
docker-compose up -d
|
||
|
||
# Obtener URL m3u8
|
||
curl http://localhost:8080/stream/VIDEO_ID | jq -r '.stream_url'
|
||
|
||
# Transmitir con FFmpeg
|
||
ffmpeg -re -i "URL_M3U8" -c copy -f flv rtmp://destino/key
|
||
```
|
||
|
||
---
|
||
|
||
¡Todo listo para usar! 🚀📺
|