inetsoftware/i-net-clear-reports Docker 镜像 - 轩辕镜像 | Docker 镜像高效稳定拉取服务

i-net Clear Reports Docker Container

This is a pre-build containerized version of the i-net Clear Reports reporting application. The container only brings the application and tools required to run the application.

The container does not provide any default users. You have to use the Sign Up method first. See below for advanced use cases.

Please have a look at our website for more information about the i-net Clear Reports.

Quickstart

Run the following command to start an i-net Clear Reports Server Docker Container:

bash
docker run -d -p 9000:9000 -e CONF_listener__port=9000 --name reporting inetsoftware/i-net-clear-reports

Available Tags

• Version 25.x: latest, alpine-25
• Version 24.x: alpine-24
• Version 23.x: alpine-23
• Version 22.x: alpine-22
• Version 21.x: alpine-21
• Version 20.x: alpine-20
• Version 19.x: alpine-19
• Version 18.x: alpine-18

Creating a pre-set configuration

The i-net Clear Reports Docker Container should be pre-configured using either a configuration properties file or environment variables. Either way, a local installation with the specific setup should be created first. Using the Maintenance module a backup of the configuration can be created and the configuration properties file in there can be used as a basis.

To have the container fully set up on startup you have to specify at least the following properties: CONF_listener__port and CONF_licensekey

In private cloud environments you have to set the property CONF_serverURL as well. It is recommended to set this property in other environments too.

Adding the configuration

A configuration file can be added by using a volume or any other means that adds a specified configuration to the container. The default configuration file can be used or a different one can be set using an environment variable. See Environment Properties Matrix.

Setting up the configuration using environment variables

To create the environment variable names use the following rule:

• prefix the property with CONF__
• replace every . (dot) with __ (two underlines)

To make the configuration reproducible and updatable you should use a docker-compose.yml file.

Example

yaml
version: '2.1'

services:

    reporting:
        image: 'inetsoftware/i-net-clear-reports:latest'
        restart: 'always'
        ports:
            - 9000:9000

        environment:
            - DEFAULT_PROPFILE=/tmp/defaultConfiguration.properties
            - DEFAULT_CONFIG=User/Default

            # Set the externally visible server url (un-comment and insert the correct url)
            #- CONF_serverURL=[***]

            # Set the license key (un-comment and insert the full license key)
            #- CONF_licensekey=...

            # Run the application on a pre-determined port for easier mapping
            - CONF_listener__port=9000

            # Customize an option, e.g. the theming colors
            - CONF_theme__themecolors={"@base-color":"#0a89dd","@primary-color":"#42a7ca"}

            # Enable logging, route log to the container log-file
            - CONF_log__engine=true
            - CONF_log__file=/dev/stdout

            # Location for automatic backups
            - CONF_BackupLocation=/home/reporting/.i-net software/reporting_User_Default/backup

Advanced Use Case

If there are more specific requirements, such as a pre-filled user database, a custom container should be created

Example: internal access with public account

Using the following compose example you can create a server that is started without any permission restrictions and can be used without further authentication using the public URL context.

yaml
version: '2.1'

services:

    reporting:
        image: 'inetsoftware/i-net-clear-reports:latest'
        restart: 'always'
        ports:
            # Not setting a host port allows to use --scale, but the external port varies
            - 9000/tcp

        environment:
            # Using the System/Default config is mandatory in cloud persistence environments
            - DEFAULT_CONFIG=System/Default

            # Set the license key (un-comment and insert the full license key)
            #- CONF_licensekey=...

            # Run the application on a pre-determined port for easier mapping
            - CONF_listener_ _port=9000

            # Only guest account is active. Activate webapi.
            - CONF_authentication__settings=[{"provider"\:"guest"}]
            - CONF_plugins__activated={"webapi.core"\:true}

Example: add PAM authentication and a default user

The following Dockerfile will create a user admin with the password password in a new container.

Dockerfile
FROM inetsoftware/i-net-clear-reports

# Switch to root user for installation
USER root

# Tools
RUN apk add --update linux-pam

# grant pam permissions to everybody
# Create User that we can log in with
RUN chmod +r /etc/shadow \
    && adduser -D -g "User" admin \
    && echo admin:password | chpasswd \
    && ln -s "/etc/pam.d/base-password" "/etc/pam.d/reporting"

# Switch back to product user
USER reporting

Mounting / Re-using a given configuration

If the data of the container should be persisted beyond restarts, e.g. for new container versions, a volume should be mounted.

The persistence and configuration is located in the home folder of the product user. You should use the following additional options to mount this folder:

bash
-v /folder/to/mount/from:/home/$PRODUCT -e FORCE_IMPORT_CONFIG=0

• -v /folder/to/mount/from:/home/$PRODUCT - mount the specific folder to the home folder of the product user
• -e FORCE_IMPORT_CONFIG=0 - specify that the given configuration should not be overwritten

the product user depends on the product you are using. It is determined by the $PRODUCT variable in the container. Possible values are: reporting, pdfc, cowork and helpdesk.

Adding additional fonts

The default container comes with, e.g. the DejaVu font pre-installed. Adding additional fonts, such as the license restricted Microsoft fonts Arial, require building a custom container. You can use the following Dockerfile as a basis.

