Pelican Panel

Pelican Panel is a self‑hosted, open‑source administration utility that abstracts the complexity of running game servers behind a unified web interface. At its core, it orchestrates Docker containers—referred to as eggs—for a wide range of games such as Minecraft, Terraria, Palworld, Valheim, Enshrouded, and Factorio. Each egg runs in its own isolated container, allowing developers to deploy multiple game instances on a single host or across a cluster without resource contention. The panel exposes a RESTful API and WebSocket endpoints that let external tooling query server status, trigger restarts, or stream console output in real time.

Pelican is built on a lightweight Go‑based backend that serves the web UI and handles Docker orchestration via the official Docker SDK. The frontend is a single‑page application written in Vue.js, leveraging WebSocket for live console feeds and reactive status updates. Persistent data—including user accounts, server metadata, and configuration—is stored in a PostgreSQL database accessed through GORM. All sensitive data (SSH keys, passwords) are encrypted on disk using AES‑256, and the panel itself can be exposed over HTTPS with optional 2FA support. Docker Compose is used for local development, while the production image can be run directly with docker run or managed by Kubernetes via Helm charts.

• Egg Management: Pre‑defined templates for popular games; developers can create custom eggs by specifying Docker image, command line arguments, and environment variables.
• API & Webhooks: CRUD endpoints for servers, users, and logs; webhooks can be configured to trigger external scripts on events such as server start or stop.
• Real‑time Console: WebSocket streams provide live terminal access, enabling integration with chat bots or monitoring dashboards.
• Resource Allocation: CPU, memory, and disk limits can be set per container; the panel exposes metrics via Prometheus exporters for observability.
• User & Permission System: Role‑based access control with granular permissions, useful for delegating server management to community members.

Pelican is designed with self‑hosting in mind. The official Docker image bundles everything needed, so a single command can spin up the panel on any machine with Docker installed. For scalability, each game server runs in its own container, making it trivial to add or remove instances without downtime. The application supports horizontal scaling through a shared PostgreSQL database and optional Redis for session storage, enabling multi‑node deployments behind a load balancer. Container orchestration can be handled by Docker Swarm, Kubernetes, or even Nomad, giving developers flexibility to match their existing infrastructure.

The plugin architecture is intentionally minimal: developers can extend Pelican by adding custom Go modules that register new endpoints or modify the egg lifecycle. Because all server interactions go through Docker, any tool that can control containers (e.g., Ansible, Terraform) can be integrated. The API’s OAuth2 support allows external services to authenticate securely, while the WebSocket console can be consumed by any client that understands the protocol. Additionally, Pelican exposes a simple CLI for bulk operations, making it easy to script deployments or backups.

Pelican’s documentation is organized into sections covering architecture, API reference, and egg creation. The GitHub repository hosts a comprehensive README, issue templates, and a contributor guide, fostering an active community. Configuration is driven by environment variables or a YAML file, keeping the setup declarative and version‑controlled. The panel’s UI is responsive and intuitive, reducing the learning curve for developers who are new to containerized game hosting. Moreover, the open‑source license (MIT) removes licensing friction for commercial or private projects.

• Community Server Hosting: A gaming guild can deploy multiple servers, each with its own isolated environment, and grant members limited access via the panel.
• Game Development Pipelines: Continuous integration workflows can spin up temporary test servers, run automated tests against them, and tear them down automatically.
• Educational Platforms: Instructors can provide students with isolated game instances for labs, all managed through a single web interface.
• Hybrid Cloud Deployments: Enterprises can run game servers on-premises while exposing them to external users through the panel’s secure API, enabling hybrid scaling.

Pelican offers a blend of performance, flexibility, and security that outpaces many legacy control panels. By leveraging Docker’s isolation, it eliminates the “noisy neighbor” problem common in shared hosting environments. The lightweight Go runtime keeps resource overhead low, while the AES‑256 encryption and 2FA ensure data protection. Because it is open source under MIT, developers can modify the codebase to fit niche requirements without vendor lock‑in. Finally, the active community and comprehensive documentation mean that new contributors can get up to speed quickly, making Pelican an attractive choice for both hobbyists and production‑grade deployments.