---
title: "Cómo instalar Pterodactyl Panel y Wings en Ubuntu 24.04"
description: "Monta tu propio hosting de juegos: instala Pterodactyl Panel con Nginx, MariaDB y HTTPS, añade Wings con Docker en Ubuntu 24.04 y despliega tu primer servidor."
category: "Linux"
language: es
source: https://cubepath.com/es/docs/linux/como-crear-tu-propio-hosting-de-juegos-y-desplegar-servidores
updated: 2026-09-25
---

# Cómo instalar Pterodactyl Panel y Wings en Ubuntu 24.04

Pterodactyl es un panel de código abierto para gestionar servidores de juegos. Se divide en dos piezas: el **Panel**, una aplicación web en PHP desde la que administras usuarios, nodos y servidores, y **Wings**, el servicio que se ejecuta en cada nodo y lanza cada servidor de juego en un contenedor Docker aislado. En esta guía instalarás el Panel y Wings en un mismo servidor con Ubuntu 24.04, lo publicarás con HTTPS y desplegarás un primer servidor de Minecraft.

## Requisitos previos

- Un servidor con Ubuntu 24.04 LTS y virtualización KVM, por ejemplo un VPS de CubePath. Wings usa Docker y no funciona en contenedores OpenVZ o LXC.
- Al menos 2 vCPU y 4 GB de RAM: el Panel necesita poco, pero cada servidor de juego consume su propia memoria (un servidor de Minecraft pequeño, unos 2 GB).
- Un usuario no root con privilegios `sudo`.
- Un dominio o subdominio (en esta guía `your_domain`, por ejemplo `panel.example.com`) con un registro DNS A que apunte a la IP pública del servidor.
- UFW activo con SSH permitido.

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

Ubuntu 24.04 incluye PHP 8.3, compatible con Pterodactyl, así que no hace falta ningún repositorio externo. Instala PHP con las extensiones que necesita el Panel, junto con MariaDB, Redis, Nginx, Certbot y utilidades básicas:

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

Comprueba que los servicios están activos:

```bash
systemctl is-active php8.3-fpm mariadb redis-server nginx
```

```output
active
active
active
active
```

Instala Composer, el gestor de dependencias de PHP, en `/usr/local/bin`:

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

```output
Composer version 2.8.12
```

## Paso 2: Crear la base de datos

Asegura la instalación de MariaDB (contraseña de root, eliminación de usuarios anónimos y de la base de datos de prueba):

```bash
sudo mariadb-secure-installation
```

Abre la consola de MariaDB:

```bash
sudo mariadb
```

Crea la base de datos y un usuario para el Panel. Sustituye `your_strong_password` por una contraseña larga y aleatoria y guárdala, la necesitarás en el paso 4:

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

## Paso 3: Descargar el Panel

Crea el directorio del Panel y descarga la última versión publicada:

```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 rm panel.tar.gz
sudo chmod -R 755 storage/* bootstrap/cache/
```

Copia el archivo de entorno de ejemplo e instala las dependencias de PHP:

```bash
sudo cp .env.example .env
sudo COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader
```

Genera la clave de cifrado de la aplicación:

```bash
sudo php artisan key:generate --force
```

> Importante: la clave se guarda como `APP_KEY` en `/var/www/pterodactyl/.env`. Haz una copia de seguridad de ese archivo. Si pierdes la clave, los datos cifrados del Panel no se pueden recuperar.

## Paso 4: Configurar el entorno e inicializar la base de datos

El Panel incluye asistentes interactivos para escribir la configuración en `.env`. Empieza por la configuración general:

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

Responde a las preguntas principales así:

- **Egg Author Email**: tu correo.
- **Application URL**: `https://your_domain` (con `https`).
- **Application Timezone**: por ejemplo `Europe/Madrid`.
- **Cache Driver**, **Session Driver** y **Queue Driver**: `redis`.
- **Redis Host**: `localhost`, sin contraseña y puerto `6379`.

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

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

Configura el envío de correo, necesario para restablecer contraseñas e invitar usuarios. Puedes usar SMTP con tu proveedor de correo:

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

Crea las tablas e importa los datos iniciales, incluidos los "eggs", las plantillas de cada juego:

```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 con el que se ejecutan Nginx y PHP-FPM:

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

## Paso 5: Configurar las tareas programadas y la cola

El Panel necesita ejecutar tareas cada minuto (copias programadas, limpieza) y procesar una cola de trabajos en segundo plano.

Abre el crontab de root:

```bash
sudo crontab -e
```

Añade esta línea al final:

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

Para la cola, crea un servicio de systemd:

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

Añade el siguiente contenido:

```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
```

Activa e inicia el servicio y comprueba su estado:

```bash
sudo systemctl enable --now redis-server pteroq.service
systemctl status pteroq.service --no-pager
```

```output
● pteroq.service - Pterodactyl Queue Worker
     Loaded: loaded (/etc/systemd/system/pteroq.service; enabled; preset: enabled)
     Active: active (running) since Thu 2026-09-25 10:20:14 UTC; 3s ago
