Categories
Cloud Sotfware & Developers & DevOps Tools & How-Tos

Jitsi with Docker

Build your own Free Video Conference system

Video conference jitsi

Jitsi is an open source video conference application that can be installed on its own server. Now, this being said in this post we will install jitsi with docker. One of them is by using jitsi as a distributor of IFRAME API JITSI and LIB-JITSI-MEET API integration into the applications they create. With an active community and support community, make jitsi more popular. You can create a custom application according to the UI you create and integrate it with Jitsi API. You can find api documentation steps on jitsi documentation.

This video conferencing application provides an SDK for those of you to create video conference applications for mobile.

How to configure jitsi with docker?

Jitsi meet docker

In this post, we create a video conference jitsi that will run on docker. Why we use docker to build jitsi. We will be running the server on AWS, but you can run on other Cloud services. The first things you need to install are docker and docker compose on the server. I will assume you have already installed docker and docker compose on our server. I this case we will be using ubuntu server 18.04 to make jitsi run on docker. This is so we can run jitsi on docker. As well as we will have to install alsa loopback module.

Add Alsa-loopback kernel module to Ubuntu

Alsa-loopback module requires jibri to make live streaming and recording run on the jitsi video conference server. This module is not present on AWS Ubuntu Server and that is why we need to add it and enable it. To do that we will use a generic kernel to make alsa-loopback work on the server. The next few steps are to provide guidance to replace the AWS kernel with a generic AWS kernel. In this case we selected Ubuntu on AWS and is what we recomment if your would like to follow this tutorial. It could be for instace this image:

ubuntu/images/hvm-ssd/ubuntu-bionic-18.04-amd64-server-20200408 - ami-003634241a8fcdec0

If you have created an EC2 machine with the recommended version. Log in to the server and let’s install alsa-utils with this command.

sudo apt install alsa-utils -y
jitsi install alsa-utils

Let’s check with the command “arecord -L” to make sure alsa-loopback runs successfully on the server. If there is still error an error ” If output : null” when running the command. We must make sure to change the AWS kernel to a GENERIC kernel.

If output : null
Discard all samples (playback) or generate zero samples (capture)
Jitsi checking arecord

Then for the next step let’s look for a generic linux module with the “apt search” command.

sudo apt search linux-modules-5.4.0 | grep generic
jitsi search linux-modules

Install kernel generic AWS

We have found a generic Linux module, this time we will use linux-modules-5.4.0-77-generic. Let’s install it on the machine.

sudo apt install linux-image-5.4.0-77-generic linux-modules-5.4.0-77-generic linux-modules-extra-5.4.0-77-generic -y
jitsi install linux modules generic

Now we have installed generic linux modules on the EC2 machine. Next we will try to find the menu entry in the linux grub so that we can change the AWS kernel to our newly installed GENERIC kernel.

sudo grep -A100 submenu /boot/grub/grub.cfg | grep menuentry
Menuentry kernel linux

This is it we’ve got the menu entry for generic kernel modules. Next we need to change GRUB_DEFAULT on the EC2 machine to use generic kernel modules in the file /etc/default/grub. We will replace GRUB_DEFAULT with the sed command on linux.

sudo sed -i -e 's/GRUB_DEFAULT=0/GRUB_DEFAULT="gnulinux-advanced-6156ec80-9446-4eb1-95e0-9ae6b7a46187>gnulinux-5.4.0-77-generic-advanced-6156ec80-9446-4eb1-95e0-9ae6b7a46187"/' /etc/default/grub
Jitsi sed grub default

Now that we have replaced GRUB_DEFAULT with generic linux modules, we will update Linux grub using the command “update-grub”.

sudo update-grub
Jitsi update grub linux

Linux grub has been successfully updated, it’s time for us to reboot our server to see if the kernel has changed from AWS to the generic kernel. Use the command ” reboot” to reboot the server.

reboot
jitsi reboot

Kernel successful change

After rebooting the server, let’s see with the command “uname -r” whether the kernel has been changed from AWS to GENERIC.

uname -r
jitsi uname kernel linux

The kernel has been changed to GENERIC, it’s time for us to activate the alsa-loopback module. We can activate it with the command “modprobe snd-aloop”.

sudo modprobe snd-aloop
Jitsi activated modprobe snd-aloop

