Cómo instalar Coolify en Ubuntu 24.04 como PaaS self-hosted

Coolify es una plataforma PaaS de código abierto que convierte un servidor propio en algo parecido a Heroku, Netlify o Vercel: despliegas aplicaciones desde un repositorio Git o una imagen Docker, creas bases de datos y obtienes certificados HTTPS sin configurar el proxy a mano. Todo corre en contenedores Docker gestionados desde un panel web. En este tutorial instalarás Coolify en Ubuntu 24.04, publicarás el panel en tu dominio con HTTPS, desplegarás una primera aplicación y crearás una base de datos PostgreSQL con copias de seguridad.

Requisitos previos

• Un servidor con Ubuntu 24.04 LTS recién instalado, por ejemplo un VPS de CubePath, con al menos 2 vCPU, 2 GB de RAM y 30 GB de disco. Con varias aplicaciones y bases de datos, 4 GB de RAM o más es más cómodo.
• Acceso como root o con un usuario con privilegios sudo.
• Un dominio con dos registros DNS de tipo A apuntando a la IP del servidor: uno para el panel (en esta guía coolify.your_domain) y otro para la aplicación de prueba (app.your_domain). Sustituye your_domain por tu dominio.
• Los puertos 22, 80, 443, 8000, 6001 y 6002 accesibles desde Internet durante la instalación.

Importante

usa un servidor dedicado a Coolify. El instalador instala Docker, arranca su propio proxy en los puertos 80 y 443 y entraría en conflicto con un Nginx o Apache que ya estén en marcha.

Paso 1: Preparar el servidor

Actualiza el sistema e instala curl:

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl

Si usas UFW, abre los puertos que necesita Coolify. SSH va primero para no perder el acceso:

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 8000/tcp
sudo ufw allow 6001/tcp
sudo ufw allow 6002/tcp
sudo ufw enable

Cada puerto tiene una función:

Nota

Docker publica sus puertos con reglas de iptables propias que no pasan por UFW. Un puerto que un contenedor publique quedará accesible aunque UFW no lo permita. Tenlo en cuenta al exponer bases de datos (paso 6).

Paso 2: Instalar Coolify

Coolify se instala con un script oficial que instala Docker Engine si no está presente, crea los directorios en /data/coolify y arranca los contenedores del panel. Descárgalo y revísalo antes de ejecutarlo:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh -o install-coolify.sh
less install-coolify.sh

Ejecútalo como root:

sudo bash install-coolify.sh

La instalación tarda unos minutos. Al terminar, el script muestra la dirección del panel:

Your instance is ready to use!

You can access Coolify through your Public IP: http://your_server_ip:8000

Comprueba que los contenedores principales están en marcha:

sudo docker ps --format 'table {{.Names}}\t{{.Status}}'

NAMES              STATUS
coolify            Up 2 minutes (healthy)
coolify-realtime   Up 2 minutes (healthy)
coolify-db         Up 2 minutes (healthy)
coolify-redis      Up 2 minutes (healthy)

El contenedor del proxy (coolify-proxy) aparecerá después de completar la configuración inicial. La configuración de la instalación, incluidas las credenciales internas, queda en /data/coolify/source/.env. Haz una copia de ese archivo en un lugar seguro.

Paso 3: Crear la cuenta de administrador

Abre http://your_server_ip:8000 en el navegador. La primera pantalla es el registro: la primera cuenta que se crea es la de administrador de la instancia.

Advertencia

hasta que registres esa cuenta, cualquiera que llegue al puerto 8000 podría hacerlo en tu lugar. Crea la cuenta nada más terminar la instalación.

Después del registro, el asistente de bienvenida pregunta dónde desplegar los recursos. Elige This Machine (el propio servidor) para usar el mismo equipo que ejecuta Coolify. El asistente valida la conexión y arranca el proxy.

Verifica en la terminal que el proxy ya está activo y escuchando en los puertos 80 y 443:

sudo docker ps --filter name=coolify-proxy --format '{{.Names}} {{.Ports}}'

coolify-proxy 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, ...

Paso 4: Publicar el panel en tu dominio con HTTPS

Trabajar con el panel por HTTP en el puerto 8000 expone tus credenciales. Configura el dominio para que el proxy lo sirva por HTTPS con un certificado de Let's Encrypt.

Comprueba primero que el registro DNS ya resuelve a tu servidor:

dig +short coolify.your_domain

your_server_ip

En el panel, ve a Settings y, en el campo Domain de la instancia, escribe la URL completa con el esquema:

https://coolify.your_domain

Guarda los cambios. El proxy solicitará el certificado en unos segundos. Compruébalo desde la terminal:

curl -sI https://coolify.your_domain | head -n 1

HTTP/2 302

Una respuesta 302 (redirección a la pantalla de login) o 200 indica que el panel responde por HTTPS con un certificado válido. A partir de ahora entra siempre por https://coolify.your_domain. Cuando lo hayas comprobado, puedes cerrar el acceso directo al puerto 8000 en tu cortafuegos de red.

Paso 5: Desplegar una primera aplicación

Coolify organiza los recursos en proyectos y, dentro de cada proyecto, en entornos (por ejemplo production y staging). Para comprobar que todo el flujo funciona, despliega primero una imagen Docker pública.

