Deploying a Corporate Server or Publisher without Kubernetes (docker-compose) - MongoDB

Products: FastReport Corporate Server, FastReport Publisher

General

This guide provides an example of deploying a reporting server (Corporate Server / Publisher) using MongoDB as the database and RabbitMQ as the message broker.

All configuration files in this directory are examples and are intended for local testing and evaluation. For production use, you must adapt the settings to your environment.

Important Support Information

Fast Reports provides support only for FastReport products (Corporate Server, Publisher).

We are not responsible for the operation, configuration, or support of the following components:

MongoDB - database

RabbitMQ - message broker

Any other third-party services and containers presented in this example

If you encounter problems with the database or third-party services, please consult their documentation or relevant communities.

Prerequisites

Before installation, make sure you have the following installed on your system:

Docker (version 20.10+ recommended) - installation instructions
Docker Compose (Docker plugin, version v2+) - usually included with Docker Desktop. You can check with the command:

docker compose version

Sufficient RAM (at least 4 GB of free RAM for all containers is recommended).
Port 8080 (web interface) must be available on the host machine.

Directory Contents

File	Description
`docker-compose.yml`	Description of all services (containers), their connections, and settings.
`.env`	Environment variables - name and version of the product Docker images.
`appsettings.Production.json`	Application configuration: connection to the database, broker, internal security keys, service addresses.
`mongo-init.js`	MongoDB database initialization script (creating users and roles).

Environment Variables (`.env`)

The .env file defines parameters that are substituted into docker-compose.yml using the ${VARIABLE} syntax.

FRC_SOURCE=storage.fast-report.com/repository/docker-registry/fastreport-corporate-server
FRC_VERSION=2026.2.13

Explanation:

FRC_SOURCE is the address of the Docker registry from which Docker images for the Fast Reports product will be downloaded.
FRC_VERSION is the product version. Make sure the specified version exists in the registry and you have access to it.

Important: Do not change FRC_SOURCE unless you are sure the registry address is correct. Make sure your Docker daemon has access to this registry.

Application configuration (`appsettings.Production.json`)

This file contains the main application settings. Let's look at the key sections:

{
  "Auth": {
    "UseOpenId": false,
    "UseLocal": true
  },
  "MainConfig": {
    "InternalHeaders": {
      "S56nHMSzjQzXYx5KJJsU3cjU": "000000000000000000000001",
      "x2aHtuSsxFeYqE8xPTaxAnbH": "000000000000000000000002",
      "QNpq2nyzvDNSCBLtVhMJ9e8m": "000000000000000000000003",
      "9MXgeFwLNjeUrJvw7N2aQv9F": "000000000000000000000004",
      "227881200f7cd43f238b327d": "000000000000000000000005"
    },
    "Frontend": {
      "Mixins": {
        "Head": "",
        "Body": ""
      },
      "InvariantLocale": ""
    },
    "License": "",
    "Server": {
      "Title": "МоиОтчеты Сервисные решения",
      "CorporateServerMode": true
    },
    "Rabbit": {
      "Host": "rabbitmq",
      "Port": 5672,
      "UserName": "fastreports",
      "Password": "Qwerty!23456"
    },
    "Database": {
      "ConnectionString": "mongodb://fastreport:Qwerty!23456@mongo:27017/?authSource=ReportStore&readPreference=primary&maxPoolSize=100&waitQueueMultiple=100",
      "DatabaseName": "ReportStore"
    }
  },
  "Gateway": {
    "BackendUrl": "http://fr-backend:80",
    "InternalKey": "QNpq2nyzvDNSCBLtVhMJ9e8m",
    "SignInPagePath": "/account/signin?r={0}",
    "MaxConcurrentRequests": 200,
    "RequestQueueLimit": 5000
  },
  "Serilog": {
    "MinimumLevel": {
      "Default": "Debug"
    }
  },
  "Services": {
    "Items": {
      "OnlineDesigner": {
        "Type": "Static",
        "Urls": [
          "http://fr-onlinedesigner:80"
        ]
      },
      "Backend": {
        "Type": "Static",
        "Urls": [
          "http://fr-backend:80"
        ]
      },
      "FrontendApp": {
        "Type": "Static",
        "Urls": [
          "http://fr-app:80"
        ]
      },
      "Fonts": {
        "Type": "Static",
        "Urls": [
          "http://fr-fonts:80"
        ]
      },
      "StaticPreviewApp": {
        "Type": "Static",
        "Urls": [
          "http://fr-staticpreview:80"
        ]
      },
      "AdminApp": {
        "Type": "Static",
        "Urls": [
          "http://fr-admin:80"
        ]
      }
    }
  },
  "Designer": {
    "BackendUrl": "http://fr-backend:80",
    "InternalKey": "x2aHtuSsxFeYqE8xPTaxAnbH"
  },
  "WorkerCore": {
    "BackendUrl": "http://fr-backend:80",
    "InternalKey": "S56nHMSzjQzXYx5KJJsU3cjU"
  },
  "Scheduler": {
    "BackendUrl": "http://fr-backend:80",
    "InternalKey": "9MXgeFwLNjeUrJvw7N2aQv9F"
  },
  "Fonts": {
    "BackendUrl": "http://fr-backend:80",
    "InternalKey": "227881200f7cd43f238b327d"
  }
}

