Aether Panel Documentation

Getting Started - Complete Guide

Welcome to Aether Panel

This guide will take you step by step from installation to having your first server running. Follow each section in order for a successful setup.

System Requirements

Before starting, make sure your system meets the following requirements:

Hardware and Software
Minimum
  • Operating System: Ubuntu 22.04/20.04, Debian 11/10, CentOS 9/8 Stream, Fedora 40/43.
  • Virtualization: KVM, OpenVZ, LXC or dedicated server (for nodes).
  • Software: Docker and Docker Compose (v20.10.0+, optional).
  • Hardware: 2 CPU vcores, 2GB RAM, 5GB storage (minimum).

It is important to note that Aether Panel requires at least 2 CPU vcores, 2GB RAM, and 5GB storage just to function correctly. These requirements do not cover the usage of the services it will manage in the panel.

Recommended
  • Operating System: Ubuntu 22.04/20.04, Debian 11/10, CentOS 9/8 Stream, Fedora 40/43.
  • Virtualization: KVM, OpenVZ, LXC or dedicated server (for nodes).
  • Software: Docker and Docker Compose (v20.10.0+, optional).
  • Hardware: 2 CPU vcores, 4GB RAM, 20GB storage.
Required Ports

Make sure the following ports are available:

  • 8080/TCP: Web panel (HTTP/HTTPS) - Required
  • 5657/TCP: SFTP for file transfer - Required
  • 8081/TCP: Gatus (uptime monitoring) - Optional but recommended
  • 22/TCP: SSH for administration - Recommended to change to non-standard port
Verify Requirements

Before installing, verify that you have root or sudo access:

sudo whoami

Verify that ports are free:

# Check port 8080
sudo netstat -tuln | grep 8080

# Check port 5657
sudo netstat -tuln | grep 5657

# Check port 8081
sudo netstat -tuln | grep 8081

If any port is in use, stop the service or change the port in the configuration.

Step-by-Step Installation

Installation Methods

Aether Panel can be installed in three different ways. Choose the one that best suits your needs:

  • Automatic Installation with Script (Recommended): The easiest and fastest method
  • Docker Installation: Ideal for containerized environments
  • Manual Installation: For advanced users who want full control

Method 1: Automatic Installation with Script

This is the most recommended method. The script detects your operating system and installs everything automatically.

Run the following command as root or with sudo to start the installation:

