Skip to content

Docker Installation

Emakin Docker images are published on Docker Hub at 6kare.

When the container starts for the first time, the documented default domain and admin user are created automatically:

Default access points:

  • Application Access: http://localhost
  • Host Administration: https://localhost:7180

Docker Compose Configuration

Create a docker-compose.yml file similar to the following:

 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
services:
    web:
        image: 6kare/emakin:8.8
        restart: unless-stopped
        ports:
            - "80:80"
            - "443:443"
            - "7180:7180"
            - "25:25"
            - "587:587"
            - "465:465"
        sysctls:
            - "net.ipv4.ip_unprivileged_port_start=0"
        depends_on:
            dragonfly:
                condition: service_started
            postgres:
                condition: service_healthy
            basex:
                condition: service_started
            tika:
                condition: service_started
        volumes:
            - "./data/emkdata:/app/Configuration/Data"
        environment:
            - AK_DbProvider=PostgreSql
            - AK_DbConnStr=Host=postgres;Database=ALTIKARE;Username=ALTIKARE;Password=ALTIKARE;
            - AK_RedisConnStr=dragonfly,allowAdmin=true
            - AK_BasexConnStr=http://admin:admin@basex:1984/
            - AK_TikaConnStr=http://tika:9998/
            - AK_WopiConnStr=http://onlyoffice:81/hosting/discovery
            - AK_AntivirusServerUrl=tcp://clamav:3310
    postgres:
        image: "postgres:18"
        restart: unless-stopped
        healthcheck:
            test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB -h localhost"]
            interval: 5s
            timeout: 5s
            retries: 20
            start_period: 10s
        volumes:
            - "./data/postgres:/var/lib/postgresql"
        environment:
            - POSTGRES_USER=ALTIKARE
            - POSTGRES_PASSWORD=ALTIKARE
            - POSTGRES_DB=ALTIKARE
    dragonfly:
        image: docker.dragonflydb.io/dragonflydb/dragonfly
        restart: unless-stopped
        expose:
            - "6379"
        ulimits:
            memlock: -1
    basex:
        image: "6kare/basex"
        restart: unless-stopped
        expose:
            - "1984"
        volumes:
            - "./data/basex:/srv/basex/data"
    tika:
        image: "6kare/tika2"
        restart: unless-stopped
        expose:
            - 9998
    onlyoffice:
        image: onlyoffice/documentserver:8.0
        restart: unless-stopped
        environment:
            USE_UNAUTHORIZED_STORAGE: "true"
            WOPI_ENABLED: "true"
        ports:
            - "81:80"
            - "8443:443"
    clamav:
        image: "clamav/clamav:1.5"
        platform: linux/amd64
        restart: unless-stopped
        expose:
            - 3310
        volumes:
            - "./data/clamav:/var/lib/clamav"

Replace placeholders such as credentials and hostnames with your actual environment values, then start the stack with docker compose up.

Environment Variables

The documented database environment variables are:

1
2
AK_DbProvider=PostgreSQL  # Or "Oracle", "SqlServer"
AK_DbConnStr=Host=databaseserver;Database=database;Username=user;Password=pass;

Packaging Images

Use the following script to package Docker images for deployment to a closed network. After execution, emakin-deploy.tar.gz will be created in the current directory.

1
2
3
4
5
6
7
8
9
docker compose pull

echo "Packaging..."

docker compose config --images | sort -u | xargs docker save > emakin-deploy.tar && \
tar czf emakin-deploy.tar.gz docker-compose.yml emakin-deploy.tar && \
rm -f emakin-deploy.tar

echo "Packaging completed."

Unpacking Images

1
2
3
4
5
6
7
echo "Loading Docker images..."

tar xzf emakin-deploy.tar.gz && \
docker load -i emakin-deploy.tar && \
rm -f emakin-deploy.tar

echo "Unpack completed."

Once unpacking is completed, start services with Docker Compose:

1
docker compose up -d --pull never

Load Balancer Example with HAProxy

The following example shows how an HAProxy service can be added for load balancing across multiple Emakin web nodes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#...previous services definition...
haproxy:
    image: haproxy:latest
    volumes:
        - "./haproxy.cfg:/usr/local/etc/haproxy:ro"
    restart: always
    ports:
        - "80:80"
        - "443:443"
        - "7180:7180"
        - "25:25"
        - "587:587"
        - "465:465"

#...rest of the configuration...

You also need a separate haproxy.cfg file. The documented sample is:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
frontend http
    bind *:80
    bind *:443
    bind *:5000
    mode http
    timeout client 1000s
    use_backend all

backend all
    mode http
    timeout server 1000s
    timeout connect 1000s
    server s1 web1:80
    server s2 web2:80
    server s3 web3:80

Adapt the sample to your actual hostnames, ports, and network layout.