Run DPA in Docker

Running DPA with Docker Compose

The DPA Platform is designed to operate in a wide range of deployment environments, from pilot installations to large-scale distributed manufacturing systems.

The following sections describe three common Docker Compose deployment scenarios based on real-world implementations. Each configuration is suitable for production use:

All services on a single server.
DPA with an external PostgreSQL database.
Separate deployment of DPA Server and DPA Host.

System Requirements

Docker Engine 24 or later and Docker Compose v2.
Network connectivity with the following ports open between hosts:
- 5432/tcp for PostgreSQL.
- 45616/tcp for the DPA Server gRPC interface.
- 45619/tcp for DPA Host transport (when DPA Server and DPA Host are deployed on separate hosts).
- 6216/tcp and 6217/tcp for the DPA Host web interface.
Persistent storage directories:
- /usr/share/X-tensive for DPA services.
- /var/lib/postgresql/data for PostgreSQL.

All Services on a Single Server

DPA Host, DPA Server, microservices, and PostgreSQL are deployed as a single Docker Compose project on one physical or virtual server. This is the most compact deployment architecture: all containers run on the same host, communicate over the internal Docker network, and use a locally hosted PostgreSQL database.

This configuration is well suited for evaluation and demonstration environments, pilot projects, and small manufacturing facilities. It requires minimal network configuration and has very few dependencies on the existing IT infrastructure. Installation, upgrades, and backups are also simplified, since the entire system resides on a single server.

The main limitation of this approach is scalability, which is constrained by the resources of the host machine. As the number of connected machines or the workload increases, a more powerful server may be required. Nevertheless, this deployment model is fully suitable for production use under moderate workloads and is commonly used as the primary configuration in small manufacturing environments.

`.env` File

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
COMPOSE_PROJECT_NAME=dpa
DPA_VERSION=7.1.5
TZ=UTC
SYSTEM_LOCALE=ru-RU

DPA_DATA_PATH=./dpa-data
POSTGRES_DATA_PATH=./postgres-data/16

HOST_HTTP_PORT=80
HOST_HTTPS_PORT=443

POSTGRES_HOST=dpa-postgres
POSTGRES_PORT=5432
POSTGRES_ADMIN_USER=postgres
POSTGRES_ADMIN_PASSWORD=postgres
POSTGRES_MULTIPLE_DATABASES=dpa_host,dpa_audit,dpa_toolmanagement,dpa_messenger,dpa_kpi

DPA_SERVER_ADDRESS=dpa-server
DPA_HOST_ADDRESS=dpa-host

DPA_AUDIT_ADDRESS=dpa-audit
DPA_AUDIT_PORT=5880
DPA_KPI_ADDRESS=dpa-kpi
DPA_KPI_PORT=5780
DPA_MESSENGER_ADDRESS=dpa-messenger
DPA_MESSENGER_PORT=6080
DPA_TOOLMANAGEMENT_ADDRESS=dpa-toolmanagement
DPA_TOOLMANAGEMENT_PORT=6180
DPA_VNC_ADDRESS=dpa-vnc
DPA_VNC_PORT=5980

`docker-compose.yml` File

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
services:
  dpa-postgres:
    image: xtensive/dpa-postgres:16
    ports:
      - "5432:5432"
    environment:
      POSTGRES_MULTIPLE_DATABASES: ${POSTGRES_MULTIPLE_DATABASES}
      PGUSER: ${POSTGRES_ADMIN_USER}
      POSTGRES_USER: ${POSTGRES_ADMIN_USER}
      POSTGRES_PASSWORD: ${POSTGRES_ADMIN_PASSWORD}
      TZ: ${TZ}
    volumes:
      - ${POSTGRES_DATA_PATH}:/var/lib/postgresql/data
    restart: unless-stopped
    logging:
      driver: "local"
    stop_grace_period: 2m
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      interval: 30s
      timeout: 5s
      retries: 5

  dpa-server:
    image: xtensive/dpa-server:${DPA_VERSION}
    environment:
      - TZ=${TZ}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    ports:
      - "45616:45616"
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-host:
    image: xtensive/dpa-host:${DPA_VERSION}
    ports:
      - "${HOST_HTTP_PORT}:6216"
      - "${HOST_HTTPS_PORT}:6217"
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - DatabaseConnection__ConnectionString=Host=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_host;User ID=dpa_host;Password=dpa_host;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
      - SystemLocale=${SYSTEM_LOCALE}
      - DefaultDpaServerAddress=${DPA_SERVER_ADDRESS}
      - DefaultHostAddress=${DPA_HOST_ADDRESS}
      - Microservices__ToolManagement__Address=${DPA_TOOLMANAGEMENT_ADDRESS}
      - Microservices__ToolManagement__Port=${DPA_TOOLMANAGEMENT_PORT}
      - Microservices__Messenger__Address=${DPA_MESSENGER_ADDRESS}
      - Microservices__Messenger__Port=${DPA_MESSENGER_PORT}
      - Microservices__Kpi__Address=${DPA_KPI_ADDRESS}
      - Microservices__Kpi__Port=${DPA_KPI_PORT}
      - Microservices__Vnc__Address=${DPA_VNC_ADDRESS}
      - Microservices__Vnc__Port=${DPA_VNC_PORT}
      - Microservices__Audit__Address=${DPA_AUDIT_ADDRESS}
      - Microservices__Audit__Port=${DPA_AUDIT_PORT}
    depends_on:
      dpa-postgres:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-audit:
    image: xtensive/dpa-audit:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_AUDIT_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_audit;User Id=dpa_audit;Password=dpa_audit;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    depends_on:
      dpa-postgres:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-kpi:
    image: xtensive/dpa-kpi:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_KPI_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_kpi;User Id=dpa_kpi;Password=dpa_kpi;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    depends_on:
      dpa-postgres:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-messenger:
    image: xtensive/dpa-messenger:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_MESSENGER_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_messenger;User Id=dpa_messenger;Password=dpa_messenger;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    depends_on:
      dpa-postgres:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-toolmanagement:
    image: xtensive/dpa-toolmanagement:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_TOOLMANAGEMENT_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_toolmanagement;User Id=dpa_toolmanagement;Password=dpa_toolmanagement;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    depends_on:
      dpa-postgres:
        condition: service_healthy
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-vnc:
    image: xtensive/dpa-vnc:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_VNC_PORT}
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

Start: docker compose up -d

DPA with an External Database

DPA Host, DPA Server, and the platform microservices continue to run in Docker, while PostgreSQL is hosted separately, typically on a database server provided by the customer. In this configuration, DPA connects to an external PostgreSQL instance over the network, and database administration, backups, and monitoring are handled by the customer’s IT team.

This deployment model is commonly used in organizations with centralized database infrastructure and established policies for managing enterprise services. DPA integrates seamlessly into the existing IT environment without introducing a separate data storage infrastructure. This improves operational control and simplifies compliance with internal IT policies.

From an architectural perspective, the solution remains straightforward but requires proper network connectivity and sufficient performance of the external database server. This is a typical deployment scenario for medium-sized production environments where integration with the corporate infrastructure is important, but there is no need to physically separate the production and office networks.

In the dpa-host and microservice configuration, specify the external PostgreSQL server, for example:

POSTGRES_HOST=10.20.30.40
POSTGRES_PORT=5432

Requirements for the external PostgreSQL database:

The following databases must be created: dpa_host, dpa_audit, dpa_toolmanagement, dpa_messenger, and dpa_kpi.
A corresponding database user must be created for each database with the required privileges.
The PostgreSQL server must allow connections from the hosts running the DPA containers.

Minimal docker-compose.yml for a DPA deployment using an external PostgreSQL database:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
services:
  dpa-server:
    image: xtensive/dpa-server:${DPA_VERSION}
    environment:
      - TZ=${TZ}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    ports:
      - "45616:45616"
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-host:
    image: xtensive/dpa-host:${DPA_VERSION}
    ports:
      - "${HOST_HTTP_PORT}:6216"
      - "${HOST_HTTPS_PORT}:6217"
      - "45619:45619"
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - DatabaseConnection__ConnectionString=Host=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_host;User ID=dpa_host;Password=dpa_host;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
      - SystemLocale=${SYSTEM_LOCALE}
      - DefaultDpaServerAddress=${DPA_SERVER_ADDRESS}
      - DefaultHostAddress=${DPA_HOST_ADDRESS}
      - Microservices__ToolManagement__Address=${DPA_TOOLMANAGEMENT_ADDRESS}
      - Microservices__ToolManagement__Port=${DPA_TOOLMANAGEMENT_PORT}
      - Microservices__Messenger__Address=${DPA_MESSENGER_ADDRESS}
      - Microservices__Messenger__Port=${DPA_MESSENGER_PORT}
      - Microservices__Kpi__Address=${DPA_KPI_ADDRESS}
      - Microservices__Kpi__Port=${DPA_KPI_PORT}
      - Microservices__Vnc__Address=${DPA_VNC_ADDRESS}
      - Microservices__Vnc__Port=${DPA_VNC_PORT}
      - Microservices__Audit__Address=${DPA_AUDIT_ADDRESS}
      - Microservices__Audit__Port=${DPA_AUDIT_PORT}
    restart: unless-stopped
    logging:
      driver: "local"

The remaining microservices are configured in the same way as in Scenario 1, except that they use the external POSTGRES_HOST and POSTGRES_PORT settings.

Separate Deployment of DPA Server and DPA Host

This deployment architecture separates the platform into two network zones: DPA Server is deployed in the production network, where it communicates directly with industrial equipment, while DPA Host and the platform microservices run in the corporate network. The two networks are typically separated by a firewall with controlled traffic rules and, in some environments, by a one-way gateway (data diode).

This architecture reflects the requirements of modern industrial environments. The production network remains isolated and protected from external access, with no unnecessary clients or third-party services. DPA Server is responsible for collecting and normalizing machine data before forwarding it to DPA Host, where long-term storage, analytics, and integration with users and enterprise systems take place.

The architecture is designed for horizontal scalability. A single DPA Host can communicate with multiple DPA Server instances. In practice, one DPA Server is typically recommended for approximately 100 machines, although significantly larger deployments are possible with sufficient hardware resources. As the system grows, additional DPA Server instances can be deployed by production site or by equipment group.

This deployment model is recommended for medium and large manufacturing environments where network segmentation, cybersecurity, and scalability are important. It provides a robust architecture aligned with industrial security requirements and enterprise IT best practices.

Machine A — DPA Server

docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
services:
  dpa-server:
    image: xtensive/dpa-server:${DPA_VERSION}
    environment:
      - TZ=${TZ}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    ports:
      - "45616:45616"
    restart: unless-stopped
    logging:
      driver: "local"

Machine B — DPA Host and microservices

docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
services:
  dpa-host:
    image: xtensive/dpa-host:${DPA_VERSION}
    ports:
      - "${HOST_HTTP_PORT}:6216"
      - "${HOST_HTTPS_PORT}:6217"
      - "45619:45619"
      - "1000-1010:1000-1010/tcp"
      - "1000-1010:1000-1010/udp"
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - DatabaseConnection__ConnectionString=Host=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_host;User ID=dpa_host;Password=dpa_host;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
      - SystemLocale=${SYSTEM_LOCALE}
      - DefaultDpaServerAddress=${DPA_SERVER_ADDRESS}
      - DefaultHostAddress=${DPA_HOST_ADDRESS}
      - Microservices__ToolManagement__Address=${DPA_TOOLMANAGEMENT_ADDRESS}
      - Microservices__ToolManagement__Port=${DPA_TOOLMANAGEMENT_PORT}
      - Microservices__Messenger__Address=${DPA_MESSENGER_ADDRESS}
      - Microservices__Messenger__Port=${DPA_MESSENGER_PORT}
      - Microservices__Kpi__Address=${DPA_KPI_ADDRESS}
      - Microservices__Kpi__Port=${DPA_KPI_PORT}
      - Microservices__Vnc__Address=${DPA_VNC_ADDRESS}
      - Microservices__Vnc__Port=${DPA_VNC_PORT}
      - Microservices__Audit__Address=${DPA_AUDIT_ADDRESS}
      - Microservices__Audit__Port=${DPA_AUDIT_PORT}
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-audit:
    image: xtensive/dpa-audit:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_AUDIT_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_audit;User Id=dpa_audit;Password=dpa_audit;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-kpi:
    image: xtensive/dpa-kpi:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_KPI_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_kpi;User Id=dpa_kpi;Password=dpa_kpi;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-messenger:
    image: xtensive/dpa-messenger:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_MESSENGER_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_messenger;User Id=dpa_messenger;Password=dpa_messenger;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-toolmanagement:
    image: xtensive/dpa-toolmanagement:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_TOOLMANAGEMENT_PORT}
      - DatabaseConnection__ConnectionString=Server=${POSTGRES_HOST};Port=${POSTGRES_PORT};Database=dpa_toolmanagement;User Id=dpa_toolmanagement;Password=dpa_toolmanagement;
      - DatabaseConnection__Provider=postgresql
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

  dpa-vnc:
    image: xtensive/dpa-vnc:${DPA_VERSION}
    volumes:
      - ${DPA_DATA_PATH}:/usr/share/X-tensive
    environment:
      - urls=http://*:${DPA_VNC_PORT}
      - TZ=${TZ}
    restart: unless-stopped
    logging:
      driver: "local"

Key configuration requirements for this deployment scenario:

DPA_SERVER_ADDRESS must point to the actual address (DNS name or IP address) of Host A.
DPA_HOST_ADDRESS must point to the actual address of Host B that is reachable from Host A.
Port 45619/tcp must be open on Host B.
Ports 1000-1010 over both TCP and UDP must be open on Host B for state subscriptions, snapshots, and machine discovery.
If PostgreSQL is hosted on a third server, Host B must have network access to port 5432/tcp on the PostgreSQL server.

Environment Variables

.env Variables for Docker Compose

Variable	Description	Example
`COMPOSE_PROJECT_NAME`	Docker Compose project name	`dpa`
`DPA_VERSION`	Tag of the DPA container images (`dpa-host`, `dpa-server`, and microservices)	`7.1.5`
`TZ`	Container time zone (IANA time zone identifier)	`UTC`
`SYSTEM_LOCALE`	DPA Host system locale	`en-US`
`DPA_DATA_PATH`	Host directory for DPA persistent data	`./dpa-data`
`POSTGRES_DATA_PATH`	Host directory for PostgreSQL data	`./postgres-data/16`
`HOST_HTTP_PORT`	Published HTTP port for DPA Host	`80`
`HOST_HTTPS_PORT`	Published HTTPS port for DPA Host	`443`
`POSTGRES_HOST`	PostgreSQL host name or IP address	`dpa-postgres` or `10.20.30.40`
`POSTGRES_PORT`	PostgreSQL port	`5432`
`POSTGRES_ADMIN_USER`	PostgreSQL container administrator username	`postgres`
`POSTGRES_ADMIN_PASSWORD`	Password for the PostgreSQL container administrator user	`postgres`
`POSTGRES_MULTIPLE_DATABASES`	Databases automatically created by the `dpa-postgres` container	`dpa_host, dpa_audit, dpa_toolmanagement, dpa_messenger, dpa_kpi`
`DPA_SERVER_ADDRESS`	DPA Server address used for automatic DPA Host configuration	`dpa-server` or `server.company.local`
`DPA_HOST_ADDRESS`	DPA Host address used to register the transport endpoint with DPA Server	`dpa-host` or `host.company.local`
`DPA_AUDIT_ADDRESS`	Address of the Audit microservice	`dpa-audit`
`DPA_AUDIT_PORT`	Port of the Audit microservice	`5880`
`DPA_KPI_ADDRESS`	Address of the KPI microservice	`dpa-kpi`
`DPA_KPI_PORT`	Port of the KPI microservice	`5780`
`DPA_MESSENGER_ADDRESS`	Address of the Messenger microservice	`dpa-messenger`
`DPA_MESSENGER_PORT`	Port of the Messenger microservice	`6080`
`DPA_TOOLMANAGEMENT_ADDRESS`	Address of the Tool Management microservice	`dpa-toolmanagement`
`DPA_TOOLMANAGEMENT_PORT`	Port of the Tool Management microservice	`6180`
`DPA_VNC_ADDRESS`	Address of the VNC microservice	`dpa-vnc`
`DPA_VNC_PORT`	Port of the VNC microservice	`5980`

