NetLock RMMNetLock RMM Docs
III — How-To Guides

Install the NetLock RMM server with Docker

Deploy the NetLock RMM server and Web Console on your own infrastructure with Docker, using the guided installer or a manual Docker Compose setup.

Install the NetLock RMM server with Docker

Self-hosted only: This guide applies to self-hosted deployments. Cloud customers do not install the server — the hosted platform is run for them.

This guide covers installing the NetLock RMM server and Web Console with Docker. Both can run in the cloud or in an offline environment, depending on your requirements. Two methods are described: a guided installer that generates the setup for a standard server, and a manual Docker Compose setup for full control.

Network structure

Agents only make outgoing connections, so no port forwarding is required on the managed machines. The Web Console renders content server-side and sends it to the administrator's browser, so a persistent connection between the Web Console and the administrator is required during operation.

The Web Console communicates either directly with the SQL server or, for real-time features such as the remote shell and file browser, with the NetLock Remote Server over SignalR. Make sure the Web Console can reach the NetLock Remote Server.

Warning: The Web Console should only be reachable from trusted networks.

Guided installation

NetLock RMM can be deployed in any environment with Docker support, including setups behind Cloudflare tunnels and similar. The guided script builder targets typical server installations.

For help deploying NetLock RMM in non-standard environments, contact the support team.

Open the installation tool and follow its steps: https://netlockrmm.com/install

Manual installation

For full control, install the stack manually with Docker Compose.

Requirements

  • The latest version of Docker.
  • MySQL Server 8.4 LTS (the compose file below uses mysql:8.4). MySQL 8.0 still runs, but Oracle support ended on 30 April 2026 — see Upgrade MySQL to 8.4.
  • 2 CPU cores — more may be needed depending on how many agents you monitor.
  • 8 GB RAM.

Note: The 8 GB RAM requirement supports the high-performance, memory-optimised update delivery. With insufficient RAM the setup may fail, or NetLock RMM may run slowly because it falls back to swap space. 8 GB is enough for about 2,000 devices.

The Docker images are published under the latest tag.

Warning: The database name, password, domains, time zone, Let's Encrypt email address (acme.email), and Members Portal API key in the templates below are examples. Use your own email address for Let's Encrypt and replace every other value with values for your own environment before deploying.

Web Console

Create a directory for the appsettings.json file:

mkdir -p /home/netlock/web_console

Create directories for Let's Encrypt, internal data, and logs:

mkdir -p /home/netlock/web_console/letsencrypt
mkdir -p /home/netlock/web_console/logs
mkdir -p /home/netlock/web_console/internal

Create the appsettings.json file:

nano /home/netlock/web_console/appsettings.json

Fill it in with your configuration:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning",
      "Microsoft": "Error",
      "Microsoft.Hosting.Lifetime": "Warning"
    },
    "Custom": {
      "Enabled": false
    }
  },
  "AllowedHosts": "*",
  "Kestrel": {
    "Endpoint": {
      "Http": {
        "Enabled": true,
        "Port": 80
      },
      "Https": {
        "Enabled": false,
        "Port": 443,
        "Force": false,
        "Hsts": {
          "Enabled": true
        },
        "Certificate": {
          "Path": "/certificates/certificate.pfx",
          "Password": ""
        }
      }
    },
    "IpWhitelist": [],
    "KnownProxies": ["172.18.0.2"]
  },
  "NetLock_Remote_Server": {
    "Server": "netlock-rmm-server",
    "Port": 7080,
    "UseSSL": false
  },
  "NetLock_File_Server": {
    "Server": "netlock-rmm-server",
    "Port": 7080,
    "UseSSL": false
  },
  "MySQL": {
    "Server": "mysql-container",
    "Port": 3306,
    "Database": "vwffyq",
    "User": "root",
    "Password": "frfsL9FGmQWGbZDM",
    "SslMode": "None",
    "AdditionalConnectionParameters": "AllowPublicKeyRetrieval=True;"
  },
  "Webinterface": {
    "Title": "NetLock RMM On Premises",
    "Language": "en-US",
    "Membership_Reminder": false,
    "PublicOverrideUrl": "https://nl-backend.penguin-monitoring.de"
  },
  "Members_Portal_Api": {
    "Enabled": true,
    "ApiKeyOverride": "YOUR-MEMBERS-PORTAL-API-KEY"
  }
}