Authentication

UseLocal: true - the built-in local authentication (login/password) is used. This is suitable for local usage..
UseOpenId: false - an external OpenID Connect provider is not used. For production, it is recommended to configure OIDC.

Internal Security Headers

"InternalHeaders": {
  "S56nHMSzjQzXYx5KJJsU3cjU": "000000000000000000000001",
  "x2aHtuSsxFeYqE8xPTaxAnbH": "000000000000000000000002",
  "QNpq2nyzvDNSCBLtVhMJ9e8m": "000000000000000000000003",
  "9MXgeFwLNjeUrJvw7N2aQv9F": "000000000000000000000004",
  "227881200f7cd43f238b327d": "000000000000000000000005"
}

Each key:value pair is a unique identifier and secret for internal communication between product services.

Security Warning:

These keys must be unique and must not match any other secrets in the system.

They are used to authorize internal requests between microservices (Gateway, Backend, Designer, WorkerCore, Scheduler, Fonts).

Never publish these keys publicly.

For the production environment, be sure to replace the sample values with your own random strings.

Connecting to RabbitMQ (message broker)

"Rabbit": {
  "Host": "rabbitmq",
  "Port": 5672,
  "UserName": "fastreports",
  "Password": "Qwerty!23456",
  ...
}

Host - the RabbitMQ service name from docker-compose.yml (rabbitmq in this example).
Port - the AMQP port (default 5672).
UserName / Password - credentials for connecting to RabbitMQ.

Security Warning: The password Qwerty!23456 and username fastreports are provided for example purposes only. In production, you should use strong, randomly generated credentials. Do not use this password in production deployments.

Connecting to a database (MongoDB)

"Database": {
  "ConnectionString": "mongodb://fastreport:Qwerty!23456@mongo:27017/?authSource=ReportStore&readPreference=primary&maxPoolSize=100&waitQueueMultiple=100",
  "DatabaseName": "ReportStore"
}

ConnectionString - MongoDB connection address. The service is specified as mongo (matches the name in docker-compose.yml), port is 27017.
authSource=ReportStore - the database used for authentication.
fastreport:Qwerty!23456 - the database username and password.
ReportStore - the target database name.

Security Warning: The database password Qwerty!23456 is provided as an example only. For production, be sure to replace it with a strong password. Ensure that the passwords in appsettings.Production.json match the MongoDB container settings in docker-compose.yml.

Gateway, Designer, WorkerCore, Scheduler, Fonts

Each of these services contains an InternalKey field, which must match the corresponding key from the InternalHeaders section. This ensures secure internal communication.

MongoDB initialization script (`mongo-init.js`)

db = db.getSiblingDB('admin')

db.auth('admin', 'Qwerty!23456')

db = db.getSiblingDB('ReportStore')

db.createUser({
  user: "fastreport",
  pwd: "Qwerty!23456",
  roles: [ { role: "readWrite", db: "ReportStore" } ]
});

The mongo-init.js file is executed automatically the first time the MongoDB container is started. It performs the following actions:

Switches to the admin database and authenticates the administrator.
Switches to the ReportStore database.
Creates the fastreport user with a password and readWrite permissions to the ReportStore database.

Note: This script is executed only the first time the database is created. If the database already exists (for example, when restarting with a saved data volume), the script will not be executed again.

File docker-compose.yml

services:
  mongo:
    image: mongo:5.0
    volumes:
      - ./mongo:/data/db
      - ./mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
    restart: always
    environment:
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=Qwerty!23456
      - MONGO_INITDB_DATABASE=ReportStore
    networks: 
      - fr-cs
  rabbitmq:
    image: bitnamilegacy/rabbitmq:3.9.27-debian-11-r9
    volumes:
      - ./rabbitmq:/bitnami
    restart: always
    networks: 
      - fr-cs
    environment:
      - RABBITMQ_USERNAME=fastreports
      - RABBITMQ_PASSWORD=Qwerty!23456
  fr-backend:
    image: ${FRC_SOURCE}-backend:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-gateway:
    image: ${FRC_SOURCE}-gateway:debian-${FRC_VERSION}
    ports:
      - 8080:80
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-fonts:
    image: ${FRC_SOURCE}-fonts:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-app:
    image: ${FRC_SOURCE}-app:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-staticpreview:
    image: ${FRC_SOURCE}-static-preview:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-onlinedesigner:
    image: ${FRC_SOURCE}-designer:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-admin:
    image: ${FRC_SOURCE}-admin:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
  fr-workercore:
    image: ${FRC_SOURCE}-workercore:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
    deploy:
      mode: replicated
      replicas: 1
      endpoint_mode: vip
  fr-scheduler:
    image: ${FRC_SOURCE}-scheduler:debian-${FRC_VERSION}
    restart: always
    volumes:
      - ./appsettings.Production.json:/app/appsettings.Production.json:ro
    networks: 
      - fr-cs
networks: 
  fr-cs:
    driver: bridge

The docker-compose.yml file describes all containers that will be launched.

Note: All product services (fr-*) use the same appsettings.Production.json configuration file, which is mounted in the container as a read-only volume (:ro). This ensures that the configuration is preserved when updating images.

Security Warning:

Container images (image) are taken from .env variables. Make sure you trust the source of the images.

The passwords set in the example (Qwerty!23456) are used for testing only. Replace them before using them in production.

Installation and Launch

Step 1. Create Configuration Files

This directory should contain the following files:

.env
appsettings.Production.json
docker-compose.yml
mongo-init.js

Edit the files and replace the passwords with your own.

Step 2: Run Containers

docker compose up -d

This command will create and run all containers in the background (-d).

Step 3. Verify that all containers are running

docker compose ps

Make sure all containers have a running status. The first run may take a few minutes as Docker downloads images from the registry. Migrations will also be applied. Monitor the logs to confirm migrations have been applied to the backend service.

Step 4. Open the web interface

In your browser, go to:

http://localhost:8080

Step 5. Log in

Use the default credentials (for testing purposes only!):

Login: admin@example.com
Password: admin

Step 6. Administration Panel

To access the administration panel, follow this link:

http://localhost:8080/admin

Stopping the server

To stop and remove all containers, run:

docker compose down

To stop while preserving data (volumes), simply run docker compose stop.

Completely deleting data (including the database)

Warning: The following command will delete all data from MongoDB, RabbitMQ, and downloaded reports. Use only if you want to start from a clean slate.

docker compose down -v

Useful Commands

Command	Description
`docker compose logs -f`	View logs of all services in real time
`docker compose logs fr-backend`	Logs only the `fr-backend` service
`docker compose restart`	Restart all services
`docker compose ps`	Status of all containers
`docker compose stop`	Stop containers without deleting them

Troubleshooting

Container fails to start - Check the logs: docker compose logs <service_name>. Make sure the images are available in the registry and the .env parameters are correct.
Unable to connect to the web interface - Make sure port 8080 is not in use by another application. Check: docker compose ps. Check that all migrations have been applied via the backend service logs.
Database connection errors - Make sure MongoDB has fully initialized and the mongo-init.js script has completed successfully. Wait 1-2 minutes after startup.
RabbitMQ connection errors - Make sure the credentials in appsettings.Production.json match the RabbitMQ container settings in docker-compose.yml.

Table of Contents