Settings for the database of operational data, e.g. processes, metadata, persisted session summaries, and so on.

Configuration

{
   "db": {
      "dir": "./config"
   },
}

CORE_DB_DIR="./config"

dir (string)

Directory for holding the operational data. The path is relative to where the binary is executed and the directory must exist.

The default value is ./config

The API allows you to manipulate the contents of the available filesystems.

The profiling endpoint allows you to fetch profiling information from a running datarhei Core instance. It has to be enabled with debug.profiling in the config.

Navigate you browser to /profiling where you can access different diagnostic solutions as described in https://go.dev/doc/diagnostics.

Docker way

docker pull {image}
docker kill core
docker rm core
docker run {params ...} {image}

docker pull {image}
docker kill core
docker rm core
docker run {params ...} {image}

Systemd way

The /ping endpoint returns a plain text pong response. This can be used for liveliness and/or latency checks.

curl http://127.0.0.1:8080/ping

from core_client import Client

client = Client(

A/V Processing

1. Core launches and monitors FFmpeg processes

2. FFmpeg can use HTTP, RTMP, and SRT services as streaming backends for processing incoming and outgoing A/V content.

3. Several storage locations are available for the HTTP service: In-memory file system, aka MemFS (very fast without disk I/O.) Disk file system, aka DiskFS, for storage on the HDD/SSD of the host system.

4. Optionally, FFmpeg can access host system devices such as GPU and USB interfaces (requires FFmpeg built-in support).

Settings for static HTTP routes.

Configuration

The datarhei Core includes a simple RTMP server for publishing and playing streams. It is not enabled by default. You have to enable it in the config in the or via the corresponding environemnt variables.

Example:

In the above example /live is the RTMP app and 12345.stream is the name of the resource.

The documentation of the API is available on /api/swagger/index.html

Example:

Settings for the host datarhei Core is running on.

Configuration

The datarhei Core is a process management solution for FFmpeg that offers a range of interfaces for media content, including HTTP, RTMP, SRT, and storage options. It is optimized for use in virtual environments such as Docker. It has been implemented in various contexts, from small-scale applications like Restreamer to large-scale, multi-instance frameworks spanning multiple locations, such as dedicated servers, cloud instances, and single-board computers. The datarhei Core stands out from traditional media servers by emphasizing FFmpeg and its capabilities rather than focusing on media conversion.

__

Settings for collecting metrics of the core and FFmpeg processes.

Configuration

The datarhei Core provides two filesystem abstractions that you can use in your FFmpeg process configurations.

Disk

The disk filesystem is the directory you defined in the configuration at . Any FFmpeg command will be restricted to this directory (or its subdirectories) for file access (read or write). One exception is /dev in order to access, e.g. USB cameras.

The debugging settings can help to find and solve issues with the datarhei Core.

Configuration

The datarhei Core includes a simple SRT server for publishing and playing streams. Check out the and the . This API endpoint will list the details of all currently publishing and playing streams.

This class of endpoints provide access to information that can be used for widgets in a website. These endpoints are not protected by the API access control.

Process

Fetch minimal statistics about a process. You need to know the process ID.

Restreamer-UI

The Restreamer-UI is an easy interface to manage multiple live and restreams on different platforms like the website, YouTube, Facebook and more.

The datarhei Core includes a simple RTMP server for publishing and playing streams. Check out the and the . This API endpoint will list the names of all currently publishing streams.

The settings for the built-in SRT server. Check out our SRT guide for more information.

Configuration

{
   "srt": {
      

CORE_SRT_ENABLE=false
CORE_SRT_ADDRESS=":6000"
CORE_SRT_PASSPHRASE=
CORE_SRT_TOKEN=
CORE_SRT_LOG_ENABLE=false
CORE_SRT_LOG_TOPIC=

enable (bool)

Set this value to true in order to enable the built-in SRT server.

By default the SRT server is disabled.

address (string)

If the SRT server is enabled, it will listen on this address. The default address is :6000.

passphrase (string)

Define a passphrase in order to enable SRT encryption. If the passphrase is set it is required and applies to all connections.

By default the passphrase is not set (i.e. an empty string).

token (string)

The token is an arbitrary string that needs to be comunicated in the streamid. Only with a valid token it is possible to publish or request streams. If the token is not set, anybody could publish and request streams.

By default the token is not set (i.e. an empty string).

log.enable (bool)

Set this value to true in order to enable logging for the SRT server. This will log events on the SRT protocol level. You have to provide the topics you are interested in, otherwise nothing will be logged.

By default the logging is disabled.

log.topic (array)

Logging topics allow you to define what type of messages will be logged. This is practical if you want to debug a SRT connection. An empty list of topics means that no topics will be logged.

Find a list of known logging topics on the .

By default no topics are logged (i.e. an empty array).

Golang

Example

Repository

Python3

Install

Example

Repository

The last log events are kept in memory and are accessible via the /api/v3/log endpoint. You can either retrieve the log lines in the format the Core is writing them to the console (?format=console) or in raw format (?format=raw). By default they are returned in "console" format.

You can define the number of last log lines kept in memory by either setting an appropriate value in the config (log.max_lines) or via an enviroment variable (CORE_LOG_MAX_LINES).

Read

Example:

Description:

Settings for session capturing. Sessions for HLS, RTMP, SRT, HTTP, and FFmpeg are captured.

Configurations

{
   "sessions": {
      "enable": true,
      "ip_ignorelist": [
         "127.0.0.1/32",
         "::1/128"
      ],
      "session_timeout_sec": 30,
      "persist": false,
      "persist_interval_sec": 300,
      "max_bitrate_mbit": 0,
      "max_sessions": 0
   }
}

CORE_SESSIONS_ENABLE=false
CORE_SESSIONS_IP_IGNORELIST="127.0.0.1/32,::1/128"
CORE_SESSIONS_SESSION_TIMEOUT_SEC=30
CORE_SESSIONS_PERSIST=false
CORE_SESSIONS_PERSIST_INTERVAL_SEC=300
CORE_SESSIONS_MAXBITRATE_MBIT=0
CORE_SESSIONS_MAXSESSIONS=0

enable (bool)

Set this value to true in order to enable session capturing.

By default this value is set to true.

ip_ignorelist (array)

List of IP ranges in CIDR notation to ignore for session capturing. If either end of a connection falls into this list of IPs, the session will not be captured. For the environment variable provide a comma-separated list of IP ranges in CIDR notation.

By default this value is set to ["127.0.0.1/32","::1/128"].

session_timeout_sec (integer)

The timeout in seconds for an idle session. After this timeout the session is considered as closed. Applies only to HTTP and HLS sessions.

By default this value is set to 30 seconds.

persist (bool)

Whether to persist the session history. The session history is stored as sessions.json in . If the session history is not persisted it will be kept only in memory.

By default the session history is not persisted, i.e. this value is set to false.

persist_interval_sec (integer)

Interval in seconds in which to persist the current session history. This setting has only effect if persisting the session history is enabled.

By default this value is set to 300 seconds.

max_bitrate_mbit (unsigned integer)

The maximum allowed outgoing bitrate in mbit/s. If the limit is reached, any new HLS sessions will be rejected. A value of 0 means no limitation of the outgoing bitrate.

By default this is value is set to 0, i.e. unlimited.

max_sessions (unsigned integer)

The maximum allowed number of simultaneous sessions. If the limit is reached, any new HLS sessions will be rejected. A value of 0 means no limitation of the number of sessions.

By default this value is set to 0, i.e. unlimited.

Settings for accessing the available storage types. The storages are accessible via HTTP, mounted to different paths.

Configuration

{
   "storage": {
     "mimetypes_file": "./mime.types",
     "cors": {
         "origins": [
            "*"
         ]
     },
     "disk": {...},
     "memory": {...},
     "s3": []
   }
}

CORE_STORAGE_MIMETYPES_FILE="./mime.types"
CORE_STORAGE_CORS_ORIGINS="*"

mimetypes_file (string)

Path to a file with the mime-type definitions. This is a file with the MIME types has one MIME type per line followed by a list of file extensions (including the "."). Files served from the storages will have the matching mime-type associated to it.

Example:

Default: ./mime.types

cors.origins (array)

Define a list of allowed CORS origin for accessing the storages.

By default it contains the only element *, allowing access from anywhere.

Disk

The disk storage is mounted at / via the HTTP server.

In-memory

The memory storage is mounted at /memfs via the HTTP server.

S3

The S3 storage is mounted at the configured path via the HTTP server.

The settings for the built-in SRT server. Check out our RTMP guide for more information.

Configuration

{
   "rtmp": {
      "enable": false,
      "enable_tls": false,
      "address": ":1935",
      "address_tls": ":1936",
      "app": "/",
      "token": ""
   }
}

CORE_RTMP_ENABLE=false
CORE_RTMP_ENABLE_TLS=false
CORE_RTMP_ADDRESS=":1935"
CORE_RTMP_ADDRESS_TLS=":1936"
CORE_RTMP_APP="/"
CORE_RTMP_TOKEN=

enable (bool)

Set this value to true in order to enable the built-in RTMP server.

By default the RTMP server is disabled.

enable_tls (bool)

Set this value to true to enable the RTMPS server that will run in parallel with the RTMP server on a different port. You have to have set to true in order for enabling the RTMPS server because it will use the same certificate as for the HTTPS server.

By default TLS is disabled.

address (string)

If the RTMP server is enabled, it will listen on this address. The default address is :1935.

address_tls (string)

If the RTMPS server is enabled, it will listen on this address. The default address is :1936.

app (string)

Define the app a stream can be published on, e.g. /live to require the path in an RTMP URLs to start with /live.

The default app is /.

token (string)

To prevent anybody from publish or playing streams, define token to be a secret only known to the publishers and subscribers. The token has to be put in the query of the stream URL, e.g. /live/stream?token=abc123.

As of version 16.12.0 the token can be appended to the path instead of a query parameter, e.g. /live/stream/abc123. With this the token corresponds to a stream key.

By default the token is not set (i.e. an empty string).

There are basically two commands you can give to a process: start or stop. This is the order for the process.

Additionally to these two commands are the commands restart which is sending a stop followed by a start command packed in one command, and reload which is the same as if you would update the process config with itself, e.g. in order to update references to another process.

• start the process. If the process is already started, this won't have any effect.

• stop the process. If the process is already stopped, this won't have any effect.

• restart the process. If the process is not running, this won't have any effect.

• reload the process. If the process was running, the reloaded process will start automatically.

Example:

Description:

The settings for the in-memory filesystem. This filesystem is accessible on /memfs via HTTP. This filesystem can only be accessed via HTTP. Writing to and deleting from the filesystem can be restricted by HTTP basic auth.

Configuration

{
   "storage": {
      

CORE_STORAGE_MEMORY_AUTH_ENABLE=true
CORE_STORAGE_MEMORY_AUTH_USERNAME=admin
CORE_STORAGE_MEMORY_AUTH_PASSWORD=datarhei
CORE_STORAGE_MEMORY_MAXSIZEMBYTES=0
CORE_STORAGE_MEMORY_PURGE=false

auth.enable (bool)

Set this value to true in order to enable basic auth for PUT, POST, and DELETE operations on /memfs. Read access (GET, HEAD) is not restricted. If enabled, you have to define a username and a password.

By default this value is set to false.

auth.username (string)

Username for Basic-Auth of /memfs. This has to be set if basic auth is enabled.

By default this value is not set, i.e. an empty string.

auth.password (string)

Password for Basic-Auth of /memfs. This has to be set if basic auth is enabled.

By default this value is not set, i.e. an empty string.

max_size_mbytes (unsigned integer)

The maximum amount of data that is allowed to be stored in this filesystem. The value is interpreted as megabytes. A 507 Insufficient Storage will be returned if you hit the limit. Use a value equal to or smaller than 0 to not set any limits. The limit will be the available memory.

By default no limit is set, i.e. a value of 0.

purge (bool)

Whether to automatically remove the oldest files if the filesystem is full.

By default this value is set to false.

The datarhei Core includes a simple SRT server for publishing and playing streams. It is not enabled by default. You have to enable it in the config in the srt section or via the corresponding environment variables.

SRT is a modern live streaming protocol with a low latency and network failure tolerance. Read more.

The SRT server supports publishing and requesting streams, similar to an RTMP server. With your SRT client you have to connect to the SRT server always in caller mode and live transmission mode.

Example:

Passphrase

If a passphrase is set in the config (or via environment variable), you have to provide the passphrase in the SRT URL. Example SRT URL with the passphrase foobarfoobar:

StreamID

In order to define whether you want to publish or request a resource, you have to provide your intent in the streamid.

The streamid is formatted as follows:

The resource is the name of the stream. This can be anything. You can publish only one stream with that same name.

The mode is either request or publish. If you don't provide a mode, request will be assumed. You can only request resources that are currently publishing. You can only publish resources that are not already publishing.

The token is the one defined in the config (see ). If no token is configured, you can omit the token in the streamid.

Examples

Publishing the resource 12345 with the token foobar:

Publishing the resource 12345 with no token defined in the configuration:

Requesting the resource 12345 with no token defined in the configuration:

Requesting the resource 12345 with the token foobar:

The whole SRT URL might look like this for the last example:

API

Via the in the API you can gather statistics about the currently connected SRT clients.

Requirements

• Go v1.18+ (Download here)

Build

Clone the repository and build the binary:

After the build process, the binary is available as core

For more build options, run make help.

Repository

Cross Compile

If you want to run the binary on a different operating system and/or architecture, you create the appropriate binary by simply setting some environment variables, e.g.

Docker

Build the Docker image and run it to try out the API with FFmpeg

How to customize FFmpeg

Code style

The source code is formatted with go fmt, or run make fmt. Static analysis of the source code is done with staticcheck (see ), or run make lint.

Before committing changes, you should run make commit to ensure that the source code is in shape.

Raspberry Pi 4

Date: 12.02.2021 Version: 2.1.0 (non-public release)

Goal: Bandwidth Limitation Test (HLS Sessions)

Settings

Results

Location

You have to provide the location of the config file by setting the environment variable CORE_CONFIGFILE to path to the config file. Example:

The config file is written in JSON format.

Quick start

1. Install Docker if not present

Skills denote the capabilities of the used FFmpeg binary. It includes version information, supported input and output protocols, available hardware accelerators, supported formats for muxing and demuxing, filters, and available input and output devices.

Read

Example:

Logging settings for the datarhei Core.

Configuration

The settings for the disk filesystem. This filesystem is accessible on / via HTTP. This filesystem can only be accessed for reading via HTTP. Writing to and deleting from the filesystem is possible via the API.

Configuration

{
   "storage": {
      "disk": {
         "dir": "./data",
         "max_size_mbytes": 0,
         "cache": {
            "enable": true,
            "max_size_mbytes": 0,
            "ttl_seconds": 300,
            "max_file_size_mbytes": 1,
            "types": {
               "allow": [],
               "block": []
            }

CORE_STORAGE_DISK_DIR="./data"
CORE_STORAGE_DISK_MAXSIZEMBYTES=0
CORE_STORAGE_DISK_CACHE_ENABLE=true
CORE_STORAGE_DISK_CACHE_MAXSIZEMBYTES=0
CORE_STORAGE_DISK_CACHE_TTLSECONDS=300
CORE_STORAGE_DISK_CACHE_MAXFILESIZEMBYTES=1
CORE_STORAGE_DISK_CACHE_TYPES_ALLOW=
CORE_STORAGE_DISK_CACHE_TYPES_BLOCK=".m3u8 .mpd"

dir (string)

Path to a directory on disk. It will be exposed on / for reading.

By default it is set to ./data.

max_size_mbytes (unsigned integer)

The maximum amount of data that is allowed to be stored in this filesystem. The value is interpreted as megabytes. A 507 Insufficient Storage will be returned if you hit the limit. Use a value equal to or smaller than 0 to not impose any limits. Then all the available space on the disk is the limit.

By default no limit is set, i.e. a value of 0.

cache.enable (bool)

Set this value to true in order to enable the cache for the disk. The cache is an LRU cache, i.e. the least recently accessed files in the cache will be removed in case the cache is full and a new file wants to be added.

By default the value is set to true.

cache.max_size_mbytes (unsigned integer)

Limit for the size of the cache in megabytes. A value of 0 doesn't impose any limit. The limit will be the available memory.

By default no limit is set, i.e. a value of 0.

cache.ttl_seconds (integer)

Number of seconds to keep a file in the cache.

By default this value is set to 300 seconds.

cache.max_file_size_mbytes (unsigned integer)

Limit for the size of a file to be allowed to be put in the cache in megabytes.

By default this value is set to 1 megabyte.

cache.types.allow (array)

A list of file extensions to cache, e.g. [".ts", ".mp4"]. Leave the list empty in order to cache all files. Use a space-separated list of extensions for the environment variable, e.g. .ts .mp4.

By default the list is empty.

cache.types.block (array)

A list of file extensions not to cache, e.g. [".m3u8", ".mpd"]. Leave the list empty in order to block no extension. Use a space-separated list of extensions for the environment variable, e.g. .m3u8 .mpd.

By default the manifest files for HLS and DASH are blocked from caching, i.e. [".m3u8", ".mpd"].

The settings for the S3 filesystem. This filesystem is accessible on the configured path via HTTP. This filesystem can only be accessed via HTTP. Writing to and deleting from the filesystem can be restricted by HTTP basic auth.

Any S3 compatible service can be used, e.g. Amazon, Minio, Backblaze, ...

Configuration

name (string)

The name for this storage. The name will be used in placeholders, e.g. {fs:aws}, and for accessing the filesystem via the api, e.g. /api/v3/fs/aws. The name memfs is reserved for the in-memory filesystem.

By default this value is not set, but is required.

mountpoint (string)

The path where the filesystem will be mounted in the HTTP server. It needs to be an absolute path. A mountpoint is required.

By default this value is not set, but is required.

auth.enable (bool)

Set this value to true in order to enable basic auth for PUT, POST, and DELETE operations on the configured mountpoint. Read access (GET, HEAD) is not restricted. If enabled, you have to define a username and a password.

By default this value is set to false.

auth.username (string)

Username for Basic-Auth of the configured mountpoint. This has to be set if basic auth is enabled.

By default this value is not set, i.e. an empty string.

auth.password (string)

Password for Basic-Auth of the configured mountpoint. This has to be set if basic auth is enabled.

By default this value is not set, i.e. an empty string.

endpoint (string)

The endpoint for the S3 storage. For Amazon AWS S3 it would be e.g. s3.amazonaws.com. Ask your S3 storage provider to the necessary credentials.

By default this value is not set, i.e. an empty string.

access_key_id (string)

Your access key ID for the S3 storage. Ask your S3 storage provider to the necessary credentials.

By default this value is not set, i.e. an empty string.

secret_access_key (string)

Your secret access key for the S3 storage. Ask your S3 storage provider to the necessary credentials.

By default this value is not set, i.e. an empty string.

bucket (string)

The name of the bucket you want to use. If the bucket does not exist already it will be created.

By default this value is not set, i.e. an empty string.

region (string)

Identifier for the region the storage is located, e.g. eu, us-west1, ... . If your S3 storage provider doesn't support regions, leave this field empty.

By default this value is not set, i.e. an empty string.

use_ssl (bool)

Whether to use HTTPS or HTTP. It is strongly recommended to enable this setting.

By default this is set to false.

Settings for the FFmpeg binary.

Configuration

{
   "ffmpeg": {
      "binary": "ffmpeg",
      "max_processes": 0,
      "access": {
         "input": {
            "allow": [],
            "block": []
         },
         "output": {
            "allow": [],
            "block": []
         }
      },
      "log": {

CORE_FFMPEG_BINARY="ffmpeg"
CORE_FFMPEG_MAX_PROCESSES=0
CORE_FFMPEG_ACCESS_INPUT_ALLOW=a,b,c
CORE_FFMPEG_ACCESS_INPUT_BLOCK=a,b,c
CORE_FFMPEG_ACCESS_OUTPUT_ALLOW=a,b,c
CORE_FFMPEG_ACCESS_OUTPUT_BLOCK=a,b,c

binary (string)

Path to the ffmpeg binary. The system's %PATH will be searched for the ffmpeg binary. You can also provide an absolute or relative path to the binary.

By default this value is set to ffmpeg.

max_processes (integer)

The maximum number of simultaneously running ffmpeg instances. Set this value to 0 in order to not impose any limit.

By default this value is set to 0.

access.*

To control where FFmpeg can read from and where FFmpeg can write from, you can define patterns that matches the input addresses or the output addresses. These patterns are regular expressions that can be provided here. For the respective environment variables the expressions need to be space-separated, e.g. https?:// rtsp:// rtmp://.

Independently of the values of access.output there's a check that verifies that output can only be written to the directory specified in and works as follows: if the address has a protocol specifier other than file:, then no further checks will be applied. If the protocol is file: or no protocol specifier is given, the address is assumed to be a path that is checked to be inside of storage.disk.dir.

It will be rejected if the address is outside the storage.disk.dir directory. Otherwise, the protocol file: will be prepended. If you want to explicitely allow or block access to the filesystem, use file: as pattern in the respective list.

Special cases are the output addresses - (which will be rewritten to pipe:), and /dev/null, which will be allowed even though it's outside of storage.disk.dir.

access.input.allow (array)

List of patterns for allowed inputs.

By default this list is empty, i.e. all inputs are allowed.

access.input.block (array)

List of patterns for disallowed inputs.

By default this list is empty, i.e. no inputs are blocked.

access.output.allow (array)

List of patterns for allowed outputs.

By default this list is empty, i.e. all outputs are allowed.

access.output.block (array)

List of patterns for disallowed outputs.

By default this list is empty, i.e. no outputs are blocked.

log.max_lines (integer)

The number of latest FFmpeg log lines for each process to keep.

By default this value is set to 50 lines.

log.max_history (integer)

The number of historic logs for each process to keep.

By default this value is set to 3.

Sessions are tracking user actions regarding pushing and pulling video data to and from the core. There are different kind of sessions that are captured:

• HLS Sessions (hls collector) How many users are watching an HLS stream

• HLS Ingress Sessions (hlsingress collector) How many users are publishing a stream via the in-memory filesystem

• HTTP Sessions (http collector) How many users are reading or writing http data via the build-in HTTP server

• RTMP Sessions (rtmp collector) How many users are publishing or watching a stream via the built-in RTMP server

• SRT Sessions (srt collector) How many users are publishing or watching a stream via the built-in SRT server

• FFmpeg Sessions (ffmpeg collector) How many streams is FFmpeg using as an input or as an output

The data for each session include the current ingress and egress bandwidth, the total amount of data, an identifier for the session itself, the local end of the stream and the remote end of the stream.

The following API endpoints allow to extract information about the currently active sessions or additionally a summary of the already finished sessions. Each endpoint requires a comma-separated list of collectors as query parameter collectors.

Active sessions with summary

Example:

Description:

Active sessions

Example:

Description:

Helping Hands

To ensure your project's success, we offer installation services and ongoing support from the datarhei team. Helping Hands includes installing a datarhei Restreamer or datarhei Core on a server instance and managing the server as a managed service.

1. Installation

2. Configuration

3. Updates

4. Fix errors

Communication and assistance can be accessed through email or chat on our and conducted in English and German. We appreciate your support of "Helping Hands."

Within 48 hours of becoming a patron or sponsor on Open Collective, a representative from will contact you for further information regarding the installation process.

Service level agreements are in effect for the duration of the active donation.

If you have questions about the Helping Hands Service Level Agreement (SLA), contact us on or by email at [email protected]. We're here to help!"

Book now

Business Inquiries

We're the team at FOSS GmbH () from Switzerland, the creators of . We'll do our best to get back to you within 1-2 days during our regular business hours, excluding weekends and holidays in Switzerland and Germany. No matter what you need help with, we're here to provide professional support, software development, and consulting for anything related to datarhei software.

If you have a commercial request, such as a bug fix or feature enhancement, just let us know, and we'll be happy to provide a quote.

Business contact

Please fill out this form to help us respond to your request as quickly as possible. We're able to assist you in both German and English. However, please remember that we cannot process any requests not submitted through this form.

Community

Private and non-commercial requests can be discussed and resolved on and public channels.

Open issue on GitHub

Say hello on Discord

Donation

Every little bit helps! Consider becoming a patron on Patreon or backer on Open Collective to support keeping the software free.

Rate on Google

💙💚🧡💜 Help datarhei with a rating or review on Google. #feelsgoodtobeloved

>>

💛 Thanks for using datarhei software. Your datarhei.com team

The metadata for a process allows you to store arbitrary JSON data with that process, e.g. if you have an app that uses the datarhei Core API you can store app-specific information in the metadata.

In order not to conflict with other apps that might write to the metadata as well, you have to provide a key under which your metadata is stored. Think of a namespace or similar.

Create, Update

Add or update the metadata for a process and key.

Example: Write a metadata object into the metadata for the process test and key desc.

Description:

Read

Read out the stored metadata. The key is optional. If the key is not provided, all stored metadata for that process will be in the result.

Example: read the metadata object for process test that is stored under the key desc.

Description:

These are the settings for securing the API from unwanted access.

Configuration

Metrics for the processes and other aspects are provided for a Prometheus scraper on /metrics.

Currently, available metrics are:

The Core-FFmpeg bundle uses Docker's multi-stage process so that FFmpeg and the Core can be updated and maintained independently.

When building the Core-FFmpeg bundle, an FFmpeg image is used. The previously created Golang libraries and folder structures are copied into this image.

This process speeds up the creation of the final Core-FFmpeg bundle, as existing or previously created images can be used, and compiling all the code is no longer required.

The following base images are available: