Red5 Documentation

Wowza to Red5 Pro Server Migration Guide

Introduction

Purpose

The purpose of this migration guide is to assist developers in transitioning from Wowza Streaming Engine to Red5 Pro, providing detailed instructions and best practices to ensure a smooth and efficient migration process. This guide aims to highlight the key differences and similarities between the two platforms, enabling developers to replicate or enhance their current streaming functionalities on Red5 Pro.

Audience

This guide is intended for developers and technical teams who are currently utilizing Wowza Streaming Engine for their streaming applications and are looking to migrate to Red5 Pro. The audience includes:

  • Software developers with experience in streaming technologies.
  • DevOps teams responsible for infrastructure and deployment.
  • System architects evaluating the benefits of transitioning to Red5 Pro.

Overview of Platforms

  • Wowza Streaming Engine: A media server platform designed for live and on-demand video streaming, supporting a wide range of protocols and formats.
  • Red5 Pro: A scalable, low-latency streaming solution with a focus on WebRTC, RTMP, and HLS, suited for real-time streaming applications like live video, gaming, and conferencing.

Key Differences

  • Protocol Support:
    • Wowza supports HLS, MPEG-DASH, CMAF, WebRTC, RTSP/RTP, RTMP, ShoutCast
    • Red5 Pro emphasizes WebRTC, RTMP, HLS, Zixi, SRT, RTSP, MPEG-TS
  • Latency:
    • Wowza offers low-latency streaming but may require additional configuration.
    • Red5 Pro is optimized for real-time streaming with WebRTC and sub-500ms latency.
  • Scalability:
    • Wowza uses clustering and load-balancing systems, and scaling based on cloud infrastructure.
    • Red5 Pro, via the Stream Manager, allows for dynamic autoscaling, enabling the automatic addition of server resources based on traffic patterns and user load.
  • SDKs:
    • Wowza has a Flowplayer SDK for playback and streaming for:
SDK Link
Wowza Flowplayer HTML SDK Wowza Flowplayer HTML SDK
Wowza Flowplayer Apple SDK Wowza Flowplayer Apple SDK
Wowza Flowplayer Android SDK Wowza Flowplayer Android SDK
Wowza Flowplayer React Native SDK Wowza Flowplayer React Native SDK
Wowza Flowplayer Smart TV SDK Wowza Flowplayer Smart TV SDK
  • Red5pro has SDKs for playback and streaming for:
SDK Link
Red5 Pro HTML5 WebRTC SDK Red5 Pro HTML5 WebRTC SDK
Red5 Pro SDK for iOS Red5 Pro SDK for iOS
Red5 Pro SDK for Android Red5 Pro SDK for Android
Red5 Pro Core SDK (Windows, MacOS, Linux) Red5 Pro Core SDK
Unreal Engine SDK Contact us
Unity SDK Contact us
  • For More about SDK migration please see our full guide here: https://www.red5.net/docs/red5-pro/resources/migration-guides/wozwa-to-red5-pro-sdk-migration-guide/

Feature Comparison Chart

Feature Wowza Streaming Engine Red5 Pro
Supported Protocols HLS, MPEG-DASH, CMAF, WebRTC, RTSP/RTP, RTMP, ShoutCast WebRTC, RTMP, HLS, Zixi, SRT, RTSP, MPEG-TS
Autoscaling No (External Manual configurations can allow this) Yes (dynamic autoscaling)
SDKs Mobile (iOS, Android), Web (HTML) Mobile (iOS, Android), Web (HTML), and Other
Transcoding Yes Yes
Cloud Integration Yes Yes

Installation & Initial Setup

Wowza Setup Recap

Wowza Streaming Engine is typically installed through a straightforward executable on Windows and Linux or cloud options. The process involves setting up a license and an administrator account, with configuration handled mainly through XML files for streams, transcoding, and protocols.

  • Wowza Streaming Engine (WSE) Download :

    • Wowza Streaming Engine Official Site URL : Wowza installer.
    • Developers download the installer for their platform (varieties include Windows, and Linux).
  • Installation Options :

    • Pre-installed packages for Windows or Mac
    • Linux-based installation
  • Configuration :

    • Starts up with out-of-the-box configurations, but developers are generally expected to modify XML files like Server.xml or Application.xml to customize ports, applications, authentication methods, etc.
    • Or modify with Wowza Streaming Engine Manager
  • Licensing :

    • Wowza is licensed via the key provided after installing the engine, entering it into a config file, or as part of initial setup screens.
      Keep These Wowza Config Files in Mind for upcoming comparisons:
  • Server.xml – Major server settings.

  • Application.xml – Defines application-specific settings.

  • VHost.xml – Defines virtual hosts

Red5 Pro Installation

  • Server installation configuration options

    • When setting up Red5 Pro, you have two main configuration options: the Standalone Server and the Autoscaling Deployment. Here’s a comparison to help understand their key differences and when to use each.
    • Standalone Server Installation
      • Generally simpler, as it involves setting up only one server. Although the user is limited to the resources of the single server
      • Use Cases: Ideal for smaller-scale streaming needs, development environments, or testing purposes.
    • Autoscaling Deployment
      • More complex, Distributed deployment across multiple nodes with automatic scaling via our Stream Manager to handle varying demands. usually done on cloud platforms
      • Use Cases: Ideal for large audiences or unpredictable traffic, production environments, and events with high viewership.
  • Supported platforms and operating systems

  • Installation Process:

    • You will need to install JDK 11 or newer, LTS versions preferred (tested on JDK 17 and 21). unzip to run and deploy the Red5 Pro server. In addition, there are several native libraries required for WebRTC support, and jsvc is necessary for running Red5 Pro as a service. NTP service is necessary for autoscaling and communication with any other Red5 Pro servers if you are running a cluster

    • Standalone Server Installation

      • Manually deployment steps can be followed here: https://www.red5.net/docs/installation/installation/ubuntuinstall/ but Red5 Pro also offers Red5Pro installer
      • Red5Pro installer – https://github.com/red5pro/red5pro-installer
        • The Red5 Pro installer is a shell script that will install a single server Red5 Pro instance. The script presents a collection of menu-driven options to help achieve various Red5 Pro setup tasks including SSL certificate via Let’s Encrypt, adding/changing license key, and managing the red5pro service. You may also check your Red5 Pro installation and verify which version of Java you are running.
    • Autoscaling Deployment

      • Red5 Pro clusters can be installed on Cloud Platforms using our public Terraform Modules. These modules are available on the Red5 Pro Terraform Registry. We recommend using Terraform as it helps ensure the installations are proper and allows you to more easily manage your Red5 Pro clusters. Documentation for each of the modules is available on the Terraform Registry.
      • Manual deployment steps can also be followed, although they differ depending on the deployment cloud environment. links to documentation can be found above in the Supported platforms section
    • Licensing and Activation:

      • Red5 Pro server will not function without a valid license key. Your LICENSE.KEY file will be included in your server download in the root of the Red5 Pro server directory (i.e., /usr/local/red5pro). You can find your license key listed on your Red5 Pro Professional account overview page.
  • SSL certificate and WebRTC

System requirements

Feature Wowza Streaming Engine Red5 Pro
Hardware Minimum:
CPU: Single quad core, 3.00 GHz or better
Network: 1Gbps Ethernet
RAM: 4GB
Disk: SATA HDD

Ideal:
CPU: 6 cores, 3.00 GHz or better
RAM: 16-32GB
Disk: SATA SSD
Network: 10Gbps Ethernet

Minimum:
CPU: 2 CPU cores
RAM: 4GB
Disk Space: 4GB
Java Java versions 17 or 21 are suported. Java 11 or newer is required; Java versions 17 or 21 are suported
Supported Operating Systems Linux
Mac
Windows
Docker
Ubuntu 22.04 or newer
CentOS (CentOS 8 Stream)
Windows
Docker
Cloud Support Amazon Web Services (AWS)
Google Cloud Platform (GCP)
Microsoft Azure
Amazon Web Services
Digital Ocean
Google Cloud
Linode
Oracle Cloud (OCI)
Microsoft Azure
Simulated Cloud
VMware vSphere

