noviembre de 2026
Coolify in Production
Por qué Nashua respalda Coolify, y cómo lo construimos: un host Ubuntu LTS fortificado, el instalador de Coolify, CrowdSec con Traefik AppSec, Docker y Kubernetes, y una cadena de Claude Code y GitHub para CI/CD.
Resumen
Coolify es una plataforma de código abierto y autoalojada que convierte un servidor Linux corriente en una plataforma de despliegue con la comodidad de una nube gestionada y sin nada de su cautividad. En Nashua lo respaldamos como la forma de ser dueño de tu propio alojamiento, y este es el artículo para profesionales que hay detrás de ese respaldo: una construcción completa y con criterio. Partimos de un host Ubuntu LTS fortificado, instalamos Coolify y colocamos delante un verdadero borde de seguridad con CrowdSec y el firewall de aplicaciones web Traefik AppSec. Mostramos cómo se ejecutan realmente las cargas de trabajo, Docker primero, porque es lo que Coolify orquesta, y Kubernetes con honestidad, porque es una decisión distinta. Y cableamos el bucle de desarrollo que hace que la plataforma merezca la pena: Claude Code para construir, GitHub para la revisión y la integración continua, y Coolify para el despliegue continuo, de modo que un commit se convierte en un servicio probado y en marcha sin que una persona toque un servidor. Es un lugar de trabajo soberano para tu propio software, y Nashua lo construye, lo asegura y lo opera.
Palabras clave: Coolify; PaaS autoalojado; Ubuntu LTS; fortificación de servidores; CrowdSec; Traefik; AppSec; firewall de aplicaciones web; Docker; Docker Swarm; Kubernetes; Claude Code; GitHub; CI/CD; despliegue continuo; vibe coding; soberanía digital; DevOps; infraestructura como servicio
1. Introducción
Un equipo de desarrollo se enfrenta hoy a una elección que antes era sencilla. Puedes alquilar una plataforma gestionada, Heroku, Vercel, Render y sus semejantes, y obtener un despliegue en cada push a cambio de una factura por asiento y por servicio que se acumula y de una dependencia que no controlas. O puedes ejecutar tus propios servidores y aceptar que ahora eres responsable del trabajo pesado indiferenciado que las plataformas gestionadas ocultan: aprovisionamiento, proxies inversos, certificados TLS, cadenas de construcción, reversiones y lo demás. Durante años la primera opción ganó por defecto, porque la segunda era, sencillamente, demasiado trabajo.
Ese cálculo ha cambiado, y lo que lo cambió es Coolify. Coolify es una plataforma de código abierto y autoalojada que se asienta sobre Docker y da a un servidor Linux corriente la ergonomía de una nube gestionada: conecta un repositorio Git y construye tu aplicación, la ejecuta en un contenedor, la pone tras un proxy inverso, emite y renueva su certificado TLS y la redespliega en cada push. Hace por tu propio software lo que Nextcloud hace por tus archivos y tu colaboración: te permite ser dueño de la plataforma en lugar de alquilarla. Por eso Nashua lo respalda, y este artículo es la construcción que hay detrás del respaldo.
Este es un artículo para profesionales, no un estudio comparativo. Es una receta con criterio y de principio a fin para levantar Coolify tal como lo ejecutaríamos para un cliente, y es deliberadamente concreta. Fortificamos un host Ubuntu LTS (Sección 3), instalamos Coolify y aseguramos su plano de control (Sección 4), y colocamos delante un verdadero borde de seguridad con CrowdSec y el firewall de aplicaciones web Traefik AppSec (Sección 5). Somos lúcidos acerca de las cargas de trabajo: Docker es lo que Coolify orquesta y lo que la mayoría de los equipos debería usar (Sección 6), y Kubernetes es una decisión aparte y más pesada que tratamos con honestidad en lugar de como una casilla que marcar (Sección 7). Por último cableamos el bucle que hace que todo ello rinda: Claude Code, GitHub y despliegue continuo (Sección 8), antes de unas palabras sobre su operación (Sección 9). La Figura 1 muestra la forma del resultado.
2. Por qué Nashua respalda Coolify
Nuestra postura sobre el lugar de trabajo digital, expuesta en otro lugar, es que una organización debería ser dueña de las herramientas de las que depende en lugar de alquilarlas indefinidamente en condiciones que no fija. El mismo argumento se aplica con toda su fuerza al lugar donde se ejecuta tu propio software. Una plataforma de aplicaciones gestionada es un casero cómodo, y como todo casero es dueño del edificio, fija el alquiler y puede cambiar ambas cosas.
Coolify responde a eso sin renunciar a la comodidad. Es de código abierto, con una licencia que te permite leerlo, ejecutarlo y extenderlo. Se ejecuta en el hardware que elijas, en el país que elijas, bajo la ley que elijas, lo que lo convierte en una plataforma soberana justo en el sentido que importa para el RGPD y la NIS2. Su coste es el de un servidor y el trabajo de ejecutarlo bien, no una anualidad por asiento que crece con tu éxito. Y no es un juguete: gestiona construcciones, despliegues, bases de datos, TLS, copias de seguridad y vistas previas a través de uno o muchos servidores, con una interfaz web que un equipo puede usar de verdad. Para una organización que ya valora ser dueña de sus datos, ser dueña de la plataforma sobre la que se envía su software es la misma decisión tomada dos veces. Por eso lo respaldamos, y por eso estamos dispuestos a poner nuestro nombre en una guía de construcción para ello.
3. El host: un servidor Ubuntu LTS fortificado
Todo empieza con el servidor, y el servidor empieza con un sistema operativo de soporte a largo plazo. Construimos sobre Ubuntu LTS porque es la plataforma a la que Coolify, Docker y el ecosistema en general apuntan primero y dan soporte durante más tiempo. Al momento de escribir esto desplegamos en Ubuntu 24.04 LTS para producción: está probado y cuenta con actualizaciones de seguridad hasta 2029. Ubuntu 26.04 LTS está disponible para construcciones nuevas que quieran el horizonte más largo; dejamos que una versión de mantenimiento se asiente antes de poner una LTS bajo la carga de producción de un cliente. Dos núcleos, 2 GB de RAM y 10 GB de disco son el suelo documentado para Coolify; dimensionamos al alza a partir de ahí, porque las construcciones son voraces y el margen es barato.
Un servidor recién creado no es un servidor seguro. Antes de que Coolify lo toque, lo ponemos completamente al día e instalamos las herramientas que lo mantienen actual y protegido:
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y ufw fail2ban \
unattended-upgrades
Después creamos un usuario administrativo sin privilegios y dejamos de usar root directamente:
sudo adduser deploy
sudo usermod -aG sudo deploy
3.1 Blindar SSH
El paso de fortificación más valioso es hacer que el inicio de sesión remoto dependa de una clave, no de una contraseña, y negar por completo al usuario root un shell remoto. Copia tu clave pública al nuevo usuario con ssh-copy-id deploy@your-server, confirma que puedes iniciar sesión con ella y luego escribe un fragmento que clausure las opciones más débiles:
# /etc/ssh/sshd_config.d/99-hardening.conf
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
Recarga el demonio con sudo systemctl restart ssh, manteniendo abierta tu sesión actual hasta que una segunda sesión demuestre que la clave funciona. Con las contraseñas desactivadas, el grueso de los ataques SSH automatizados deja sencillamente de importar, y fail2ban se encarga del ruido que queda.
3.2 Un firewall de denegación por defecto
El host debería aceptar solo el tráfico que debe. Usamos el firewall uncomplicated (ufw) para denegar por defecto todo lo entrante y abrir luego las tres puertas que la plataforma necesita: SSH para nosotros, y HTTP y HTTPS para las aplicaciones que Coolify servirá.
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
Fíjate en lo que no abrimos: el puerto 8000, donde escucha el panel de Coolify. El plano de control no tiene nada que hacer en la internet pública, y la Sección 4 explica cómo llegamos a él sin exponerlo.
3.3 Parchear mientras duermes
Un servidor que está al día es un servidor que no es vulnerable al exploit del mes pasado. Dejamos que Ubuntu aplique las actualizaciones de seguridad de forma automática y desatendida:
sudo dpkg-reconfigure \
-plow unattended-upgrades
Esto, una puerta SSH solo con clave, un firewall de denegación por defecto y fail2ban son la base. No son exóticos, y ese es el punto: la mayoría de las brechas explotan la ausencia de lo ordinario, no la presencia de lo ingenioso. Para clientes regulados vamos más allá, hasta un referencial reconocido como la base CIS de Ubuntu, pero los pasos anteriores son los que ningún servidor debería lanzar sin ellos.
4. Instalar Coolify
Con un host fortificado en su sitio, Coolify en sí resulta casi anticlimático. Un solo comando, ejecutado como usuario privilegiado, instala Docker si falta, descarga los servicios de Coolify y los arranca:
curl -fsSL \
https://cdn.coollabs.io/coolify/install.sh \
| sudo bash
Cuando termina, el panel escucha en el puerto 8000, y Coolify también ha arrancado su propio proxy inverso. Por defecto ese proxy es Traefik, lo que importa mucho para la sección siguiente, porque es la instancia de Traefik que armaremos con un firewall.
4.1 Asegura primero el plano de control
Antes que nada, llega al panel y crea la cuenta de administrador, de inmediato, para que no lo haga nadie más. Como no abrimos el puerto 8000 en el firewall, llegamos a él por un túnel SSH desde nuestra propia máquina en lugar de a través de internet:
ssh -L 8000:localhost:8000 deploy@your-server
Ahora http://localhost:8000 en tu navegador es el panel, viajando por completo dentro de la sesión SSH cifrada. Crea el usuario administrador y luego dale al panel su propio dominio y certificado TLS a través de los propios ajustes de Coolify, de modo que la administración continua use una URL HTTPS real protegida por el proxy en lugar de un túnel. El principio es sencillo y es el que la mayoría de los autoalojadores equivoca: la cosa que puede desplegar todas tus demás cosas es la superficie más sensible que ejecutas, así que es lo último que expones y lo primero que proteges.
5. El borde de seguridad: CrowdSec y Traefik AppSec
Una plataforma que despliega aplicaciones web públicas necesita un borde de seguridad, algo entre la internet abierta y tus contenedores que inspeccione las peticiones, bloquee lo manifiestamente hostil y aprenda. Como Coolify ejecuta Traefik como su proxy, podemos añadir exactamente eso sin introducir otra pieza móvil, usando CrowdSec.
CrowdSec es un motor de seguridad de código abierto con dos mitades que importan aquí. Lee registros y decide qué fuentes se comportan de forma maliciosa, y comparte esos veredictos a través de una comunidad global, de modo que tu servidor se beneficia de los ataques vistos en los de todos los demás. Y trae un componente AppSec: un firewall de aplicaciones web, construido sobre el motor Coraza y capaz de ejecutar el OWASP Core Rule Set, que inspecciona el contenido de las peticiones y bloquea los intentos de exploit en línea, antes de que lleguen a tu aplicación. Instala el agente y luego añade las colecciones de reglas del firewall:
curl -s https://install.crowdsec.net | sudo sh
sudo apt install -y crowdsec
sudo cscli collections install \
crowdsecurity/appsec-virtual-patching
sudo cscli collections install \
crowdsecurity/appsec-generic-rules
Activa el escuchador de AppSec añadiendo un archivo de adquisición que le dice a CrowdSec que sirva el firewall en el puerto 7422:
# /etc/crowdsec/acquis.d/appsec.yaml
listen_addr: 0.0.0.0:7422
appsec_config: crowdsecurity/appsec-default
name: appsec
source: appsec
labels:
type: appsec
Luego acuña una clave de API que Traefik usará para consultar a CrowdSec, y reinicia el agente:
sudo cscli bouncers add traefik-bouncer
sudo systemctl restart crowdsec
5.1 Armar Traefik
La conexión entre Traefik y CrowdSec es un plugin de la comunidad, el CrowdSec Bouncer Traefik Plugin, que es la vía mantenida hacia el firewall AppSec. Se carga como plugin experimental en la configuración estática de Traefik:
# traefik static config
experimental:
plugins:
bouncer:
moduleName: github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
version: v1.8.2
y se convierte en un middleware en la configuración dinámica, apuntado a ambas mitades de CrowdSec: la API de decisión en el puerto 8080 y el firewall AppSec en el puerto 7422, con la clave que acabas de acuñar. Poner crowdsecAppsecEnabled a true es lo que activa el firewall de aplicaciones web:
# traefik dynamic config
http:
middlewares:
crowdsec:
plugin:
bouncer:
enabled: true
crowdsecMode: live
crowdsecAppsecEnabled: true
crowdsecAppsecHost: 172.17.0.1:7422
crowdsecLapiHost: 172.17.0.1:8080
crowdsecLapiKey: YOUR_BOUNCER_KEY
La dirección del host 172.17.0.1 es la puerta de enlace del puente de Docker, cómo un contenedor llega al agente de CrowdSec que corre en el host; ajústala si tu red difiere. Como Coolify gestiona Traefik, estos fragmentos van en la configuración del proxy que Coolify expone en lugar de en un Traefik ejecutado a mano, y luego adjuntas el middleware crowdsec a un servicio mediante sus etiquetas de Traefik en el panel de Coolify. Este es un paso avanzado, y es uno que lo más frecuente es que configuremos y luego operemos para los clientes, pero el resultado merece la pena: cada petición pública pasa ahora por una comprobación de reputación informada por la comunidad y por un verdadero firewall de aplicaciones web antes de llegar a una línea de tu código.
6. Ejecutar cargas de trabajo con Docker
Coolify es, en su núcleo, una cara amable sobre Docker, y Docker es cómo debería ejecutarse la inmensa mayoría de las cargas de trabajo en él. Rara vez escribes la fontanería de contenedores a mano. Apuntas Coolify a un repositorio Git y detecta cómo construir el proyecto (mediante Nixpacks, o tu propio Dockerfile si lo proporcionas), produce una imagen y la ejecuta como un contenedor al que Traefik enruta con TLS automático. Las bases de datos, cachés y otros servicios de apoyo, PostgreSQL, Redis, MySQL y más, son recursos de un clic que Coolify aprovisiona y conecta. Las variables de entorno, los volúmenes persistentes, los chequeos de salud y las tareas programadas son todos asuntos del panel en lugar de arqueología de YAML.
Cuando un servidor no basta, Coolify escala horizontalmente a varios usando Docker Swarm, el propio clustering de Docker, de modo que el mismo modelo, contenedores tras un proxy, se estira a través de un puñado de nodos sin un cambio en cómo piensas sobre ello. Para la gran mayoría de los equipos, un único host bien especificado o un pequeño Swarm no es una concesión de camino hacia algo serio; es la respuesta correcta, y es muchísimo menos que operar que la alternativa.
7. Cuándo Kubernetes y cuándo no
La honestidad importa más que la exageración aquí, así que seremos claros al respecto. Coolify orquesta Docker y Docker Swarm; no orquesta, en su producto estable, Kubernetes de forma nativa. El soporte nativo de Kubernetes se ha discutido y prototipado, pero al momento de escribir esto no es algo sobre lo que apostaríamos la plataforma de producción de un cliente dentro de Coolify.
Esa no es la limitación que parece a primera vista, porque la mayoría de los equipos no necesita Kubernetes. Kubernetes se gana su considerable coste operativo cuando genuinamente requieres planificación multinodo, autoescalado de grano fino y el vasto ecosistema de operadores y controladores que lo presuponen, típicamente a una escala y con un equipo de plataforma a la altura. Por debajo de ese umbral es un impuesto pagado en complejidad por una capacidad que no usas.
Así que nuestra orientación es una decisión, no un valor por defecto. Ejecuta tus cargas de trabajo en Coolify con Docker, y Swarm cuando superes un nodo; eso cubre por completo a la mayoría de las organizaciones. Si de verdad llegas a necesitar Kubernetes, ejecútalo como lo que es, un clúster separado y dedicado, k3s donde la huella deba mantenerse pequeña o una distribución completa donde no, aprovisionado y operado en sus propios términos en lugar de atornillado a la plataforma de conveniencia. La buena noticia es que el patrón de seguridad se traslada sin cambios: el ingress de Kubernetes corre comúnmente también sobre Traefik, y el mismo firewall CrowdSec AppSec lo guarda. No reaprendes seguridad para cambiar de orquestador; reaprendes operaciones, que es exactamente el coste a sopesar.
8. El bucle de desarrollo: Claude Code, GitHub y CI/CD
Una plataforma de despliegue solo merece la pena si llevar el código hasta ella es fácil y seguro. Aquí es donde Coolify deja de ser una herramienta de alojamiento y se convierte en el último eslabón de una cadena que empieza en el teclado, y es la parte de la construcción que cambia cómo trabaja un equipo en el día a día.
El bucle funciona así. Construyes con Claude Code, describiendo lo que quieres y revisando, ejecutando y refinando lo que escribe, la práctica que ha dado en llamarse vibe coding. La parte difícil de esa práctica, como hemos argumentado en otro lugar, no es generar código sino verificarlo, así que el bucle está construido en torno a la verificación. Claude Code hace commit y push a GitHub. El push abre una pull request, y GitHub ejecuta la integración continua contra ella: tus pruebas, tu linter, tu comprobador de tipos y tu build, como una puerta que un cambio debe pasar antes de que se le permita fusionarse. Una puerta mínima son unas pocas líneas:
# .github/workflows/ci.yml
name: ci
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
- run: npm ci
- run: npm test
Exige que esa comprobación pase en tu rama protegida, y ningún cambio no verificado podrá llegar a producción. Ahora Coolify cierra el bucle. Instalas la Coolify GitHub App una sola vez, en las fuentes del panel, y habilitas el despliegue automático para el proyecto. A partir de entonces, una fusión a tu rama de producción dispara un webhook, y Coolify construye el nuevo commit y lo despliega, sin que una persona toque un servidor. Las pull requests pueden obtener sus propios despliegues de vista previa, una URL en vivo por rama, de modo que un cambio se revisa en marcha en lugar de meramente leído. Los secretos viven en las variables de entorno de Coolify, no en el repositorio, y una mala versión es un clic para revertir a la imagen anterior.
El resultado es la cadena de lo mejor de cada clase sobre la que construimos nuestros propios productos, ensamblada a partir de piezas que cada una hace una cosa bien: Claude Code genera, GitHub verifica y cierra la puerta, Coolify despliega y CrowdSec guarda. Ningún proveedor único es dueño de todo ello, cada eslabón es abierto o reemplazable, y lo que produce es un camino de una idea a un servicio probado, en marcha y defendido que un equipo pequeño puede operar con confianza.
9. Operarlo
Una plataforma no está terminada cuando se construye; está terminada cuando se la está ejecutando bien. Coolify se mantiene a sí mismo y a sus despliegues actualizables desde el panel, toma copias de seguridad programadas de sus bases de datos a almacenamiento compatible con S3, envía notificaciones a correo, Slack o la herramienta de chat que ya vigilas, y muestra el uso de recursos del servidor y de sus contenedores. El host fortificado de debajo sigue necesitando que se apliquen sus parches, que se revise su firewall y que se vigilen sus decisiones de CrowdSec. Nada de esto es pesado, pero todo ello es necesario, y es precisamente la responsabilidad continua que un servicio gestionado existe para cargar. Es la parte de la historia de Coolify de la que Nashua más a menudo se hace dueña para un cliente: construimos la plataforma, aseguramos su borde, cableamos la cadena y luego nos quedamos a ejecutarla.
10. Conclusión
Ser dueño de la plataforma sobre la que corre tu software solía significar elegir entre comodidad y control. Coolify pone fin a ese dilema: da a un servidor del que eres dueño la ergonomía de una nube que no lo es. Ponlo en un host Ubuntu LTS fortificado, guárdalo con CrowdSec y el firewall Traefik AppSec, ejecuta tus cargas de trabajo en Docker con la cabeza clara sobre cuándo Kubernetes merece su coste, y cablealo a Claude Code y GitHub, y tendrás un camino soberano, seguro y automatizado de un commit a un servicio en marcha. Por eso Nashua respalda Coolify, y es lo que construimos, aseguramos y operamos para organizaciones que prefieren ser dueñas de su plataforma antes que alquilarla. Sé dueño del hogar de tu software. Habla con nosotros.
Referencias
Coolify (2026). Coolify documentation: installation and core concepts. https://coolify.io/docs
coolLabs (2026). Coolify installation script. https://cdn.coollabs.io/coolify/install.sh
CrowdSec (2026). Application Security (AppSec) WAF QuickStart for Traefik. https://docs.crowdsec.net/docs/appsec/quickstart/traefik
Lerebourg, M. (2026). CrowdSec Bouncer Traefik Plugin. https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
Traefik Labs (2026). Traefik Proxy documentation. https://doc.traefik.io/traefik/
OWASP Foundation (2026). OWASP Coraza Web Application Firewall. https://coraza.io/
OWASP Foundation (2026). OWASP CRS (Core Rule Set). https://coreruleset.org/
Canonical (2026). Ubuntu 24.04 LTS (Noble Numbat) release notes. https://releases.ubuntu.com/24.04/
Center for Internet Security (2026). CIS Ubuntu Linux Benchmark. https://www.cisecurity.org/benchmark/ubuntu_linux
Docker, Inc. (2026). Docker documentation. https://docs.docker.com/
The Kubernetes Authors (2026). Kubernetes documentation. https://kubernetes.io/docs/
GitHub (2026). GitHub Actions documentation. https://docs.github.com/actions
Anthropic (2026). Claude Code documentation. https://code.claude.com/docs