we have activated the alsa-loopback module, we need to check with the “arecord” command to find out whether this module is really active on our server. Use the command “arecord -L”.

sudo arecord -L
jitsi checking alsa-loopback module

Jitsi with docker

The alsa-loopback module is already active on the server. For the next step we will clone jitsi docker from the jitsi github repository. Jitsi has provided a docker configuration in its repository.

git clone https://github.com/jitsi/docker-jitsi-meet.git
Clone jitsi docker

Then we will move to the docker-jitsi-meet directory to configure some files. I will enable recording and streaming on jitsi.

cd docker-jitsi-meet/

Docker compose & jitsi

We need to configure the env file in docker jitsi, it is necessary to pay attention to this in configuring docker jitsi. We will create a jitsi docker using a network with its own domain. First change the network and alias from meet.jitsi to your own domain. Let’s first edit docker-compose.yml.

Front end jitsi landing

version: '3'

services:
    # Frontend
    web:
        image: jitsi/web:latest
        restart: ${RESTART_POLICY}
        ports:
            - '${HTTP_PORT}:80'
            - '${HTTPS_PORT}:443'
        volumes:
            - ${CONFIG}/web:/config:Z
            - ${CONFIG}/transcripts:/usr/share/jitsi-meet/transcripts:Z
        environment:
            - ENABLE_COLIBRI_WEBSOCKET
            - ENABLE_FLOC
            - ENABLE_LETSENCRYPT
            - ENABLE_HTTP_REDIRECT
            - ENABLE_HSTS
            - ENABLE_XMPP_WEBSOCKET
            - DISABLE_HTTPS
            - DISABLE_DEEP_LINKING
            - LETSENCRYPT_DOMAIN
            - LETSENCRYPT_EMAIL
            - LETSENCRYPT_USE_STAGING
            - PUBLIC_URL
            - TZ
            - AMPLITUDE_ID
            - ANALYTICS_SCRIPT_URLS
            - ANALYTICS_WHITELISTED_EVENTS
            - CALLSTATS_CUSTOM_SCRIPT_URL
            - CALLSTATS_ID
            - CALLSTATS_SECRET
            - CHROME_EXTENSION_BANNER_JSON
            - CONFCODE_URL
            - CONFIG_EXTERNAL_CONNECT
            - DEFAULT_LANGUAGE
            - DEPLOYMENTINFO_ENVIRONMENT
            - DEPLOYMENTINFO_ENVIRONMENT_TYPE
            - DEPLOYMENTINFO_REGION
            - DEPLOYMENTINFO_SHARD
            - DEPLOYMENTINFO_USERREGION
            - DIALIN_NUMBERS_URL
            - DIALOUT_AUTH_URL
            - DIALOUT_CODES_URL
            - DROPBOX_APPKEY
            - DROPBOX_REDIRECT_URI
            - DYNAMIC_BRANDING_URL
            - ENABLE_AUDIO_PROCESSING
            - ENABLE_AUTH
            - ENABLE_CALENDAR
            - ENABLE_FILE_RECORDING_SERVICE
            - ENABLE_FILE_RECORDING_SERVICE_SHARING
            - ENABLE_GUESTS
            - ENABLE_IPV6
            - ENABLE_LIPSYNC
            - ENABLE_NO_AUDIO_DETECTION
            - ENABLE_P2P
            - ENABLE_PREJOIN_PAGE
            - ENABLE_WELCOME_PAGE
            - ENABLE_CLOSE_PAGE
            - ENABLE_RECORDING
            - ENABLE_REMB
            - ENABLE_REQUIRE_DISPLAY_NAME
            - ENABLE_SIMULCAST
            - ENABLE_STATS_ID
            - ENABLE_STEREO
            - ENABLE_SUBDOMAINS
            - ENABLE_TALK_WHILE_MUTED
            - ENABLE_TCC
            - ENABLE_TRANSCRIPTIONS
            - ETHERPAD_PUBLIC_URL
            - ETHERPAD_URL_BASE
            - GOOGLE_ANALYTICS_ID
            - GOOGLE_API_APP_CLIENT_ID
            - INVITE_SERVICE_URL
            - JICOFO_AUTH_USER
            - MATOMO_ENDPOINT
            - MATOMO_SITE_ID
            - MICROSOFT_API_APP_CLIENT_ID
            - NGINX_RESOLVER
            - NGINX_WORKER_PROCESSES
            - NGINX_WORKER_CONNECTIONS
            - PEOPLE_SEARCH_URL
            - RESOLUTION
            - RESOLUTION_MIN
            - RESOLUTION_WIDTH
            - RESOLUTION_WIDTH_MIN
            - START_AUDIO_ONLY
            - START_AUDIO_MUTED
            - START_WITH_AUDIO_MUTED
            - START_SILENT
            - DISABLE_AUDIO_LEVELS
            - ENABLE_NOISY_MIC_DETECTION
            - START_BITRATE
            - DESKTOP_SHARING_FRAMERATE_MIN
            - DESKTOP_SHARING_FRAMERATE_MAX
            - START_VIDEO_MUTED
            - START_WITH_VIDEO_MUTED
            - TESTING_CAP_SCREENSHARE_BITRATE
            - TESTING_OCTO_PROBABILITY
            - XMPP_AUTH_DOMAIN
            - XMPP_BOSH_URL_BASE
            - XMPP_DOMAIN
            - XMPP_GUEST_DOMAIN
            - XMPP_MUC_DOMAIN
            - XMPP_RECORDER_DOMAIN
            - TOKEN_AUTH_URL
        networks:
            meet.busanid.dev:
Prosody configuration network
# XMPP server
    prosody:
        image: jitsi/prosody:latest
        restart: ${RESTART_POLICY}
        expose:
            - '5222'
            - '5347'
            - '5280'
        volumes:
            - ${CONFIG}/prosody/config:/config:Z
            - ${CONFIG}/prosody/prosody-plugins-custom:/prosody-plugins-custom:Z
        environment:
            - AUTH_TYPE
            - ENABLE_AUTH
            - ENABLE_GUESTS
            - ENABLE_LOBBY
            - ENABLE_XMPP_WEBSOCKET
            - GLOBAL_MODULES
            - GLOBAL_CONFIG
            - LDAP_URL
            - LDAP_BASE
            - LDAP_BINDDN
            - LDAP_BINDPW
            - LDAP_FILTER
            - LDAP_AUTH_METHOD
            - LDAP_VERSION
            - LDAP_USE_TLS
            - LDAP_TLS_CIPHERS
            - LDAP_TLS_CHECK_PEER
            - LDAP_TLS_CACERT_FILE
            - LDAP_TLS_CACERT_DIR
            - LDAP_START_TLS
            - XMPP_DOMAIN
            - XMPP_AUTH_DOMAIN
            - XMPP_GUEST_DOMAIN
            - XMPP_MUC_DOMAIN
            - XMPP_INTERNAL_MUC_DOMAIN
            - XMPP_MODULES
            - XMPP_MUC_MODULES
            - XMPP_INTERNAL_MUC_MODULES
            - XMPP_RECORDER_DOMAIN
            - XMPP_CROSS_DOMAIN
            - JICOFO_COMPONENT_SECRET
            - JICOFO_AUTH_USER
            - JICOFO_AUTH_PASSWORD
            - JVB_AUTH_USER
            - JVB_AUTH_PASSWORD
            - JIGASI_XMPP_USER
            - JIGASI_XMPP_PASSWORD
            - JIBRI_XMPP_USER
            - JIBRI_XMPP_PASSWORD
            - JIBRI_RECORDER_USER
            - JIBRI_RECORDER_PASSWORD
            - JWT_APP_ID
            - JWT_APP_SECRET
            - JWT_ACCEPTED_ISSUERS
            - JWT_ACCEPTED_AUDIENCES
            - JWT_ASAP_KEYSERVER
            - JWT_ALLOW_EMPTY
            - JWT_AUTH_TYPE
            - JWT_TOKEN_AUTH_MODULE
            - LOG_LEVEL
            - PUBLIC_URL
            - TZ
        networks:
            meet.busanid.dev:
                aliases:
                    - ${XMPP_SERVER}