Configuration and Customization

Configuration Files

Wowza Streaming Engine uses XML configuration files extensively for various parts of the system. Red5 Pro, on the other hand, uses properties files, such as red5.properties and webrtc.properties for its configurations.

Wowza Configuration Files and Equivalents in Red5 Pro

Wowza Configuration File Purpose Red5 Pro Equivalent
Server.xml General server configuration (port bindings, etc.) The red5.properties and network.properties contain the network and port configuration items.
VHosts.xml Virtual host definition (multiple virtual hosts setup) Red5 Pro does not support multiple virtual hosts, uses red5.properties to configure server behavior.
log4j2-config.xml Logging configuration for server events and error reporting logback.xml (Red5 Pro uses Logback for logging).
Tune.xml Server performance and optimization settings red5.properties (Contains performance-related configurations).
StartupStreams.xml Automatic stream startup at virtual host startup No direct equivalent, but streams can be dynamically configured via API and launched within Red5 Pro.
Application.xml Specifies application-level configurations The /webapps/{yourAppName}/WEB-INF/red5-web.properties contains per-App settings.

Developers will need to adjust to Red5 Pro’s Spring and property-based configuration schemes, but the functionality largely parallels Wowza’s settings.
A full list of Red5 Server Configuration Files are seen here – https://www.red5.net/docs/development/serverside-guides/config-files/

Server Settings

Wowza Settings vs. Red5 Pro Counterparts

  • Ports Configuration :

    • Wowza : Configured in Server.xml

      • DatagramStartingPort: Sets the starting UDP port for incoming UDP streams, commonly set to 6970 for RTSP/RTP servers. To support RTSP/RTP, native RTP, or MPEG-TS streams, ensure UDP ports 6970-9999 are open.
      • DatagramPortSharing: A Boolean setting that controls whether UDP ports can be shared. When true, it allows port sharing between SDP files, MPEG-TS streams, or application instances, enabling multiple audio streams or applications to share video or RTP ports. When false, port sharing is disabled, and an error occurs if reuse is attempted.
    • Red5 Pro : Configured in red5.properties and conf/network.properties

      • HTTP/WebSocket: Port 5080 (TCP), used for default web access and WebRTC WebSocket connections.
      • HTTPS/Secure WebSocket: Port 443 (TCP), recommended for secure HTTPS access and WebRTC secure WebSocket connections.
      • RTMP: Port 1935 (TCP), the default port for RTMP streams.
      • RTSP: Port 8554 (TCP), often used for streaming over the Real-Time Streaming Protocol.
      • UDP Ports: Configured in conf/network.properties using the port.min and port.max settings. These determine the range of ports available for UDP, equivalent to Wowza’s DatagramStartingPort and the UDP range.

      For WebRTC functionalities, a wider port range is required:

      • TURN/STUN/ICE: Ports 40000-65535 (TCP/UDP)
  • Bitrate Settings :

    • Wowza : Bitrate can be controlled by transcoder settings directly, application-defined parameters, or with the use of Application.xml. Specific stream profiles can be customized.
    • Red5 Pro : Bitrates are defined in application-level properties files or streaming configurations. It also supports adaptive bitrate Rate streaming (ABR) and configuration for individual protocols (e.g., WebRTC and RTMP).

Optimizing Streaming Protocols

  • Wowza Streaming Options : Wowza configures RTMP, HLS, and WebRTC through .xml profiles and server settings. Optimizations are made at the application level.
  • Red5 Pro Streaming Protocols :
    • RTMP : Configured in red5.properties.
    • WebRTC : Configured in webrtc-plugin.properties
      Example properties:Copy
      Red5 Pro gives more flexibility and dynamic control over WebRTC settings, allowing developers to fine-tune WebRTC connections beyond what Wowza supports.
    • RTSP
      • Configured in red5.properties, Enabled RTSP by setting rtsp.enabled=true

Access Control

Wowza Access Control
In Wowza , access control for streams is typically defined in Application.xml, allowing for different access rules per application (i.e., user authentication, IP-blocking, DRM control, etc.).
Example in Wowza Application.xml:

<StreamType>live</StreamType>
<StreamSecurity>
    <SecureToken>
        <Enable>true</Enable>
    </SecureToken>
</StreamSecurity>

Red5 Pro Access Control

Red5 Pro’s Round Trip Authentication provides a robust method for authorizing actions such as publishing and subscribing to streams on a per-request basis, enhancing control and security for stream management.

  1. Authentication Process: Red5 Pro uses a RoundTripAuthValidator class, which serves as an intermediary for stream authorization between the application and an external server. When a client initiates a publish or subscribe request, the validator communicates with a remote server to verify user credentials and permissions based on business logic. This verification process is specifically triggered by the stream action, not by a simple connection attempt.
  2. Token-Based Security: To initiate authentication, clients provide a username, password, and optionally a secure token, received upon login to the business server. This token acts as a session identifier and enhances security, especially when combined with the client’s role (e.g., publisher or subscriber). The authentication server then confirms whether the client has the necessary permissions for the intended action.
    1. With Stream Manager 2.0, JWT support has been introduced. This feature requires configuring a secret on the Red5 Pro server and eliminates the need to connect to an authentication backend.
  3. Implementation Requirements: This setup involves a few components:
    • Simple Authentication Plugin: A required library for enabling the round-trip validator.
    • Validator Configuration: Set up within red5-web.xml, defining endpoints and parameters.
    • Remote Server Endpoint: A server that processes the credentials and permissions check.

More information about Red5 Pro’s Round Trip Authentication can be seen here:

Web-Based Administration

Wowza Web Interface
Wowza includes a web-based admin console that allows users to configure server features, monitor live streams, and view server logs from a browser interface.
Red5 Pro Admin Tools
The Stream Manager is the cornerstone of Red5 Pro’s architecture, providing a comprehensive solution for managing, orchestrating, and scaling your streaming infrastructure. Designed to handle the complexities of live and on-demand video streaming, the Stream Manager ensures that all components of the Red5 Pro ecosystem work together to deliver high-quality, low-latency streams to viewers around the world.

Red5 Pro provides admin tools for monitoring live streaming environments, emphasizing real-time tracking and proactive maintenance. For effective visualization, it leverages third-party tools like Grafana and Prometheus. Grafana offers customizable dashboards for visualizing key metrics such as CPU and memory usage, network traffic, and stream statistics. Prometheus, an open-source monitoring solution, integrates seamlessly with Grafana to gather and analyze metrics from Red5 Pro instances. Prometheus also features a flexible query language and efficient time-series database, ideal for real-time data aggregation in complex streaming setups.

These monitoring tools work together to provide a comprehensive view of streaming infrastructure, enhancing stability and responsiveness by detecting and resolving issues promptly. For further details, you can review Red5 Pro’s documentation and setup guides for integrating these tools into a Red5 Pro environment.

More information about Red5 Pro’s Web tools see here:

Stream Management

Stream Creation

Wowza Streaming Engine:

  • Stream Creation Methods : Wowza allows developers to create streams through several methods such as WebRTC, RTMP, and RTSP. These streams can be initiated through the Wowza Streaming Engine Manager UI or via the REST API .
  • Within Wowza, after configuring the application, you can publish streams by pushing them into the application’s ApplicationInstance, and streams are automatically available via set protocols depending on the configuration.
  • Wowza’s REST API : Wowza provides a REST API for managing streams, creating applications, and configuring live streaming sessions. You can start and stop streams, list active streams, and configure stream settings via this API.
    Resource – https://www.wowza.com/docs/how-to-connect-a-publisher-to-wowza-streaming-engine

