novembre 2026
Coolify in Production
Perché Nashua sostiene Coolify, e come lo costruiamo: un host Ubuntu LTS irrobustito, l'installer di Coolify, CrowdSec con Traefik AppSec, Docker e Kubernetes, e una pipeline Claude Code e GitHub per il CI/CD.
Sommario
Coolify è una piattaforma open-source e self-hosted che trasforma un semplice server Linux in una piattaforma di deployment con la comodità di un cloud gestito e senza alcun lock-in. In Nashua la sosteniamo come il modo per possedere il proprio hosting, e questo è l’articolo per i professionisti che sta dietro a quel sostegno: una costruzione completa e con scelte nette. Partiamo da un host Ubuntu LTS irrobustito, installiamo Coolify e gli mettiamo davanti un vero perimetro di sicurezza con CrowdSec e il web application firewall Traefik AppSec. Mostriamo come i carichi di lavoro girano davvero, Docker per primo, perché è ciò che Coolify orchestra, e Kubernetes con onestà, perché è una decisione diversa. E colleghiamo il ciclo di sviluppo che rende la piattaforma degna di essere avuta: Claude Code per costruire, GitHub per la revisione e l’integrazione continua, e Coolify per il continuous deployment, così che un commit diventi un servizio testato e in esecuzione senza che un essere umano tocchi un server. È un luogo di lavoro sovrano per il proprio software, e Nashua lo costruisce, lo mette in sicurezza e lo gestisce.
Parole chiave: Coolify; PaaS self-hosted; Ubuntu LTS; hardening del server; CrowdSec; Traefik; AppSec; web application firewall; Docker; Docker Swarm; Kubernetes; Claude Code; GitHub; CI/CD; continuous deployment; vibe coding; sovranità digitale; DevOps; infrastructure as a service
1. Introduzione
Oggi un team di sviluppo si trova davanti a una scelta che un tempo era semplice. Puoi affittare una piattaforma gestita, Heroku, Vercel, Render e simili, e ottenere un deploy a ogni push in cambio di una fattura per utente e per servizio che si accumula e di una dipendenza che non controlli. Oppure puoi gestire i tuoi server e accettare di essere ora responsabile del lavoro pesante e indifferenziato che le piattaforme gestite nascondono: provisioning, reverse proxy, certificati TLS, pipeline di build, rollback e tutto il resto. Per anni la prima opzione ha vinto per default, perché la seconda era davvero troppo lavoro.
Quel calcolo è cambiato, e ciò che lo ha cambiato è Coolify. Coolify è una piattaforma open-source e self-hosted che poggia su Docker e dà a un semplice server Linux l’ergonomia di un cloud gestito: colleghi un repository Git e lui costruisce la tua applicazione, la esegue in un container, la mette dietro un reverse proxy, emette e rinnova il suo certificato TLS e la ridistribuisce a ogni push. Fa per il tuo software ciò che Nextcloud fa per i tuoi file e la collaborazione: ti permette di possedere la piattaforma invece di affittarla. È per questo che Nashua lo sostiene, e questo articolo è la costruzione che sta dietro al sostegno.
Questo è un articolo per i professionisti, non una rassegna. È una ricetta end-to-end e con scelte nette per mettere in piedi Coolify nel modo in cui lo gestiremmo per un cliente, ed è deliberatamente concreta. Irrobustiamo un host Ubuntu LTS (Sezione 3), installiamo Coolify e mettiamo in sicurezza il suo piano di controllo (Sezione 4), e gli mettiamo davanti un vero perimetro di sicurezza con CrowdSec e il web application firewall Traefik AppSec (Sezione 5). Siamo lucidi sui carichi di lavoro: Docker è ciò che Coolify orchestra e ciò che la maggior parte dei team dovrebbe usare (Sezione 6), e Kubernetes è una decisione separata e più pesante che trattiamo con onestà anziché come una casella da spuntare (Sezione 7). Infine colleghiamo il ciclo che fa ripagare il tutto: Claude Code, GitHub e continuous deployment (Sezione 8), prima di una parola sul gestirlo (Sezione 9). La Figura 1 mostra la forma del risultato.
2. Perché Nashua sostiene Coolify
La nostra posizione sul luogo di lavoro digitale, esposta altrove, è che un’organizzazione dovrebbe possedere gli strumenti da cui dipende anziché affittarli a tempo indeterminato a condizioni che non stabilisce. Lo stesso argomento vale con piena forza per il luogo in cui gira il tuo software. Una piattaforma applicativa gestita è un padrone di casa comodo, e come ogni padrone di casa possiede l’edificio, fissa l’affitto e può cambiare entrambi.
Coolify risponde a tutto ciò senza rinunciare alla comodità. È open source, concesso in licenza in modo che tu possa leggerlo, eseguirlo ed estenderlo. Gira su hardware che scegli tu, in un paese che scegli tu, sotto una legge che scegli tu, il che ne fa una piattaforma sovrana esattamente nel senso che conta per il GDPR e la NIS2. Il suo costo è il costo di un server e del lavoro per gestirlo bene, non una rendita per utente che cresce con il tuo successo. E non è un giocattolo: gestisce build, deployment, database, TLS, backup e preview su uno o più server, con un’interfaccia web che un team può davvero usare. Per un’organizzazione che già dà valore al possedere i propri dati, possedere la piattaforma su cui viaggia il suo software è la stessa decisione presa due volte. È per questo che lo sosteniamo, ed è per questo che siamo disposti a mettere il nostro nome su una guida per costruirlo.
3. L’host: un server Ubuntu LTS irrobustito
Tutto comincia dal server, e il server comincia da un sistema operativo con supporto a lungo termine. Costruiamo su Ubuntu LTS perché è la piattaforma che Coolify, Docker e l’ecosistema più ampio prendono di mira per primi e supportano più a lungo. Al momento in cui scriviamo, per la produzione installiamo Ubuntu 24.04 LTS: è collaudato ed è supportato con aggiornamenti di sicurezza fino al 2029. Ubuntu 26.04 LTS è disponibile per le nuove installazioni che vogliono l’orizzonte più lungo; lasciamo che una point release si assesti prima di mettere una LTS sotto il carico di produzione di un cliente. Due core, 2 GB di RAM e 10 GB di disco sono il minimo documentato per Coolify; da lì dimensioniamo al rialzo, perché le build sono affamate e il margine costa poco.
Un server appena creato non è un server sicuro. Prima che Coolify lo tocchi, lo portiamo completamente all’ultima versione e installiamo gli strumenti che lo mantengono aggiornato e protetto:
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y ufw fail2ban \
unattended-upgrades
Creiamo poi un utente amministrativo senza privilegi e smettiamo di usare root direttamente:
sudo adduser deploy
sudo usermod -aG sudo deploy
3.1 Blindare SSH
Il passo di hardening più prezioso in assoluto è far dipendere il login remoto da una chiave, non da una password, e negare del tutto all’account root una shell remota. Copia la tua chiave pubblica sul nuovo utente con ssh-copy-id deploy@your-server, verifica di poter accedere con essa, e poi scrivi un drop-in che sbarra le opzioni più deboli:
# /etc/ssh/sshd_config.d/99-hardening.conf
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
Ricarica il daemon con sudo systemctl restart ssh, tenendo aperta la sessione corrente finché una seconda sessione non dimostra che la chiave funziona. Con le password disattivate, la gran parte degli attacchi SSH automatizzati smette semplicemente di contare, e fail2ban gestisce il rumore che resta.
3.2 Un firewall default-deny
L’host dovrebbe accettare solo il traffico indispensabile. Usiamo l’uncomplicated firewall per negare per default tutto il traffico in entrata e poi aprire le tre porte di cui la piattaforma ha bisogno: SSH per noi, e HTTP e HTTPS per le applicazioni che 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
Nota ciò che non apriamo: la porta 8000, dove è in ascolto la dashboard di Coolify. Il piano di controllo non ha nulla da fare sull’internet pubblica, e la Sezione 4 spiega come vi accediamo senza esporlo.
3.3 Applica le patch mentre dormi
Un server aggiornato è un server non vulnerabile all’exploit del mese scorso. Lasciamo che Ubuntu applichi gli aggiornamenti di sicurezza in modo automatico e non presidiato:
sudo dpkg-reconfigure \
-plow unattended-upgrades
Questo, una porta SSH solo-chiave, un firewall default-deny e fail2ban sono la base. Non sono cose esotiche, ed è proprio questo il punto: la maggior parte delle violazioni sfrutta l’assenza dell’ordinario, non la presenza dell’ingegnoso. Per i clienti soggetti a regolamentazione andiamo oltre, verso un benchmark riconosciuto come la baseline CIS Ubuntu, ma i passi qui sopra sono quelli senza cui nessun server dovrebbe partire.
4. Installare Coolify
Con un host irrobustito a posto, Coolify in sé è quasi un anticlimax. Un unico comando, eseguito come utente privilegiato, installa Docker se manca, scarica i servizi di Coolify e li avvia:
curl -fsSL \
https://cdn.coollabs.io/coolify/install.sh \
| sudo bash
Quando termina, la dashboard è in ascolto sulla porta 8000, e Coolify ha anche avviato il proprio reverse proxy. Per default quel proxy è Traefik, il che conta moltissimo per la sezione successiva, perché è l’istanza di Traefik che armeremo con un firewall.
4.1 Metti in sicurezza prima il piano di controllo
Prima di ogni altra cosa, raggiungi la dashboard e crea l’account amministratore, subito, così che nessun altro lo faccia. Poiché non abbiamo aperto la porta 8000 sul firewall, la raggiungiamo tramite un tunnel SSH dalla nostra macchina anziché attraverso internet:
ssh -L 8000:localhost:8000 deploy@your-server
Ora http://localhost:8000 nel tuo browser è la dashboard, che viaggia interamente dentro la sessione SSH cifrata. Crea l’utente admin, poi assegna alla dashboard un proprio dominio e certificato TLS tramite le impostazioni di Coolify, così che l’amministrazione quotidiana usi un vero URL HTTPS protetto dal proxy anziché un tunnel. Il principio è semplice ed è quello che la maggior parte di chi fa self-hosting sbaglia: la cosa che può distribuire tutte le tue altre cose è la superficie più sensibile che gestisci, perciò è l’ultima che esponi e la prima che proteggi.
5. Il perimetro di sicurezza: CrowdSec e Traefik AppSec
Una piattaforma che distribuisce applicazioni web pubbliche ha bisogno di un perimetro di sicurezza, qualcosa tra l’internet aperta e i tuoi container che ispezioni le richieste, blocchi ciò che è palesemente ostile e impari. Poiché Coolify usa Traefik come proxy, possiamo aggiungere esattamente questo senza introdurre un’altra parte in movimento, usando CrowdSec.
CrowdSec è un motore di sicurezza open-source con due metà che qui contano. Legge i log e decide quali sorgenti si comportano in modo malevolo, e condivide quei verdetti con una comunità globale, così che il tuo server benefici degli attacchi visti su quelli di tutti gli altri. E include un componente AppSec: un web application firewall, costruito sul motore Coraza e in grado di eseguire l’OWASP Core Rule Set, che ispeziona il contenuto delle richieste e blocca i tentativi di exploit inline, prima che raggiungano la tua applicazione. Installa l’agent, poi aggiungi le collection di regole 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
Attiva il listener AppSec aggiungendo un file di acquisizione che dice a CrowdSec di servire il firewall sulla porta 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
Poi genera una chiave API che Traefik userà per consultare CrowdSec, e riavvia l’agent:
sudo cscli bouncers add traefik-bouncer
sudo systemctl restart crowdsec
5.1 Armare Traefik
La connessione tra Traefik e CrowdSec è un plugin della comunità, il CrowdSec Bouncer Traefik Plugin, che è la via mantenuta verso il firewall AppSec. Si carica come plugin sperimentale nella configurazione statica di Traefik:
# traefik static config
experimental:
plugins:
bouncer:
moduleName: github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
version: v1.8.2
e diventa un middleware nella configurazione dinamica, puntato a entrambe le metà di CrowdSec: l’API delle decisioni sulla porta 8080 e il firewall AppSec sulla porta 7422, con la chiave che hai appena generato. Impostare crowdsecAppsecEnabled a true è ciò che attiva il web application firewall:
# 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
L’indirizzo host 172.17.0.1 è il gateway del bridge Docker, il modo in cui un container raggiunge l’agent CrowdSec in esecuzione sull’host; modificalo se la tua rete è diversa. Poiché Coolify gestisce Traefik, questi frammenti vanno nella configurazione del proxy che Coolify espone anziché in un Traefik gestito a mano, e poi colleghi il middleware crowdsec a un servizio tramite le sue label Traefik nella dashboard di Coolify. È un passo avanzato, ed è uno di quelli che il più delle volte configuriamo e poi gestiamo per i clienti, ma il risultato ne vale la pena: ogni richiesta pubblica passa ora attraverso un controllo di reputazione informato dalla comunità e un vero web application firewall prima di raggiungere una riga del tuo codice.
6. Eseguire i carichi di lavoro con Docker
Coolify è, nel suo nucleo, un volto amichevole sopra Docker, e Docker è il modo in cui la stragrande maggioranza dei carichi di lavoro dovrebbe girarci. Raramente scrivi a mano l’impianto dei container. Punti Coolify a un repository Git, e lui rileva come costruire il progetto (tramite Nixpacks, o il tuo Dockerfile se ne fornisci uno), produce un’immagine e la esegue come container verso cui Traefik instrada con TLS automatico. Database, cache e altri servizi di supporto, PostgreSQL, Redis, MySQL e altri, sono risorse one-click che Coolify provisiona e collega. Variabili d’ambiente, volumi persistenti, health check e task pianificati sono tutte faccende da dashboard anziché archeologia YAML.
Quando un server non basta, Coolify scala su più nodi usando Docker Swarm, il clustering proprio di Docker, così che lo stesso modello, container dietro un proxy, si estenda su una manciata di nodi senza un cambiamento nel modo in cui lo concepisci. Per la grande maggioranza dei team, un singolo host ben dimensionato o un piccolo Swarm non è un compromesso sulla via di qualcosa di serio; è la risposta giusta, ed è parecchio meno da gestire rispetto all’alternativa.
7. Quando Kubernetes, e quando no
Qui l’onestà conta più dell’hype, perciò lo diciamo chiaramente. Coolify orchestra Docker e Docker Swarm; non orchestra, nel suo prodotto stabile, Kubernetes in modo nativo. Il supporto nativo a Kubernetes è stato discusso e prototipato, ma al momento in cui scriviamo non è qualcosa su cui scommetteremmo la piattaforma di produzione di un cliente dentro Coolify.
Non è il limite che sembra a prima vista, perché la maggior parte dei team non ha bisogno di Kubernetes. Kubernetes si guadagna il suo considerevole costo operativo quando hai davvero bisogno di scheduling multi-nodo, autoscaling a grana fine e del vasto ecosistema di operator e controller che lo presuppongono, tipicamente a una scala e con un platform team all’altezza. Sotto quella soglia è una tassa pagata in complessità per una capacità che non usi.
Perciò la nostra indicazione è una decisione, non un default. Esegui i tuoi carichi di lavoro su Coolify con Docker, e con Swarm quando superi un singolo nodo; questo copre completamente la maggior parte delle organizzazioni. Se e quando hai davvero bisogno di Kubernetes, eseguilo per ciò che è, un cluster separato e dedicato, k3s dove l’impronta deve restare piccola o una distribuzione completa dove non deve, provisionato e gestito a condizioni proprie anziché avvitato sopra la piattaforma della comodità. La buona notizia è che il pattern di sicurezza si trasferisce invariato: anche l’ingress di Kubernetes gira comunemente su Traefik, e lo stesso firewall CrowdSec AppSec lo presidia. Non reimpari la sicurezza per cambiare orchestratore; reimpari le operations, che è esattamente il costo da soppesare.
8. Il ciclo di sviluppo: Claude Code, GitHub e CI/CD
Una piattaforma di deployment vale la pena di essere avuta solo se portarci il codice è semplice e sicuro. È qui che Coolify smette di essere uno strumento di hosting e diventa l’ultimo anello di una catena che comincia dalla tastiera, ed è la parte della costruzione che cambia il modo in cui un team lavora giorno per giorno.
Il ciclo funziona così. Costruisci con Claude Code, descrivendo ciò che vuoi e rivedendo, eseguendo e affinando ciò che scrive, la pratica che si è arrivati a chiamare vibe coding. La parte difficile di questa pratica, come abbiamo sostenuto altrove, non è generare il codice ma verificarlo, perciò il ciclo è costruito attorno alla verifica. Claude Code fa commit e push su GitHub. Il push apre una pull request, e GitHub vi esegue contro l’integrazione continua: i tuoi test, il tuo linter, il tuo type checker e la tua build, come un gate che una modifica deve superare prima che le sia consentito il merge. Un gate minimo è poche righe:
# .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
Richiedi che quel controllo passi sul tuo branch protetto, e nessuna modifica non verificata potrà raggiungere la produzione. Ora Coolify chiude il ciclo. Installi la Coolify GitHub App una volta sola, sotto le sources della dashboard, e abiliti il deployment automatico per il progetto. Da quel momento, un merge sul tuo branch di produzione fa scattare un webhook, e Coolify costruisce il nuovo commit e lo distribuisce, senza che un essere umano tocchi un server. Le pull request possono ottenere i propri preview deployment, un URL attivo per branch, così che una modifica venga rivista in esecuzione anziché soltanto letta. I segreti vivono nelle variabili d’ambiente di Coolify, non nel repository, e un rilascio difettoso è un clic per tornare all’immagine precedente.
Il risultato è la catena best-of-breed su cui costruiamo i nostri stessi prodotti, assemblata da parti che fanno ciascuna bene una cosa: Claude Code genera, GitHub verifica e fa da gate, Coolify distribuisce e CrowdSec presidia. Nessun singolo vendor ne possiede l’interezza, ogni anello è aperto o sostituibile, e ciò che produce è un percorso da un’idea a un servizio testato, in esecuzione e difeso che un piccolo team può gestire con fiducia.
9. Gestirlo
Una piattaforma non è finita quando è costruita; è finita quando viene gestita bene. Coolify mantiene aggiornabili se stesso e i suoi deployment dalla dashboard, esegue backup pianificati dei suoi database su storage compatibile con S3, invia notifiche a email, Slack o allo strumento di chat che già tieni d’occhio, e mostra l’uso delle risorse del server e dei suoi container. L’host irrobustito sottostante ha comunque bisogno che gli si applichino le patch, che se ne riveda il firewall e che se ne osservino le decisioni di CrowdSec. Nulla di tutto ciò è gravoso, ma tutto è necessario, ed è precisamente la responsabilità continuativa che un servizio gestito esiste per farsi carico. È la parte della storia di Coolify di cui Nashua più spesso si fa carico per un cliente: costruiamo la piattaforma, mettiamo in sicurezza il suo perimetro, colleghiamo la pipeline e poi restiamo a gestirla.
10. Conclusione
Possedere la piattaforma su cui gira il tuo software significava un tempo scegliere tra comodità e controllo. Coolify mette fine a questo compromesso: dà a un server che possiedi l’ergonomia di un cloud che non possiedi. Mettilo su un host Ubuntu LTS irrobustito, difendilo con CrowdSec e il firewall Traefik AppSec, esegui i tuoi carichi di lavoro su Docker con la testa lucida su quando Kubernetes vale il suo costo, e collegalo a Claude Code e GitHub, e avrai un percorso sovrano, sicuro e automatizzato da un commit a un servizio in esecuzione. È per questo che Nashua sostiene Coolify, ed è ciò che costruiamo, mettiamo in sicurezza e gestiamo per le organizzazioni che preferiscono possedere la propria piattaforma anziché affittarla. Possiedi la casa del tuo software. Parla con noi.
Bibliografia
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
