De Radio AM a Streaming Global: Infraestructura de Resiliencia para Doctor Mestizo

# Configuración de Nginx para proxy de segmentos HLS desde Azure CDN
# Minimiza latencia con cache inteligente por tipo de archivo

proxy_cache_path /var/cache/nginx levels=1:2
    keys_zone=hls_cache:10m max_size=1g
    inactive=60s use_temp_path=off;

server {
    listen 443 ssl http2;
    server_name stream.doctormestizo.com;

    location /live/ {
        proxy_pass https://amsorigin.azure.net/live/;

        # Manifests: TTL corto para reflejar cambios inmediatos
        location ~* \.m3u8$ {
            proxy_cache hls_cache;
            proxy_cache_valid 200 2s;
            proxy_cache_key "$uri";
            add_header Cache-Control "max-age=2, public";
            add_header X-Cache-Status $upstream_cache_status;
        }

        # Segmentos: TTL más largo, son inmutables una vez generados
        location ~* \.ts$ {
            proxy_cache hls_cache;
            proxy_cache_valid 200 30s;
            add_header Cache-Control "max-age=30, public";
        }

        # Partial segments LL-HLS: no cachear, sirven fragmentos en vivo
        location ~* \.m4s$ {
            proxy_cache off;
            proxy_buffering off;
            proxy_read_timeout 30s;
        }
    }
}

import asyncio
import aiohttp
from azure.mgmt.media import AzureMediaServices
from azure.identity import DefaultAzureCredential

INGEST_PRIMARY   = "https://ingest-primary.ams.azure.net/live/input"
INGEST_SECONDARY = "https://ingest-backup.ams.azure.net/live/input"
FAILOVER_TIMEOUT = 3  # segundos máximos para detectar y conmutar

async def check_ingest_health(url: str, session: aiohttp.ClientSession) -> bool:
    """Verifica si el endpoint de ingest responde correctamente."""
    try:
        async with session.get(
            f"{url}/health",
            timeout=aiohttp.ClientTimeout(total=2),
        ) as resp:
            return resp.status == 200
    except Exception:
        return False

async def failover_to_secondary(ams_client: AzureMediaServices) -> None:
    """
    Activa el Live Event secundario y actualiza el routing en Azure CDN.
    Operación idempotente: si ya está activo, no hace nada.
    """
    live_event = ams_client.live_events.get(
        resource_group="rg-doctormestizo",
        account_name="ams-doctormestizo",
        live_event_name="backup-event",
    )
    if live_event.resource_state != "Running":
        await ams_client.live_events.begin_start(
            resource_group="rg-doctormestizo",
            account_name="ams-doctormestizo",
            live_event_name="backup-event",
        )
    # Actualizar origin en Azure CDN para apuntar al endpoint secundario
    update_cdn_origin(endpoint="doctormestizo-cdn", new_origin=INGEST_SECONDARY)

async def monitor_loop():
    credential = DefaultAzureCredential()
    ams = AzureMediaServices(credential, subscription_id="...")
    async with aiohttp.ClientSession() as session:
        consecutive_failures = 0
        while True:
            healthy = await check_ingest_health(INGEST_PRIMARY, session)
            if not healthy:
                consecutive_failures += 1
                if consecutive_failures >= 2:   # 2 checks consecutivos fallidos = failover
                    await failover_to_secondary(ams)
                    consecutive_failures = 0
            else:
                consecutive_failures = 0
            await asyncio.sleep(1.5)  # check cada 1.5s → detección en <3s

"use client";
import { useEffect, useRef } from "react";
import Hls from "hls.js";

interface LivePlayerProps {
  streamUrl: string;   // URL del manifest .m3u8 en Azure CDN
  posterUrl?: string;
}

export default function LivePlayer({ streamUrl, posterUrl }: LivePlayerProps) {
  const videoRef = useRef<HTMLVideoElement>(null);
  const hlsRef   = useRef<Hls | null>(null);

  useEffect(() => {
    const video = videoRef.current;
    if (!video) return;

    if (Hls.isSupported()) {
      const hls = new Hls({
        // LL-HLS: segmentos parciales habilitados
        lowLatencyMode: true,
        backBufferLength: 30,       // 30s de buffer hacia atrás
        maxBufferLength: 8,         // 8s máximo de buffer adelante en vivo
        // ABR conservador: prioriza estabilidad sobre calidad máxima
        startLevel: -1,             // auto-detect nivel inicial
        abrEwmaFastLive: 3.0,
        abrEwmaSlowLive: 9.0,
        // Reintentos automáticos ante errores de red
        manifestLoadingMaxRetry: 6,
        fragLoadingMaxRetry: 4,
      });
      hls.loadSource(streamUrl);
      hls.attachMedia(video);
      hls.on(Hls.Events.MANIFEST_PARSED, () => { video.play(); });
      hls.on(Hls.Events.ERROR, (_evt, data) => {
        if (data.fatal) hls.recoverMediaError();   // intento de recuperación automática
      });
      hlsRef.current = hls;
    } else if (video.canPlayType("application/vnd.apple.mpegurl")) {
      // Safari: HLS nativo
      video.src = streamUrl;
      video.play();
    }

    return () => { hlsRef.current?.destroy(); };
  }, [streamUrl]);

  return (
    <video
      ref={videoRef}
      poster={posterUrl}
      controls
      playsInline
      className="w-full rounded-2xl aspect-video bg-black"
    />
  );
}