Red5 Pro:

  • Stream Creation Methods : Red5 Pro supports similar ingest protocols for stream creation— WebRTC, RTMP, and RTSP being the most commonly used. Live streams are published via the server using these protocols, and developers leverage the Stream Manager to manage the stream lifecycle.
  • Red5 Pro’s Stream Manager 2.0 :
    • Stream Manager 2.0 simplifies stream creation, management, and scaling. It acts as an orchestration and management layer for autoscaling Red5 Pro servers across cluster instances. Unlike Wowza’s Stream Engine Manager which is primarily an administrative tool, Red5 pro’s Stream Manager is code-forward and API-centric for managing stream lifecycles.
    • Restreamer plugin – https://www.red5.net/docs/special/restreamer/overview/
      • plugins that provide re-streaming from ingest sources that are not incoming RTMP, RTSP, or WebRTC connections such that you would typically receive from end user browsers or industry standard encoders. Plugin configuration options are located in the conf/restreamer-plugin.properties configuration file; which includes the ability to enable or disable the various ingest plugins such as RTSP IP Cameras (which require a connection to be established with them), Zixi, SRT, or MPEG-TS to name a few.
  • WebRTC Testbed:
    • The Red5 Pro Testbeds are practical resources that Red5 Pro provides to help developers evaluate and experiment with features in controlled, sandbox-like environments. Testbeds are tailored for WebRTC capabilities on Red5 Pro, providing essential tools for managing live streaming across web clients.
    • Red5 Pro WebRTC Testbeds allow the user to easily and simply generate a live stream, mainly for testing purposes.
      • The Testbed are included as a webapp with the server release for developer testing, and can be accessed at https://<your_server_ip>/webrtcexamples/

Protocol-Specific Stream Initialization

Wowza Streaming Engine

Wowza Streaming Engine provides support for a variety of protocols. The Wowza Streaming Engine Manager is the graphical interface where you configure and manage your streams.

  1. WebRTC

  2. RTSP

  3. RTMP

    1. https://www.wowza.com/docs/how-to-set-up-live-streaming-using-an-rtmp-based-encoder
    2. Depending on your encoder, you may need to enter this information in the following format instead:
      rtmp://[source-user-name]:[source-password]@[wowza-ip-address]:[port]/[application-name]
  4. HLS:

  5. MPEG-TS :

Red5 Pro

Red5 Pro’s platform is primarily focused on enabling low-latency streams. Stream Manager 2.0 allows centralized management for your clouds and servers. Let’s explore how to start streams for the protocols supported by Red5 Pro.

  1. WebRTC – https://www.red5.net/docs/red5-pro/users-guide/protocols/webrtc/red5-pro-webrtc-overview/

    1. WebRTC supports H264, VP8, AAC, and Opus broadcasts
    2. Publishing via WebRTC requires a valid SSL certificate for a registered URL, whereas subscribing does not. Red5 Pro with SSL
    3. To generate a WebRTC stream you can use the Red5 Pro WebRTC SDK to develop your browser-based application. The Red5 Pro HTML5 Streaming Example App contains a simple project with a number of examples that can be used for testing and reference with the Red5 Pro WebRTC SDK.
    4. Red5 Pro WebRTC Testbeds allow the user to easily and simply generate a live stream, mainly for testing purposes.
      • The Testbed are included as a webapp with the server release for developer testing, and can be accessed at https://<your_server_ip>/webrtcexamples/
  2. RTSP – RTSP streams can be generated a number of ways

    1. Make a GET Server for Publish Request
      1. GET https://<host>/as/v1/streams/stream/<nodeGroupName>/publish/<streamGuid>?subGroup=us-east&strict=false&transcode=false&endpoints=1
    2. Use the origin IP returned from that call as the target for your RTSP broadcaster on port 8554 (assuming you have not changed the default port)
    3. Red5 Pro SDKs (iOS, Android, and CORE)
      1. https://www.red5.net/docs/red5-pro/users-guide/protocols/rtsp/ios/red5-pro-ios-api-documentation/
      2. https://www.red5.net/docs/red5-pro/users-guide/protocols/rtsp/android/red5-pro-android-api-documentation/
    4. Ingesting RTSP feeds from IP cameras via the restreamer plugin
      1. https://www.red5.net/docs/development/restreamer/api/
      2. https://www.red5.net/docs/special/restreamer/ipcameras/
  3. RTMP – https://www.red5.net/docs/red5-pro/users-guide/protocols/rtmp/red5-pro-rtmp-publish-autoscale/

    1. Make the GET Server for Publish Request
      1. GET https://<host>/as/v1/streams/stream/<nodeGroupName>/publish/<streamGuid>?subGroup=us-east&strict=false&transcode=false&endpoints=1
    2. Use the origin IP returned from that call as the target for your RTMP broadcaster.
  4. HLS plugin – https://www.red5.net/docs/red5-pro/users-guide/protocols/hls-plugin/red5-pro-hls-plugin-overview/

    • Red5 Pro HLS supports H264 and AAC broadcasts
    • The HLS plugin consumes live streams from any application and transforms them into an MPEG live transport stream with an m3u8 playlist.
    • A stream consumable at the URI rtmp://serverurl/live/streamName will be also playable at https://serverurl/live/streamName.m3u8, by a browser that supports native HLS playback (like Safari) or a third-party player like VLC.
  5. MPEG-TS

    1. https://www.red5.net/docs/development/restreamer/api/#mpeg-ts
  6. Zixi

    1. The steps for publishing Zixi to an autoscale cluster are as follows:
      1. Make the broadcast API call.
      2. Using the origin IP address returned from that call, make the Zixi stream create API call.
      3. Start the Zixi publisher.
    2. With Red5 Pro, Zixi is avialable via caller mode or listener mode
  7. SRT

    1. The steps for publishing SRT to an autoscale cluster are as follows:
      1. Make the broadcast API call.
      2. Using the origin IP address returned from that call, make the SRT stream create API call.
      3. Start the SRT publisher.
    2. With Red5 Pro, SRT streaming is only available via listener modehttps://www.red5.net/docs/special/restreamer/caller-vs-listener/

Recordings and Cloud Storage

Recording Live Streams

Wowza Streaming Engine

  • Overview : Wowza Streaming Engine supports server-side recording of live streams in adaptive bitrate formats (MP4 or FLV), using customizable configurations. Recordings can be managed via the Wowza Streaming Engine Manager or programmatically using Wowza APIs.
  • How It Works :
    • Wowza records incoming streams from supported protocols such as RTMP, RTSP/RTP, and MPEG-TS.
    • Recording can be started and stopped manually through the admin interface or automatically via server-side configuration.
  • Key Configuration Options :
    1. Start/Stop Recording : Stream recording can be initiated manually in the Streaming Engine Manager or configured to start automatically when a stream begins.
    2. File Formats and Naming : Supports output in MP4 or FLV , with flexible naming conventions based on stream metadata or configuration.
    3. Split Recording : Allows files to be automatically split into multiple segments based on duration or file size. This is useful for long-running live streams.
  • Key Tools/Utilities :
    • Wowza Streaming Engine Manager : Provides an intuitive interface to manage live stream recordings (e.g., start/stop a recording, configure storage paths, split settings).
    • REST API for Recording Control : REST endpoints allow for programmatic start/stop recording of streams and querying recording status.
    • Module for Custom Processing : Developers can use Wowza’s Java-based server-side APIs to build custom recording workflows.