Change jicofo network
 # Focus component
    jicofo:
        image: jitsi/jicofo:latest
        restart: ${RESTART_POLICY}
        volumes:
            - ${CONFIG}/jicofo:/config:Z
        environment:
            - AUTH_TYPE
            - BRIDGE_AVG_PARTICIPANT_STRESS
            - BRIDGE_STRESS_THRESHOLD
            - ENABLE_AUTH
            - ENABLE_AUTO_OWNER
            - ENABLE_CODEC_VP8
            - ENABLE_CODEC_VP9
            - ENABLE_CODEC_H264
            - ENABLE_OCTO
            - ENABLE_RECORDING
            - ENABLE_SCTP
            - JICOFO_AUTH_USER
            - JICOFO_AUTH_PASSWORD
            - JICOFO_ENABLE_BRIDGE_HEALTH_CHECKS
            - JICOFO_CONF_INITIAL_PARTICIPANT_WAIT_TIMEOUT
            - JICOFO_CONF_SINGLE_PARTICIPANT_TIMEOUT
            - JICOFO_ENABLE_HEALTH_CHECKS
            - JICOFO_SHORT_ID
            - JICOFO_RESERVATION_ENABLED 
            - JICOFO_RESERVATION_REST_BASE_URL 
            - JIBRI_BREWERY_MUC
            - JIBRI_REQUEST_RETRIES
            - JIBRI_PENDING_TIMEOUT
            - JIGASI_BREWERY_MUC
            - JIGASI_SIP_URI
            - JVB_BREWERY_MUC
            - MAX_BRIDGE_PARTICIPANTS
            - OCTO_BRIDGE_SELECTION_STRATEGY
            - TZ
            - XMPP_DOMAIN
            - XMPP_AUTH_DOMAIN
            - XMPP_INTERNAL_MUC_DOMAIN
            - XMPP_MUC_DOMAIN
            - XMPP_SERVER
        depends_on:
            - prosody
        networks:
            meet.busanid.dev:
Videobridge2 network docker compose
# Video bridge
    jvb:
        image: jitsi/jvb:latest
        restart: ${RESTART_POLICY}
        ports:
            - '${JVB_PORT}:${JVB_PORT}/udp'
            - '${JVB_TCP_PORT}:${JVB_TCP_PORT}'
        volumes:
            - ${CONFIG}/jvb:/config:Z
        environment:
            - ENABLE_COLIBRI_WEBSOCKET
            - ENABLE_OCTO
            - DOCKER_HOST_ADDRESS
            - XMPP_AUTH_DOMAIN
            - XMPP_INTERNAL_MUC_DOMAIN
            - XMPP_SERVER
            - JVB_AUTH_USER
            - JVB_AUTH_PASSWORD
            - JVB_BREWERY_MUC
            - JVB_PORT
            - JVB_TCP_HARVESTER_DISABLED
            - JVB_TCP_PORT
            - JVB_TCP_MAPPED_PORT
            - JVB_STUN_SERVERS
            - JVB_ENABLE_APIS
            - JVB_WS_DOMAIN
            - JVB_WS_SERVER_ID
            - PUBLIC_URL
            - JVB_OCTO_BIND_ADDRESS
            - JVB_OCTO_PUBLIC_ADDRESS
            - JVB_OCTO_BIND_PORT
            - JVB_OCTO_REGION
            - TZ
        depends_on:
            - prosody
        networks:
            meet.busanid.dev:
                aliases:
                    - jvb.meet.busanid.dev

# Custom network so all services can communicate using a FQDN
networks:
    meet.busanid.dev:

Configure env file

We have edited the docker-compose.yml file according to our own network. First you need to copy env.example to .env with the command “cp env.example .env”.

cp env.example .env
copy env file jitsi

Let’s edit something needed on the env file. And you can read the use of each function contained in the env file in the jitsi docker documentation.

Port and location config
# Directory where all configuration will be stored
CONFIG=~/.jitsi-meet-cfg

# Exposed HTTP port
HTTP_PORT=80

# Exposed HTTPS port
HTTPS_PORT=443

# System time zone
TZ=UTC

# Public URL for the web service (required)
PUBLIC_URL=https://meet.busanid.dev

# IP address of the Docker host
# See the "Running behind NAT or on a LAN environment" section in the Handbook:
# https://jitsi.github.io/handbook/docs/devops-guide/devops-guide-docker#running-behind-nat-or-on-a-lan-environment
DOCKER_HOST_ADDRESS=192.168.1.10

# Control whether the lobby feature should be enabled or not
ENABLE_LOBBY=1

# Show a prejoin page before entering a conference
ENABLE_PREJOIN_PAGE=0

# Enable the welcome page
ENABLE_WELCOME_PAGE=1

# Enable the close page
ENABLE_CLOSE_PAGE=0

