Skip to content
Klutch.sh Docs

Deploying a Jibri App

Introduction

Jibri provides recording and live streaming for Jitsi Meet deployments. Deploying Jibri with a Dockerfile on Klutch.sh gives you reproducible builds, managed secrets, and persistent storage for recordings—all controlled from klutch.sh/app. This guide covers installation, repository prep, a production-ready Dockerfile, deployment steps, Nixpacks overrides, and best practices for reliable capture.

Prerequisites

  • A Klutch.sh account (create one)
  • A GitHub repository containing your Jibri configuration (GitHub is the only supported git source)
  • Docker familiarity and basic Jitsi Meet/SIP knowledge
  • Access to your XMPP server and Jitsi Meet domain for authentication
  • Storage for recordings and logs

Review platform basics in the Quick Start.

Architecture and ports

  • Jibri runs as a worker; it does not serve a public HTTP UI. Use TCP traffic in Klutch.sh and set the internal port to 2222 (commonly exposed for SSH/management). If you do not need inbound connectivity, keep traffic disabled and rely on outbound connections to Jitsi/XMPP.
  • Outbound connections to XMPP (5222/5280), Jitsi web (443), and RTMP endpoints are required.
  • Persistent storage is required for recordings and optional for logs.

Repository layout

jibri/
├── config/                 # Jibri config (xmpp, sip, streaming settings)
├── recordings/             # Output directory (mount as volume)
├── Dockerfile              # Must be at repo root for auto-detection
├── README.md
└── .env.example            # Template only; no secrets

Keep secrets out of Git; store them in Klutch.sh environment variables.

Installation (local) and starter commands

Quick local test using the official image:

Terminal window
docker run --rm -p 2222:2222 \
  -v $(pwd)/config:/config \
  -v $(pwd)/recordings:/recordings \
  -e XMPP_DOMAIN=meet.example.com \
  -e XMPP_AUTH_DOMAIN=auth.meet.example.com \
  -e XMPP_MUC_DOMAIN=internal.auth.meet.example.com \
  -e JIBRI_RECORDER_USER=recorder \
  -e JIBRI_RECORDER_PASSWORD=strongpass \
  -e JIBRI_XMPP_USER=jibri \
  -e JIBRI_XMPP_PASSWORD=strongpass \
  jitsi/jibri:stable-9044

Optional helper start.sh for portability and Nixpacks fallback:

#!/usr/bin/env bash
set -euo pipefail
exec /init

Make it executable with chmod +x start.sh.

Dockerfile for Jibri (production-ready)

Place this Dockerfile at the repo root; Klutch.sh auto-detects it (no Docker selection in the UI):

FROM jitsi/jibri:stable-9044


WORKDIR /app


# Copy custom configuration
COPY config /config


# Expose SSH/management port if needed
EXPOSE 2222


CMD ["/init"]

Notes:

  • Pin the Jibri image tag to align with your Jitsi Meet release.
  • Ensure Chromium/Chrome dependencies match your recording needs.

Environment variables (Klutch.sh)

Set these in the Klutch.sh app settings (Secrets tab) before deploying:

  • XMPP_DOMAIN=meet.example.com
  • XMPP_AUTH_DOMAIN=auth.meet.example.com
  • XMPP_MUC_DOMAIN=internal.auth.meet.example.com
  • XMPP_RECORDER_DOMAIN=recorder.meet.example.com
  • JIBRI_RECORDER_USER=recorder
  • JIBRI_RECORDER_PASSWORD=<strong-password>
  • JIBRI_XMPP_USER=jibri
  • JIBRI_XMPP_PASSWORD=<strong-password>
  • JIBRI_BREWERY_MUC=jibribrewery
  • JIBRI_PENDING_TIMEOUT=90
  • JIBRI_STRIP_DOMAIN_JID=conference
  • JIBRI_RECORDING_DIR=/recordings
  • PORT=2222

If you deploy without the Dockerfile and need Nixpacks overrides:

  • NIXPACKS_BUILD_CMD="echo Jibri uses prebuilt image"
  • NIXPACKS_START_CMD=/init
  • NIXPACKS_JDK_VERSION=11

These keep Jibri compatible with Nixpacks defaults when a Dockerfile is absent.

Attach persistent volumes

In Klutch.sh storage settings, add mount paths and sizes (no names required):

  • /recordings — required for captured video files.
  • /config — optional if you want runtime-editable config persisted.

Ensure these paths are writable inside the container.

Deploy Jibri on Klutch.sh (Dockerfile workflow)

  1. Push your repository (with the Dockerfile at the root) to GitHub.
  2. Open klutch.sh/app, create a project, and add an app.
  1. Connect the GitHub repository; Klutch.sh automatically detects the Dockerfile.
  2. Choose TCP traffic for Jibri and set the internal port to 2222.
  3. Add the environment variables above (XMPP domains, credentials, recording dir, and any NIXPACKS_* overrides if you temporarily deploy without the Dockerfile).
  4. Attach persistent volumes for /recordings (and /config if desired), selecting sizes that match your retention policy.
  5. Deploy. Jibri will connect outbound to your Jitsi Meet/XMPP services; inbound TCP on example-app.klutch.sh:8000 maps to internal 2222 if needed for management.

Health checks and production tips

  • Monitor logs for XMPP connection status and recording success; ship logs externally instead of relying on container storage alone.
  • Keep image and Chrome/Chromium versions aligned with your Jitsi deployment.
  • Enforce strong credentials for recorder and Jibri users; rotate regularly.
  • Track disk usage on /recordings and resize volumes before they fill.
  • If using RTMP, ensure egress to your streaming endpoint is allowed.

Jibri on Klutch.sh combines reproducible Docker builds with managed secrets, durable recording storage, and flexible TCP routing. With the Dockerfile at the repo root and ports set to 2222 for management (8000 externally for TCP), you can deliver reliable Jitsi recording and streaming without extra YAML or workflow overhead.