Dockerfile
#############################################################################
# Prepare product
# Note: alpine 3.12 due to issue with newer versions of alpine!
FROM alpine:3.12 as builder

RUN apk add --update msttcorefonts-installer \
    && update-ms-fonts

FROM inetsoftware/i-net-<PRODUCT>:<TAG>

USER "root"

# Copy fonts from intermedia builder
COPY --from=builder /usr/share/fonts/truetype/msttcorefonts /usr/share/fonts/truetype/msttcorefonts

# Update font cache for product user
USER $PRODUCT
RUN fc-cache -fv /usr/share/fonts

Environment Properties Matrix

MongoDB Persistence

Using MongoDB Persistence is recommended in scenarios where no hard drive is available or the file system can disappear together with the server instance. For technical details, please have a look at the documentation.

To configure either persistences the environment variable inet_persistence has to be set up accordingly:

bash
inet_persistence=<PERSISTENCE URI>

# MongoDB
inet_persistence=mongodb://(<USERNAME>:<PASSWORD>@)<MONGODB SERVER>/<DATABASE>

If the platform does provide these URIs using environment variables, these have to be forwarded respectively.

Since the configuration is being stored in the persistence it might be required to set the application port to a specific value every time the container starts (e.g. Heroku provides an environment variable for that). This port has to be set using the environment variables: inet_http_port or init_https_port

Docker Compose Example

To bundle a docker container with a MongoDB persistence using Docker Compose, the following docker-compose.yml script can be used as a starting point:

yaml
version: '2.1'

services:

    reporting:
        image: 'inetsoftware/i-net-clear-reports:latest'
        restart: 'always'
        ports:
            # Not setting a host port allows to use --scale, but the external port varies
            - 9000/tcp

        environment:
            # Using the System/Default config is mandatory in cloud persistence environments
            - DEFAULT_CONFIG=System/Default

            # Set the externally visible server url (un-comment and insert the correct url)
            #- CONF_serverURL=[***]

            # Set the license key (un-comment and insert the full license key)
            #- CONF_licensekey=...

            # Run the application on a pre-determined port for easier mapping
            - CONF_listener_ _port=9000

            # Do not force the application to overwrite a previously imported configuration
            # or other instances using the same MongoDB will have their configuration modified
            - FORCE_IMPORT_CONFIG=0
            
            # Set up the connection the MongoDB persistence
            - inet_persistence=mongodb://root:example@mongo:27017/reporting

    mongo:
        image: mongo
        environment:
            MONGO_INITDB_ROOT_PASSWORD: example
            MONGO_INITDB_ROOT_USERNAME: root
        restart: always

The parameter FORCE_IMPORT_CONFIG should be set to 0 so that the configuration is imported only once versus every time the container is started. This way the configuration may be persisted and re-used on subsequent restarts or in a scaled environment.

Depending on the specific environment there may be some more options that have to be set. Please have a look at the Environment Properties Matrix.

Creating a load balanced environment

To distribute the computation load across several server nodes it possible to create a load balanced environment. It is crucial to know that each node will be frontend and backend server at the same time. The nodes can share the data persistence - using a MongoDB setup - so that comparisons are available across nodes.

A load ***, such as HAProxy, has to support some kind of sticky sessions so that a logged-in user will always be directed to the same node.

In case of the HAProxy you can use the balance hdr(Cookie) setting. To showcase a setup of i-net Clear Reports using HAProxy have a look at our gitHub example.

Installing Additional Plugins

Additional plugins can be added to the Docker container either during a custom Dockerfile build or on the fly during container startup. In both cases you can use the install-plugin command of the container:

bash
/usr/share/product $ install-plugin --help
Usage install all Plugins: /bin/install-plugin -p <product> -v <version>
Usage install defined plugins: /bin/install-plugin -p <product> -v <version> <list of plugins to install>
Usage install BETA Plugins: /bin/install-plugin -p <product> -v <version> -b <list of plugins to install>
Usage install additional persistence: /bin/install-plugin -s <type>

Plugin names can be derived, e.g. from the plugin store URL, specifically the path component after /pid: [***] → webapi.core

There are distinct containers available for each persistence type. The MongoDB persistence is installed in the default container that has no additional tag. Available persistences are: mongodb, cosmosdb, dynamodb.

Dockerfile Example

In a Dockerfile you can add the following lines to install a plugin:

Dockerfile
# Add Web API plugin 
RUN install-plugin web.api

Docker Compose Example

In a docker-compose.yml you can use the following setup to install a plugin:

yaml
version: '2.1'
services:
    service:
        command: >
            sh -c "
            install-plugin web.api &&
            ./startServer.sh -Dclearreports.config=User/Default -Dsetupautoexecution=true
            "

the original startServer.sh command can be determined using docker inspect on an already running container.

The example is incomplete and requires definition of the specific container.

Restarting the Service

In situations where the service is unresponsive but the container can still be accessed, the servers subprocess can be terminated and restarted without restarting the whole container. In this case, the user has to enter the container using shell and run the following command:

bash
ps xo pid,command | grep exitcode | grep -v grep | awk '{print $1}' | xargs -r kill -TERM