```

## Paso 6: Configurar Nginx y HTTPS

Desactiva el sitio por defecto de Nginx y crea uno para el Panel:

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

Añade esta configuración, sustituyendo `your_domain` por tu dominio:

```nginx
server {
    listen 80;
    listen [::]:80;
    server_name your_domain;

    root /var/www/pterodactyl/public;
    index index.php;
    charset utf-8;

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

    client_max_body_size 100m;
    client_body_timeout 120s;
    sendfile off;

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

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    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 configuración 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
```

Abre HTTP y HTTPS en el firewall y obtén el certificado de Let's Encrypt. Certbot añadirá la configuración TLS y la redirección de HTTP a HTTPS:

```bash
sudo ufw allow "Nginx Full"
sudo certbot --nginx -d your_domain
```

```output
Successfully deployed certificate for your_domain to /etc/nginx/sites-enabled/pterodactyl.conf
Congratulations! You have successfully enabled HTTPS on https://your_domain
```

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

## Paso 7: Instalar Docker y Wings

Wings ejecuta cada servidor de juego en un contenedor Docker. Instala Docker desde su 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 de tu servidor (`amd64` o `arm64`):

```bash
sudo mkdir -p /etc/pterodactyl
ARCH=$(dpkg --print-architecture)
sudo curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_${ARCH}"
sudo chmod u+x /usr/local/bin/wings
sudo wings --version
```

```output
wings v1.11.13
```

Crea el servicio de systemd para Wings:

```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
```

No lo inicies todavía: antes necesitas el archivo de configuración que genera el Panel.

## Paso 8: Registrar el nodo en el Panel

En el Panel, entra en el área de administración (icono de engranaje, arriba a la derecha):

1. En **Locations**, pulsa **Create New** y crea una ubicación, por ejemplo con el código `mad1`.
2. En **Nodes**, pulsa **Create New** y rellena:
   - **FQDN**: `your_domain`. Como el Panel usa HTTPS, el navegador solo puede hablar con Wings mediante un nombre de dominio con certificado; aquí reutilizas el que obtuviste en el paso 6.
   - **Communicate Over SSL**: **Use SSL Connection**.
   - **Total Memory** y **Total Disk Space**: lo que quieres repartir entre servidores de juego, dejando margen para el sistema (por ejemplo, 3072 MB en un servidor de 4 GB).
   - **Daemon Port** `8080` y **Daemon SFTP Port** `2022` (los valores por defecto).
3. Guarda el nodo, abre su pestaña **Configuration** y copia el bloque YAML que muestra.

Pega ese contenido en el archivo de configuración de Wings:

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

Comprueba que la sección `ssl` del archivo apunta a los certificados de Let's Encrypt de tu dominio (`/etc/letsencrypt/live/your_domain/fullchain.pem` y `privkey.pem`). Después abre los puertos de Wings en el firewall e inicia el servicio:

```bash
sudo ufw allow 8080/tcp
sudo ufw allow 2022/tcp
sudo systemctl enable --now wings
```

Verifica que arranca sin errores:

```bash
sudo journalctl -u wings -n 20 --no-pager
```

En el Panel, la lista **Nodes** debe mostrar el nodo con un corazón verde, señal de que el Panel contacta con Wings.

> Nota: cuando Certbot renueve el certificado, Wings debe reiniciarse para cargarlo. Crea un hook de renovación con `echo -e '#!/bin/sh\nsystemctl restart wings' | sudo tee /etc/letsencrypt/renewal-hooks/deploy/restart-wings.sh` y hazlo ejecutable con `sudo chmod +x /etc/letsencrypt/renewal-hooks/deploy/restart-wings.sh`.

## Paso 9: Crear las asignaciones y el primer servidor

Cada servidor de juego necesita una asignación: una combinación de IP y puerto del nodo.

1. En **Nodes**, abre tu nodo y ve a la pestaña **Allocation**.
2. En **IP Address** introduce la IP pública del servidor y en **Ports** el puerto o rango, por ejemplo `25565` para Minecraft o `25565-25570` para varios servidores.
3. Guarda.

Wings publica esos puertos a través de Docker, que añade sus propias reglas de filtrado, así que el puerto del juego será accesible aunque no lo abras en UFW.

Ahora crea el servidor:

1. Ve a **Servers** y pulsa **Create New**.
2. Indica un nombre y el usuario propietario.
3. Elige el nodo y la asignación `25565`.
4. En **Resource Management**, asigna memoria (por ejemplo, 2048 MB), disco y CPU.
5. En **Nest Configuration**, elige el nest **Minecraft** y el egg **Paper**.
6. Pulsa **Create Server**.

Wings descargará la imagen Docker y ejecutará el instalador del egg. Cuando termine, abre el servidor desde la vista de cliente del Panel, pulsa **Start** y sigue el arranque en la consola. Conecta con un cliente de Minecraft a `your_server_ip:25565` para confirmar que funciona.

## Solución de problemas

**El nodo aparece con un corazón rojo.** Revisa `sudo journalctl -u wings`. Las causas habituales son que el puerto 8080 está cerrado en UFW, que el FQDN del nodo no coincide con el dominio del certificado o que las rutas de `ssl` en `config.yml` son incorrectas.

**Error 500 al abrir el Panel.** Consulta el log de Laravel en `/var/www/pterodactyl/storage/logs/` y el de Nginx en `/var/log/nginx/pterodactyl.app-error.log`. Suele deberse a permisos: repite el `chown` del paso 4.

**Los servidores se quedan en "Installing".** Comprueba que `pteroq.service` está activo y que el servidor tiene salida a Internet para descargar las imágenes de Docker.

## Conclusión

Tienes Pterodactyl Panel funcionando con HTTPS, un nodo Wings conectado y un primer servidor de juego desplegado en su propio contenedor. Como siguientes pasos, añade más nodos Wings en otros servidores para repartir la carga, importa eggs de la comunidad para otros juegos y, si tus servidores reciben ataques, protege los puertos de juego con reglas en el firewall perimetral de CubePath.