Red5 Pro

  • Overview : Red5 Pro includes built-in server-side and client-side functionality for recording live streams. it enables efficient server-side recording of live streams delivered via multiple protocols. Recordings output in HLS, FLV and MP4 format. Red5 Pro offers an expandable and developer-friendly approach tailored to real-time streaming use cases.
  • How It Works :
    • Recordings are initiated through server configuration, client-side configuration, query string parameters, or via REST API calls.
    • Red5 Pro records the incoming streams and writes them to locations based on red5-server settings, normally the streams directory within your application.
  • Key Configuration Options :
    1. Start/Stop Recording : Recordings can be started manually, automatically (as the stream starts), or via REST APIs.
    2. File Format: Recordings output in HLS, FLV and MP4 format (via post-process file writer)
  • Key Tools/Utilities :
    • Red5 Pro REST API : Endpoints allow developers to start/stop recordings on demand (e.g., /record/start and /record/stop endpoints).
    • Default Recording Logic : An automatic recording trigger can be enabled in the red5-server properties.
    • Custom Server Hooks : Developers can write logic to enhance the recording workflow by utilizing server-side extensions or integrating client-side SDKs.
    • Mobile SDKs (iOS/Android) : Enable live-stream capture and recording directly from mobile devices.

Key Comparison: Live Stream Recordings

Feature Wowza Streaming Engine Red5 Pro
Supported Protocols All that are supported All that are supported
Recording Formats MP4, FLV HLS, FLV, and MP4 format (via post-process file writer)
Trigger Mechanisms Manual, API, Engine Manager Manual, REST API, Server Configuration, Mobile SDKs
Split Recording Supported (based on duration/size) Supported via Append Mode
Metadata Handling Configurable file naming and metadata Configurable file naming and custom metadata injection
Upload to Cloud Storage Yes Yes

Configuring Storage for Recordings

Proper storage configuration is critical for maintaining accessibility and scalability of recorded streams. Both platforms offer flexible approaches for managing storage.

Wowza Streaming Engine

  • Default Storage : By default, recorded streams are saved to the /content folder within the Wowza installation directory.
  • Configurable Storage Options :
    1. Local Disk : Recording files can be saved locally on the server by specifying the directory path in the Application.xml configuration file.
    2. Cloud Storage Integration : Wowza supports direct integration with platforms like Amazon S3 , Google Cloud Storage , and Azure Blob Storage . Configurations are set via properties files or the Engine Manager.
    3. External Storage : Network shares, NAS, or SAN can be configured by mapping the directories to the Wowza server.
  • How to Configure :
    • Use the Wowza Streaming Engine Manager to set the recording location through the Applications > Recording menu.
    • Update the Recorder property in the application’s Application.xml file to customize the output path.
  • Tools for Integration :
    • REST API : Configure storage destinations dynamically using API calls.
    • Cloud Modules : Pre-built integration modules to automate uploads to S3 or other cloud services directly after recording.

Red5 Pro – https://www.red5.net/docs/red5-pro/users-guide/recording-and-vod/red5-pro-recording-and-vod-record-a-stream/

  • Default Storage : By default, Red5 Pro saves recorded files in the /webapps/{app-name}/streams directory.
  • Configurable Storage Options :
    1. Local Disk : Customize the storage location by modifying webapps/{app-name}/WEB-INF/red5-web.properties configuration files.
    2. Cloud Storage Integration: Red5 Pro includes a Cloud Storage Plugin to automatically upload recorded streams to cloud storage providers such as OCI, Amazon S3 , Google Cloud Storage, Azure Blob Storage and Digital Ocean spaces. In addition, other providers that support S3 interoperability may also work such as PhoenixNAP.
    3. External Storage : External paths can be configured similarly to local storage by modifying the server’s recording.path. For more advanced workflows, custom scripts can also be integrated.
  • How the Cloud Storage Plugin Works :
    • The Red5 Pro Cloud Storage Plugin facilitates direct uploads of recordings to cloud platforms upon completion of the recording. No external scripts are required, reducing complexity for cloud archiving.
    • Supported Platforms: Amazon S3-compatible systems, including DigitalOcean Spaces and similar providers with S3 API compatibility.
  • How to Configure :
    • Local Disk : The server automatically uses the streams sub-directory; to modify this, a developer would need to customize the stream path being used.
    • Cloud Storage :
  • Tools for Integration :
    • Red5 Pro REST API : This allows querying or programmatically managing recordings and storage paths.
    • Cloud Storage Plugin : Natively supports upload workflows, automatically archiving recordings once they are completed.

Key Comparison: Recording Storage Configuration

Feature Wowza Streaming Engine Red5 Pro
Default Storage Path /content folder /webapps/{app}/streams folder
Cloud Storage Capabilities Prebuilt modules for S3, Google Cloud Storage, etc. Cloud Storage Plugin for S3 and compatible systems
Dynamic Paths Supported via REST API and Application settings Supported via REST API and configuration
External Storage NAS/SAN support NAS/SAN support

Migration Recommendations

  1. Analyze Current Workflow :
    • Identify whether your Wowza setup relies on local, cloud-integrated, or external file systems for recording storage.
    • Document any cloud storage configurations such as S3 buckets, folder structures, or credentials used in Wowza’s modules.
  2. Replicate in Red5 Pro :
    • Use the Cloud Storage Plugin to recreate Wowza’s cloud integration workflows. Install it on your Red5 Pro server, configure your S3-compatible provider, and test uploads for accuracy.
    • Customize recording file paths using the recording.path configuration to match your existing storage hierarchy.
    • Leverage REST API where dynamic runtime configurations are needed.
  3. Enhance Storage Automation :
    • If custom Wowza workflows rely on REST API triggers, script replacement functionality using Red5 Pro REST endpoints.
    • Use the Cloud Storage Plugin for a simpler and more automated upload process, reducing reliance on external scripts or manual uploads.

By carefully mapping Wowza workflows to Red5 Pro’s APIs and configuration options, you can ensure a smooth transition with minimal disruption to your live stream recording and storage systems.

Media Transcoding and Codec Support

Wowza Transcoder

Overview

Wowza Streaming Engine offers a built-in Wowza Transcoder feature. This transcoder is an adaptive bitrate streaming and media processing engine that delivers quality streaming experiences by automatically transcoding live video into multiple versions (bitrates) suitable for different network conditions and devices.

Key Features:

  • Multi-bitrate Transcoding: The ability to generate multiple bitrates of a single live stream for adaptive bitrate delivery.
  • Codec Support: Wowza supports H.264 (video), AAC (audio) for ingestion, with output in various codecs like H.264, VP8, and AAC.
  • Custom Transcoding Profiles: Developers can tailor transcoding to specific use-cases through custom transcoder templates.

Transcoding Workflow in Wowza:

  1. Input sources: The live stream fed to your Wowza instance.
  2. Transcoding Pipeline: Ingest stream is passed through the Wowza transcoder engine to make adaptive bitrate versions.
  3. Delivery: Transcoded streams are delivered using various protocols, with support for DVR, if needed

Management via Stream Manager:

Wowza doesn’t have a Stream Manager feature directly equivalent to Red5 Pro’s Stream Manager 2.0 , but developers can manage transcoding through the Wowza Streaming Engine Manager, a web-based graphical interface that allows configuration and management of live applications. Here, you can:

  • Activate transcoding for a live stream.
  • Apply transcoding templates with defined bitrate configurations.
  • Directly monitor streaming and transcoding processes through the admin panel.

Red5 Pro Transcoding

Overview

Red5 Pro offers live video transcoding services in combination with Stream Manager 2.0. This new version of Stream Manager is important to note because it centralizes and improves the management of live streams, deployments, autoscaled clusters, and crucially – transcoding.
Unlike Wowza, Red5 Pro’s approach to transcoding leverages a distributed cloud-based architecture, with Stream Manager 2.0 handling much of the heavy lifting. Red5 Pro’s transcoding solution is designed to work within its Autoscaling-Node-Server architecture, particularly in clustered environments where performance and autoscaling are key.