# Disable measuring of audio levels
DISABLE_AUDIO_LEVELS=0

# Enable noisy mic detection
ENABLE_NOISY_MIC_DETECTION=1
Guest access conference
# Authentication configuration (see handbook for details)
#

# Enable authentication
#ENABLE_AUTH=1

# Enable guest access
ENABLE_GUESTS=1

# Select authentication type: internal, jwt or ldap
#AUTH_TYPE=internal
Letsencrypt for ssl https
# Let's Encrypt configuration
#

# Enable Let's Encrypt certificate generation
ENABLE_LETSENCRYPT=1

# Domain for which to generate the certificate
LETSENCRYPT_DOMAIN=meet.busanid.dev

# E-Mail for receiving important account notifications (mandatory)
[email protected]

# Use the staging server (for avoiding rate limits while testing)
#LETSENCRYPT_USE_STAGING=1
Xmpp server with own domain
# Internal XMPP domain
XMPP_DOMAIN=meet.busanid.dev

# Internal XMPP server
XMPP_SERVER=xmpp.meet.busanid.dev

# Internal XMPP server URL
XMPP_BOSH_URL_BASE=http://xmpp.meet.busanid.dev:5280

# Internal XMPP domain for authenticated services
XMPP_AUTH_DOMAIN=auth.meet.busanid.dev

# XMPP domain for the MUC
XMPP_MUC_DOMAIN=muc.meet.busanid.dev

# XMPP domain for the internal MUC used for jibri, jigasi and jvb pools
XMPP_INTERNAL_MUC_DOMAIN=internal-muc.meet.busanid.dev

# XMPP domain for unauthenticated users
XMPP_GUEST_DOMAIN=guest.meet.busanid.dev

# Comma separated list of domains for cross domain policy or "true" to allow all
# The PUBLIC_URL is always allowed
XMPP_CROSS_DOMAIN=true

# Custom Prosody modules for XMPP_DOMAIN (comma separated)
XMPP_MODULES=

# Custom Prosody modules for MUC component (comma separated)
XMPP_MUC_MODULES=

# Custom Prosody modules for internal MUC component (comma separated)
XMPP_INTERNAL_MUC_MODULES=
Videobridge and rest api
# MUC for the JVB pool
JVB_BREWERY_MUC=jvbbrewery

# XMPP user for JVB client connections
JVB_AUTH_USER=jvb

# STUN servers used to discover the server's public IP
JVB_STUN_SERVERS=meet-jit-si-turnrelay.jitsi.net:443

# Media port for the Jitsi Videobridge
JVB_PORT=10000

# TCP Fallback for Jitsi Videobridge for when UDP isn't available
JVB_TCP_HARVESTER_DISABLED=true
JVB_TCP_PORT=4443
JVB_TCP_MAPPED_PORT=4443

# A comma separated list of APIs to enable when the JVB is started [default: none]
# See https://github.com/jitsi/jitsi-videobridge/blob/master/doc/rest.md for more information
JVB_ENABLE_APIS=rest,colibri
Enable recording and jibri
# Enable recording
ENABLE_RECORDING=1

# XMPP domain for the jibri recorder
XMPP_RECORDER_DOMAIN=recorder.meet.busanid.dev

# XMPP recorder user for Jibri client connections
JIBRI_RECORDER_USER=recorder

# Directory for recordings inside Jibri container
JIBRI_RECORDING_DIR=/config/recordings

# The finalizing script. Will run after recording is complete
#JIBRI_FINALIZE_RECORDING_SCRIPT_PATH=/config/finalize.sh

# XMPP user for Jibri client connections
JIBRI_XMPP_USER=jibri

# MUC name for the Jibri pool
JIBRI_BREWERY_MUC=jibribrewery

# MUC connection timeout
JIBRI_PENDING_TIMEOUT=90

# When jibri gets a request to start a service for a room, the room
# jid will look like: [email protected]_domain
# We'll build the url for the call by transforming that into:
# https://xmpp_domain/subdomain/roomName
# So if there are any prefixes in the jid (like jitsi meet, which
# has its participants join a muc at conference.xmpp_domain) then
# list that prefix here so it can be stripped out to generate
# the call url correctly
JIBRI_STRIP_DOMAIN_JID=muc