bash <(curl -s https://install.aetherpanel.es/install.sh)

Or download the script first and then run it:

# Download the script
wget https://install.aetherpanel.es/install.sh

# Give execution permissions
chmod +x install.sh

# Run as root
sudo bash install.sh
The installation script will perform the following steps:
  • Automatically detect your operating system (Ubuntu, Debian, Fedora, CentOS, RHEL)
  • Install all necessary dependencies (Go, Node.js, Yarn, etc.)
  • Configure the firewall and open necessary ports
  • Clone the repository from GitHub
  • Compile the frontend and backend
  • Configure Nginx as reverse proxy
  • Create the systemd service for automatic execution
  • Allow you to configure domain and SSL with Let's Encrypt
Interactive Process

During installation, the script will ask you:

  • Installation type: With Docker or without Docker?
  • Domain or IP: Do you want to use a domain or just IP?
  • SSL: Do you want to configure SSL with Let's Encrypt? (only if using domain)
  • Ports: Do you want to change the default ports? (optional)

Method 2: Docker Installation

If you prefer to use Docker, you can deploy Aether Panel with Docker Compose. This method is ideal if you are already familiar with Docker.

Prerequisites

Make sure you have Docker and Docker Compose installed:

# Verify Docker
docker --version

# Verify Docker Compose
docker-compose --version

If you don't have Docker installed:

Ubuntu/Debian:

# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Fedora/RHEL/CentOS:

# Fedora/RHEL/CentOS
sudo dnf install -y docker docker-compose
sudo systemctl enable docker
sudo systemctl start docker
Steps to install with Docker:

1. Clone the repository

git clone https://github.com/Aether-Panel/Panel.git
cd SkyPanel

This will download all the panel source code.

2. Configure database (optional)

If you want to use external MySQL, edit config.docker.json:

{
  "panel": {
    "database": {
      "dialect": "mysql",
      "url": "user:password@tcp(IP:3306)/database?charset=utf8mb4&parseTime=true"
    }
  }
}

If you use the MySQL from docker-compose.yml, you don't need to change anything.

3. Build the Docker image

docker-compose build

This process may take several minutes the first time, as it downloads dependencies and compiles the panel.

4. Start the containers

docker-compose up -d

The -d flag runs the containers in the background (detached mode).

5. Verify that containers are running

docker-compose ps

You should see the 'skypanel' and 'skypanel-mysql' containers (if you configured MySQL) with 'Up' status.

6. View logs (optional)

docker-compose logs -f

Press Ctrl+C to exit the logs.

Docker Configuration

The docker-compose.yml includes:

  • MySQL/MariaDB service for the database
  • SkyPanel service with all necessary ports
  • Persistent volumes for data and configuration
  • Health checks to verify service status

Method 3: Manual Installation (Without Docker)

To install manually without Docker, you need to compile the panel yourself. This method gives you full control over the process.

Install Dependencies Manually

Ubuntu/Debian

# Update system
sudo apt update && sudo apt upgrade -y

# Install basic dependencies
sudo apt install -y git build-essential curl wget sqlite3

# Install Go 1.24.4
wget https://go.dev/dl/go1.24.4.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.24.4.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

# Verify Go
go version

# Install Node.js 22
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

# Install Yarn
sudo npm install -g yarn

# Verify installations
node --version
yarn --version

Fedora/RHEL/CentOS

# Update system
sudo dnf update -y

# Install basic dependencies
sudo dnf install -y git gcc make curl wget sqlite

# Install Go 1.24.4
wget https://go.dev/dl/go1.24.4.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.24.4.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

# Install Node.js 22
curl -fsSL https://rpm.nodesource.com/setup_22.x | sudo bash -
sudo dnf install -y nodejs

# Install Yarn
sudo npm install -g yarn
Manual Compilation Process:

1. Clone the repository

git clone https://github.com/Aether-Panel/Panel.git
cd SkyPanel

2. Compile the frontend

cd client/frontend
yarn install
yarn build

This will compile the Vue.js web interface.

3. Compile the backend

cd ../..
go mod download
go build -o skypanel ./cmd

This will create the executable binary 'skypanel'.

4. Create directory structure

sudo mkdir -p /etc/skypanel
sudo mkdir -p /var/lib/skypanel
sudo mkdir -p /var/log/skypanel
sudo mkdir -p /var/www/skypanel

5. Copy compiled files

sudo cp -r client/frontend/dist/* /var/www/skypanel/
sudo cp skypanel /usr/local/bin/
sudo chmod +x /usr/local/bin/skypanel

6. Create configuration file

sudo tee /etc/skypanel/config.json > /dev/null <<EOF
{
  "logs": "/var/log/skypanel",
  "panel": {
    "database": {
      "dialect": "sqlite3",
      "url": "file:/var/lib/skypanel/database.db?cache=shared"
    },
    "web": {
      "files": "/var/www/skypanel"
    },
    "gatus": {
      "enable": true
    }
  },
  "daemon": {
    "data": {
      "root": "/var/lib/skypanel"
    }
  }
}
EOF

7. Create system user

sudo useradd -r -m -d /var/lib/skypanel -s /bin/bash skypanel
sudo chown -R skypanel:skypanel /var/lib/skypanel /var/log/skypanel

8. Create systemd service

sudo tee /etc/systemd/system/skypanel.service > /dev/null <<EOF
[Unit]
Description=Aether Panel - Server Management Panel
After=network.target

[Service]
Type=simple
User=skypanel
WorkingDirectory=/var/lib/skypanel
ExecStart=/usr/local/bin/skypanel run
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable skypanel

Installation Verification

After installing, verify that everything is working correctly:

Verify Service (Native Installation)
# Check service status
sudo systemctl status skypanel

# View logs in real-time
sudo journalctl -u skypanel -f
Verify Containers (Docker Installation)
# Check container status
docker-compose ps

# View logs
docker-compose logs -f skypanel
Verify Ports
# Verify that ports are listening
sudo netstat -tuln | grep -E '8080|5657|8081'

# Or use ss
sudo ss -tuln | grep -E '8080|5657|8081'
Verify Web Panel
# From the server
curl http://localhost:8080

# Or from your browser
# http://YOUR_IP:8080
Verify Gatus (Monitoring)
# Verify that Gatus is running
curl http://localhost:8081

# Or from your browser
# http://YOUR_IP:8081

First Access and Initial Configuration

Once installation and verification are complete, it's time to access the panel and configure it for the first time.

Access the Panel

Open your browser and access:

  • Con IP: http://YOUR_IP:8080
  • Con dominio: https://your-domain.com (if you configured domain and SSL)

You will be greeted by the login screen.

Step 1: Create Administrator User

Before you can log in, you need to create an administrator user using the CLI.

If you installed with Docker, run the commands inside the container:

# Enter the container
docker exec -it skypanel sh

# Create admin user
./SkyPanel/bin/SkyPanel user add --username admin --email admin@example.com --admin

If you installed natively, run directly:

sudo -u skypanel /usr/local/bin/skypanel user add --username admin --email admin@example.com --admin

Or from the installation directory:

./skypanel user add --username admin --email admin@example.com --admin

The system will ask you for a password. Choose a secure password.

Command Parameters

  • --username: Username for login
  • --email: Email address
  • --admin: Grants full administrator permissions
Step 2: Log In

Now you can log in to the panel:

  1. Open http://YOUR_IP:8080 in your browser
  2. Enter the username you created
  3. Enter the password
  4. Click 'Log In'
Available CLI Commands

To see all available commands from the Aether Panel CLI:

./skypanel --help

Or from the Docker container:

docker exec skypanel ./SkyPanel/bin/SkyPanel --help

User Management

  • ./skypanel user add --username USER --email EMAIL --admin
  • ./skypanel user list
  • ./skypanel user delete --email EMAIL
  • ./skypanel user password --email EMAIL --password NEW_PASSWORD

Database Management

  • ./skypanel db migrate (update database schema)
  • ./skypanel db upgrade (upgrade to new version)

Run Panel

  • ./skypanel run (start panel in foreground)
  • ./skypanel version (view version)
Step 3: Configure Firewall

If you don't have the ports enabled in the firewall, the panel will not be accessible from outside the server.

Ubuntu/Debian (UFW)

# Enable UFW if not active
sudo ufw enable

# Allow necessary ports
sudo ufw allow 8080/tcp
sudo ufw allow 5657/tcp
sudo ufw allow 8081/tcp

# Verify rules
sudo ufw status

Fedora/RHEL/CentOS (firewalld)

# Start firewalld if not active
sudo systemctl start firewalld
sudo systemctl enable firewalld

# Allow necessary ports
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --permanent --add-port=5657/tcp
sudo firewall-cmd --permanent --add-port=8081/tcp

# Apply changes
sudo firewall-cmd --reload

# Verify rules
sudo firewall-cmd --list-ports
Step 4: Initial Configuration in the Panel

Once you have logged in, configure the basic settings:

Basic Configuration

  1. Go to Settings in the menu
  2. Configure the panel URL (e.g., http://YOUR_IP:8080 or https://your-domain.com)
  3. Configure the administrator email
  4. Configure the company/organization name
  5. Save changes

Configure Nodes

If you installed on the same server where servers will run (local node), you don't need to configure anything else. The local node is configured automatically.

If you want to use remote nodes:

  1. Go to Admin → Nodes
  2. Click 'Create Node'
  3. Enter the remote node IP
  4. Enter the daemon port (default 5656)
  5. Enter the daemon authentication token
  6. Verify the connection
  7. Save the node

Configure Discord (Optional)

To receive notifications on Discord:

  1. Go to Settings → Notifications
  2. Enter the Discord webhook URL
  3. Configure the types of notifications you want to receive
  4. Save changes

To create a Discord webhook:

  1. Go to your Discord server
  2. Channel Settings → Integrations → Webhooks
  3. Create a new webhook
  4. Copy the webhook URL
Step 5: Create Your First Server

Now you're ready to create your first server:

  1. Go to the Servers section
  2. Click 'Create Server'
  3. Select the node where it will run (or use the local node)
  4. Choose a template (e.g., Minecraft Java Edition)
  5. Configure the server name
  6. Configure the server port
  7. Adjust resources (RAM, CPU) if necessary
  8. Click 'Create'
  9. Wait for the server to install
  10. Click 'Start' to boot the server

Congratulations! You now have your first server running on Aether Panel.

Installation Summary

If you have followed all the steps, you should have:

Checklist de Instalación
  • ✓Aether Panel installed and running
  • ✓Administrator user created
  • ✓Firewall configured
  • ✓Panel accessible at http://YOUR_IP:8080
  • ✓Gatus running at http://YOUR_IP:8081
  • ✓Basic configuration completed
  • ✓First server created (optional)
Next Steps

Now that you have the panel running, you can:

  • Explore all panel functionalities
  • Create more servers of different types
  • Configure Database Hosts for MySQL databases
  • Add additional users with specific permissions
  • Configure automatic backups
  • Explore the API for automation
  • Read the complete documentation in other sections
Need Help?

If you encounter problems during installation:

  • Review the Troubleshooting section in the documentation
  • Check the panel logs
  • Consult the FAQ for common issues
  • Join the community Discord for help

Advanced Panel Configuration

Configuration File

The main configuration file is located at:

  • Nativo: /etc/skypanel/config.json (native installation)
  • Docker: /etc/SkyPanel/config.json (inside Docker container)

You can edit this file to customize the panel configuration.

Database Configuration

Aether Panel supports SQLite (default) and MySQL/MariaDB.

SQLite (Default)

SQLite is configured automatically and requires no additional configuration. It's ideal for small installations.

MySQL/MariaDB

To use MySQL, edit the configuration file:

{
  "panel": {
    "database": {
      "dialect": "mysql",
      "url": "user:password@tcp(host:3306)/database?charset=utf8mb4&parseTime=true"
    }
  }
}

Make sure the database and user exist before starting the panel.

Port Configuration

The default ports are:

  • 8080: Web panel (HTTP)
  • 5657: SFTP for file transfer
  • 8081: Gatus (uptime monitoring)

You can change these ports by editing the configuration file or environment variables.

Gatus Configuration (Monitoring)

Gatus is enabled by default and automatically monitors:

  • The main panel (http://localhost:8080/api/config)
  • All configured nodes
  • The uptime and status of each service

You can access the Gatus dashboard at http://YOUR_IP:8081

Configuration File

The Gatus configuration is located at /var/lib/SkyPanel/gatus/config.yaml and is automatically updated when you add or remove nodes.

No olvides que Aether Panel es un proyecto en desarrollo open source, si tienes alguna duda o problema al instalar o el comando del instalador no funciona puedes contactarnos en el Discord de Aether Panel.

    Aether Panel | Open Source Game Server & Cloud Hosting Platform