1. Ve a Projects y crea un proyecto llamado demo. Coolify crea el entorno production.
2. Dentro del entorno, pulsa + New (nuevo recurso) y elige Docker Image.
3. Escribe la imagen nginx:alpine y continúa.
4. En la configuración del recurso, pon en Domains https://app.your_domain y comprueba que Ports Exposes vale 80, el puerto en el que escucha Nginx dentro del contenedor.
5. Pulsa Deploy y sigue el registro del despliegue en pantalla.

Cuando el estado pase a Running, verifica la aplicación:

curl -sI https://app.your_domain | head -n 1

HTTP/2 200

Desplegar desde un repositorio Git

El flujo con código propio es el mismo, eligiendo otro tipo de recurso:

• Public Repository: pegas la URL de un repositorio público y la rama.
• Private Repository (with GitHub App): antes, en Sources, registras una GitHub App para tu cuenta u organización. Además de dar acceso a los repositorios privados, permite desplegar automáticamente con cada push.
• Private Repository (with Deploy Key): Coolify usa una clave SSH que añades como deploy key en tu proveedor Git. Las claves se gestionan en Keys & Tokens.

Después eliges el Build Pack:

Revisa en la configuración los comandos de instalación, compilación y arranque que propone Nixpacks, el puerto expuesto y el dominio. Las variables de entorno se añaden en la pestaña Environment Variables del recurso; marca como secretas las que contengan credenciales y vuelve a desplegar para que se apliquen.

Paso 6: Crear una base de datos PostgreSQL

Coolify despliega bases de datos como PostgreSQL, MySQL, MariaDB, MongoDB, Redis y otras con credenciales generadas automáticamente.

1. En el entorno production del proyecto demo, pulsa + New y elige PostgreSQL.
2. Revisa el usuario, la contraseña y el nombre de la base de datos que propone Coolify y pulsa Start.
3. Copia la URL interna de conexión que muestra el recurso. Tus aplicaciones del mismo servidor la usan como variable de entorno (por ejemplo DATABASE_URL) y se conectan por la red interna de Docker, sin exponer el puerto a Internet.

Comprueba desde la terminal que la base de datos acepta conexiones. Busca el nombre del contenedor y ejecuta psql dentro de él con el usuario que muestra el panel:

sudo docker ps --format '{{.Names}} {{.Image}}' | grep postgres
sudo docker exec -it nombre_del_contenedor psql -U postgres -c 'SELECT version();'

                              version
-------------------------------------------------------------------
 PostgreSQL 17.x on x86_64-pc-linux-musl, compiled by gcc ...
(1 row)

La opción Make it publicly available del recurso publica el puerto de la base de datos en el servidor. Úsala solo si la necesitas de verdad y limita el acceso con un cortafuegos de red, porque UFW no filtra los puertos que publica Docker.

Paso 7: Programar copias de seguridad

Las copias de las bases de datos se pueden guardar en el propio servidor o en un almacenamiento compatible con S3, que es lo recomendable para no perderlas junto con el servidor.

1. Ve a Storages y añade un almacenamiento S3 con el endpoint, el bucket, la región y las claves de acceso. Coolify valida la conexión al guardarlo.
2. En el recurso PostgreSQL, abre la pestaña Backups, crea una copia programada con una expresión cron (por ejemplo 0 3 * * * para las 03:00 cada día) y activa el envío al almacenamiento S3.
3. Pulsa Backup Now para lanzar una copia inmediata y comprueba que aparece en la lista de ejecuciones y en el bucket.

Programa también una copia periódica de /data/coolify, donde Coolify guarda su propia configuración, sus claves SSH y los datos de sus servicios.

Paso 8: Actualizar Coolify

Coolify avisa en el panel cuando hay una versión nueva y se puede actualizar con un clic. En Settings también puedes activar las actualizaciones automáticas y elegir su horario. Si el panel no responde, vuelve a ejecutar el script de instalación: detecta la instalación existente y la actualiza sin borrar los datos.

curl -fsSL https://cdn.coollabs.io/coolify/install.sh -o install-coolify.sh
sudo bash install-coolify.sh

Solución de problemas

No carga el panel en el puerto 8000. Comprueba que el contenedor coolify está en marcha y revisa su registro:

sudo docker ps --filter name=coolify
sudo docker logs --tail 100 coolify

Si el contenedor funciona, revisa que el puerto 8000 está permitido en UFW y en cualquier cortafuegos de red delante del servidor.

El certificado HTTPS no se emite. Let's Encrypt necesita llegar al servidor por el puerto 80 con el dominio correcto. Verifica el DNS con dig +short app.your_domain, que los puertos 80 y 443 estén abiertos, y busca errores ACME en el proxy:

sudo docker logs --tail 100 coolify-proxy 2>&1 | grep -i -E 'acme|certificate|error'

La aplicación despliega pero devuelve 502 o 503. El puerto de Ports Exposes no coincide con el que escucha la aplicación dentro del contenedor, o la aplicación escucha solo en 127.0.0.1. Configúrala para escuchar en 0.0.0.0 y revisa los logs del recurso en la pestaña Logs.

El build se queda sin memoria. La compilación de aplicaciones Node.js o Java puede agotar 2 GB de RAM. Añade swap al servidor o amplía la memoria del VPS.

Conclusión

Tienes Coolify funcionando en Ubuntu 24.04, con el panel servido por HTTPS en tu dominio, una aplicación desplegada con certificado automático y una base de datos PostgreSQL con copias programadas en S3. Como siguientes pasos, conecta una GitHub App para desplegar con cada push, añade un segundo servidor en Servers para separar las aplicaciones del panel y crea un entorno staging en tu proyecto para probar los cambios antes de producción.