Adjust the values to match your environment. On the first start the key from ApiKeyOverride is stored in the database; to replace it later, use Settings → Licensing (see Replace the Members Portal API key). Likewise, the URL from PublicOverrideUrl is stored in the database on the first start; to change it later, use Settings → Overview (see Public backend URL). The address of the web console itself is not part of this file: set it under Settings → Overview after the first sign-in, otherwise ticket webhooks and notification mails contain no link to the ticket (see Public console URL).

Server

Create a directory for the appsettings.json file:

mkdir -p /home/netlock/server

Create directories for Let's Encrypt and logs:

mkdir -p /home/netlock/server/letsencrypt
mkdir -p /home/netlock/server/logs

Create the persistent files directory used by the file server:

mkdir -p /home/netlock/server/files
mkdir -p /home/netlock/server/internal

Create the appsettings.json file:

nano /home/netlock/server/appsettings.json

Fill it in with your configuration:

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning",
      "Microsoft": "Error",
      "Microsoft.Hosting.Lifetime": "Warning",
      "Microsoft.AspNetCore.SignalR": "Error",
      "Microsoft.AspNetCore.Http.Connections": "Error"
    },
    "Custom": {
      "Enabled": false
    }
  },
  "AllowedHosts": "*",
  "Kestrel": {
    "Endpoint": {
      "Http": {
        "Enabled": true,
        "Port": 7080
      },
      "Https": {
        "Enabled": false,
        "Port": 7443,
        "Force": false,
        "Hsts": {
          "Enabled": true
        },
        "Certificate": {
          "Path": "/certificates/certificate.pfx",
          "Password": ""
        }
      }
    },
    "Roles": {
      "Comm": true,
      "Update": true,
      "Trust": true,
      "Remote": true,
      "Notification": true,
      "File": true,
      "LLM": true
    }
  },
  "MySQL": {
    "Server": "mysql-container",
    "Port": 3306,
    "Database": "vwffyq",
    "User": "root",
    "Password": "frfsL9FGmQWGbZDM",
    "SslMode": "None",
    "AdditionalConnectionParameters": "AllowPublicKeyRetrieval=True;"
  },
  "Members_Portal_Api": {
    "Enabled": true,
    "ApiKeyOverride": "YOUR-MEMBERS-PORTAL-API-KEY"
  },
  "Environment": {
    "Docker": true
  }
}

The Roles block decides which server roles this instance runs — see Server roles below.

Ownership of the data directories

Both application containers run as the unprivileged user with id 1654. Give that user ownership of the two data directories, including the appsettings.json files you just created:

sudo chown -R 1654:1654 /home/netlock/web_console /home/netlock/server

Leave /home/netlock/certificates and /home/netlock/mysql as they are; Traefik and MySQL manage their own files.

Docker Compose

