Cómo configurar Nginx RTMP para streaming en vivo desde OBS

Actualiza el índice de paquetes de APT:

sudo apt update

Este comando sincroniza las listas de paquetes disponibles. Es necesario antes de instalar cualquier cosa nueva en un servidor que ha estado inactivo.

Instala el compilador y las bibliotecas de desarrollo:

sudo apt install -y build-essential libpcre3-dev libssl-dev zlib1g-dev git wget

build-essential trae gcc y make. libpcre3-dev es necesario para el módulo de regex de Nginx, libssl-dev para HTTPS y zlib1g-dev para gzip. Total de ~250 MB instalados.

Crea un directorio de trabajo y descarga Nginx estable:

mkdir -p ~/build && cd ~/build
wget https://nginx.org/download/nginx-1.26.2.tar.gz
tar -xzvf nginx-1.26.2.tar.gz

La versión 1.26.x es la línea estable actual. Evita la mainline (1.27.x) en producción a menos que necesites una característica específica.

Clona el módulo RTMP:

cd ~/build
git clone https://github.com/sergey-dryabzhinsky/nginx-rtmp-module.git

Este fork mantiene compatibilidad con Nginx moderno y tiene bugfixes que el original archivado no recibió.

Configura el build apuntando al módulo RTMP:

cd ~/build/nginx-1.26.2
./configure \
  --prefix=/etc/nginx \
  --sbin-path=/usr/sbin/nginx \
  --conf-path=/etc/nginx/nginx.conf \
  --pid-path=/var/run/nginx.pid \
  --with-http_ssl_module \
  --with-http_v2_module \
  --add-module=../nginx-rtmp-module

Si algún --with-* se queja por una biblioteca faltante, instala el -dev correspondiente vía apt y vuelve a ejecutar configure.

Compila e instala:

make -j$(nproc)
sudo make install

-j$(nproc) paraleliza la compilación en el número de núcleos disponibles. En una vCPU única lleva ~7 minutos; en 4 vCPUs, ~2 minutos.

Crea el servicio systemd para gestionar Nginx:

sudo tee /etc/systemd/system/nginx.service > /dev/null <<'EOF'
[Unit]
Description=Nginx HTTP and RTMP server
After=network.target

[Service]
Type=forking
PIDFile=/var/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/usr/sbin/nginx -s reload
ExecStop=/usr/sbin/nginx -s quit
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable nginx

ExecStartPre valida la configuración antes de arrancar — evita un servicio roto tras una edición.

Crea el directorio donde se escribirán los fragmentos HLS:

sudo mkdir -p /var/www/hls
sudo chown -R nobody:nogroup /var/www/hls

Nginx, sin un usuario personalizado configurado, se ejecuta como nobody. Ajusta esto si defines user www-data en el nginx.conf.

Sustituye /etc/nginx/nginx.conf por una configuración que combine HTTP + RTMP:

worker_processes auto;
events {
    worker_connections 1024;
}

rtmp {
    server {
        listen 1935;
        chunk_size 4096;

        application live {
            live on;
            record off;

            hls on;
            hls_path /var/www/hls;
            hls_fragment 3s;
            hls_playlist_length 60s;

            allow publish 127.0.0.1;
            allow publish 198.51.100.0/24;
            deny publish all;
        }
    }
}

http {
    include mime.types;
    default_type application/octet-stream;
    sendfile on;
    keepalive_timeout 65;

    server {
        listen 80;
        server_name _;

        location /hls {
            types {
                application/vnd.apple.mpegurl m3u8;
                video/mp2t ts;
            }
            root /var/www;
            add_header Cache-Control no-cache;
            add_header Access-Control-Allow-Origin *;
        }

        location /stat {
            rtmp_stat all;
            rtmp_stat_stylesheet stat.xsl;
        }

        location /stat.xsl {
            root /var/www;
        }
    }
}

Sustituye 198.51.100.0/24 por tu IP/red de origen real. El bloque allow publish es la primera capa de defensa — sin él, cualquier persona con tu URL RTMP podría publicar.

Valida la sintaxis y arranca el servicio:

sudo nginx -t
sudo systemctl start nginx

nginx -t debería responder configuration file ... test is successful. Cualquier error aquí indica la línea exacta — corrígelo antes de continuar.

Habilita UFW y abre los puertos necesarios:

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 1935/tcp
sudo ufw enable

Confirma con sudo ufw status numbered que aparecen las 4 reglas antes de desconectar del SSH.

Abre OBS → Configuración → Emisión y completa:

La “clave” es el nombre (name) que aparece en los fragmentos HLS y en los logs de Nginx-RTMP. Puede ser cualquier cadena ASCII sin espacios.

Haz clic en “Iniciar transmisión” en OBS. OBS conecta a rtmp://TU-IP/live y empieza a publicar el stream con el nombre mi-stream-001.

Lista los archivos en /var/www/hls:

ls -la /var/www/hls/

Salida esperada, ~3 segundos después de empezar a publicar:

mi-stream-001-0.ts
mi-stream-001-1.ts
mi-stream-001.m3u8

Los .ts son fragmentos MPEG-TS de ~3 segundos cada uno. El .m3u8 es el manifiesto que apunta a los fragmentos actuales.

Prueba en el navegador vía https://hls-js.netlify.app/demo/ o cualquier reproductor que acepte HLS. Pega http://TU-IP/hls/mi-stream-001.m3u8 y dale play.

Para una prueba rápida sin reproductor web, usa ffplay:

ffplay http://TU-IP/hls/mi-stream-001.m3u8

La latencia esperada de OBS al reproductor es de 9-15 segundos con la configuración por defecto de arriba (hls_fragment 3s × buffer de 3 fragmentos en el reproductor).