Deployment management

Use the instructions for your installation to check status, logs, and configuration. For routine maintenance, start with Compose services or source deployments. For updates, see Upgrade and backup.

Access Panel using a server IP

One-click installations and this Wiki's Compose templates allow local access by default. Follow these steps to access Panel through the server's IP. Source deployments listen externally by default; start at step 3. Check ports first if you use a custom Compose file.

1. Edit /opt/gamex-compose/compose.yaml for an installer deployment, or ~/gamex-compose/compose.yaml for a manual deployment. Change Panel's ports entry from 127.0.0.1:3000:3000 to 3000:3000; keep Daemon's GAMEX_PANEL_URL unchanged.

2. Apply the configuration.

   One-click installation:

   sudo docker --host unix:///var/run/docker.sock compose \
     -p gamex -f /opt/gamex-compose/compose.yaml up -d

   Manual Compose installation: run in ~/gamex-compose:

   docker compose up -d

   After editing installer-generated configuration, manage it directly with Compose. The installer only accepts retries with the same options and unchanged owned files; it refuses to overwrite manual changes.

3. Allow your computer to reach TCP port 3000 in the server firewall and cloud security group.

4. Replace SERVER_IP with the actual address and open http://SERVER_IP:3000/setup. Set the Panel address to http://SERVER_IP:3000 during setup, or update it in System Settings if setup is already complete.

HTTP supports setup and password sign-in; remote passkey access requires an HTTPS hostname.

Customize script installation

The one-click installer supports Linux amd64 and arm64 with the local system Docker Engine at /var/run/docker.sock. It requires Bash, curl, sha256sum, and image registry access. It does not select a remote Docker context or a rootless socket. If Docker is not installed, automatic installation requires systemd; if it is already installed, Docker Engine must be 28+ and Compose must be 2.24+. Upgrade older versions before running the script.

Option	Purpose
--version latest	Image tag; defaults to latest, or specify an exact release version
--prefix /opt/gamex-compose	Dedicated absolute installation path; default /opt/gamex-compose
--project gamex	Compose project name; default gamex
--port 3000	Panel localhost port; default 3000
--panel-only	Install Panel without a local Daemon
--apply	Apply the installation; omit to preview without installing dependencies or starting services

Run bash install-compose.sh --help to view all options.

For example, use a custom directory, project name, and port on a new host:

curl -fsSLO https://docs.gamexserver.com/install/install-compose.sh &&
sudo bash install-compose.sh \
  --prefix /srv/gamex --project gamex-prod --port 3001 --apply

The script does not configure HTTPS or firewalls, upgrade versions, or delete data.

Verify the installation script

In an empty directory, download the script and checksum list. Install after verification:

curl -fsSLO https://docs.gamexserver.com/install/install-compose.sh &&
curl -fSL https://docs.gamexserver.com/install/SHA256SUMS -o SHA256SUMS &&
sha256sum --check --ignore-missing SHA256SUMS &&
sudo bash install-compose.sh --apply

Manage Compose services

Installer deployment: check status with the following command when using the default options:

sudo docker --host unix:///var/run/docker.sock compose \
  -p gamex -f /opt/gamex-compose/compose.yaml ps

Replace the final ps with a command below. Update -f and -p if you customized the directory or project name.

Task	Replacement command
View recent logs	logs --tail 100
Follow Daemon logs	logs -f daemon
Restart services	restart
Stop and remove containers	down
Start again	up -d

Custom Compose deployment: check status from the directory containing compose.yaml. Replace the final ps as shown above for other tasks:

docker compose ps

Panel-only deployments have no Daemon logs; for data retention, see Deployment data and access.

Manage a source deployment

For initial installation and build requirements, see Build from source.

In the Panel repository, choose the operation you need and use the account that started it:

Task	Command
Start in the background	npm start
Restart a running application	npm restart
Stop the background application	npm stop
Run in the foreground and view logs	Run npm stop first; after it succeeds, run npm start -- --foreground

npm start runs in the background without registering a startup service; press Ctrl+C to stop a foreground process.

For file logs, set LOG_TARGETS in config.toml to "console,local".

For node diagnostics and service commands, see Daemon CLI.

Configure a startup service

The native installer builds Panel from source and registers a systemd service. Connect Daemon separately.

Prepare Linux amd64 or arm64, systemd 240+, Node.js 22.13+, npm 10+, Git, Python 3, gcc, g++, make, Bash, curl, sha256sum, and standard Linux account tools. Node.js and npm must use system-wide paths outside home directories. The installer does not install these dependencies.

Run in a new, empty directory:

git clone --branch release/v1.2.0 --depth 1 https://github.com/gamex-sh/gamex-panel.git gamex-panel
git -C gamex-panel archive --format=tar.gz release/v1.2.0 > gamex-panel-v1.2.0.tar.gz
curl -fSL https://docs.gamexserver.com/install/install-native.sh -o install-native.sh
sudo bash install-native.sh \
  --archive ./gamex-panel-v1.2.0.tar.gz \
  --sha256 "$(sha256sum gamex-panel-v1.2.0.tar.gz | cut -d ' ' -f 1)" \
  --version 1.2.0 --apply

With the default options, program files are in /opt/gamex-native, with configuration, data, and logs in /var/lib/gamex-panel. Run bash install-native.sh --help for custom options; omit --apply to preview installation.

Open http://localhost:3000/setup and retain 127.0.0.1:3000 and the default relative data paths. For a remote server, connect through SSH forwarding first.

Choose the systemd operation you need:

Task	Command
Check status	sudo systemctl status gamex-panel.service
View recent logs	sudo journalctl -u gamex-panel.service -n 100 --no-pager
Start the service	sudo systemctl start gamex-panel.service
Restart the service	sudo systemctl restart gamex-panel.service
Stop the service	sudo systemctl stop gamex-panel.service
Enable startup at boot	sudo systemctl enable gamex-panel.service
Disable startup at boot	sudo systemctl disable gamex-panel.service

Stopping or disabling the service retains program files and data.

Deploy components separately

Run Panel only

On a Linux amd64 or arm64 management host, prepare Docker Engine 28+ and Compose 2.24+. Save this as compose.yaml:

name: gamex

services:
  panel:
    image: ghcr.io/gamex-sh/gamex-panel:latest
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    volumes:
      - panel-data:/app/data
      - panel-logs:/app/logs
    stop_grace_period: 30s

volumes:
  panel-data:
  panel-logs:

Run docker compose up -d in the configuration directory. Open http://localhost:3000/setup locally or through SSH forwarding and create the administrator.

Connect Daemon with Compose

1. Create a node in Panel for the game host.
2. Prepare Docker Engine 28+ and Compose 2.24+ on the Linux game host. Save the standalone Daemon template as compose.yaml.
3. Create .env in the same directory with the Panel address and this node's pairing information:

GAMEX_PANEL_URL=https://panel.example.com
GAMEX_DAEMON_ID=NODE_UUID_FROM_PANEL
GAMEX_ENROLLMENT_TOKEN=ONE_TIME_TOKEN_FROM_PANEL

Replace the example address, NODE_UUID_FROM_PANEL, and ONE_TIME_TOKEN_FROM_PANEL with the actual values shown in Panel.

4. Run docker compose up -d and wait for the node to come online with Docker status Running.
5. After pairing, clear GAMEX_ENROLLMENT_TOKEN in .env and retain daemon-data.

Create a separate node and use its own pairing information for each host. Paired nodes use /data/config.yaml first: edit that file and restart to change the address. Editing .env alone does not override it. For container updates, see Upgrade and backup.

Deployment data and access

Compose volume	Contents
panel-data	Database, uploads, plugins, local bootstrap state, and config/config.toml with its rollback files
panel-logs	Panel file logs when enabled
daemon-data	Node configuration, identity, and persistent command journal
enrollment	Temporary credentials for automatic local pairing

Panel-only deployments use the first two volumes; a standalone Daemon uses daemon-data. Retain the Compose project name and its volumes. docker compose down retains volumes; docker compose down -v deletes the volumes and their data. Game server files live in separate Docker workspace volumes and require separate backups.

The Panel image uses GAMEX_CONFIG_DIR=/app/data/config. Persist the configuration directory rather than bind-mounting config.toml alone: configuration updates replace the file atomically and keep adjacent rollback files. Keep custom data paths inside persisted directories and run one Panel process per database.

Automatic local pairing retains its identity across restarts. Deleting, revoking, or archiving the node does not recreate or reauthorize it. Keep the Panel and Daemon data together; if the Daemon identity is lost after pairing, create and enroll a new node.

For the backup checklist and restore procedure for your installation, see Upgrade and backup.

For connections across hosts, set APP_DOMAIN to the actual Panel address reachable from the game hosts; HTTPS is recommended. Daemon manages game servers through the host's Docker Engine; use trusted images and configure ports for each game.

For a custom single-host Compose configuration, keep Panel listening on 0.0.0.0:3000 inside the container and bind the host port to 127.0.0.1. When changing the host port, update both ports and Daemon's GAMEX_PANEL_URL. For an already paired Daemon, also update panel_url in its persisted /data/config.yaml and restart it.