Key Features:

  • Cloud-Based Adaptive Transcoding: Red5 Pro supports transcoding, similar to Wowza, converting live video into multiple bitrates (adaptive streaming), allowing the support of multiple endpoints.
  • Stream Manager 2.0 Integration: Stream Manager 2.0 improves orchestration for transcoding workflows, scaling streams dynamically as demands fluctuate.
  • Dynamic Clustering: Integration with the autoscaling aspect of Stream Manager 2.0 allows dynamic scaling of transcoding resources, which makes it particularly powerful for cloud deployments.
  • Custom Codec Support: Supports H.264 (and soon H.265) and AAC for transcoding, but more formats can be integrated via its plug-in architecture.
  • Edge and Origin Node Management: Stream Manager 2.0 ensures seamless synchronization between transcoded streams across edge nodes and origin servers.

Stream Manager 2.0 Transcoding Workflow:

  1. Input stream: The developer ingests a live stream to Red5 Pro (via protocols such as WebRTC or RTMP).
  2. Stream Manager 2.0 Orchestration: Stream Manager handles the distribution of this stream across the autoscaled Red5 Pro infrastructure.
    1. https://www.red5.net/docs/red5-pro/users-guide/stream-manager-2-0/migration-guide/stream-manager-2-migration-abr/
  3. Resource Monitoring & Scaling: Stream Manager monitors resource usage and scales the transcoding resources up or down as necessary based on viewership peaks to avoid any overuse of resources.
  4. Delivery: The transcoded streams are delivered by Red5 Pro via HLS, RTMP, or WebRTC protocols.

Cloud and Distributed Approach:

A major differentiator for Red5 Pro is its emphasis on distributed computing and cloud-first transcoding solutions, which contrasts with Wowza’s more traditional server-based approach. The integration of Stream Manager 2.0 with cloud-native transcoding on Red5 Pro makes it incredibly useful when scaling large live events or services.

API Comparison: Red5 Pro vs Wowza Streaming Engine

Red5 Pro’s Stream Manager 2.0 API is a comprehensive suite designed to manage Red5 Pro nodes, authenticate clients, securely route client requests, schedule scaling operations, and provision streams dynamically.
Stream Manager 2.0 introduces several APIs:

API Role
Admin API Manages the Red5 Pro nodes.
Deploys and manages Red5 Pro nodes.
Scales nodes in and out based on scaling expressions, capacity expressions, and current node group load.
Auth API Authenticates clients.
Provides JWT tokens for use with other Stream Manager services.
Proxy API Securely routes client requests to appropriate Red5 Pro nodes.
Utilizes capacity ranking expressions, limit expressions, and current node group load to determine routing.
Scheduling NodeGroups API Schedules node groups for scaling in and out based on predefined schedules.
Streams API Handles publishing and subscribing requests from clients.
Provides insights into the current load of nodes in the node group.
Streams Provision API Provisions streams for publishing and subscribing.
Processes parameters passed in the provision request.

The inclusion of OpenAPI/Swagger UI makes it easy for developers to explore and test endpoints, while command-line tools like CURL, along with cheat sheets, streamline integration workflows. With a focus on autoscaling, a microservices-driven architecture, and intelligent distribution, Stream Manager 2.0 aligns with modern cloud-based streaming solutions.

By comparison, the Wowza Streaming Engine REST API provides a RESTful interface for programmatically managing the Wowza Streaming Engine, a highly extensible, on-premises, and cloud-compatible media server platform. It offers endpoints for controlling core server operations such as starting and stopping applications, querying server statistics. Wowza’s REST API is particularly suited for tightly controlled environments with administrator-managed configurations, supporting tasks like stream monitoring, load balancing, and VOD workflows. While highly versatile, the Wowza REST API operates within a monolithic server architecture, contrasting the distributed, node-based system of Red5 Pro.

Both platforms offer powerful APIs catered to streaming application needs, but developers transitioning from Wowza to Red5 Pro must adapt to Red5 Pro’s distributed infrastructure, which emphasizes scalability, dynamic provisioning, and multi-node load management. The sections ahead will delve into the technical parallels and distinctions between these APIs, highlighting tools and utilities to replicate or enhance existing functionality in Red5 Pro while leveraging the full potential of Stream Manager 2.0.

Key Areas of Comparison

Stream Manager 2.0 Admin API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-admin-api/

The Admin API is a powerful set of endpoints that enables the administration, configuration, and management of Red5 Pro’s autoscaling infrastructure. It provides functionality to create, update, retrieve, and delete cluster configurations (NodeGroups), manage Terraform-related resources, monitor the state of clusters, and evaluate scaling rules. Authentication for this API is mandatory via JWT (passed in the Authorization header).

Authentication

All Admin API requests require a valid JWT (JSON Web Token) in the Authorization header in the form Bearer <token>. Refer to the Auth API documentation for generating valid tokens.

NodeGroup Management

NodeGroups define clusters that autoscale based on predefined configurations, roles, rules, and cloud infrastructure. Use these APIs to manage NodeGroups effectively.

Category API Name HTTP Method Endpoint Description
NodeGroup Management Create NodeGroup POST /as/v1/admin/nodegroup Create a new NodeGroup with a specified configuration.
NodeGroup Management List All NodeGroups GET /as/v1/admin/nodegroup Retrieve a list of all active NodeGroups (by name).
NodeGroup Management Get NodeGroup Configuration GET /as/v1/admin/nodegroup/<name>?isEffective=<true> Return the configuration for a given NodeGroup, by name.
NodeGroup Management Update NodeGroup PUT /as/v1/admin/nodegroup Update the configuration of a specified NodeGroupConfig.
NodeGroup Management Delete NodeGroup DELETE /as/v1/admin/nodegroup/<name> Delete a NodeGroup and all its associated nodes.
NodeGroup Management List All Scheduled NodeGroups GET /as/v1/admin/nodegroup/scheduled Retrieve a list of all scheduled NodeGroups.
NodeGroup Management List Scheduled Overlays GET /as/v1/admin/nodegroup/scheduled/<nodeGroupName> Retrieve all scheduled overlays of a given base NodeGroupConfig.
NodeGroup Management Read NodeGroup Status GET /as/v1/admin/nodegroup/status/<nodeGroupName> Return metrics, status, scaling events, and node events for all nodes in a specific NodeGroup.
NodeGroup Management Get NodeGroup Idle Time GET /as/v1/admin/nodegroup/<nodeGroupName>/idle Retrieve the minimum lastIdleMs metric from all INSERVICE nodes in a NodeGroup.
NodeGroup Management List Proxy Sessions GET /as/v1/admin/rtcproxy Retrieve a list of all active AS-Proxy WebRTC connections.
NodeGroup Management Terminate Proxy Session DELETE /as/v1/admin/rtcproxy/<sessionIdOrStreamGuid> Forcefully terminate a WebRTC proxy session or all sessions associated with a stream.
Category API Name HTTP Method Endpoint Description
Terraform Management List Terraform Images GET /as/v1/admin/terraform/image Retrieve a list of all available Terraform images for each cloud platform.
Terraform Management List Instance Types GET /as/v1/admin/terraform/instanceType Retrieve a list of all available instance types for each cloud platform.
Terraform Management List Nodes GET /as/v1/admin/terraform/node Retrieve a list of all nodes for each cloud platform and region.
Terraform Management List Regions GET /as/v1/admin/terraform/region Retrieve a list of all regions for each cloud platform.
Terraform Management List Terraform Events GET /as/v1/admin/terraform/node/events/<nodeGroupName> Retrieve Terraform events related to a specific NodeGroup.
Terraform Management Terraform Update Info GET /as/v1/admin/terraform/updateInfo Update Terraform information, including instances, regions, and images.
Category API Name HTTP Method Endpoint Description
Expression Evaluation Evaluate Capacity Expression (Live) POST /as/v1/admin/evaluate/capacity/<nodeGroupName>/<nodeId> Evaluate a Capacity Expression using the live metrics from a specific node in the NodeGroup.
Expression Evaluation Evaluate Capacity Expression (User) POST /as/v1/admin/evaluate/capacity/ Evaluate a Capacity Expression using user-provided metrics.
Expression Evaluation Evaluate Scale Expression (Live) POST /as/v1/admin/evaluate/scale/<nodeGroupName>/<subGroupName>/<nodeRoleName> Evaluate a Scale Expression using aggregated live metrics from nodes of a specific role.
Expression Evaluation Evaluate Scale Expression (User) POST /as/v1/admin/evaluate/scale/ Evaluate a Scale Expression using user-provided aggregated metrics.
Category API Name HTTP Method Endpoint Description
Other Monitoring APIs Read NodeGroup Status GET /as/v1/admin/nodegroup/status/<nodeGroupName> Retrieve detailed metrics (CPU, memory, connections, etc.) for all active nodes in the NodeGroup.
Other Monitoring APIs Get NodeGroup Idle Time GET /as/v1/admin/nodegroup/<nodeGroupName>/idle Check the idle time (lastIdleMs) for nodes in a NodeGroup.

Stream Manager 2.0 Auth API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-auth-api/

The Auth service is responsible for user authentication. When users provide valid credentials, a JWT (JSON Web Token) is generated. This JWT is required for performing authenticated tasks in certain services, such as as-admin and as-streams.

Usage

  1. Obtain a JWT by providing valid credentials (username and password).
  2. Verify the JWT using a specific endpoint or pass the JWT as a Bearer token in subsequent API requests.
Category API Name HTTP Method Endpoint Description
Login/Authentication Login and Get JWT PUT /as/v1/auth/login Authenticate a user with credentials (username and password) to receive a valid JWT.
Token Verification Verify Token via Streams GET /streams/verify/<token> Verify a JWT against the Streams service (if DebugVerifyController is enabled).
Token Verification Provision with Bearer Token POST /streams/provision/foo Use the JWT as a Bearer token to authenticate a request to provision a stream (requires authentication).

Mapping Authentication: Wowza to Red5 Pro

Functionality Wowza Authentication Red5 Pro Auth API
Login/Authenticate Provide basic auth via the Authorization header. Make a PUT request to /auth/login to obtain a JWT.
Token Handling N/A (no token-based auth). Use JWT as a bearer token for subsequent requests (e.g., /streams/provision).
Provisioning/Stream Operations Authenticate with basic auth for API tasks. Make API requests with the JWT in the Authorization header.

https://www.wowza.com/docs/how-to-change-the-authentication-method-for-the-wowza-streaming-engine-rest-api

Stream Manager 2.0 Proxy API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-proxy-api/

The Proxy API serves as a secure relay mechanism for routing traffic between clients and Red5 Pro cluster nodes, which do not have their own SSL certificates. It handles WebRTC Ingest (WHIP) , WebRTC Egress (WHEP) , WebRTC over WebSockets , and plain HTTP proxying for APIs and servlets hosted on cluster nodes.

Category API Name HTTP Method Endpoint Description
WebRTC (WHIP or WHEP) OPTIONS OPTIONS /as/v1/proxy/whip/<streamGuid> Retrieve options for a specific stream.
WebRTC (WHIP or WHEP) POST POST /as/v1/proxy/whip/<streamGuid> Start a WHIP/WHEP/WebRTC session.
WebRTC (WHIP or WHEP) PATCH PATCH /as/v1/proxy/whip/<streamGuid> Update details for a WHIP/WHEP/WebRTC session.
WebRTC (WHIP or WHEP) DELETE DELETE /as/v1/proxy/whip/<streamGuid> Stop or delete a WHIP/WHEP/WebRTC session.

Wowza supports WebRTC for both publishing and subscribing. To transition this functionality to Red5 Pro, developers may utilize the WHIP, WHEP, or WebRTC endpoints provided by the Stream Manager Proxy API.

WHIP (WebRTC Publishing)

In Wowza:

  • WebRTC publishing is done through specific endpoints, often requiring SSL/TLS and additional headers for security.
    In Red5 Pro Stream Manager 2.0 Proxy API:
  • Publishing is achieved using the WHIP endpoint above
  • If host is unspecified, the Proxy API uses the nodeGroup to determine the cluster node.
  • Transcode streams by setting transcode: true.

WHEP (WebRTC Subscribing)

In Wowza:

  • WebRTC subscribing typically requires connecting via a JavaScript WebRTC client to specific Wowza-generated SDP links.
    In Red5 Pro:
  • WHEP (WebRTC Egress Protocol) simplifies the subscription process.

Using WebSockets for WebRTC

Wowza Streaming Engine provides WebSocket support for WebRTC in certain scenarios. Similarly, Red5 Pro’s WebSocket Proxy facilitates both publishing and subscribing:

Category API Name Endpoint Description
WebSockets WebRTC WebSockets (Subscribe) wss://<host>/as/v1/proxy/ws/subscribe/<contextPath>/<streamGuid> Use WebSockets for WebRTC Subscribe traffic.

HTTP Proxy for Cluster Node Access

Wowza’s REST API supports managing streams via HTTP, including servlets for low-level control. In Red5 Pro, the Plain HTTP Proxy simplifies cluster communication.

Category API Name Endpoint Description
WebSockets WebRTC WebSockets (Subscribe) wss://<host>/as/v1/proxy/ws/subscribe/<contextPath>/<streamGuid> Use WebSockets for WebRTC Subscribe traffic.

Stream Manager 2.0 Streams API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-streams-api/
The Streams API manages operations related to listing streams, retrieving stream statistics, and finding the best servers for publishing or subscribing to streams within a NodeGroup. It supports flexible options for querying streams in different configurations, aggregating stats, and determining the “best-fit” server nodes.

Category API Name HTTP Method Endpoint Description
Stream Management List All Streams GET /as/v1/streams/stream/<nodeGroupName> Retrieve a summary of all streams within a NodeGroup (supports stats and aggregation).
Stream Management Get Stream Stats GET /as/v1/streams/stream/<nodeGroupName>/stream/<streamGuid> Retrieve subscriber counts for a specific stream (supports aggregation).
Server Selection (Publish) Get Server for Publish GET /as/v1/streams/stream/<nodeGroupName>/publish/<streamGuid> Find the best “origin” server for publishing a stream based on NodeGroup configurations.
Server Selection (Subscribe) Get Server for Subscribe GET /as/v1/streams/stream/<nodeGroupName>/subscribe/<streamGuid> Find the best “edge” server for subscribing to a stream based on NodeGroup configurations.

Listing All Streams

In Wowza:

In Wowza Streaming Engine, streams can be queried on a per-application basis, typically using the HTTP REST API.

Wowza API Endpoint:
GET https://<wowza-host>:8087/v2/servers/_defaultServer_/vhosts/_defaultVHost_/applications/<application-name>/instances/<instance-name>/incomingstreams
Wowza’s API provides a way to list all incoming streams, but synchronization across multiple servers in clustered environments may require additional effort.

Equivalent in Red5 Pro: List All Streams

Red5 Pro simplifies this process using the Streams Service in Stream Manager 2.0. The List All Streams functionality aggregates stream information from all nodes and supports configurable options for stats (e.g., subscriber counts) and aggregation.

Red5 Pro API Endpoint

GET https://<host>/as/v1/streams/stream/<nodeGroupName>?stats=true&aggregate=false

  • Key Options:
    • stats: Include subscriber counts (true/false).
    • aggregate: Aggregate stats across nodes, reporting on origin streams (true/false).

Retrieving Stream Statistics

In Wowza:

Wowza’s REST API supports fetching statistics like the connected client count and stream bitrate on a per-application or per-stream level.

Wowza API Endpoint

GET https://<wowza-host>:8087/v2/servers/_defaultServer_/vhosts/_defaultVHost_/applications/<application-name>/instances/<instance-name>/monitoring/current

Equivalent in Red5 Pro: Get Stream Stats

Red5 Pro allows retrieval of subscriber statistics either at the node level or aggregated across the nodes in a cluster. This is useful for monitoring stream usage, load balancing, or application-level routing decisions.