The following docker-compose.yml brings up Traefik (as a reverse proxy handling Let's Encrypt certificates), MySQL, the Web Console, and the server:

services:
  traefik:
    image: traefik:latest
    container_name: traefik
    command:
        - '--providers.docker=true'
        - '--providers.docker.exposedbydefault=false'
        - '--entrypoints.web.address=:80'
        - '--entrypoints.websecure.address=:443'
        - '--entrypoints.web.http.redirections.entryPoint.to=websecure'
        - '--entrypoints.web.http.redirections.entryPoint.scheme=https'
        - '--entrypoints.web.http.redirections.entryPoint.permanent=true'
        - '--entrypoints.web.transport.respondingTimeouts.readTimeout=24h'
        - '--entrypoints.websecure.transport.respondingTimeouts.readTimeout=24h'
        - '--certificatesresolvers.myresolver.acme.httpchallenge=true'
        - '--certificatesresolvers.myresolver.acme.httpchallenge.entrypoint=web'
        - '--certificatesresolvers.myresolver.acme.email=admin@example.com'
        - '--certificatesresolvers.myresolver.acme.storage=/certificates/acme.json'
    ports:
        - '80:80'
        - '443:443'
    volumes:
        - '/var/run/docker.sock:/var/run/docker.sock:ro'
        - '/home/netlock/certificates/traefik:/certificates'
    networks:
      netlock-network:
        ipv4_address: 172.18.0.2
    restart: always

  mysql:
    image: mysql:8.4
    container_name: mysql-container
    environment:
      MYSQL_ROOT_PASSWORD: "frfsL9FGmQWGbZDM"
      MYSQL_DATABASE: "vwffyq"
    volumes:
      - /home/netlock/mysql/data:/var/lib/mysql
      - /etc/localtime:/etc/localtime:ro
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETUID
      - SETGID
      - DAC_OVERRIDE
    networks:
      netlock-network:
        ipv4_address: 172.18.0.3
    restart: always
    command:
      - --skip-log-bin
      - --innodb_buffer_pool_size=1G
      - --innodb_redo_log_capacity=512M
      - --innodb_flush_log_at_trx_commit=2
      - --max_connections=200

  netlock-rmm-web-console:
    image: nicomak101/netlock-rmm-web-console:latest
    container_name: netlock-rmm-web-console
    user: "1654:1654"
    environment:
      - TZ=Europe/Berlin
    volumes:
      - '/home/netlock/web_console/appsettings.json:/app/appsettings.json'
      - '/home/netlock/web_console/internal:/app/internal'
      - '/home/netlock/web_console/logs:/var/0x101 Cyber Security/NetLock RMM/Web Console/'
      - '/home/netlock/certificates:/app/certificates'
      - /etc/localtime:/etc/localtime:ro
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
    labels:
      - 'traefik.enable=true'
      - "traefik.http.routers.webconsole.rule=Host(`nl-webconsole.penguin-monitoring.de`)"
      - 'traefik.http.routers.webconsole.entrypoints=websecure'
      - 'traefik.http.routers.webconsole.tls.certresolver=myresolver'
      - 'traefik.http.services.webconsole.loadbalancer.server.port=80'
      - "traefik.http.routers.webconsole-http.rule=Host(`nl-webconsole.penguin-monitoring.de`)"
      - 'traefik.http.routers.webconsole-http.entrypoints=web'
      - 'traefik.http.routers.webconsole-http.middlewares=redirect-to-https'
      - 'traefik.http.middlewares.redirect-to-https.redirectscheme.scheme=https'
    networks:
      netlock-network:
        ipv4_address: 172.18.0.4
    restart: always
    depends_on:
      - mysql

  netlock-rmm-server:
    image: nicomak101/netlock-rmm-server:latest
    container_name: netlock-rmm-server
    user: "1654:1654"
    environment:
      - TZ=Europe/Berlin
    volumes:
      - '/home/netlock/server/appsettings.json:/app/appsettings.json'
      - '/home/netlock/server/internal:/app/internal'
      - '/home/netlock/server/files:/app/www/private/files'
      - '/home/netlock/server/logs:/var/0x101 Cyber Security/NetLock RMM/Server/'
      - '/home/netlock/certificates:/app/certificates'
      - /etc/localtime:/etc/localtime:ro
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    labels:
      - 'traefik.enable=true'
      - "traefik.http.routers.rmmserver.rule=Host(`nl-backend.penguin-monitoring.de`)"
      - 'traefik.http.routers.rmmserver.entrypoints=websecure'
      - 'traefik.http.routers.rmmserver.tls.certresolver=myresolver'
      - 'traefik.http.services.rmmserver.loadbalancer.server.port=7080'
      - "traefik.http.routers.rmmserver-http.rule=Host(`nl-backend.penguin-monitoring.de`)"
      - 'traefik.http.routers.rmmserver-http.entrypoints=web'
      - 'traefik.http.routers.rmmserver-http.middlewares=redirect-to-https'
    networks:
      netlock-network:
        ipv4_address: 172.18.0.5
    restart: always
    depends_on:
      - mysql

networks:
  netlock-network:
    driver: bridge
    ipam:
      config:
        - subnet: 172.18.0.0/16

Note: Traefik v3 stops reading a request after 60 seconds by default (respondingTimeouts.readTimeout). That cuts off large uploads from agents and through the web interface access before they finish. The two readTimeout=24h lines in the Traefik command: block above raise the limit to 24 hours. Existing installations add both lines to the Traefik command: in their docker-compose.yml and recreate the container with docker compose up -d traefik.

Note: Existing installations that still run image: mysql:8.0: Oracle support for MySQL 8.0 ended on 30 April 2026, and the Web Console shows a notice for it. Upgrade MySQL to 8.4 walks through changing the tag on an existing data directory, including the backup and the options to check.

Running the containers as an unprivileged user

The server and Web Console images contain no shell and no package manager, and their application files are read-only. Both applications are meant to run as the unprivileged user with id 1654. A small entrypoint decides at every container start which user the application runs as and writes its decision to the container log, each line prefixed with [entrypoint].

New installations

An installation created with the guided installer or with the steps above sets user: "1654:1654" on both application services and gives user 1654 ownership of /home/netlock/web_console and /home/netlock/server. The containers run as user 1654 from the first start, and the log shows:

[entrypoint] running as uid 1654 (set by the container configuration), starting the application

Existing installations

What happens at the first start of a 3.3.0.11 or newer image depends on the capabilities the compose file grants to the container.

Compose file from this manual guide (Docker's default capabilities). The container starts as root, takes ownership of the mounted data directories (/app/internal, the log directory and, for the server, the file storage) and of the mounted appsettings.json, then switches to user 1654 on its own. On the host, the mounted directories and the two appsettings.json files under /home/netlock/web_console and /home/netlock/server are owned by user 1654 afterwards. The ownership pass runs at every start and only touches entries that are not owned by 1654 yet. Any entry inside the data directories that cannot be taken over (for example a nested mount from another filesystem) keeps the container on root, and the log names it (see Other reasons the container keeps running as root). The log shows:

[entrypoint] ownership: 1234 entries checked, 1200 changed, 0 errors, 12 ms
[entrypoint] switched to uid 1654 gid 1654, starting the application

Compose file from the guided installer (cap_drop: ALL). Nothing changes: the container keeps running as root, and the log shows how to switch:

[entrypoint] the container was started without the chown/dac_override/setuid/setgid capabilities, so the application keeps running as root
[entrypoint] to run it unprivileged, run once on the host: sudo chown -R 1654:1654 <host directories behind the mounts; guided installation: /home/netlock/web_console and /home/netlock/server>
[entrypoint] then add user: "1654:1654" under both NetLock services in the compose file and recreate the containers

To switch such an installation, give user 1654 ownership of the two data directories once:

sudo chown -R 1654:1654 /home/netlock/web_console /home/netlock/server

Then add user: "1654:1654" to both application services in /home/netlock/docker-compose.yml, directly below container_name::

  netlock-rmm-web-console:
    image: nicomak101/netlock-rmm-web-console:latest
    container_name: netlock-rmm-web-console
    user: "1654:1654"

  netlock-rmm-server:
    image: nicomak101/netlock-rmm-server:latest
    container_name: netlock-rmm-server
    user: "1654:1654"

Recreate the containers:

sudo docker compose -f /home/netlock/docker-compose.yml up -d

The same two steps apply to an installation from this manual guide that should start as user 1654 directly instead of switching at every start.

Warning: With user: "1654:1654" in the compose file, do not use an image older than 3.3.0.11. Those images expect to start as root, and the Web Console does not start as user 1654. Remove the two user: lines before going back to an older image.

Custom TLS certificate files

If Https is enabled in an appsettings.json and the certificate file lies in /home/netlock/certificates, the file must be readable for user 1654. Before it switches users, the entrypoint checks every file directly in /app/certificates. When one of them is not readable for 1654, the container keeps running as root and names the file:

[entrypoint] file "/app/certificates/certificate.pfx" is not readable for uid 1654; run on the host, inside the directory mounted at "/app/certificates": chmod 640 "certificate.pfx" && chgrp 1654 "certificate.pfx"; the application keeps running as root

A symbolic link is followed and checked at its target; the hint then names the target. A link whose target cannot be opened, for example because it points outside the mounted directory, keeps the container on root as well:

[entrypoint] file "/app/certificates/certificate.pfx" (symbolic link to "renewed/2026-10.pfx") is not readable for uid 1654; run on the host, inside the directory mounted at "/app/certificates": chmod 640 "renewed/2026-10.pfx" && chgrp 1654 "renewed/2026-10.pfx"; the application keeps running as root
[entrypoint] file "/app/certificates/old.pfx" is a symbolic link to "/nonexistent/old.pfx", which cannot be opened: No such file or directory; the application keeps running as root

Make the file readable for the group 1654 and restart the container:

sudo chmod 640 /home/netlock/certificates/certificate.pfx
sudo chgrp 1654 /home/netlock/certificates/certificate.pfx

The directory itself must be accessible for user 1654 as well (chmod 755 /home/netlock/certificates). Leave /home/netlock/certificates/traefik as it is: Traefik's certificate store lives in that subdirectory, which the entrypoint neither reads nor changes, and it stays owned by root.

With user: "1654:1654" in the compose file there is no such check: the application cannot load an unreadable certificate file and stops, which the container log reports.

Keeping root deliberately

The environment variable NETLOCK_RUN_AS_ROOT=1 on a service keeps the application running as root regardless of the capabilities the compose file grants:

    environment:
      - TZ=Europe/Berlin
      - NETLOCK_RUN_AS_ROOT=1

The log then shows [entrypoint] NETLOCK_RUN_AS_ROOT=1 is set, starting the application as root. Use it as a temporary measure while you investigate a start problem, and remove it afterwards. With user: "1654:1654" set, the container never starts as root and the variable has no effect.

Other reasons the container keeps running as root

In each of the following cases the application runs as root; the log names the cause, and the next start switches once the cause is fixed.

  • The Docker engine does not allow an unprivileged user to bind the port (engines older than 20.10, or network_mode: host): [entrypoint] the kernel does not allow unprivileged binding of port 80 on this engine (ip_unprivileged_port_start=1024), the application keeps running as root.
  • An entry inside a data directory could not be taken over, for example a nested mount from another filesystem or a file the kernel refuses to change: [entrypoint] ownership: 3 entries could not be taken over (first: "/app/www/private/files/archive"), the application keeps running as root. The line follows the ownership summary and names the first such entry.
  • A data directory itself or the appsettings.json is still not owned by user 1654 after the ownership pass, for example on a network file system: [entrypoint] "/app/internal" is still owned by uid 0 gid 0 after the ownership pass, the application keeps running as root.
  • The engine does not let the container change its group list (some user-namespace setups): [entrypoint] cannot clear the supplementary groups: Operation not permitted, the application keeps running as root.
  • The certificate directory is not accessible for user 1654: [entrypoint] directory "/app/certificates" is not accessible for uid 1654; run chmod 755 "/app/certificates" on the mounted host directory, the application keeps running as root.

Troubleshooting without a shell

The images contain no shell, so docker exec -it <container> sh into the server or Web Console container is not possible. Use docker logs <container> for the application output and the entrypoint messages, and the mounted log directories (/home/netlock/web_console/logs and /home/netlock/server/logs) for the log files.

Troubleshooting

To view a container's logs, use:

docker logs <container-id>

The server and Web Console images contain no shell, so a container cannot be entered with docker exec; the log files are in the mounted log directories on the host (see Troubleshooting without a shell).

Server roles

The NetLock RMM server runs in seven roles. Each is toggled in the server's appsettings.json under the Roles block; a single instance can run all of them, or they can be split across multiple instances.

RolePurpose
CommHandles communication with the comm agent — device information, policy, and event synchronisation.
UpdateProvides update packages for the agents — comm agent, health agent, remote agent, installer, and uninstaller.
TrustProvides the hashes of all update packages. Agents contact the trust role to verify the hash of a downloaded package.
RemoteHandles real-time connections between agents and the Web Console, such as the remote shell and file browser.
NotificationSends third-party notifications — email, Microsoft Teams, Telegram, and ntfy.sh.
FileProvides the file storage service for downloading and uploading files.
LLMProvides the AI language-model integration for the intelligent features.

Advanced server concept

The Docker Compose setup above runs every component — the reverse proxy, MySQL, the Web Console, and the NetLock RMM server — on a single host. This is the recommended starting point and is sufficient for most deployments.

Note: If you replace Traefik with another reverse proxy, it must forward request headers unmodified. nginx drops header names containing underscores unless underscores_in_headers on; is set in the server block.

For larger fleets or specific infrastructure requirements, the three main components can instead run on separate servers: the MySQL database, the NetLock RMM server (the backend), and the Web Console.

The components communicate over the network, so nothing forces them onto the same machine. Each one is pointed at the others through its appsettings.json:

  • The Web Console's MySQL block addresses the database server, and its NetLock_Remote_Server and NetLock_File_Server blocks address the backend.
  • The server's MySQL block addresses the database server.

In the single-host Compose setup these settings use Docker container names (mysql-container, netlock-rmm-server) because every component shares one Docker network. In a distributed setup, you replace those with the hostnames or IP addresses of the separate servers.

Splitting the deployment this way lets you size and scale each component independently — for example, running MySQL on dedicated database infrastructure, or keeping the Web Console and the backend on separate hosts.