# Directory for logs inside Jibri container
JIBRI_LOGS_DIR=/config/logs
Env file redirect http
# Redirect HTTP traffic to HTTPS
# Necessary for Let's Encrypt, relies on standard HTTPS port (443)
ENABLE_HTTP_REDIRECT=1

Create a high-security password in env file. To generate it, you can use the command below.

./gen-passwords.sh

We required to create config directory jitsi.

mkdir -p ~/.jitsi-meet-cfg/{web/letsencrypt,transcripts,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri}

Setting jibri.yml jitsi

In this step, I will configure jibri in the jibri.yml file to replace network with my own domain. Jibri functions to make recording and livestreaming on jitsi run well. Let’s edit the jibri.yml file.

version: '3'

services:
    jibri:
        image: jitsi/jibri:latest
        restart: ${RESTART_POLICY}
        volumes:
            - ${CONFIG}/jibri:/config:Z
            - /dev/shm:/dev/shm
        cap_add:
            - SYS_ADMIN
            - NET_BIND_SERVICE
        devices:
            - /dev/snd:/dev/snd
        environment:
            - PUBLIC_URL
            - XMPP_AUTH_DOMAIN
            - XMPP_INTERNAL_MUC_DOMAIN
            - XMPP_RECORDER_DOMAIN
            - XMPP_SERVER
            - XMPP_DOMAIN
            - JIBRI_XMPP_USER
            - JIBRI_XMPP_PASSWORD
            - JIBRI_BREWERY_MUC
            - JIBRI_RECORDER_USER
            - JIBRI_RECORDER_PASSWORD
            - JIBRI_RECORDING_DIR
            - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH
            - JIBRI_STRIP_DOMAIN_JID
            - JIBRI_LOGS_DIR
            - DISPLAY=:0
            - TZ
        depends_on:
            - jicofo
        networks:
            meet.jitsi:

Change network in jibri

version: '3'

services:
    jibri:
        image: jitsi/jibri:latest
        restart: ${RESTART_POLICY}
        volumes:
            - ${CONFIG}/jibri:/config:Z
            - /dev/shm:/dev/shm
        cap_add:
            - SYS_ADMIN
            - NET_BIND_SERVICE
        devices:
            - /dev/snd:/dev/snd
        environment:
            - PUBLIC_URL
            - XMPP_AUTH_DOMAIN
            - XMPP_INTERNAL_MUC_DOMAIN
            - XMPP_RECORDER_DOMAIN
            - XMPP_SERVER
            - XMPP_DOMAIN
            - JIBRI_XMPP_USER
            - JIBRI_XMPP_PASSWORD
            - JIBRI_BREWERY_MUC
            - JIBRI_RECORDER_USER
            - JIBRI_RECORDER_PASSWORD
            - JIBRI_RECORDING_DIR
            - JIBRI_FINALIZE_RECORDING_SCRIPT_PATH
            - JIBRI_STRIP_DOMAIN_JID
            - JIBRI_LOGS_DIR
            - DISPLAY=:0
            - TZ
        depends_on:
            - jicofo
        networks:
            meet.busanid.dev:

The configuration have done. You can use go build container.

docker-compose -f docker-compose.yml -f jibri.yml up -d
Build jitsi with docker

You can use command “docker-compose -f docker-compose.yml -f jibri.yml ps” to check container already running and up.

docker-compose -f docker-compose.yml -f jibri.yml ps
Checking service docker-compose

As you see in my case the services of jitsi are running well in my containers. Next let’s try to access the video conference page and try to conference. Open it on google chrome https://meet.domainname.tld according to the domain you configured in the env file.

Jitsi conference view website

Jitsi front page already success installed on server, let’s try to start conference.

Start video conference jitsi

Build jitsi on docker is done, you can now start video conferencing with your own server. If you want to save a file and with a large capacity. You can use sesamedisk for your choice of large storage needs. Don’t forget to read other articles we have hundreds of interesting tech posts. Have a nice day!

Hits: 40

Categories
Entrepreneurship General Topics and tips Management and Projects Sotfware & Developers & DevOps

Agile Scrum Backlog: Product and Sprint

Agile Scrum methodology may be very beneficial in a broad range of situations, but complications can occur if it is not correctly understood. It has its own set of terminology and working methods that may be confusing to people unfamiliar with the approach. In this post we will discuss part of the Agile jargon; Scrum Backlog.

