---
title: "Cómo instalar el panel Pterodactyl y Wings en Ubuntu 24.04"
description: "Instala el panel Pterodactyl con Nginx, MariaDB, Redis y HTTPS en Ubuntu 24.04, añade Wings con Docker como nodo y crea tu primer servidor de juego en la web."
category: "Servidores de Juegos"
language: es
source: https://cubepath.com/es/docs/servidores-de-juegos/instalacion-del-panel-pterodactyl-para-servidores-de-juegos
updated: 2026-09-25
---

# Cómo instalar el panel Pterodactyl y Wings en Ubuntu 24.04

Pterodactyl es un panel web de código abierto para gestionar servidores de juegos. Tiene dos piezas: el **Panel**, una aplicación PHP (Laravel) con la interfaz web, y **Wings**, el demonio que ejecuta cada servidor de juego en un contenedor Docker aislado en uno o varios nodos. En este tutorial instalarás el Panel y Wings en el mismo servidor Ubuntu 24.04, con Nginx, MariaDB, Redis y un certificado de Let's Encrypt, y crearás un servidor de Minecraft desde el navegador.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS de 64 bits, por ejemplo un VPS de CubePath, con virtualización KVM (Docker no funciona en contenedores OpenVZ o LXC sin configuración especial).
- Un usuario no root con privilegios `sudo`.
- Al menos 2 núcleos y 4 GB de RAM, más los recursos que vayan a usar los servidores de juego.
- Un dominio con un registro DNS `A` apuntando a la IP del servidor. En la guía se usa `panel.your_domain`.
- Los puertos TCP `80`, `443`, `8080` y `2022` libres.

## Paso 1: Instalar PHP, MariaDB, Nginx y Redis

Ubuntu 24.04 incluye PHP 8.3, que es compatible con el Panel, así que no hace falta un repositorio externo. Instala PHP con las extensiones que necesita Pterodactyl, la base de datos, el servidor web y Redis:

```bash
sudo apt update
sudo apt install php8.3 php8.3-{common,cli,gd,mysql,mbstring,bcmath,xml,fpm,curl,zip} mariadb-server nginx redis-server tar unzip git curl
```

Instala Composer, el gestor de dependencias de PHP:

```bash
curl -sS https://getcomposer.org/installer -o composer-setup.php
sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
rm composer-setup.php
```

Comprueba las versiones:

```bash
php -v
composer --version
```

```output
PHP 8.3.6 (cli) (built: ...) (NTS)
Composer version 2.8.x ...
```

Asegúrate de que Redis y PHP-FPM están activos:

```bash
sudo systemctl enable --now redis-server php8.3-fpm
```

## Paso 2: Descargar el Panel

Descarga la última versión publicada en `/var/www/pterodactyl` y da permisos de escritura a los directorios de caché y almacenamiento:

```bash
sudo mkdir -p /var/www/pterodactyl
cd /var/www/pterodactyl
sudo curl -Lo panel.tar.gz https://github.com/pterodactyl/panel/releases/latest/download/panel.tar.gz
sudo tar -xzvf panel.tar.gz
sudo chmod -R 755 storage/* bootstrap/cache/
```

## Paso 3: Crear la base de datos

Crea una base de datos y un usuario dedicados. Abre la consola de MariaDB como root (en Ubuntu se autentica por socket, sin contraseña):

```bash
sudo mariadb
```

Ejecuta estas sentencias sustituyendo `your_db_password` por una contraseña robusta:

```sql
CREATE USER 'pterodactyl'@'127.0.0.1' IDENTIFIED BY 'your_db_password';
CREATE DATABASE panel;
GRANT ALL PRIVILEGES ON panel.* TO 'pterodactyl'@'127.0.0.1' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;
```

## Paso 4: Configurar el Panel

Copia el archivo de entorno, instala las dependencias de PHP y genera la clave de cifrado de la aplicación:

```bash
cd /var/www/pterodactyl
sudo cp .env.example .env
sudo COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader
sudo php artisan key:generate --force
```

> Importante: guarda una copia del valor `APP_KEY` de `/var/www/pterodactyl/.env` en un lugar seguro. Sin él, los datos cifrados de la base de datos son irrecuperables aunque tengas copia de la base de datos.

Lanza los asistentes de configuración. El primero pide la URL del panel (`https://panel.your_domain`), la zona horaria y los drivers de caché, sesiones y colas: elige `redis` en los tres y acepta `127.0.0.1` como host de Redis:

```bash
sudo php artisan p:environment:setup
```

