How to Install and Self-Host Calagopus Panel
Install and verify Calagopus Panel using its official documentation, then securely expose the working web interface with a Localtonet HTTP tunnel.
In this article 11 sections
Build a recoverable panel deployment before opening remote access
This guide covers a release-pinned Calagopus deployment, local validation, storage inventory, offline backup, restoration testing, and controlled updates. It also explains how to publish the verified web interface with Localtonet while keeping game traffic separate. Release-specific details that cannot be established from the available primary evidence are identified explicitly rather than replaced with guessed ports, credentials, or wizard screens.
📋 What's in this guide
Understand the release and deployment scope
Calagopus is an open-source game-server management panel built in Rust. The Calagopus project site and documentation entry point describe Docker-based game workloads, Docker and traditional installation paths, an extension API, a guided first-run wizard, Pterodactyl egg compatibility, and migration tooling for Pterodactyl and Pelican. Those are current project statements, not proof that every capability has identical behavior in release 1.1.4.
The 1.1.4 release notes identify tag release-1.1.4 and commit prefix adc41d6. They list a database explorer, a special state for failed server-backup restores, support for global system-wide automatic backups, and fixes including password encoding in the Pterodactyl/Pelican import flow. An application backup feature should not be assumed to cover the deployment environment, all database files, host mounts, or external game nodes.
The available primary extracts do not include the contents of the pinned compose.aio.yml, .env.example, installation documentation, or wizard implementation. Consequently, this article cannot certify their exact services, required variables, default port, mounts, privileges, wizard stages, minimum versions, or readiness log messages. The commands below retrieve and inspect those artifacts locally. Do not start the stack until that review is complete. This is an inspection-led deployment procedure, not a claim that we have executed or fully verified the 1.1.4 installation and restore.
We use the previously documented all-in-one filename as the installation candidate and verify its presence before proceeding. Do not combine other Compose variants without reviewing the pinned repository instructions. The supplied evidence does not establish the detailed frontend framework stack, the exact alternative Compose variants, or their suitability for this installation, so those details are not prerequisites here.
This is a fresh-install procedure. Do not attach it to an existing panel database or import another panel's files casually. Migration requires the source product's documented export/import workflow, source backups, compatibility checks, and a separately tested rollback. Current egg compatibility claims likewise do not eliminate per-game image, architecture, variable, allocation, or protocol requirements.
Prepare the host and operational tools
Use a Linux Docker host under your administrative control. Install Docker Engine and the Compose plugin using the Docker Engine installation instructions for your distribution and Compose plugin installation instructions. Package commands differ between distributions, so do not mix repositories or reuse another distribution's installation commands.
The evidence available here does not establish Calagopus 1.1.4 minimum Docker, Compose, kernel, Linux distribution, CPU, RAM, or disk requirements. That does not mean the project publishes none; it means no exact minimum can responsibly be quoted here. Use a maintained Docker-supported distribution and validate the pinned installation instructions before selecting versions.
The current project site explicitly states ARM64 support and Raspberry Pi compatibility for its Docker Compose setup. It does not establish that every 1.1.4 image or game image supports ARM64. Check the resolved image manifests and each game's requirements. Panel compatibility is not a capacity guarantee for Minecraft, Rust, or another managed workload.
- Install Git, Bash, curl, Python 3, and GNU tar. Python is used below to read Compose JSON; GNU tar is used for ownership, ACL, and extended-attribute preservation.
- Provide outbound access to the repository and required image registries.
- Reserve storage for Docker images, databases, game files, logs, and temporary update capacity.
- Prepare a private backup destination on separate storage and an isolated restore-test host.
- Arrange local browser access, or an authorized SSH port-forwarding path, before exposing the panel publicly.
git --version
docker --version
docker compose version
docker info
python3 --version
tar --version
df -h
docker info must reach the intended daemon. Use one consistent Docker context throughout this guide. Do not switch between rootless Docker and a root-owned daemon by adding sudo to arbitrary Docker commands. Docker access can confer host-administrative power; never make its socket world-writable.
sudo mkdir -p /opt/calagopus
sudo chown "$(id -u):$(id -g)" /opt/calagopus
chmod 700 /opt/calagopus
cd /opt/calagopus
umask 077
The backup examples later use local Docker volume mountpoints. They apply only when your shell is on the Docker host and the volumes use ordinary local storage. Remote daemons, remote volume drivers, nested mounts, and storage snapshots need an adapted, storage-specific recovery procedure.
Retrieve, inspect, and start the pinned deployment
Check out the release and establish a project name
cd /opt/calagopus
git clone --branch release-1.1.4 --depth 1 \
https://github.com/calagopus/panel.git .
git describe --tags --exact-match
git rev-parse HEAD
test -f compose.aio.yml
test -f .env.example
Compare the checkout with the official repository and release page. Stop if either expected file is absent. Review the installation instructions in this checkout rather than substituting a similarly named file from the current branch.
For this new installation, every Compose invocation explicitly uses -p calagopus. This avoids relying on the directory basename or a shell variable for project identity. Docker documents the precedence rules in its Compose project-name guide.
# Define this helper in each Bash maintenance session.
cd /opt/calagopus
dc() {
docker compose -p calagopus --env-file .env -f compose.aio.yml "$@"
}
Do not add a new project name to an already running stack without checking it. Inspect a known panel container with docker inspect --format '{{ index .Config.Labels "com.docker.compose.project" }}' CONTAINER_ID, then use that exact value in the helper. Switching names can create a second stack and new empty volumes that look like lost data.
Resolve environment settings without publishing secrets
cp .env.example .env
chmod 600 .env
# Open .env.example, .env, compose.aio.yml, and the release README
# in a private local editor before continuing.
dc config --quiet
dc config --format json > resolved-compose.json
dc config > resolved-compose.yml
chmod 600 resolved-compose.json resolved-compose.yml
Compare each active example value with its use in Compose and the application documentation. Replace required placeholders and sample credentials; preserve expected variable names and formats. Generate distinct secrets for distinct purposes. Do not print resolved environment values into a recorded terminal, paste them into support tickets, or commit the resulting files.
Compose validation checks syntax and interpolation, not whether a sample password is secure or an application URL is correct. A literal placeholder can pass validation. Required variables, accepted formats, and origin-related settings cannot be enumerated from the supplied extracts, so unresolved meanings are a stop condition rather than permission to guess.
Build a concrete configuration inventory
Read the complete resolved configuration privately. The following summary highlights services, images, endpoints, storage, and security-sensitive settings without dumping the environment section. Even this summary can contain private paths or addresses.
python3 - <<'PY'
import json
with open("resolved-compose.json") as f:
c = json.load(f)
print("Project:", c.get("name"))
for name, s in c.get("services", {}).items():
print("\nSERVICE:", name)
for key in ("image", "build", "ports", "expose", "volumes",
"user", "privileged", "cap_add", "devices",
"network_mode", "pid", "ipc", "security_opt",
"read_only", "healthcheck", "depends_on"):
if key in s:
print(key + ":", s[key])
print("\nDECLARED VOLUMES:", c.get("volumes", {}))
print("SECRETS:", c.get("secrets", {}))
print("CONFIGS:", c.get("configs", {}))
PY
| Record before startup | What must be resolved | Why it matters |
|---|---|---|
| Each service and image | Role, image reference, build instructions, architecture | A pinned checkout alone does not pin downloaded images |
| Every published port | Host IP, published port, target port, transport | Identify the panel listener and unintended public listeners |
| Every storage entry | Source, destination, type, access mode, persistence purpose | Include databases, file uploads, game files, and configuration in recovery |
| Runtime authority | User, capabilities, devices, host namespaces, sockets | Determine the consequences of a compromised panel |
| Initialization | Dependency conditions, health checks, documented setup actions | Container creation is not application readiness |
Inspect named volumes with explicit names and external: true particularly carefully. Bind mounts can include files as well as directories. Configs and secrets can reference additional files outside the repository. Do not assume every mount is data or that every persistent resource belongs to the Compose project.
Pull images and start only after review
dc config --images
dc pull
dc up -d
dc ps -a
dc logs --tail=200
If the resolved file uses local builds, follow its pinned build instructions rather than assuming pull covers them. Record image IDs after startup. Do not equate the 1.1.4 Git tag with the application version unless the selected image is also tied to that release.
dc images
dc logs -f
Exit live logs with Ctrl+C; that does not stop the services. Expected generic readiness evidence is stable required services, passing health checks where defined, no recurring initialization failures, and a usable authenticated application. No exact 1.1.4 readiness message or automatic migration sequence is established here.
Verify the endpoint and first-run administration
Use the configuration inventory and dc ps to identify the panel's published listener. A mapping beginning with 127.0.0.1 is host-local; 0.0.0.0 publishes on IPv4 interfaces. Neither address is itself the remote browser URL. A service's internal expose setting is not a host-published port.
dc ps
# Replace this example URL with the verified address, scheme, and port.
PANEL_URL='http://127.0.0.1:REPLACE_WITH_VERIFIED_PORT'
curl -v "$PANEL_URL/"
Use HTTPS locally only if the actual local listener serves it. A later public HTTPS tunnel does not turn a local HTTP application into a local HTTPS listener. Test from the environment that will run our client, not merely from another container with different network access.
The current project site confirms a guided first-run wizard, but its exact 1.1.4 stages and required fields are not present in the evidence. We therefore cannot provide a verified screen-by-screen walkthrough or screenshot. If the pinned deployment presents setup, keep it private, follow its release-specific instructions, and resolve any database, node, origin, or account questions before advancing. Do not assume administrator creation is the only stage.
- Create a unique administrative credential using the supported setup path.
- Sign out and back in. Test an unauthenticated session to confirm protected pages are not accessible.
- Open several interface sections and inspect browser network errors for failed assets or API requests.
- Review logs for database, permission, initialization, and authentication failures.
- Perform a controlled restart and verify the account and configuration persist.
dc restart
dc ps -a
dc logs --tail=200
A restart tests basic persistence but is not a restoration test. If setup reappears or data disappears, stop and investigate mount paths and project identity. Test a disposable managed workload separately before entrusting production game data to the installation.
Assess administrative exposure and host privileges
A game-server panel can control workloads, files, allocations, and potentially container execution. Treat it as an administrative control plane rather than an ordinary public website. The exact privileges of compose.aio.yml cannot be asserted without its contents; review the resolved fields above and confirm the resulting runtime state.
# Contains sensitive runtime metadata. Keep private.
mapfile -t IDS < <(dc ps -a -q)
test "${#IDS[@]}" -gt 0
docker inspect "${IDS[@]}" > runtime-inspect.json
chmod 600 runtime-inspect.json
If a container mounts the Docker socket, compromise may enable creation of containers with host mounts and effectively compromise the host. A read-only filesystem mount of the socket does not make Docker API calls read-only. Host-root mounts, device access, privileged mode, host PID namespaces, or broad capabilities expand the potential impact. Record each grant and its documented purpose; do not simply remove required privileges and assume the deployment remains supported.
Use a dedicated host or VM for high-trust administrative workloads where practical. Keep unrelated credentials and personal files off it. Restrict shell and Docker access, protect backups, update the host, and install extensions only from trusted sources after the base deployment is healthy.
The provided evidence does not establish exact 1.1.4 MFA, role, trusted-proxy, allowed-origin, or external-URL controls. Enable supported least-privilege roles and stronger authentication only after confirming their availability in the installed release. Do not invent environment variables or disable CSRF, cookie security, or authentication to fix a proxy problem.
Before remote use, verify redirects remain on the intended public origin, authentication cookies work over HTTPS, sign-out invalidates access, and state-changing requests succeed without relaxing browser protections. Configure trusted proxies and canonical URLs only through documented settings. Trust forwarded headers only from the proxy path you control.
Anyone who obtains the URL can attempt to reach the service. Prefer private access for a small operator group when public reachability is unnecessary. Our VPN Manager provides a separate private mesh VPN with granular firewall rules. An HTTP tunnel is not a VPN and does not replace panel authentication.
Back up all storage and prove restoration
Correct the project-name and storage-discovery error
A directory at /opt/calagopus does not normally produce the default project name panel. More importantly, even a correct project-label filter is not a complete storage inventory. External volumes may not have that label, and bind mounts never appear in docker volume ls.
Use the explicit project name for this new stack, inspect actual containers, and reconcile the result against every service and top-level volume in resolved-compose.json. Include inactive profiles, stopped services, externally managed databases, remote game nodes, and data stored outside the panel stack in the recovery plan. A panel-only backup cannot recover unrecorded node data.
dc config --format json > resolved-compose.json
mapfile -t IDS < <(dc ps -a -q)
test "${#IDS[@]}" -gt 0
docker inspect "${IDS[@]}" > runtime-inspect.json
python3 - <<'PY'
import json
with open("runtime-inspect.json") as f:
containers = json.load(f)
for c in containers:
print("\nCONTAINER", c["Name"])
for m in c.get("Mounts", []):
print(m["Type"], m.get("Name", ""), m["Source"],
"->", m["Destination"], "RW=" + str(m["RW"]))
PY
Create a private tab-separated file named backup-items.tsv with one row per unique storage source. Its three columns are an archive ID, type (volume or bind), and the exact volume name or absolute bind source. For example, an ID can be data01. Use actual inspected values, not illustrative names. Do not use tabs or newlines inside paths.
Maintain a companion storage-review.txt listing every declared and runtime mount, its archive ID, and any deliberate exclusion. A Docker socket is a control endpoint to recreate, not data to archive. Temporary filesystems are not persistent backups. Configuration files must be included or explicitly linked to the configuration archive. Any missing, unexplained, remote, or unsupported storage entry blocks a complete-backup claim.
Create an offline archive with verification
The following Bash procedure assumes reviewed ordinary local volumes and regular file or directory bind sources. It uses host GNU tar to preserve numeric ownership, ACLs, and extended attributes. Review nested mountpoints first; this is not a universal backup script for network storage or live external databases.
Before running it, gracefully stop managed games and all other writers to the selected storage, close remote access, and arrange the maintenance window. A Compose stop alone might not stop game containers created outside this Compose project. Store the destination outside every source being archived.
# Run in Bash on the Docker host with the dc helper defined.
set -euo pipefail
umask 077
test -s backup-items.tsv
test -s storage-review.txt
BACKUP_DIR="/var/backups/calagopus/$(date -u +%Y%m%dT%H%M%SZ)"
sudo install -d -m 700 -o "$(id -u)" -g "$(id -g)" "$BACKUP_DIR"
dc config --format json > "$BACKUP_DIR/resolved-compose.json"
git rev-parse HEAD > "$BACKUP_DIR/commit.txt"
git status --short > "$BACKUP_DIR/git-status.txt"
dc images > "$BACKUP_DIR/images.txt"
cp backup-items.tsv storage-review.txt "$BACKUP_DIR/"
mapfile -t IDS < <(dc ps -a -q)
test "${#IDS[@]}" -gt 0
docker inspect "${IDS[@]}" > "$BACKUP_DIR/containers.json"
dc stop
if [ -n "$(dc ps --status running -q)" ]; then
echo "Services still running; aborting" >&2
exit 1
fi
declare -A SEEN
while IFS=$'\t' read -r id kind source; do
[[ "$id" =~ ^[a-zA-Z0-9_-]+$ ]]
test -z "${SEEN[$id]+present}"
SEEN[$id]=1
case "$kind" in
volume)
driver=$(docker volume inspect --format '{{.Driver}}' "$source")
test "$driver" = local
docker volume inspect "$source" > "$BACKUP_DIR/$id.volume.json"
path=$(docker volume inspect --format '{{.Mountpoint}}' "$source")
sudo test -d "$path"
sudo tar --acls --xattrs --numeric-owner \
-C "$path" -czpf "$BACKUP_DIR/$id.tar.gz" .
;;
bind)
[[ "$source" = /* ]]
sudo test -e "$source"
sudo test ! -S "$source"
sudo tar --acls --xattrs --numeric-owner \
-C "$(dirname "$source")" \
-czpf "$BACKUP_DIR/$id.tar.gz" -- "$(basename "$source")"
;;
*) echo "Unsupported storage type: $kind" >&2; exit 1 ;;
esac
sudo tar -tzf "$BACKUP_DIR/$id.tar.gz" > /dev/null
done < backup-items.tsv
# Includes .env, Git identity, overrides, and private operational records.
# Review any symlinked or external config files separately.
sudo tar --acls --xattrs --numeric-owner \
-C /opt -czpf "$BACKUP_DIR/deployment.tar.gz" calagopus
sudo chown -R "$(id -u):$(id -g)" "$BACKUP_DIR"
chmod -R go-rwx "$BACKUP_DIR"
while IFS=$'\t' read -r id kind source; do
test -s "$BACKUP_DIR/$id.tar.gz"
done < "$BACKUP_DIR/backup-items.tsv"
(
cd "$BACKUP_DIR"
sha256sum -- *.tar.gz > SHA256SUMS
sha256sum -c SHA256SUMS
)
dc start
dc ps -a
If a command fails, the fail-fast shell can leave the stack stopped intentionally. Investigate before manually running dc start. A successful loop proves only that listed sources were archived; the signed-off storage reconciliation proves whether the list is complete. Copy the complete directory to encrypted independent storage and apply retention rules.
Archive listing and checksum verification detect some transfer or archive failures, not application recoverability. Retain exact images by digest or save the required images to protected backup storage with Docker's image-save tooling if the registry cannot be relied upon. Include locally built images and their build inputs.
Restore on an isolated host before trusting the backup
This procedure is a recovery rehearsal to execute and record, not a claim of a test already performed. Use a clean isolated host with the appropriate Docker version and architecture, no public tunnel, and no access to production nodes. Restored credentials and scheduled jobs can otherwise affect production.
- Copy the complete backup directory to the test host and run
sha256sum -c SHA256SUMSinside it. - Restore
deployment.tar.gzinto an empty/optdeployment location. Do not extract it over a running installation. - Restore the exact images or resolve the recorded digests. Review restored configuration for production URLs, external services, node connections, and scheduled actions.
- Recreate named volumes with the recorded names, driver, and options. Provision external volumes explicitly. Never silently replace a remote volume with a default local one.
- Extract each volume archive into its empty target volume. Restore bind archives into their recorded parent directories, preserving ownership and metadata.
- Reconcile every archive with the storage review, then start the isolated stack and run the application checks below.
# Example extraction patterns, not values to paste unchanged.
# Set BACKUP_DIR, ARCHIVE_ID, and VOLUME_NAME to reviewed restore values.
sudo tar --acls --xattrs --numeric-owner \
-xzpf "$BACKUP_DIR/deployment.tar.gz" -C /opt
# Only for a confirmed ordinary local volume with no special options:
docker volume create "$VOLUME_NAME"
RESTORE_PATH=$(docker volume inspect \
--format '{{.Mountpoint}}' "$VOLUME_NAME")
# Confirm RESTORE_PATH is the intended empty volume before extracting.
sudo tar --acls --xattrs --numeric-owner \
-xzpf "$BACKUP_DIR/$ARCHIVE_ID.tar.gz" -C "$RESTORE_PATH"
# For a bind archive, use its recorded parent directory instead:
# sudo tar --acls --xattrs --numeric-owner \
# -xzpf "$BACKUP_DIR/$ARCHIVE_ID.tar.gz" -C /reviewed/parent
Start only after all data and configuration are restored. Verify login, users, settings, file samples, database-backed pages, and any relevant managed-server metadata. Test a disposable workload without contacting production nodes. Restart again and repeat checks. Record backup timestamp, image identity, restored resource counts, restore duration, failures, and the person approving the result. A failed rehearsal means the recovery plan remains incomplete.
Update with configuration comparison and rollback planning
Do not update by blindly checking out a new tag in the running directory. The installation is shallow, so fetch the selected published tag explicitly into a separate candidate worktree. Review release notes before choosing it.
cd /opt/calagopus
OLD_COMMIT=$(git rev-parse HEAD)
NEW_TAG='REPLACE_WITH_REVIEWED_RELEASE_TAG'
git fetch --depth=1 origin \
"refs/tags/$NEW_TAG:refs/tags/$NEW_TAG"
git worktree add --detach /opt/calagopus-candidate "$NEW_TAG"
git diff "$OLD_COMMIT" "$NEW_TAG" -- .env.example compose.aio.yml
git diff --stat "$OLD_COMMIT" "$NEW_TAG"
Fetching the target tag is sufficient for a snapshot comparison; unshallow the repository only if you need complete history and the remote provides it. Preserve local tracked changes, overrides, environment files, and external configuration separately. Do not use a force checkout to discard them.
Compare the old example with the new example first, then merge changes into a private candidate environment while preserving deployment secrets. Review renamed variables, deleted settings, port changes, image tags, mount destinations, privileges, dependency versions, and migration notes. Comparing only the new example with the live .env does not explain what changed between releases.
Validate the candidate configuration without starting a second stack against production volumes. Relative bind paths resolve from the candidate directory, so compare resolved paths carefully. Test the new release against an isolated restored backup before scheduling production downtime.
Plan for database migrations even if none are explicitly described in the brief release notes. Determine whether migrations run automatically, require a separate command, or prohibit downgrading from the release's instructions. If this cannot be established, do not upgrade production. Never assume starting an older image against a newly migrated database is safe.
- Complete a verified pre-update backup and retain old images and configuration.
- Stop remote access, managed workloads where required, and all relevant writers.
- Deploy the reviewed new files and environment in the production directory, retaining the same project name and intended storage paths.
- Validate the resolved model, pull or build reviewed images, and run
dc up -d. - Inspect logs, health checks, local login, API-backed pages, persistence, and a disposable managed workload.
- Test the public origin and game connectivity separately before reopening access.
Rollback means stopping the failed release and restoring the matching old images, configuration, and pre-update data to clean targets. Extracting an old archive over changed database files can leave incompatible files behind. Account for writes made since the backup and communicate the potential loss window. Use the rehearsed restore procedure, not merely a Git checkout.
Publish the verified web interface with Localtonet
With Localtonet, the client connects outward to a relay and provides a public HTTPS URL without inbound router port forwarding, firewall changes, VPN setup, or a public IP address. The selected device must remain connected and the tunnel must be running. Use this path only when your network policy permits it and public administrative reachability is appropriate.
Install and run our client
Install the Localtonet app for the operating system on the panel host or a device that can reach its verified local listener.
Open the HTTP Tunnel page
Use the HTTP Tunnel page in our dashboard for the browser-facing panel endpoint.
Select the Process Type
Choose Random Sub Domain, Custom Sub Domain, or Custom Domain where available. All serve the configured content at a public HTTPS address. Check current documentation before changing custom-domain DNS.
Select the AuthToken and server
Choose the device-specific token and an available relay server from the current dashboard. Keep the token private and never copy an example server code.
Enter the local target
Enter the panel's verified reachable IP address and port. Loopback refers to the client environment; a separate container or LAN device does not share the panel host's loopback interface.
Press Start and verify access
Creating a configuration is not starting it. Press Start, open the assigned URL, and test unauthenticated access, sign-in, protected navigation, redirects, and sign-out from an outside network.
Use our HTTP tunnel documentation for current interface details. Capabilities and relay choices can vary by account or deployment. Stop the tunnel during maintenance and whenever remote access is unnecessary.
Keep game traffic separate from panel traffic
The web panel, game listeners, query ports, file-transfer endpoints, and node-control connections can have different protocols and trust requirements. Identify each independently. Do not expose a node control endpoint merely because players need access to a game.
| Target | Localtonet family | Verify first |
|---|---|---|
| Panel web interface | HTTP | Listener, authentication, public-origin behavior |
| TCP game listener | TCP | Game-specific TCP port and reachable address |
| UDP game listener | UDP | Game-specific UDP port and player connection requirements |
| Both transports | Combined UDP/TCP or separate configurations | Exact ports and transports required by the game |
Current Calagopus documentation says Pterodactyl eggs work without modification, but each egg still has its own image, variables, resources, and allocations. Validate the chosen egg against the pinned release and host architecture. Test actual player connectivity separately from successful panel login.
Troubleshoot by separating application and connectivity failures
Containers restart or initialization fails
dc ps -a
dc logs --tail=300
Look for invalid variables, unavailable dependencies, unsupported architecture, permission errors, occupied ports, or migration failures. Correct the cause before recreating services. Do not delete volumes to suppress an error. Review logs privately because they can contain secrets or identifying data.
Database authentication fails
Check service health, network membership, and the release's actual connection settings. Inside a container, 127.0.0.1 refers to that container, not another database service. Changing an environment password after database initialization may not change the existing database account. Restore matching configuration or follow the documented credential-rotation process.
Files are inaccessible or setup reappears
Inspect the exact failing path, runtime user, mount source, and ownership. Avoid world-writable permissions. Confirm that the maintenance command used the original project name and Docker context. A new empty volume under a different project name can resemble a reset installation.
The page loads but API calls or sign-in fail
Inspect browser network requests and application logs together. Test the exact local URL first. If local access works but public access fails, review the tunnel target, public origin, redirects, cookies, and documented proxy settings. Do not disable CSRF or authentication as a workaround.
The public URL cannot reach the target
Test from the device or container running our client. Verify the IP, port, listener binding, selected token, client connection, relay selection, and tunnel running state. A listener on host loopback is not directly reachable from another LAN machine. A saved tunnel remains unavailable until started.
Routine maintenance commands
dc ps -a
dc logs --tail=200
dc stop
dc start
stop retains containers and storage. A normal Compose down retains named volumes unless volume removal is requested, but container-layer data is not a persistence strategy. Avoid down --volumes during routine maintenance and recovery.
Frequently asked questions
Does a release tag guarantee the containers run version 1.1.4?
No. The tag pins repository files. Verify the resolved image references and application version, and record image IDs or digests. Mutable image tags can change independently of the Git checkout.
Why was filtering volumes by project name panel unsafe?
The installation directory was named calagopus, so panel was not a reliable default project name. Even a correct label filter can omit external volumes and all bind mounts. Use the actual project identity and reconcile declared storage with runtime mounts.
What is the exact default port and first-run wizard sequence?
The supplied primary extracts do not establish those 1.1.4 details. Inspect the pinned configuration and release documentation before startup. The current project site confirms a guided wizard, but that is not enough evidence to invent its stages.
Can I run Calagopus on a Raspberry Pi?
The current project site states ARM64 and Raspberry Pi support. Confirm the selected release images and game images support your architecture, and size memory, CPU, and storage for the actual workloads.
Is a successful archive command a tested backup?
No. Verify storage completeness and checksums, then restore to an isolated host and test the application. Only a recorded successful rehearsal establishes that this backup and recovery procedure work for your deployment.
Does the HTTP tunnel also expose game servers?
No. It targets the panel's web listener. Configure TCP, UDP, or combined transport separately for each verified player-facing service. Our client must remain connected and each tunnel must remain running.
Connect only after the panel is ready
Resolve the release configuration, secure administration, verify persistence, and rehearse recovery first. Then use Localtonet to reach the verified web endpoint without inbound router port forwarding.
Get Started Free →Corrections & updates
Substantive changes approved by the Localtonet editorial team are listed transparently below.
Localtonet is a secure multi-protocol tunneling and proxy platform designed to expose localhost, devices, private services, and AI agents to the public internet supporting HTTP/HTTPS tunnels, TCP/UDP forwarding, mobile proxy infrastructure, file server publishing, latency-optimized game connectivity, and developer-ready AI agent endpoint exposure from a single unified control plane.