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: Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+).
Architecture: amd64 or arm64.
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).

Required Ports

Make sure the following ports are available:

8080/TCP: Web panel (HTTP/HTTPS) - Required
5657/TCP: SFTP for file transfer - Required
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

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-plugin
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 Panel

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

4. Start the containers

docker compose up -d

5. Verify that containers are running

docker compose ps

6. View logs (optional)

docker compose logs -f

Docker Configuration

The docker-compose.yml includes:

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

Quick option: Use pre-built image

If you prefer not to compile from source, you can use the pre-built Docker image:

docker run -d \
  --name skypanel \
  -p 8080:8080 \
  -p 5657:5657 \
  -v skypanel-config:/etc/SkyPanel \
  -v skypanel-data:/var/lib/SkyPanel \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --restart=always \
  ghcr.io/aether-panel/panel:latest

This command will download the latest image and run the panel with persistent data.

Simplified Docker Compose option

You can also use this simplified docker-compose.yml:

services:
  skypanel:
    image: ghcr.io/aether-panel/panel:latest
    ports:
      - "8080:8080"
      - "5657:5657"
    volumes:
      - ./config:/etc/SkyPanel
      - ./data:/var/lib/SkyPanel
      - /var/run/docker.sock:/var/run/docker.sock
    restart: always

Start the service with: docker compose up -d

Create Admin User (Docker)

Once the container is running, run this command to create your admin account:

docker exec -it skypanel /SkyPanel/bin/SkyPanel user add --name admin --email admin@example.com --password 'admin123' --admin

Remember to change admin@example.com and admin123 with your actual data.

Post-Installation

Once installed, the panel will be accessible at:

http://<YOUR-SERVER-IP>:8080

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.25.0
wget https://go.dev/dl/go1.25.0.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.25.0.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.25.0
wget https://go.dev/dl/go1.25.0.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.25.0.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 Panel

2. Compile the frontend

cd client/frontend
yarn install
yarn build

3. Compile the backend

cd ../..
go mod download
go build -o SkyPanel ./cmd/panel

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/aetherpanel

5. Copy compiled files

sudo cp -r client/frontend/dist/* /var/www/aetherpanel/
sudo cp SkyPanel /usr/sbin/
sudo chmod +x /usr/sbin/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/aetherpanel"
    }
  },
  "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/sbin/SkyPanel runService --config /etc/SkyPanel/config.json
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'

# Or use ss
sudo ss -tuln | grep -E '8080|5657'

Verify Web Panel

# From the server
curl http://localhost:8080

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

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 --name admin --email admin@example.com --admin

If you installed natively, run directly:

sudo -u skypanel /usr/sbin/SkyPanel user add --name admin --email admin@example.com --admin

Or from the installation directory:

SkyPanel user add --name 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:

Open http://YOUR_IP:8080 in your browser
Enter the username you created
Enter the password
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 --name USER --email EMAIL --admin

SkyPanel user add --name USER --email EMAIL --password PASS (non-interactive)

SkyPanel user edit (interactive menu: username/email/password/admin/2FA)

Database Management

SkyPanel db migrate (update database schema)

SkyPanel db upgrade (upgrade to new version)

Run Panel

SkyPanel runService (start as service with systemd notify)

SkyPanel version (show 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

Go to Settings in the menu
Configure the panel URL (e.g., http://YOUR_IP:8080 or https://your-domain.com)
Configure the administrator email
Configure the company/organization name
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:

Go to Admin Nodes
Click 'Create Node'
Enter the remote node IP
Enter the daemon port (default 5656)
Enter the daemon authentication token
Verify the connection
Save the node

Configure Discord (Optional)

To receive notifications on Discord:

Go to Settings Notifications
Enter the Discord webhook URL
Configure the types of notifications you want to receive
Save changes

To create a Discord webhook:

Go to your Discord server
Channel Settings Integrations Webhooks
Create a new webhook
Copy the webhook URL

Step 5: Create Your First Server

Now you're ready to create your first server:

Go to the Servers section
Click 'Create Server'
Select the node where it will run (or use the local node)
Choose a template (e.g., Minecraft Java Edition)
Configure the server name
Configure the server port
Adjust resources (RAM, CPU) if necessary
Click 'Create'
Wait for the server to install
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
✓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

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

AnteriorCore Concepts SiguientePanel Usage

Getting Started - Complete Guide

Welcome to Aether Panel

System Requirements

Hardware and Software

Recommended

Required Ports

Verify Requirements

Step-by-Step Installation

Installation Methods

Method 1: Automatic Installation with Script

The installation script will perform the following steps:

Interactive Process

Method 2: Docker Installation

Prerequisites

Steps to install with Docker:

1. Clone the repository

2. Configure database (optional)

3. Build the Docker image

4. Start the containers

5. Verify that containers are running

6. View logs (optional)

Docker Configuration

Quick option: Use pre-built image

Simplified Docker Compose option

Create Admin User (Docker)

Post-Installation

Method 3: Manual Installation (Without Docker)

Install Dependencies Manually

Ubuntu/Debian

Fedora/RHEL/CentOS

Manual Compilation Process:

1. Clone the repository

2. Compile the frontend

3. Compile the backend

4. Create directory structure

5. Copy compiled files

6. Create configuration file

7. Create system user

8. Create systemd service

Installation Verification

Verify Service (Native Installation)

Verify Containers (Docker Installation)

Verify Ports

Verify Web Panel

First Access and Initial Configuration

Access the Panel

Step 1: Create Administrator User

Command Parameters

Step 2: Log In

Available CLI Commands

User Management

Database Management

Run Panel

Step 3: Configure Firewall

Ubuntu/Debian (UFW)

Fedora/RHEL/CentOS (firewalld)

Step 4: Initial Configuration in the Panel

Basic Configuration

Configure Nodes

Configure Discord (Optional)

Step 5: Create Your First Server

Installation Summary

Checklist de Instalación

Next Steps

Need Help?

Advanced Panel Configuration

Configuration File

Database Configuration

SQLite (Default)

MySQL/MariaDB

Port Configuration