Configura la conexión a la base de datos con los datos del paso 3 (host `127.0.0.1`, puerto `3306`, base de datos `panel`, usuario `pterodactyl`):

```bash
sudo php artisan p:environment:database
```

Opcionalmente configura el envío de correo (SMTP) para restablecer contraseñas e invitar usuarios:

```bash
sudo php artisan p:environment:mail
```

Crea las tablas e importa los datos iniciales, incluidos los *eggs* (plantillas de juegos) oficiales:

```bash
sudo php artisan migrate --seed --force
```

Crea tu usuario administrador. Responde `yes` a la pregunta de si es administrador:

```bash
sudo php artisan p:user:make
```

Por último, entrega los archivos al usuario del servidor web:

```bash
sudo chown -R www-data:www-data /var/www/pterodactyl/*
```

## Paso 5: Programar tareas y el worker de colas

El Panel necesita ejecutar el planificador de Laravel cada minuto. Añádelo al crontab de root:

```bash
sudo crontab -e
```

```text
* * * * * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1
```

Las tareas en segundo plano (envío de correo, instalaciones de servidores) las procesa un worker de colas. Crea su servicio systemd:

```bash
sudo nano /etc/systemd/system/pteroq.service
```

```ini
[Unit]
Description=Pterodactyl Queue Worker
After=redis-server.service

[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/usr/bin/php /var/www/pterodactyl/artisan queue:work --queue=high,standard,low --sleep=3 --tries=3
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target
```

Actívalo y comprueba que está en marcha:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now pteroq.service
systemctl status pteroq.service
```

```output
● pteroq.service - Pterodactyl Queue Worker
     Active: active (running) since ...
```

## Paso 6: Obtener el certificado TLS

Abre los puertos web y SSH en el firewall:

```bash
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
```

Instala Certbot con el plugin de Nginx y solicita un certificado para el dominio del panel. Con `certonly` Certbot solo obtiene el certificado y no modifica la configuración de Nginx, que escribirás en el paso siguiente:

```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot certonly --nginx -d panel.your_domain
```

```output
Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/panel.your_domain/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/panel.your_domain/privkey.pem
```

El paquete instala un timer de systemd que renueva el certificado automáticamente. Compruébalo con `sudo certbot renew --dry-run`.

## Paso 7: Configurar Nginx

Elimina el sitio por defecto y crea el del panel:

```bash
sudo rm /etc/nginx/sites-enabled/default
sudo nano /etc/nginx/sites-available/pterodactyl.conf
```

Pega esta configuración sustituyendo `panel.your_domain` en las cuatro apariciones:

```nginx
server {
    listen 80;
    server_name panel.your_domain;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name panel.your_domain;

    root /var/www/pterodactyl/public;
    index index.php;

    access_log /var/log/nginx/pterodactyl.app-access.log;
    error_log  /var/log/nginx/pterodactyl.app-error.log error;

    client_max_body_size 100m;
    client_body_timeout 120s;
    sendfile off;

    ssl_certificate /etc/letsencrypt/live/panel.your_domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/panel.your_domain/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;

    add_header X-Content-Type-Options nosniff;
    add_header X-Frame-Options DENY;
    add_header Referrer-Policy same-origin;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param PHP_VALUE "upload_max_filesize = 100M \n post_max_size=100M";
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTP_PROXY "";
        fastcgi_intercept_errors off;
        fastcgi_buffer_size 16k;
        fastcgi_buffers 4 16k;
        fastcgi_connect_timeout 300;
        fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
    }

    location ~ /\.ht {
        deny all;
    }
}
```

Activa el sitio, valida la sintaxis y recarga Nginx:

```bash
sudo ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf
sudo nginx -t
sudo systemctl reload nginx
```

```output
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```

Abre `https://panel.your_domain` en el navegador e inicia sesión con el usuario creado en el paso 4.

## Paso 8: Instalar Docker y Wings

