Palisade

Formerly ARK Server Manager — it outgrew the name. Old repo links redirect.

Now on Unraid Community Applications — search "Palisade" in the Apps tab.

A self-hosted, Docker-based control panel for game dedicated servers — built Unraid-first, but it runs on any Linux box with Docker. One lean manager container spawns and supervises a container per game server, manages every setting through schema-driven forms, and handles mods, backups, schedules, player administration, and even your router's port-forwards.

Supported games (21):

Feature highlights

• Create → install → start with per-game readiness detection, graceful shutdown, a crash watchdog, and a RAM guard that offers to back up + swap servers when memory is tight.
• Full per-game settings catalogs with presets, copy-between-servers, and restart-needed tracking.
• Live player counts for every game (A2S / RakNet ping / RCON / Valheim status endpoint) with 1-hour sparklines, plus a Players roster captured from player lists and join logs — kick / ban / whitelist / admin per game.
• Backups: manual + scheduled with retention, restore, browser download, and saves import. The manager also snapshots its own database nightly.
• Schedules (restart / update / backup / stop / start) with in-game countdown warnings, pre-action snapshots, and a "skip while players are online" guard.
• ARK cluster support (shared transfer dir across servers).
• Discord/webhook notifications, host low-disk warnings, editable ports with a start-time port-conflict guard.
• Optional pfSense integration: one-click WAN port-forward create/fix/enable/disable/delete per server via the pfSense REST API.

See PLANNING.md for architecture details.

Architecture at a glance

palisade (this app) ────/var/run/docker.sock──> Docker daemon
   Next.js UI + NestJS API                       │ spawns
   SQLite · config engine · RCON · scheduler     ▼
                                       one container per game server

The manager is a control plane only — it contains no game runtime. Each game server runs in its own container from a proven community image; the manager injects config, watches logs, and talks RCON/telnet/query protocols.

Installation

Prerequisites

• Docker on a Linux host (Unraid, Debian/Ubuntu, etc.). 16 GB+ RAM recommended — a single populated game server wants 2–16 GB depending on the game.

• A Docker bridge network for the manager (game containers join it too unless you use host networking):

  docker network create ark-net
  

• Two secrets (generate once, keep safe — SECRETS_KEY encrypts stored API keys/passwords, so losing it means re-entering them):

  echo "SECRETS_KEY=$(openssl rand -hex 32)"
  echo "JWT_SECRET=$(openssl rand -hex 32)"
  

• For the Wine/Proton games (Icarus, Enshrouded, V Rising, Sons of the Forest, LiF:YO), the host needs a larger mmap limit or the server crashes on boot:

  sysctl -w vm.max_map_count=262144
  # persist it: /etc/sysctl.conf, or on Unraid append to /boot/config/go
  

Option A — Unraid (Community Applications) ⭐ recommended

Palisade is in Community Applications: open the Apps tab, search for Palisade, and install. The template pre-fills everything except your two secrets (SECRETS_KEY, JWT_SECRET — generators above) and the app-data path. The prerequisites above still apply: create the ark-net network and set the vm.max_map_count sysctl once.

Two Unraid-specific notes baked into the template:

• Use a path on the cache disk itself (/mnt/cache/appdata/...), not /mnt/user/... — the ARK game-file cache reflink-clones between servers, which needs one real filesystem.
• Spawned game servers appear on the Docker page with per-game icons and WebUI buttons that deep-link back into Palisade.

(Manual alternative: drop unraid/palisade.xml into /boot/config/plugins/dockerMan/templates-user/.)

Option B — plain docker run

docker run -d \
  --name palisade \
  --network ark-net \
  --restart unless-stopped \
  -p 8970:3000 \
  -v /opt/palisade:/data \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --add-host host.docker.internal:host-gateway \
  -e NODE_ENV=production \
  -e DATA_DIR=/data \
  -e DATABASE_URL=file:/data/db.sqlite \
  -e HOST_DATA_DIR=/opt/palisade \
  -e PUBLIC_BASE_URL=http://YOUR-LAN-IP:8970 \
  -e SECRETS_KEY=<64 hex chars> \
  -e JWT_SECRET=<random string> \
  -e PUID=99 -e PGID=100 \
  -e TZ=America/Chicago \
  -e GAME_HOST_NETWORK=true \
  ghcr.io/shakes63/palisade:latest

Then open http://YOUR-LAN-IP:8970 and complete the first-run wizard (create the admin account; API keys are optional and can be added later in Settings).

Option C — docker compose

A reference docker-compose.yml ships in the repo:

export SECRETS_KEY=... JWT_SECRET=... HOST_DATA_DIR=/opt/palisade
docker compose up -d

Environment variables

¹ Required whenever the container path and host path differ — i.e. basically always in production.

Data layout

Everything lives under your data dir — one directory to back up:

/data
├── db.sqlite            # server definitions, schedules, players, settings
├── instances/<id>/      # each server's game files + world saves
├── backups/<id>/        # world snapshots (retention-rotated)
├── backups/_manager/    # nightly self-backups of db.sqlite (newest 14)
└── clusters/<id>/       # ARK cluster transfer dirs

Deleting a server from the UI asks whether to wipe its instance + backups, and offers a browser download of the world saves first.

Updating

The image is rebuilt on every push to main (GitHub Actions → ghcr.io/shakes63/palisade:latest). To update: pull the new image and recreate the container (Unraid's update button does both). Database migrations run automatically on boot.

Integrations (all optional, all in Settings)

CurseForge terms: the mod browser uses the CurseForge API read-only to search and display mods; it never downloads or redistributes mod files — the game servers fetch mods themselves through official integrations. Bring your own key; keys are non-transferable under CurseForge's 3rd-party API terms. This repo does not ship one.

Reverse proxy / TLS

The app is LAN-first but proxy-friendly:

• Front it with Nginx Proxy Manager / Traefik / Caddy with TLS; proxy /, /api, and /socket.io to the web port (container port 3000) — the web app forwards API + websocket traffic internally.
• Set PUBLIC_BASE_URL to the external origin.
• The manager controls Docker via the host socket. If you expose the UI beyond your LAN, strongly consider the socket-proxy setup above.

Development

pnpm install

# generate secrets, then copy .env.example → .env
node -e "console.log('SECRETS_KEY=' + require('crypto').randomBytes(32).toString('hex'))"
node -e "console.log('JWT_SECRET='  + require('crypto').randomBytes(32).toString('hex'))"

pnpm --filter @ark/api db:push   # create the dev SQLite db
pnpm dev                         # API on :8787 + web on :3000
pnpm --filter @ark/api test      # unit tests

Monorepo layout: packages/shared (types + settings catalogs contract), apps/api (NestJS orchestrator), apps/web (Next.js UI), docker/ (manager entrypoint), unraid/ (CA template).

Acknowledgements

Palisade is a control plane — the actual game servers run on excellent community-maintained images. Huge thanks to their maintainers; this project wouldn't exist without them:

Also standing on: SteamCMD, GE-Proton/Wine for the Windows-only servers, Thunderstore (Valheim mod index), and the CurseForge + Steam Web APIs for mod browsing.

License

MIT © 2026 Jacob Neudorf. Not affiliated with Studio Wildcard, Overwolf/CurseForge, Valve, Iron Gate, The Fun Pimps, Keen Games, RocketWerkz, Funcom, Pocketpair, Mojang, or Netgate.