Cómo simular oyentes para pruebas de carga en tu radio online

Simular oyentes para pruebas de carga es una tarea fundamental cuando operamos una radio online independiente. En La MIX Radio, que corre sobre nuestro homelab Proxmox con Icecast2 y Nginx, la estabilidad es clave. Queremos asegurarnos de que el servidor pueda manejar picos de audiencia sin despeinarse. En este artículo, compartiremos una metodología práctica y las herramientas que utilizamos para emular oyentes, garantizando que nuestra infraestructura esté siempre lista para el siguiente éxito.

El problema de la demanda incontrolada

Imaginen esto: pasamos horas eligiendo la mejor música, configurando los automatismos y promocionando la radio. De repente, una de nuestras publicaciones se viraliza o un DJ invitado atrae a una audiencia masiva. Es el sueño de todo operador de radio independiente, ¿verdad? Sin embargo, si nuestra infraestructura no está preparada para ese aumento repentino de oyentes, el sueño puede convertirse rápidamente en una pesadilla. El servidor de Icecast podría saturarse, el proxy Nginx podría fallar, y la transmisión se cortaría para muchos, o peor aún, para todos los que están conectados. La experiencia del usuario se arruina y la reputación de nuestra radio se ve comprometida.

Sin una forma de simular oyentes para pruebas de carga, navegamos a ciegas. No sabemos dónde está el límite de nuestro sistema. ¿Puede Icecast manejar 100 oyentes? ¿Qué hay de 500? ¿Y si todos intentan conectarse al mismo tiempo? Estos son los síntomas de la falta de pruebas: interrupciones inesperadas, quejas de la audiencia y un rendimiento inconsistente que nos impide crecer con confianza. Para radios como La MIX Radio, donde cada oyente es valioso y la continuidad del servicio es primordial, dejar esto al azar no es una opción.

Requisitos previos para emular oyentes

Para llevar a cabo estas pruebas de carga, necesitamos algunas herramientas y un entorno configurado. No se preocupen, todo es software libre y fácil de instalar, incluso si son autodidactas en sistemas como nosotros. Aquí está la lista de lo que van a necesitar:

Un servidor GNU/Linux: Puede ser una máquina física, una VM o un contenedor LXC en su homelab Proxmox. En nuestro caso, a menudo usamos una VM específica (por ejemplo, la VM 111) para estas tareas, separada de la VM principal de la radio para no interferir con la transmisión real.
Python 3: La versión moderna del lenguaje de programación.
La librería requests de Python: Es una biblioteca HTTP muy popular y sencilla de usar. Pueden instalarla con pip install requests.
Acceso a su servidor Icecast2: Necesitarán la URL completa de su stream (por ejemplo, http://icecast.lamixradio.com:8000/lamixhigh.mp3 o https://stream.lamixradio.com/lamixhigh.mp3 si usan Nginx como proxy SSL).
Conocimientos básicos de línea de comandos (Bash): Para ejecutar scripts y monitorear procesos.
Opcional pero recomendado: screen o tmux para ejecutar procesos en segundo plano y desconectarse de la sesión SSH.

Una vez que tengan esto listo, podremos comenzar a simular oyentes para pruebas de carga de manera controlada y efectiva.

Solución paso a paso: Simulando la carga de oyentes

Ahora, vamos a ver cómo podemos simular oyentes para pruebas de carga de forma práctica. El objetivo es crear un «ejército» de oyentes virtuales que se conecten a nuestro stream y permanezcan escuchando durante un tiempo determinado. Esto nos permitirá observar cómo reacciona nuestro servidor Icecast y Nginx.

Paso 1: Crear el script Python para un oyente simulado

Comenzaremos con un script Python sencillo que simula la conexión de un oyente. Este script intentará conectarse a la URL de su stream de Icecast y «escuchará» la transmisión. Guardaremos este archivo como listenersim.py en un directorio conveniente, como /home/lamix/scripts/loadtest/.


import requests
import time
import sys
import logging # Configuración básica de logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') # URL de tu stream de Icecast

STREAMURL = "http://icecast.lamixradio.com:8000/lamixhigh.mp3" # Identificador único para cada oyente simulado
LISTENER_ID = sys.argv[1] if len(sys.argv) > 1 else "default" # Duración deseada de la conexión en segundos (ej. 10 minutos)
CONNECTION_DURATION = 600 # Retardo antes de intentar reconectar si hay un error
RECONNECTDELAY = 10 logging.info(f"Iniciando simulación de oyente {LISTENERID} para {STREAMURL}") starttime = time.time()
while (time.time() - starttime) < CONNECTIONDURATION: try: logging.info(f"Oyente {LISTENERID}: Conectando a {STREAMURL}") # Conexión persistente con stream=True with requests.get(STREAMURL, stream=True, timeout=10) as r: r.raiseforstatus() # Lanza un error para códigos de estado HTTP erróneos (4xx o 5xx) logging.info(f"Oyente {LISTENERID}: Conectado exitosamente. Escuchando...") for chunk in r.itercontent(chunksize=1024): # Si no hay chunk (fin de stream) o si la duración ya se alcanzó, salimos if not chunk or (time.time() - starttime) >= CONNECTIONDURATION: break # Aquí podríamos simular algún procesamiento si fuera necesario, # pero para la prueba de carga, basta con leer los datos. logging.info(f"Oyente {LISTENERID}: Conexión finalizada (duración alcanzada o stream terminado).") break # Salimos del bucle si la conexión fue exitosa y duró el tiempo deseado except requests.exceptions.RequestException as e: logging.error(f"Oyente {LISTENERID}: Error de conexión: {e}. Reintentando en {RECONNECTDELAY} segundos...") time.sleep(RECONNECTDELAY) except Exception as e: logging.error(f"Oyente {LISTENERID}: Error inesperado: {e}. Reintentando en {RECONNECTDELAY} segundos...") time.sleep(RECONNECT_DELAY)
logging.info(f"Oyente {LISTENER_ID}: Simulación terminada.")

Paso 2: Lanzar múltiples oyentes con un script Bash

Para simular oyentes para pruebas de carga de forma masiva, necesitaremos un script Bash que ejecute varias instancias del script Python en segundo plano. Guardaremos este script como start_listeners.sh en el mismo directorio.



PYTHONSCRIPT="/home/lamix/scripts/loadtest/listenersim.py" # Número de oyentes a simular. Se puede pasar como argumento (ej. ./startlisteners.sh 50)

NUM_LISTENERS=${1:-10} # Directorio para almacenar los logs de cada oyente
LOGDIR="/home/lamix/logs/loadtest"
mkdir -p "$LOGDIR" # Asegura que el directorio de logs existe echo "Iniciando $NUMLISTENERS oyentes simulados..."
echo "Los logs individuales se guardarán en $LOGDIR" for i in $(seq 1 $NUMLISTENERS); do LOGFILE="$LOGDIR/listener${i}.log" echo "Lanzando oyente $i. Log: $LOGFILE" # Ejecuta el script Python en segundo plano ( & ) y redirige su salida a un archivo de log # El identificador "listener$i" se pasa como argumento al script Python python3 "$PYTHONSCRIPT" "listener$i" > "$LOGFILE" 2>&1 & sleep 0.1 # Pequeña pausa para evitar sobrecargar el sistema al inicio
done echo "Todos los oyentes han sido lanzados en segundo plano."
echo "Para detenerlos, puedes usar 'pkill -f listenersim.py' o buscar sus PIDs con 'ps aux | grep listenersim.py' y usar 'kill PID'."
echo "Si usas screen o tmux, puedes desconectarte sin que los procesos se detengan."

Antes de ejecutar, asegúrense de que ambos scripts tengan permisos de ejecución: chmod +x /home/lamix/scripts/loadtest/*.py /home/lamix/scripts/loadtest/*.sh.

Para ejecutar la simulación, simplemente usen: /home/lamix/scripts/loadtest/startlisteners.sh 100 (para 100 oyentes).

Paso 3: Monitorear el servidor Icecast y Nginx

Mientras la prueba de carga está en curso, es crucial monitorear el rendimiento de nuestro servidor. Esto es lo que hacemos nosotros:

Accedemos a la interfaz de administración de Icecast (http://suipicecast:8000/admin/). Aquí podemos ver el número exacto de oyentes conectados.
Usamos htop o top en la consola del servidor para observar el uso de CPU y RAM.
Ejecutamos netstat -tulnp | grep :8000 para ver las conexiones activas al puerto de Icecast. Si usamos Nginx como proxy, también revisaremos sus logs y conexiones al puerto 80/443.
Revisamos los logs de Icecast (generalmente en /var/log/icecast2/error.log y access.log) y de Nginx para detectar errores o advertencias.

La clave para una buena prueba de carga no es solo la simulación, sino también el monitoreo constante. Observen cómo reacciona su sistema mientras intentan simular oyentes para pruebas de carga. Anoten los puntos de quiebre y los recursos que se agotan.

Paso 4: Detener la simulación

Cuando quieran detener a todos los oyentes simulados, pueden usar un comando muy útil:


pkill -f listener_sim.py

Esto enviará una señal de terminación a todos los procesos de Python que estén ejecutando listener_sim.py.

Errores comunes y cómo evitarlos al hacer pruebas de carga

Al intentar simular oyentes para pruebas de carga, nos hemos encontrado con algunos obstáculos. Aquí les compartimos los más comunes y cómo los abordamos en nuestro homelab.

La librería requests no está instalada: Es un error frecuente para quienes empiezan con Python. El script Python simplemente no funcionará, y verán un mensaje de «ModuleNotFoundError: No module named ‘requests'».
Solución: Deben instalarla. Ejecuten en su terminal:
```
pip install requests

pip3 install requests
```
El firewall bloquea las conexiones: A veces, nuestro servidor (o la máquina de pruebas) tiene un firewall activo (como ufw o firewalld) que impide que los oyentes simulados se conecten al puerto de Icecast (comúnmente 8000) o a Nginx (80/443).
Solución: Asegúrense de que los puertos necesarios estén abiertos. Por ejemplo, para ufw:
```
sudo ufw allow 8000/tcp comment 'Permitir Icecast para pruebas'

sudo ufw allow 80/tcp comment 'Permitir HTTP'
sudo ufw allow 443/tcp comment 'Permitir HTTPS'
sudo ufw reload
```
Verifiquen que el servidor de pruebas también pueda hacer conexiones salientes.
Los scripts no se ejecutan en segundo plano o se detienen al cerrar la terminal: Si simplemente usan ./start_listeners.sh &, los procesos pueden morir si la sesión SSH se cierra.
Solución: Utilicen herramientas de multiplexación de terminal como screen o tmux. Con ellas, pueden iniciar la simulación, «desconectar» la sesión y el proceso seguirá ejecutándose en el servidor. Luego pueden reconectarse y ver el estado.
```
screen -S loadtest # Crea una nueva sesión llamada "loadtest"
/home/lamix/scripts/loadtest/startlisteners.sh 200 # Ejecutan la simulación
Ctrl+A, D # Desconectan la sesión de screen
screen -r loadtest # Para reconectar más tarde
```
Esto es invaluable para pruebas de larga duración o para ejecutar tareas en máquinas remotas sin preocupaciones.

Evitar estos escollos les permitirá centrarse en el objetivo principal: simular oyentes para pruebas de carga de manera eficiente y obtener datos fiables sobre el rendimiento de su radio.

Resultado final y verificación de la prueba de carga

Una vez que hayan lanzado a su «ejército» de oyentes y hayan monitoreado el sistema, ¿cómo saben que la prueba fue exitosa y qué información clave deben extraer? El resultado final no es solo que el servidor no haya caído, sino entender su comportamiento bajo estrés.

La verificación es sencilla y se basa en los monitoreos que realizamos. Primero, el panel de administración de Icecast debe mostrar un número de oyentes cercano al que intentamos simular. Si lanzamos 200 oyentes y Icecast solo reporta 150, debemos investigar por qué no todos lograron conectarse o se desconectaron prematuramente. Los logs de nuestro script Python (en /home/lamix/logs/load_test/) serán cruciales para entender el comportamiento de cada oyente.

Luego, las métricas del sistema: ¿La CPU se disparó al 100% y se mantuvo ahí? ¿La RAM se agotó y el sistema empezó a usar swap? ¿El ancho de banda de red del servidor estaba saturado? Todas estas son señales de que hemos encontrado un cuello de botella. En La MIX Radio, buscamos un equilibrio. El servidor debe trabajar duro, pero no al punto de volverse inestable. Si notamos degradación del servicio para el número objetivo al simular oyentes para pruebas de carga, sabemos que necesitamos optimizar Icecast, Nginx, o incluso considerar escalar los recursos de la VM en Proxmox.

El éxito de simular oyentes para pruebas de carga radica en la capacidad de identificar los límites de su sistema antes de que los oyentes reales los encuentren. Esto les permite anticipar y resolver problemas de rendimiento.

Conclusión y siguientes pasos

En este artículo, hemos visto cómo simular oyentes para pruebas de carga es una estrategia indispensable para cualquier operador de radio online que valore la estabilidad y la experiencia de sus usuarios. A través de scripts Python y Bash, combinados con un monitoreo efectivo, podemos anticipar y mitigar problemas de rendimiento en nuestro servidor Icecast y Nginx, tal como lo hacemos en nuestro homelab con La MIX Radio.

Ahora que tienen esta herramienta en sus manos, el siguiente paso es integrar estas pruebas de carga en su flujo de trabajo. Podrían automatizar estas pruebas con herramientas como n8n para ejecutarlas periódicamente, o incluso antes de cada gran evento. Experimenten con diferentes números de oyentes y duraciones de conexión. La mejora continua de su infraestructura garantizará que su radio online no solo suene increíble, sino que también sea robusta y confiable, sin importar la cantidad de oyentes que lleguen.