eriolapp/server-streaming

eriolapp/server-streaming

Self-hosted multistream relay server for Eriol. Receives a single video stream via SRT and redistributes it simultaneously to multiple RTMP destinations (***, ***, Kick, *** Live, Restream, or any RTMP-compatible endpoint).

Quick Start

bash
docker run -d \
  --name eriol-streaming \
  -p 8080:8080 \
  -p 5000:5000/udp \
  eriolapp/server-streaming:latest

On startup the container auto-generates authentication credentials and prints them to the logs:

bash
docker logs eriol-streaming

╔══════════════════════════════════════════════════════════════╗
║       ERIOL STREAMING SERVER - CREDENTIALS                  ║
╠══════════════════════════════════════════════════════════════╣
║  Username: aBcDeFgHiJkL                                     ║
║  Password: xYz0123456789AbCdEfGh                            ║
╚══════════════════════════════════════════════════════════════╝

You can retrieve them again at any time:

bash
docker exec eriol-streaming cat /app/.credentials.txt

---

How It Works

┌─────────────┐         SRT (UDP:5000)         ┌──────────────────────┐
│  Eriol App   │ ─────────────────────────────► │  Streaming Server    │
│  (Desktop)   │                                │                      │
└─────────────┘                                 │  Demux ► Transcode   │
                                                │  ► FLV Mux ► Tee     │
                                                │         │            │
                                                │    ┌────┴────┐       │
                                                │    │  RTMP   │       │
                                                │    │  Sinks  │       │
                                                └────┴─────────┘───────┘
                                                      │    │    │
                                            ┌─────────┘    │    └─────────┐
                                            ▼              ▼              ▼
                                        Twitch         YouTube          Kick

1. Eriol desktop app captures screen/camera and sends H.264 + AAC over SRT
2. Streaming server receives, optionally transcodes, and multiplexes into FLV
3. RTMP outputs relay the stream to every configured platform simultaneously

This means you only upload one stream from your machine — the server handles duplication to all platforms, saving bandwidth and CPU on the broadcaster's side.

---

Ports

---

Environment Variables

Fixed Credentials Example

bash
docker run -d \
  --name eriol-streaming \
  -p 8080:8080 \
  -p 5000:5000/udp \
  -e STREAMING_AUTH_USER=myadmin \
  -e STREAMING_AUTH_PASS=mysecretpassword \
  eriolapp/server-streaming:latest

---

Configuration

The server is configured via a TOML file mounted at /app/config/config.toml. A default configuration is embedded in the image — mount your own to customize:

bash
docker run -d \
  --name eriol-streaming \
  -p 8080:8080 \
  -p 5000:5000/udp \
  -v ./config.toml:/app/config/config.toml:ro \
  eriolapp/server-streaming:latest

config.toml Reference

toml
[server]
bind = "0.0.0.0"
http_port = 8080
public_host = "your-domain.com"   # Public domain or IP
cert_path = "/app/config/cert.pem"  # TLS cert (optional)
key_path = "/app/config/key.pem"    # TLS key (optional)

[auth]
# Managed automatically — override with env vars
username = "placeholder"
password = "placeholder"

[srt]
port = 5000
latency_ms = 120
# passphrase = "optional-secret-min-10-chars"  # SRT encryption

[session]
grace_period_secs = 30       # Time before orphaned sessions are cleaned
keepalive_timeout_secs = 60  # Max time without keepalive before timeout
max_sessions = 1             # Concurrent session limit

[stream]
default_width = 1920
default_height = 1080
default_framerate = 30
default_bitrate = 6000000       # 6 Mbps video
default_audio_bitrate = 128000  # 128 kbps audio
keyframe_interval_ms = 2000     # 2 seconds
transcode = true                # false = passthrough (requires H264+AAC input)

[logging]
level = "info"     # trace, debug, info, warn, error
format = "json"    # json or pretty

---

Docker Compose

Basic Deployment

yaml
services:
  eriol-server:
    image: eriolapp/server-streaming:latest
    container_name: eriol-streaming-server
    restart: unless-stopped
    ports:
      - "8080:8080"
      - "5000:5000/udp"
    volumes:
      - ./config.toml:/app/config/config.toml:ro
      - ./logs:/app/logs
    environment:
      - RUST_LOG=info
      - TZ=UTC
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 4G
        reservations:
          cpus: '2'
          memory: 2G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s

With GPU Acceleration (NVIDIA)

yaml
services:
  eriol-server:
    image: eriolapp/server-streaming:latest
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,video,utility
    ports:
      - "8080:8080"
      - "5000:5000/udp"

Requires https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html on the host.

With GPU Acceleration (Intel/AMD VA-API)

yaml
services:
  eriol-server:
    image: eriolapp/server-streaming:latest
    devices:
      - /dev/dri:/dev/dri
    environment:
      - GST_VAAPI_ALL_DRIVERS=1
    ports:
      - "8080:8080"
      - "5000:5000/udp"

---

API Reference

All endpoints require HTTP Basic Auth (Authorization: Basic base64(user:pass)).

Health & Status

Stream Control

RTMP Provider Management

Session Management (API v1)

Example: Create a Session

bash
curl -u admin:password -X POST https://your-server:8080/api/v1/sessions \
  -H "Content-Type: application/json" \
  -d '{
    "providers": [
      { "name": "twitch", "url": "rtmp://live.twitch.tv/app/live_xxxxx" },
      { "name": "youtube", "url": "rtmp://a.rtmp.youtube.com/live2/xxxx-xxxx" }
    ]
  }'

Response:

json
{
  "session_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "srt_url": "srt://your-server:5000?streamid=a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "waiting_stream"
}

---

Hardware Encoding

The server auto-detects available GPU encoders at startup. Priority order:

If no GPU is available, it falls back to software encoding (x264enc). Set transcode = false in config for zero-copy passthrough if your input is already H.264 + AAC.

---

Session Lifecycle

POST /api/v1/sessions        →  WaitingStream
                                    │
SRT stream connects (port 5000)     │
                                    ▼
                                  Live  ◄──── POST keepalive (every ~30s)
                                    │
SRT disconnects or timeout          │
                                    ▼
                               Disconnected
                                    │
DELETE /api/v1/sessions/:id         │
                                    ▼
                                  Ended

• WaitingStream: Session created, server awaiting SRT connection
• Live: Stream is being received and relayed to RTMP destinations
• Disconnected: SRT connection lost (will auto-reconnect if stream resumes)
• Ended: Session terminated, pipeline cleaned up

Sessions expire after keepalive_timeout_secs (default 60s) without a heartbeat.

---

Volumes

---

Resource Recommendations

---

Supported Input Formats

---

Security Notes

• Credentials are generated randomly at each container start unless overridden via env vars
• All API endpoints require Basic Auth
• TLS is supported — provide cert_path and key_path in config
• SRT encryption is optional — set passphrase in [srt] config (minimum 10 characters)
• The container runs as non-root user eriol (UID 1000)

---

Troubleshooting

Check if the server is running

bash
curl -u user:pass http://localhost:8080/api/health

View logs

bash
docker logs -f eriol-streaming-server

Enable verbose logging

bash
docker run -e RUST_LOG=debug -e GST_DEBUG=4 eriolapp/server-streaming:latest

Verify GPU detection

Check startup logs for encoder detection:

INFO  Detected H264 encoder: nvh264enc (hardware)

If no hardware encoder is found:

INFO  Detected H264 encoder: x264enc (software fallback)

Common Issues

---

Tags

---

Links

• Docker Hub: https://hub.docker.com/r/eriolapp/server-streaming
• Eriol: eriol.io