Container Environment Variables

dpa-postgres:

POSTGRES_MULTIPLE_DATABASES - List of databases to be created automatically.
PGUSER - User for internal PostgreSQL commands (such as pg_isready).
POSTGRES_USER - PostgreSQL administrator user.
POSTGRES_PASSWORD - Password for the PostgreSQL administrator user.
TZ - PostgreSQL container time zone.

dpa-server:

TZ - DPA Server container time zone.

dpa-host:

DatabaseConnection__Provider - Database provider: postgresql or sqlserver.
DatabaseConnection__ConnectionString - Connection string for the DPA Host database.
TZ - Container time zone.
SystemLocale - Default locale for newly created users.
DefaultDpaServerAddress - DPA Server address used for automatic initialization.
DefaultHostAddress - DPA Host address to be registered with DPA Server.
Microservices__ToolManagement__Address, Microservices__ToolManagement__Port - Tool Management microservice address and port.
Microservices__Messenger__Address, Microservices__Messenger__Port - Messenger microservice address and port.
Microservices__Kpi__Address, Microservices__Kpi__Port - KPI microservice address and port.
Microservices__Vnc__Address, Microservices__Vnc__Port - VNC microservice address and port.
Microservices__Audit__Address, Microservices__Audit__Port - Audit microservice address and port.

dpa-audit, dpa-kpi, dpa-messenger, dpa-toolmanagement:

urls - Address and listening port of the microservice (for example, http://*:PORT).
DatabaseConnection__Provider - Database provider: postgresql or sqlserver.
DatabaseConnection__ConnectionString - Connection string for the microservice database.
TZ - Container time zone.

dpa-vnc:

urls - Address and listening port (for example, http://*:5980).
TZ - Container time zone.

Troubleshooting

Verifying Service Status

Make sure all containers are in the running state:

1
docker compose ps

The DPA Host web interface should be available at http://<host>:<HOST_HTTP_PORT>. If it is not accessible:

Verify that the required ports are published.
Make sure the HTTP port is not already in use by another service.
Check the host firewall configuration.

To investigate issues, inspect the container logs:

1
2
3
docker compose logs -f dpa-host
docker compose logs -f dpa-server
docker compose logs -f dpa-postgres

Database connection errors are typically reported immediately after startup.

Time Synchronization

Accurate system time is essential for scheduled tasks, authentication tokens, audit records, log correlation, subscriptions, and event processing. Time drift between hosts can lead to issues that are difficult to diagnose.

We recommend synchronizing the system clocks of all hosts using NTP, Chrony, or the Windows Time service.

Use the same TZ value for all DPA and PostgreSQL containers.

Specify the time zone using an IANA time zone identifier, for example: UTC, Europe/Berlin, America/New_York, or Asia/Tokyo.

Verify the time inside the containers:

1
2
3
docker exec -it dpa-host date
docker exec -it dpa-server date
docker exec -it dpa-postgres date

The reported time should be consistent across all containers, taking the configured time zones into account.

Example configuration on a Linux host:

1
2
sudo timedatectl set-timezone Europe/Moscow
sudo timedatectl set-ntp true

After changing the configuration, we recommend restarting the affected containers.

For detailed installation, configuration, and operation instructions, refer to the Knowledge Base: kb.dpaxt.com (coming soon)