Como configurar Nginx RTMP para streaming live a partir do OBS

Atualize o índice de pacotes do APT:

sudo apt update

Esse comando sincroniza as listas de pacotes disponíveis. Necessário antes de instalar qualquer coisa nova num servidor que ficou parado.

Instale o compilador e as bibliotecas de desenvolvimento:

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

build-essential traz gcc e make. libpcre3-dev é necessário pro módulo de regex do Nginx, libssl-dev pro HTTPS e zlib1g-dev pra gzip. Total de ~250 MB instalados.

Crie um diretório de trabalho e baixe o Nginx estável:

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

A versão 1.26.x é a linha estável atual. Evite a mainline (1.27.x) em produção a menos que precise de feature específica.

Clone o módulo RTMP:

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

Esse fork mantém compatibilidade com Nginx moderno e tem bugfixes que o original arquivado não recebeu.

Configure o build apontando pro 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

Se algum --with-* reclamar de biblioteca faltando, instale o -dev correspondente via apt e re-rode o configure.

Compile e instale:

make -j$(nproc)
sudo make install

-j$(nproc) paraleliza a compilação no número de núcleos disponíveis. Numa vCPU única leva ~7 minutos; em 4 vCPUs, ~2 minutos.

Crie o serviço systemd pra gerenciar o 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 a configuração antes de subir — evita serviço quebrado após edit.

Crie o diretório onde os fragmentos HLS serão escritos:

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

O Nginx, sem usuário customizado configurado, roda como nobody. Ajuste se você definir user www-data no nginx.conf.

Substitua /etc/nginx/nginx.conf por uma configuração que combina 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;
        }
    }
}

Substitua 198.51.100.0/24 pelo seu IP/rede de origem real. O bloco allow publish é a primeira camada de defesa — sem ele, qualquer pessoa com sua URL RTMP publica.

Valide a sintaxe e suba o serviço:

sudo nginx -t
sudo systemctl start nginx

nginx -t deve responder configuration file ... test is successful. Qualquer erro aqui aponta a linha exata — corrija antes de continuar.

Habilite UFW e libere as portas necessárias:

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

Confirme com sudo ufw status numbered que as 4 regras aparecem antes de desconectar do SSH.

Abra OBS → Configurações → Transmissão e preencha:

A “chave” é o nome (name) que aparece nos fragmentos HLS e nos logs do Nginx-RTMP. Pode ser qualquer string ASCII sem espaços.

Clique em “Iniciar transmissão” no OBS. O OBS conecta no rtmp://SEU-IP/live e começa a publicar a stream com o nome minha-stream-001.

Liste os arquivos em /var/www/hls:

ls -la /var/www/hls/

Output esperado, ~3 segundos após começar a publicar:

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

Os .ts são fragmentos MPEG-TS de ~3 segundos cada. O .m3u8 é o manifesto que aponta pros fragmentos atuais.

Teste no navegador via https://hls-js.netlify.app/demo/ ou qualquer player que aceite HLS. Cole http://SEU-IP/hls/minha-stream-001.m3u8 e dê play.

Pra um teste rápido sem player web, use ffplay:

ffplay http://SEU-IP/hls/minha-stream-001.m3u8

A latência esperada do OBS ao player é de 9-15 segundos com a configuração padrão acima (hls_fragment 3s × buffer de 3 fragmentos no player).