--- title: "Cómo instalar Coolify en Ubuntu 24.04 como PaaS self-hosted" description: "Instala Coolify en Ubuntu 24.04, publica el panel con HTTPS en tu dominio, despliega una aplicación desde Git o Docker y crea una base de datos con copias." category: "Aplicaciones Web Extendidas" language: es source: https://cubepath.com/es/docs/aplicaciones-web-extendidas/instalacion-de-coolify-paas-self-hosted updated: 2026-09-25 --- # 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`: ```bash 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: ```bash 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: | Puerto | Uso | |---|---| | 22 | SSH. Coolify también lo usa para gestionar el propio servidor | | 80 y 443 | Proxy de Coolify: aplicaciones y certificados de Let's Encrypt | | 8000 | Panel web antes de configurar un dominio | | 6001 | Actualizaciones en tiempo real del panel | | 6002 | Terminal web del panel | > 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: ```bash curl -fsSL https://cdn.coollabs.io/coolify/install.sh -o install-coolify.sh less install-coolify.sh ``` Ejecútalo como root: ```bash sudo bash install-coolify.sh ``` La instalación tarda unos minutos. Al terminar, el script muestra la dirección del panel: ```output 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: ```bash sudo docker ps --format 'table {{.Names}}\t{{.Status}}' ``` ```output 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: ```bash sudo docker ps --filter name=coolify-proxy --format '{{.Names}} {{.Ports}}' ``` ```output 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: ```bash dig +short coolify.your_domain ``` ```output your_server_ip ``` En el panel, ve a **Settings** y, en el campo **Domain** de la instancia, escribe la URL completa con el esquema: ```text https://coolify.your_domain ``` Guarda los cambios. El proxy solicitará el certificado en unos segundos. Compruébalo desde la terminal: ```bash curl -sI https://coolify.your_domain | head -n 1 ``` ```output 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: ```bash curl -sI https://app.your_domain | head -n 1 ``` ```output 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**: | Build Pack | Cuándo usarlo | |---|---| | Nixpacks | Detecta el lenguaje (Node.js, Python, PHP, Go, Ruby...) y construye la imagen sin Dockerfile | | Static | Sitios estáticos generados (por ejemplo, la carpeta `dist` de Vite) | | Dockerfile | El repositorio ya incluye un `Dockerfile` | | Docker Compose | La aplicación se define con un `docker-compose.yml` | 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: ```bash sudo docker ps --format '{{.Names}} {{.Image}}' | grep postgres sudo docker exec -it nombre_del_contenedor psql -U postgres -c 'SELECT version();' ``` ```output 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. ```bash 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: ```bash 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: ```bash 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.