However, if the whole team is unfamiliar with the agile methodology and its terms, things may easily fall into inefficiency. Two such potentially confusing scrum phrases are product backlog and sprint backlog, which are critical for planning and prioritization.

Before we go into the scrum backlogs, it’s important to keep in mind that Scrum is an agile methodology that emphasizes flexible, concurrent workflows. Scrum methodologies divide projects into sprints However Waterfall is most effective for projects that we want to finish in a linear manner and do not permit reverting to a previous phase. For more information, you can check our article on the agile vs waterfall technique.

What is a Product Backlog?

The product backlog is a list of all the tasks that we require to finish the project. However, this is not a simplistic task list. A well-organized product backlog splits each item task on the list into a sequence of stages that the development team could follow. There must be a period specified so that the team understands when to begin and how much time they will complete the job.

However, even if it has been planned, the product backlog is not fixed. As with the majority of elements of agile project management and agile scrum methodology, there will be adjustments. It is critical to maintaining flexibility. The project either extends or collapses.

We can say the same thing for the product backlog, which constantly changes and adapts to the development team’s work. In the ideal state, it implies that the product backlog is decreasing since we will remove completed tasks from the product backlog.

What is Sprint Backlog?

A Sprint Backlog is a list of tasks that are scheduled to be completed during a sprint.

The sprint backlog is similar to the product backlog in that it is a subsection of the product backlog. This backlog is derived from the product backlog, but it includes only those tasks that can be accomplished within an agile sprint.

Moreover, It will be determined by the project’s complexity, but the goal is to devote the team to just those items that can be accomplished within the sprint.

However, unlike product backlog, the sprint backlog, on the other hand, remains constant throughout the sprint. It is modifiable during the sprint planning meeting. Once agreed upon, the sprint’s elements and associated steps are frozen for the duration of the sprint. If any items remain incomplete critical sprint, they will be put to the product backlog and we handle them during the next sprint.

Product Backlog, Sprint Backlog Process in Agile Scrum Methology

Product Scrum Backlog

To successfully deploy product backlogs, follow the steps described below. So the Product Owner is the most important person in the team; read this twice to understand and prioritize your backlogs rapidly.

Recognize

Recognize the project’s scope and break it down into stages so that the team can envision and accomplish the job in a timely way. Before interacting with the team, discuss your idea with the client.

Prioritize

Set a priority for each item and rank them in order of importance. It will be more beneficial if you sit with the team and Scrum Master when prioritizing.

Estimate

Estimate the stories depending on the commonly agreed criteria. Maintain a high degree of abstraction in your stories and never go into depth when estimating. The team will complete this job of splitting it down, and the Product Owner can leave it at a high level. Allow the team to make their own decisions about their time estimates without interfering too much.

Keep it dynamic

Keep the backlog dynamic by allowing for revisiting depending on the customer’s ideas and the team’s possibilities and keep the list open so that backlogs may be added or removed at any point throughout the project.

Practical ways in managing Sprint Scrum Backlog

In agile scrum methodology, there are many effective methods to manage the Sprint Backlog.

The Scrum team will review the product backlog and choose a task to execute in the sprints based on the Product Owner’s priority. The recommendations listed below may help you handle these sprint backlogs efficiently.

Think and Make a Decision

Even if the Scrum Master organizes the sprint meeting, they do not make all of the decisions. n agile scrum methodology, you have to allow the team to debate and select each backlog so that each cross-functional group member may concentrate on their area of expertise.

Accept and do not assign

After the team has discussed and agreed on the backlogs and the time estimate for completing the job, they will accept work and do not let any person assign any task.

Update the backlog on a regular basis

During standup meetings, update the document daily so that the Product Owner can create a burndown chart and assess if the sprint backlog will be finished within the scheduled sprint.

Accept extra tasks

Sprint backlog items do not have to be coding-related; any work needed for delivery may be accepted at any time throughout the sprint.

Conclusion

Product backlogs and sprint backlogs are two different types of backlogs that we use in product development. The team needs it to stay motivated to complete the task. They provide an update on the current development as well as the remaining suggestions for improvements to the product. If a Product Backlog does not exist, a Sprint Backlog cannot be established. Product Backlog, on the other hand, can exist on its own. These backlogs are critical because they serve as a clear record that keeps all members of the Scrum Team and stakeholders informed about the product.

Hits: 11