Red5 Pro API Endpoint

GET https://<host>/as/v1/streams/stream/<nodeGroupName>/stream/<streamGuid>?aggregate=true

  • Key Query Parameter:
    • aggregate: Defaults to true, aggregates subscriber stats across nodes. If false, shows subscriber counts for individual nodes hosting the stream.

Finding a Server to Publish or subscribe

In Wowza:

Wowza manages streaming servers dynamically, ensuring that publishing points are assigned based on server load or pre-defined configurations. Developers need to programmatically assign stream publication servers.

Wowza API Endpoint:

Wowza does not provide a direct mechanism for server routing like in Red5 Pro but allows developers to customize this process through load balancer modules or custom endpoints.

Equivalent in Red5 Pro: Get Server for Publish

Red5 Pro provides a built-in mechanism for choosing the optimal server for publishing. This is handled through the Get Server for Publish API, which evaluates server capacity and optionally filters by subgroups.

Stream Manager 2.0 Streams Provision API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-streams-provision-api/

The Streams Provision API allows creating, managing, and deleting provisions for publishing streams. These provisions define additional stream parameters such as adaptive bitrate (ABR) settings, transcoding details, third-party authentication, cloud storage options, and more.

Category API Name HTTP Method Endpoint Description
Provision Management Create Provision POST /as/v1/streams/provision/<nodeGroupName> Create a new provision for additional stream parameters such as ABR, transcoding, or IP cam ingest.
Provision Management List Provisions GET /as/v1/streams/provision/<nodeGroupName> Retrieve all provisions registered under the specified NodeGroup.
Provision Management Get Provision Details GET /as/v1/streams/provision/<nodeGroupName>/<streamGuid> Retrieve details of a specific provision using its streamGuid.
Provision Management Update Provision PUT /as/v1/streams/provision/<nodeGroupName> Update an existing provision and forward it to nodes already hosting the provision.
Provision Management Delete Provision DELETE /as/v1/streams/provision/<nodeGroupName>/<streamGuid> Delete a provision by its streamGuid. The request is also forwarded to active nodes.

Wowza Transcoder Settings with Red5 Pro’s Provision API

The Wowza Streaming Engine GUI allows media transcoding setup (e.g., bitrate, resolution). Red5 Pro achieves this through the Create Provision endpoint in the Streams Provision API.

Red5 Pro Example

  • Create Provision Request replicating adaptive bitrate (ABR) transcoding:

POST https://<host>/as/v1/streams/provision/<nodeGroupName> Content-Type: application/json Authorization: Bearer <your-token>
[ { "streamGuid": "live/test", "streams": [ { "streamGuid": "live/test_3", "abrLevel": 3, "videoParams": { "videoWidth": 320, "videoHeight": 180, "videoBitRate": 500000 } }, { "streamGuid": "live/test_2", "abrLevel": 2, "videoParams": { "videoWidth": 640, "videoHeight": 360, "videoBitRate": 1000000 } }, { "streamGuid": "live/test_1", "abrLevel": 1, "videoParams": { "videoWidth": 1280, "videoHeight": 720, "videoBitRate": 2000000 } } ] } ]

Key Parameters
  • streamGuid : Acts as the identifier for a stream instance.
  • abrLevel : Specifies the Adaptive Bitrate quality level.
  • videoParams : Replicates transcoding parameters like resolution, bitrate, and keyframe intervals.

Stream Manager 2.0 Scheduling NodeGroups API

https://www.red5.net/docs/red5-pro/development/api/stream-manager-2-0/stream-manager-2-scheduling-nodegroups-api/
The Scheduling NodeGroups API enables automatic scaling of resources (NodeGroups) based on time schedules using cron expressions . You can define NodeGroups that exist only during specific timeframes or overlay additional configurations on existing clusters for temporary scaling.

Category API Name HTTP Method Endpoint Description
Schedule New NodeGroup Create Scheduled NodeGroup POST /as/v1/admin/nodegroup Create a new NodeGroup and attach a schedule to start it during specific times, defined by cron expressions.
Schedule Overlays Create Scheduled Overlay POST /as/v1/admin/nodegroup Create a NodeGroupConfig overlay to scale an existing NodeGroup up or down temporarily.

Testing and Debugging

When migrating your live streaming application from Wowza Streaming Engine to Red5 Pro, robust testing and debugging processes are critical to ensure a seamless transition. This section provides a comprehensive guide to testing stream quality, monitoring key performance metrics, assessing logs, and leveraging platform-specific debugging tools.

Testing Streams**

RTMP Testing on Red5 Pro

RTMP, which both Wowza and Red5 Pro support, is still widely used for its stability and compatibility with legacy systems. To ensure quality RTMP streaming on Red5 Pro:

WebRTC Testing on Red5 Pro
WebRTC is preferred for ultra-low latency streaming in modern applications.

  • WebRTC Testbed:
    • As mentioned earlier the Red5 Pro Testbeds are practical resources that Red5 Pro provides to help developers evaluate and experiment with features in controlled, sandbox-like environments. Testbeds are tailored for WebRTC capabilities on Red5 Pro, providing essential tools for managing live streaming across web clients.
    • Red5 Pro WebRTC Testbeds allow the user to easily and simply generate a live stream, mainly for testing purposes.
      • The Testbed are included as a webapp with the server release for developer testing, and can be accessed at https://<your_server_ip>/webrtcexamples

Monitoring and Troubleshooting

Logging Differences: Wowza’s Logging Structure vs. Red5 Pro’s Log Files

Logging systems provide critical insights for debugging live streams. If you’re familiar with Wowza’s logging setup, the transition to Red5 Pro should be straightforward:

  • Wowza :
    • Wowza logs are located in the /logs directory by default and categorized into server logs (wowzastreamingengine_access.log) and application logs (error.log, stream.log).
    • Standardized logging levels include INFO, WARN, and ERROR for debugging application and flow issues.
    • Log analysis tools like Splunk can process Wowza logs for extended insights.
  • Red5 Pro :
    • In Red5 Pro, logs are stored in the /logs directory and provide details on server activity, WebRTC connections, RTMP streams, and client interactions.
    • With Stream Manager 2.0 , Red5 Pro consolidates logs via a centralized logging interface accessible through the Stream Manager Dashboard.
    • red5.log file host General server runtime information.
    • Use tail commands or log streaming utilities to dynamically monitor logs during live operation.

Key Metrics for Monitoring

  • Latency:
    • Although simple, one of the easiest ways to measure and determine latency is by live-streaming a millisecond stopwatch. By comparing the time displayed in the published video to the subscribed video, you can calculate the latency
  • Packet Loss :
    • Packet loss can disrupt the quality of streaming, particularly in WebRTC, where UDP transport is used.
    • In chrome, chrome://webrtc-internals can be used to view many streaming Metrics, including packet loss
  • Bandwidth Usage :
    • Optimize bandwidth usage by implementing adaptive bitrate streaming with Red5 Pro’s multi-quality variants. This reduces resource strain for users on slower networks.

Common Debugging Scenarios

  • Stream Failure :
    • Ensure RTMP ingest URLs are correctly formatted, contain valid credentials, and match application names in the Red5 Pro configuration.
    • Troubleshoot WebRTC handshakes, including ICE candidate failures, using the Red5 log reports.
    • If authentication is enabled or disabled
  • Poor Quality :
    • For degraded video quality, check encoder configurations, including bitrate, codecs (H.264 for video, AAC for audio), and keyframe intervals.
    • Monitor server capacity
    • Bandwidth capabilities during subscriptions
  • Common errors include
    • 401 (Unauthorized) for missing/invalid JWT
    • 404 (Not Found) for invalid resources
    • 400 (Bad Request) for syntax errors.