Wings ejecuta cada servidor de juego en un contenedor, así que necesita Docker. Instálalo desde el repositorio oficial:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io
sudo systemctl enable --now docker
```

Descarga el binario de Wings para la arquitectura del servidor:

```bash
sudo mkdir -p /etc/pterodactyl
sudo curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
sudo chmod u+x /usr/local/bin/wings
```

Comprueba que se ejecuta:

```bash
sudo wings version
```

Abre los puertos de Wings: `8080` para la API que usa el panel y `2022` para el acceso SFTP a los archivos de los servidores:

```bash
sudo ufw allow 8080/tcp
sudo ufw allow 2022/tcp
```

## Paso 9: Crear la ubicación y el nodo en el Panel

En el panel, entra en el área de administración (icono de engranaje) y crea primero una ubicación en **Locations** > **Create New**, por ejemplo con el código `eu1`.

Después ve a **Nodes** > **Create New** y rellena:

- **FQDN**: `panel.your_domain` (Wings reutiliza el mismo dominio y certificado porque está en el mismo servidor).
- **Communicate Over SSL**: *Use SSL Connection*.
- **Behind Proxy**: *Not Behind Proxy*.
- **Total Memory** y **Total Disk Space**: lo que quieras reservar para servidores de juego, dejando margen para el sistema y el panel.
- **Daemon Port** `8080` y **Daemon SFTP Port** `2022`.

Guarda el nodo y abre su pestaña **Configuration**. Copia el bloque YAML que aparece y pégalo en el archivo de configuración de Wings:

```bash
sudo nano /etc/pterodactyl/config.yml
```

Comprueba que las rutas del certificado en la sección `ssl` apuntan a `/etc/letsencrypt/live/panel.your_domain/`. Arranca Wings en modo depuración para verificar que conecta:

```bash
sudo wings --debug
```

Si no aparecen errores y el corazón del nodo en **Nodes** se pone verde, detén Wings con `Ctrl+C` y crea su servicio:

```bash
sudo nano /etc/systemd/system/wings.service
```

```ini
[Unit]
Description=Pterodactyl Wings Daemon
After=docker.service
Requires=docker.service
PartOf=docker.service

[Service]
User=root
WorkingDirectory=/etc/pterodactyl
LimitNOFILE=4096
PIDFile=/var/run/wings/daemon.pid
ExecStart=/usr/local/bin/wings
Restart=on-failure
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target
```

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now wings
systemctl status wings
```

## Paso 10: Añadir puertos y crear un servidor

Cada servidor de juego necesita una *allocation*, es decir, una combinación de IP y puerto. En la pestaña **Allocation** del nodo, introduce la IP pública `your_server_ip` y los puertos que quieras ofrecer, por ejemplo `25565-25570` para Minecraft, y guarda.

Ve a **Servers** > **Create New** y completa:

- **Server Name** y **Server Owner** (tu usuario administrador u otro usuario).
- **Default Allocation**: uno de los puertos creados.
- **Memory**, **Disk Space** y **CPU Limit** para el contenedor (por ejemplo 2048 MB de RAM y 10240 MB de disco).
- **Nest** `Minecraft` y **Egg** `Paper`.

Al guardar, Wings descarga la imagen Docker y ejecuta el script de instalación del egg. Cuando termine, abre el servidor desde la vista de usuario del panel, pulsa **Start** y observa la consola hasta que Minecraft indique que está listo. Conéctate desde el juego a `your_server_ip:25565`.

> Nota: Docker publica los puertos de los contenedores con sus propias reglas de iptables, que tienen prioridad sobre UFW. Los puertos de las *allocations* quedan accesibles desde Internet aunque no los abras en UFW.

Para otros juegos, el panel incluye eggs oficiales en **Nests** (Minecraft, juegos de Source Engine, Rust, servicios de voz) y puedes importar más desde el repositorio comunitario de eggs de Pterodactyl con **Nests** > **Import Egg**.

## Solución de problemas

- **Error 500 al abrir el panel**: revisa `/var/www/pterodactyl/storage/logs/` y el log de Nginx `/var/log/nginx/pterodactyl.app-error.log`. Suele ser un problema de permisos: repite el `chown` del paso 4.
- **El nodo aparece con el corazón rojo**: Wings no está en marcha o el navegador no puede llegar al puerto `8080`. Comprueba `sudo journalctl -u wings -n 50` y que el certificado de `config.yml` es válido para el FQDN del nodo.
- **Los correos o instalaciones se quedan pendientes**: el worker de colas no funciona. Comprueba `systemctl status pteroq` y que Redis está activo.
- **El servidor se queda en "Installing"**: mira la salida del instalador en la consola del servidor y el log de Wings; a menudo es un fallo de descarga de la imagen Docker o falta de disco.

## Conclusión

Tienes el panel Pterodactyl funcionando con HTTPS, Wings conectado como nodo y un servidor de Minecraft gestionado desde el navegador. Como siguientes pasos, activa la autenticación en dos pasos para tu cuenta de administrador, programa copias de seguridad de la base de datos `panel` y del archivo `.env`, y añade más nodos Wings en otros servidores para repartir la carga de los juegos.