IGEL UMS Java Console

Running IGEL UMS Java Console with Docker

by 4 min read

Docker containers let you isolate applications and their dependencies from one another. Each container has its own libraries, configuration, and runtime environment, reducing conflicts between applications and improving deployment reliability. Because containers behave consistently across systems, you can develop, test, and deploy an application without unexpected environmental differences.

This isolation also allows the same application to run multiple times on one computer or server. Each container can use a different version of the application, along with the specific dependencies that version requires. For example, an older version can remain available for existing users while a newer version is tested or gradually introduced, without the two versions interfering with each other.

This is perfect for running IGEL UMS Java Console. This is because the IGEL UMS Java Console version must match the installed IGEL UMS version. If you’re running multiple versions of IGEL UMS, you will be able to run multiple versions of IGEL UMS Java Console with Docker.

In this article, I will describe how to build the Docker images containing the IGEL UMS Java Console. For running this tutorial, you need the following prerequisites:

  • IGEL UMS installation pack for Linux
  • Docker installed

Create Dockerfile

You first need to create a new file in a folder on your computer. Call this file Dockerfile. Copy the content below into the file. You need the IGEL UMS Installation Package for Linux in the same folder.

# Debian 12 (bookworm)
FROM debian:bookworm-slim

ENV DEBIAN_FRONTEND=noninteractive

# copy ums installer
COPY setup-igel-ums-linux_*.bin  /tmp

RUN apt-get update && apt-get install -y --no-install-recommends \
    bc \
    ca-certificates \
    curl \
    gnupg \
 && mkdir -p /etc/apt/keyrings \
 && curl -fsSL https://dl-ssl.google.com/linux/linux_signing_key.pub \
    | gpg --dearmor -o /etc/apt/keyrings/google-linux.gpg

RUN echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-linux.gpg] \
    http://dl.google.com/linux/chrome/deb/ stable main" \
    > /etc/apt/sources.list.d/google-chrome.list

RUN apt-get update && apt-get install -y google-chrome-stable

RUN chmod +x /tmp/setup-igel-ums-linux_*.bin && \
/tmp/setup-igel-ums-linux_*.bin --nox11 -- --accept-eula yes \
  --accept-license-info yes --accept-sso-info yes --silent yes \
  --installation-type client --install-dependencies yes --upload-license-file no \
  --create-shortcut no

# Remove ums installer
RUN rm -f /tmp/setup-igel-ums-linux_*.bin 

# Create group and user
RUN groupadd -r appuser && useradd -r -g appuser -m appuser

# Setup for coping settings out of container
RUN mkdir /export && chown appuser:appuser /export

# Switch to the new user
USER appuser

# Run UMS Java Console
ENTRYPOINT ["/opt/IGEL/RemoteManager/RemoteManager.sh"]

Create run_docker.sh script

Next, you need to create a second file. Let’s call this file run_docker.sh. Copy the content below into the file. 

#!/bin/bash

set -euo pipefail

#
# For X11:
#   xhost +local:docker
#

xhost +local:docker

IMAGE="ums-java-console:12.14.100"
EXPORT_DIR="$(pwd)/container-export"

mkdir -p "$EXPORT_DIR"

if docker image inspect "$IMAGE" >/dev/null 2>&1; then
    echo "Image $IMAGE exists."
else
    echo "Image $IMAGE does not exist. Building it now."
    docker build --network host -t "$IMAGE" .
fi

docker run --network host --rm -it \
  --user root \
  --security-opt seccomp=unconfined \
  -e DISPLAY="$DISPLAY" \
  -e HOST_UID="$(id -u)" \
  -e HOST_GID="$(id -g)" \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -e PULSE_SERVER=unix:/run/user/777/pulse/native \
  -e PULSE_COOKIE=/root/.config/pulse/cookie \
  -v /run/user/777/pulse:/run/user/777/pulse \
  -v /userhome/config/pulse/cookie:/root/.config/pulse/cookie:ro \
  -v "$EXPORT_DIR:/export" \
  --device=/dev/dri \
  --group-add video \
  --group-add audio \
  --shm-size=2g \
  --entrypoint /bin/bash \
  "$IMAGE" \
  -c '
    set +e

    echo "Restoring exported files..."

    if [ "$(find /export -mindepth 1 -print -quit 2>/dev/null)" ]; then
        cp -a /export/. /home/appuser/
        chown -R appuser:appuser /home/appuser
        echo "Restore complete."
    else
        echo "No exported files found."
    fi

    # Run the UMS Remote Manager as the non-root application user.
    runuser -u appuser -- env \
      HOME=/home/appuser \
      DISPLAY="$DISPLAY" \
      PULSE_SERVER="$PULSE_SERVER" \
      /opt/IGEL/RemoteManager/RemoteManager.sh
    RC=$?

    echo "Copying generated files to /export..."

    if [ -f /home/appuser/rmconsole.truststore ]; then
        cp -a /home/appuser/rmconsole.truststore /export/
    else
        echo "Warning: /home/appuser/rmconsole.truststore was not found."
    fi

    cp -a /home/appuser/.* /export/

    # Make the copied files belong to the user who started the container.
    chown -R "$HOST_UID:$HOST_GID" /export

    echo "Export complete: /export"
    exit "$RC"
  '

echo "Files exported to: $EXPORT_DIR"

Change [VERSION] on line 12 to the version that you downloaded. So, if you have downloaded version 12.14.100 the line will look like this.

IMAGE="igel-ums-java-console:12.14.100"

Run the IGEL UMS Java Console

All you have to do now is to run the run_docker.sh script.

./run_docker.sh

If the image does not exist, the script will create it. If the image exists, it will start the container and the IGEL UMS Java Console.

Repeat this tutorial for each version that you need.

Related reading