https://www.red5.net/docs/troubleshooting/webrtc-troubleshooting/troubleshooting/
https://www.red5.net/docs/troubleshooting/inspector/overview/
https://www.red5.net/docs/troubleshooting/auto-install-troubleshooting/general-auto-troubleshooting/

Best Practices for Red5 Pro

Building a high-performance streaming application using Red5 Pro requires an understanding of configuration optimizations and best practices. Developers transitioning from Wowza Streaming Engine to Red5 Pro will benefit from the tips and strategies outlined here to ensure smooth deployment and operation. This section will cover performance optimization, memory allocation, file system tweaks, and Red5 Pro-specific configuration enhancements.

Performance Optimization in Red5 Pro

  1. Prioritize Critical Web Apps :
    • To improve performance, only keep web apps that are essential for your solution.
    • Critical web apps:
      • live – Required for normal Red5 Pro streaming operations.
      • root – Default web application.
    • Remove unnecessary web apps such as webrtcexamples (unless using the examples for testing) and custom web apps that are no longer in use.
  2. Remove Unused Plugins :
    • If your use case doesn’t rely on certain functionality, remove the related plugins from the red5pro/plugins directory:
      • red5pro-mpegts-plugin-*.jar – Remove if HLS streaming and recording are not required.
      • red5pro-restreamer-plugin-*.jar – Remove if you’re not restreaming MPEG-TS streams.
      • red5pro-webrtc-plugin-*.jar – Essential for WebRTC publishing/subscribing, remove if unused.
      • red5pro-whip-plugin-*.jar – Essential for WHIP/WHEP features; note that this requires the WebRTC plugin jar
      • red5pro-autoscale-plugin-*.jar – Keep only if using Autoscaling.
      • Note: If removing the inspector web app, ensure you also remove its associated inspector.jar from the plugins directory.
  3. Optimize Connection Handling :
    • Fine-tune your server to handle the expected number of concurrent streams effectively.
    • Avoid over-allocating resources to unused functions, as it can degrade server performance.

Memory Allocation

  • Proper memory allocation for the Java Virtual Machine (JVM) is crucial for Red5 Pro’s optimal performance. Follow the best practices outlined below:
    1. Determine Available Memory :
      • Before starting the Red5 Pro service, check the system’s available memory using:
        cat /proc/meminfo
        Focus on the MemFree value.
      • For example, on a system with 4GB memory:
        MemTotal:        4026028 kB
        MemFree:         2541440 kB
        MemAvailable:    3015708 kB
        • Set JVM memory allocation based on the MemFree value, ideally allocating 80%. In this example, allocate 2G RAM to the JVM process:
          java -Xmx2G -Xms2G -jar red5pro.jar
    2. Avoid Overallocation :
      • Ensure other processes running on the server also have adequate free memory.

Linux File System Optimizations

To handle the high demands of streaming servers, Red5 Pro benefits from file system-level tuning. Here’s how to get started:

  1. Increase Open File Limits :

    • By default, Linux has a low limit for open files (1024). Increase this to prevent bottlenecking:
      • Run: ulimit -n
      • If required, modify settings in:
        • /etc/security/limits.conf
        • /etc/pam.d/common-session (add session required pam_limits.so)
      • Example configuration:
        root soft nofile 1000000
        root hard nofile 1000000
        ubuntu soft nofile 1000000
        ubuntu hard nofile 1000000
      • Reload user sessions with: sysctl -p
  2. Adjust Kernel Settings for File Descriptors :

    • Edit /etc/sysctl.conf and add:
      fs.file-max = 1000000
      kernel.pid_max = 999999
      kernel.threads-max = 999999
      vm.max_map_count = 1999999
    • Apply changes: sysctl -p
  3. Increase Red5 Pro Service Open File Limit :

    • Modify the LimitNOFILE value in /lib/systemd/system/red5pro.service:
      LimitNOFILE=1000000
    • Reload the system service:
      sudo systemctl daemon-reload

Red5 Pro-Specific Optimizations

  1. Optimize Thread Pool Settings :
    • Update HTTP and thread pool settings for better performance in the red5pro/conf/red5.properties:
       http.max_threads=20
       http.acceptor_thread_count=10
       http.processor_cache=20
    • For systems with high CPU and memory, you can increase these values as appropriate, ensuring adequate resources are available.
  2. Tomcat Configurations :

    • Edit the red5pro/conf/jee-container.xml file:
      <map>
      <entry key="maxThreads" value="100"/>
      <entry key="acceptorThreadCount" value="2"/>
      <entry key="acceptCount" value="1000"/>
      <entry key="processorCache" value="100"/>
      <entry key="connectionTimeout" value="20000"/>
      <entry key="maxConnections" value="100"/>
      </map>
  3. Set HTTP Keep-Alive Settings :
    • In the jee-container.xml file:
      <entry key="maxKeepAliveRequests" value="100"/>
      <entry key="keepAliveTimout" value="5000"/>
  4. Autoscaling and Stream Manager 2.0 Integration :
    • For autoscaling setups, ensure that the configuration aligns with Stream Manager 2.0’s requirements. Documentation from Red5 Pro covers how to set up autoscale nodes.
    • Ensure Stream Manager’s HTTP endpoint is optimized with updated red5.properties settings for threads and caching.

Autoscale Best Practices

Pre-Event Preparation :

  • For event-based deployments (e.g., live concerts or webinars), it’s recommended to refresh your autoscaling environment before each event. This ensures a clean state and minimizes the risk of performance degradation due to lingering resource demands or fragmented processes.
    • Steps:
      • Take down the existing nodegroup (origin and edge groups) once the previous event ends.
      • Cycle your Stream Manager(s) by restarting them to clear the cache and reset configurations.
      • Launch a fresh nodegroup for the new event.
  • Capacity and Resource Planning :
    • Ensure your system can handle the anticipated peak traffic load:
      • Create a testing environment to simulate expected traffic and tune the autoscaling configuration accordingly (e.g., CPU, memory, and instance type selection).
      • Use monitoring tools to keep track of metrics such as CPU usage, memory, and bandwidth.
  • Scaling Policies :
    • Configure clear scaling thresholds to control when nodes are added or removed based on subscriber demand:
  • Region and Latency Considerations :
    • Deploy nodes close to your audience to reduce latency. Utilize CDN integration where applicable to extend geographic reach and limit direct server loads on autoscale nodes.

Conclusion

Switching from Wowza Streaming Engine to Red5 Pro is a major step that brings notable advantages, such as reduced latency, improved scalability, and support for modern streaming protocols. This migration guide has offered a detailed comparison of the two platforms, outlining their similarities, differences, and key workflows to help ensure a successful transition.

Red5 Pro is purpose-built for low-latency streaming and adaptive scaling. Its dynamic infrastructure, leveraging WebRTC and other state-of-the-art protocols, makes it an excellent choice for real-time applications. With features like Stream Manager 2.0, dynamic API provisioning, and powerful SDKs, Red5 Pro offers developers the flexibility to build streaming solutions customized to their needs. Its microservice-based architecture allows businesses to future-proof their streaming platforms, meeting today’s audience demands for speed, quality, and reliability.

By using this guide, you’ve learned how to install, configure, and optimize Red5 Pro to replicate—or improve upon—your current Wowza workflows. With thorough testing, debugging, and best practices such as resource optimization and autoscaling strategies, you can achieve a smooth migration and maintain high-quality streaming with minimal downtime.

every migration is unique, requiring continuous testing, monitoring, and iteration to meet your specific needs. Red5 Pro’s comprehensive documentation, testing tools, and troubleshooting resources can help you adapt the platform to your use case. These innovative features enable you to create scalable, real-time streaming solutions that offer exceptional performance and flexibility, setting your platform up for future growth.

By adopting Red5 Pro, you’re preparing your streaming architecture for the next generation of technological advancements. This ensures your platform is ready to deliver engaging, low-latency experiences to users anywhere in the world. We wish you great success with your migration and in all your future streaming projects!