# Coolify e Claude Code: distribuisci un progetto sul tuo VPS
> Installazione di Coolify, collegamento a GitHub, distribuzione di Next.js, dominio e HTTPS, MCP, requisiti del VPS e risoluzione dei problemi. Prezzi tecnici denominati in dollari e limitazioni originali.
Source: https://ailoot.ai/blog/it/coolify-claude-code-deploy/
Canonical: https://ailoot.ai/blog/it/coolify-claude-code-deploy/
Language: it
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-087
Revision: sha256-eeea1278b1d4effdb5b650770b5eb1cefe03bc457a6843acf9b16b92c1c6cbcc
[Documentazione Ailoot](https://ailoot.ai/docs/) — materiali di riferimento per lavorare con il servizio.
## Limiti della piattaforma e condizioni di pagamento nel 2026
Punto chiave
I piani gratuiti funzionano finché non superi per la prima volta un limite; dopodiché è necessaria una carta internazionale. Heroku ha chiuso il suo piano gratuito a tutti nel 2022 ed è entrato in modalità di mantenimento nel febbraio 2026. Con Coolify self-hosted, il server è tuo: non ci sono tariffe per utente né vincoli con il fornitore.
Uno scenario tipico per chi fa vibe coding nel 2026: crei un MVP in Cursor o Claude Code in una sera, lo sposti in un repository GitHub, apri vercel.com → colleghi il repository → arrivi alla schermata dell'abbonamento → inserisci la carta → ricevi `Transaction declined`.
Non è un bug né un'interruzione temporanea.
Railway, Render, Heroku: è la stessa storia. Heroku ha effettivamente chiuso il suo piano gratuito a tutti nel 2022 e, nel febbraio 2026, il progetto è entrato in modalità di mantenimento: nessuna nuova funzionalità e nessun nuovo contratto Enterprise. Per un utente con una carta non supportata, significa: «la porta è chiusa; aggirala passando da un intermediario che applica una commissione del 20%».
Puoi pagare tramite carte Visa virtuali in Kazakistan o servizi di pagamento aziendali. Ma questo significa +20% sul prezzo, +30 minuti per ogni transazione e il rischio che il tuo account venga bloccato quando il gestore dei pagamenti rileva una discrepanza tra paesi.
L'esempio originale includeva tre tentativi: su Vercel Pro, Railway e Render.
## Che cos'è Coolify e come funziona una piattaforma self-hosted?
Punto chiave
Coolify è una piattaforma PaaS open source e self-hostable, un'alternativa diretta a Heroku, Vercel e Netlify. Si installa con un singolo comando curl su qualsiasi VPS con Ubuntu. Sotto il cofano usa Docker + Traefik per il reverse proxy e Let's Encrypt per HTTPS. Supporta l'integrazione con GitHub, webhook per le distribuzioni automatiche, backup su S3 e oltre 280 servizi installabili con un clic (PostgreSQL, Redis, MinIO). La versione self-hosted è gratuita per sempre e senza limiti. Ha 55.800 stelle su GitHub e una licenza Apache-2.0.
Coolify è un progetto open source realizzato con Laravel + Docker che trasforma qualsiasi VPS vuoto in una piattaforma per distribuire applicazioni. Installa Coolify una volta, poi fai tutto il resto tramite l'interfaccia web: colleghi GitHub, scegli un repository e fai clic su Deploy.
La documentazione ufficiale lo descrive in modo conciso e preciso:
Coolify è un'alternativa open source e self-hostable a Heroku / Netlify / Vercel ecc.
— README di Coolify su GitHub, https://github.com/coollabsio/coolify
Sotto il cofano, Coolify è composto da quattro parti:
1. **Interfaccia web realizzata con Laravel 12 + Livewire 3 + Tailwind v4** — un pannello per gestire le applicazioni.
2. **Docker + Docker Compose** — ogni applicazione viene eseguita in un container, isolato dagli altri.
3. **Reverse proxy (Traefik o Caddy)** — riceve il traffico HTTP/HTTPS in ingresso e lo instrada verso i container.
4. **Integrazione con Let's Encrypt** — emette e rinnova automaticamente i certificati SSL per tutti i domini.
Funzionalità chiave che rendono Coolify paragonabile a Vercel sul piano funzionale:
| Funzionalità | Vercel | Coolify |
|----|----|----|
| Distribuzione automatica al push su git | ✅ | ✅ (tramite webhook GitHub) |
| HTTPS gratuito | ✅ | ✅ (Let's Encrypt) |
| Distribuzioni di anteprima delle PR | ✅ | ✅ (tramite GitHub App) |
| Interfaccia per le variabili d'ambiente | ✅ | ✅ |
| Backup dei database | ❌ (non ha database propri) | ✅ (su storage compatibile con S3) |
| PostgreSQL / Redis / MongoDB | \$20+/mese ciascuno | ✅ Un clic, gratis |
| Attività pianificate (cron) | ❌ | ✅ (sintassi cron) |
| Tariffa per utente | \$20/utente/mese | Nessuna |
| Vincolo con il fornitore | Elevato (Edge Functions, ISR) | Zero (il tuo Docker) |
| CDN globale | ✅ | ❌ (solo il tuo VPS) |
L'unica cosa che Coolify non include di serie è una CDN globale. Questa è la risposta sincera. Se il tuo progetto ha un pubblico globale e vuoi ridurre la latenza per gli utenti negli Stati Uniti e in Europa, metti Cloudflare davanti: è gratuito per i contenuti statici.
Prezzo: **la versione self-hosted è gratuita per sempre**, senza limiti sul numero di applicazioni, server o distribuzioni. Coolify Cloud è disponibile a \$5/mese per 2 server + \$3 per ogni server aggiuntivo, ma i server restano tuoi: Coolify Cloud ospita semplicemente il pannello.
L'ultima versione è **v4.1.0 del 18 maggio 2026**. Le nuove funzionalità includono il build pack Railpack in beta, la registrazione degli audit, le differenze di configurazione tra le distribuzioni e un endpoint MCP nativo (sola lettura). Fonte: [release su GitHub](https://github.com/coollabsio/coolify/releases).
## Quale VPS scegliere per Coolify nel 2026?
Punto chiave
Coolify richiede almeno 2 vCPU, 2 GB di RAM, 30 GB SSD e Ubuntu LTS (20.04, 22.04 o 24.04). Un VPS di questo tipo può eseguire comodamente 3–5 progetti creati con il vibe coding in parallelo.
I requisiti minimi di Coolify provengono direttamente dalla [documentazione ufficiale](https://coolify.io/docs/get-started/installation):
| Parametro | Minimo | Consigliato |
|-------------|----------------------------------|---------------------------|
| CPU | 2 core | 2–4 core |
| RAM | 2 GB | 4 GB (con margine per le build) |
| Storage | 30 GB | 50–80 GB (per immagini + database) |
| Architettura | AMD64 o ARM64 (64 bit) | AMD64 |
| Sistema operativo | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS |
| Root | Necessario | Tramite chiave SSH, non password |
Il minimo — 2 GB di RAM — è un **limite inferiore rigido**. Con 1 GB, il programma di installazione arriva a Docker, incontra un OOM (memoria esaurita) e si blocca. Non risparmiare sulla RAM.
Fonti dei prezzi: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting) e [Selectel](https://selectel.ru/services/cloud/vps-vds/).
Se ti serve più potenza (un database da 100 GB, diverse istanze Postgres), scegli Aeza Dedicated.
Cosa NON scegliere:
- **VPS condiviso con 512 MB–1 GB di RAM** — non basta nemmeno per Coolify. È adatto ai siti statici su nginx, non a una PaaS.
Vuoi non solo configurare la distribuzione, ma anche creare una **configurazione che renda Claude affidabile**? Coolify è uno strumento di esecuzione, ma senza un contesto strutturato ([`CLAUDE.md`](https://ailoot.ai/blog/it/claude-md-template/), un [secondo cervello](https://ailoot.ai/blog/it/claude-code-second-brain/) e la [context engineering](https://ailoot.ai/blog/it/context-engineering/)), Claude continuerà ad avere allucinazioni nelle attività lunghe. La configurazione completa include tutti e tre gli elementi: **clone AI + Second Brain + Context Engineering** — questa combinazione trasforma Claude da «un assistente che ha allucinazioni» in uno strumento affidabile.
## Come installare Coolify in 5 minuti
Punto chiave
L'installazione richiede un solo comando curl dalla documentazione. Quando parte, compare un'interfaccia web sulla porta 8000. Qui crei il primo utente amministratore e visualizzi un pannello vuoto. Il tempo effettivo da un'installazione Ubuntu vuota a Coolify funzionante è 5–7 minuti, di cui 3–4 servono per `apt-get install docker`. Lo script recupera le dipendenze necessarie e configura Docker da solo; devi solo aspettare che finisca.
**Passaggio 1. Connettiti al VPS tramite SSH.**
Dopo aver creato un VPS presso il provider, l'indirizzo IP del server e la password root compariranno in un'email o nel pannello di controllo. Connettiti dal computer locale:
```bash
ssh root@1.2.3.4
```
Se il provider ti ha fornito una chiave SSH invece di una password, connettiti con `-i path/to/key`. Da qui in avanti, presumo che tu abbia una nuova installazione di Ubuntu 22.04 o 24.04 LTS.
**Passaggio 2. Esegui il comando di installazione di Coolify.**
Un comando dalla [documentazione ufficiale](https://coolify.io/docs/get-started/installation):
```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
```
Lo script esegue tre operazioni:
1. Controlla il sistema (Ubuntu LTS? root? AMD64?)
2. Installa Docker e Docker Compose se non sono già installati
3. Scarica le immagini di Coolify (`coolify/coolify`, `coolify/realtime`, `traefik`) e le esegue in background tramite docker-compose
Ci vogliono 3–5 minuti. Vedrai scorrere i log di `apt-get`, seguiti da `docker pull`. Quando appare `Coolify v4.1.0 is now running`, passa al passaggio 3.
**Passaggio 3. Apri l'interfaccia web.**
Apri questo indirizzo nel browser:
```
http://1.2.3.4:8000
```
Coolify mostrerà una procedura guidata di configurazione: un modulo per creare il primo utente. Inserisci un'email e una password, quindi salvale. Questo utente diventa automaticamente amministratore; per ora non ti servono altri utenti.
Dopo aver salvato, arriverai a un pannello vuoto: una barra laterale a sinistra con Resources / Projects / Servers / Sources / Notifications / Settings e, al centro, l'invito «Add your first resource».
**Passaggio 4. Apri le porte nel firewall del provider (non in UFW).**
Coolify è già in esecuzione, ma dall'esterno è accessibile solo la porta 8000 (il pannello). Per consentire agli utenti di raggiungere le applicazioni, devi aprire le porte 80 (HTTP) e 443 (HTTPS):
| Porta | Scopo |
|----|----|
| 22 | Accesso SSH al server |
| 80 | Riceve traffico HTTP, necessario per la convalida di Let's Encrypt |
| 443 | Riceve il traffico HTTPS degli utenti |
| 8000 | Pannello Coolify (la chiuderemo dopo aver configurato un dominio personalizzato per il pannello) |
Una trappola importante segnalata dalla documentazione ufficiale:
Docker usa regole iptables basate su NAT che possono aggirare i firewall Linux tradizionali come UFW.
— Documentazione di Coolify (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Questo significa che, anche se abiliti UFW e chiudi tutte le porte, Docker continuerà a esporre i suoi container tramite iptables. UFW qui è inutile. La soluzione è **aprire e chiudere le porte dal pannello di controllo del provider**, non tramite UFW. Con Timeweb / Selectel / Aeza, lo fai nella sezione «Network → Firewall» della console web.
**Passaggio 5 (facoltativo). Associa il pannello al tuo dominio.**
Per visitare `https://coolify.example.com` invece di `http://1.2.3.4:8000`, crea un record DNS A `coolify.example.com → 1.2.3.4`, vai in **Settings → Instance Settings → Instance Domain** in Coolify, inserisci il sottodominio e salva. Coolify richiederà un certificato Let's Encrypt e, un minuto dopo, ricaricherà il pannello tramite HTTPS.
Dopodiché, puoi chiudere la porta 8000 nel firewall: il pannello sarà disponibile via HTTPS sulla porta standard 443.
## Come collegare GitHub: App o PAT?
Punto chiave
Coolify supporta due modi per collegarsi a GitHub: **GitHub App** (consigliato) e **Personal Access Token (PAT)**. Usa GitHub App: la configurazione richiede 5 minuti con la procedura guidata, le anteprime delle PR funzionano e le autorizzazioni possono essere limitate con precisione a livello di repository. PAT è un'opzione obsoleta per casi legacy; non offre distribuzioni di anteprima e comporta il rischio di accesso globale a tutti i tuoi repository. La documentazione ufficiale lo afferma direttamente: «per il 95% degli utenti, GitHub App è la scelta giusta».
In Coolify, vai su **Sources → + Add → GitHub App**. Coolify mostrerà una procedura guidata in tre schermate:
1. **Nome e descrizione** — assegna un nome alla fonte (inserisci `github-main`) e, facoltativamente, aggiungi una descrizione.
2. **Configura su GitHub** — un pulsante che ti porta su GitHub.com e apre automaticamente un modulo per creare una GitHub App con le autorizzazioni corrette.
3. **Conferma** — dopo essere tornato da GitHub, fai clic su «Save».
Nel secondo passaggio, GitHub ti chiederà di confermare le autorizzazioni richieste da Coolify:
| Autorizzazione | Livello | Scopo |
|-----------------|------------|----------------------------------------------|
| Contents | Sola lettura | Clonare il repository |
| Pull Requests | Lettura e scrittura | Creare distribuzioni di anteprima e commentare le PR |
| Indirizzi email | Sola lettura | Identificare i commit |
| Metadata | Sola lettura | Elencare i repository |
Queste sono **autorizzazioni minime**: GitHub App non può vedere le tue chiavi private, non può scrivere su `main` e non può accedere ai repository che non hai collegato esplicitamente.
Dalla documentazione ufficiale:
Personal Access Token (PAT) è il vecchio metodo; **ti consiglio di non usarlo**. Svantaggi:
- PAT concede accesso globale a tutti i tuoi repository (anche a quelli privati)
- Le anteprime delle PR non funzionano: questa funzionalità è esclusiva di GitHub App
- Il token dura a lungo (90 giorni, un anno o indefinitamente): se viene divulgato, è un problema
Usa PAT solo se lavori con un repository di un'organizzazione in cui le norme di sicurezza vietano GitHub App e non esistono alternative.
Dopo aver salvato la fonte in Coolify, vedrai GitHub App nel pannello con l'elenco dei repository collegati. Quando crei una nuova applicazione, potrai selezionarne uno con un clic.
## Come distribuire un progetto Next.js da Claude Code in 6 passaggi
Punto chiave
Il percorso completo da una configurazione vuota di Claude Code a un sito attivo: 1) esegui `claude` in una cartella vuota, descrivi il progetto e Claude genera il codice; 2) esegui `git init && git remote add` (Claude può farlo da solo tramite un comando slash); 3) invia il codice a GitHub; 4) in Coolify, scegli «+ New Resource → Application» e seleziona il repository; 5) aggiungi le variabili d'ambiente; 6) fai clic su Deploy. Coolify rileverà che si tratta di Next.js, sceglierà il build pack Nixpacks, creerà un'immagine Docker in 3–5 minuti e fornirà un dominio temporaneo con HTTPS già configurato.
**Passaggio 1. Descrivi il progetto a Claude Code in una cartella vuota.**
```bash
mkdir my-vibe-app
cd my-vibe-app
git init
claude
```
Nella sessione:
```
Crea un progetto app router Next.js 14:
- una home page con un elenco di utenti
- l'endpoint /api/users restituisce un array dal database
- Postgres tramite Prisma
- Tailwind per gli stili
- .env.example con DATABASE_URL
- README.md con istruzioni per eseguire il progetto
```
Claude genererà la struttura dei file, package.json, prisma/schema.prisma e .env.example. Chiedi anche:
```
Crea un Dockerfile per le build di produzione e un .dockerignore.
```
È facoltativo: Coolify compilerà con Nixpacks anche senza Dockerfile. Un Dockerfile però ti dà il controllo sul processo ed è più veloce per i progetti più grandi.
**Passaggio 2. Crea un repository GitHub e inviaci il codice.**
Puoi farlo manualmente tramite l'interfaccia di GitHub + `git remote add origin ...`, ma Claude Code può farlo da solo:
```
/commit-push-pr Initial Next.js app generated with Claude Code
```
Oppure dì semplicemente: «Esegui il commit di tutto e invialo a un nuovo repository `my-vibe-app` nel mio account». Claude userà la CLI `gh` per creare un repository privato (o pubblico) ed eseguire il primo push. Fonte: [comando ufficiale di Claude Code](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md).
**Passaggio 3. Crea un'applicazione in Coolify.**
Nel pannello di Coolify, fai clic su **+ New → Application**. Si aprirà un modulo:
1. **Source** — seleziona `github-main` (la GitHub App che hai collegato nel precedente H2)
2. **Repository** — seleziona `my-vibe-app` dall'elenco
3. **Branch** — `main`
4. **Build Pack** — Coolify lo rileverà automaticamente. Se c'è un Dockerfile, userà `dockerfile`. Altrimenti, userà `nixpacks`. Puoi modificarlo manualmente.
5. **Domain** — per ora lascia il valore suggerito; è temporaneo e in seguito lo sostituirai con il tuo
6. **Port** — `3000` per Next.js per impostazione predefinita
Salva.
**Passaggio 4. Aggiungi le variabili d'ambiente.**
Nell'applicazione creata, apri la scheda **Environment Variables**. Aggiungi le variabili una per volta:
```
DATABASE_URL=postgresql://user:pass@db-host:5432/mydb
NODE_ENV=production
ANTHROPIC_API_KEY=sk-ant-...
```
Se non hai un database, creane uno direttamente in Coolify: **+ New → Database → PostgreSQL**. Coolify avvierà un container Postgres in 30 secondi e fornirà un DATABASE_URL interno nel formato `postgresql://postgres@postgres-xyz:5432/postgres`: inseriscilo nella tua applicazione.
Tutte le variabili sono cifrate nel database di Coolify e non vengono mostrate nei log di build.
**Passaggio 5. Fai clic su Deploy.**
Nell'angolo in alto a destra c'è un pulsante blu Deploy. I log in tempo reale appariranno nella scheda Logs:
```
[stage: clone] Cloning ''
[stage: build] Detected Next.js, using Nixpacks
[stage: build] Installing Node 20, npm 10
[stage: build] npm install (245s)
[stage: build] npm run build (87s)
[stage: deploy] Creating container my-vibe-app-xyz
[stage: deploy] Container started, health check passed
[stage: proxy] Traefik routing configured
[stage: ssl] Let's Encrypt cert issued
```
La prima build richiede 3–5 minuti (scarica l'immagine base di Node e installa le dipendenze). Le build successive richiedono 60–90 secondi grazie alla cache dei layer Docker.
Quando lo stato passa a **Running**, copia l’URL applicativo mostrato nel campo **Domains** e apri esattamente quello nel browser. Usalo come `` qui sotto: l’etichetta tra parentesi angolari è un segnaposto, non un indirizzo reale. Dovrebbe apparire la home page, con HTTPS già configurato. Coolify usa un servizio DNS wildcard gratuito per i domini temporanei, così puoi aprire subito il sito senza configurare un DNS tuo.
**Passaggio 6. Verifica che tutto funzioni.**
Apri l’URL copiato nel passaggio precedente aggiungendo `/api/users`, per esempio `/api/users`, senza duplicare la barra. È l’endpoint JSON del passaggio 1; la radice applicativa è la home page. Se compare un errore 500, vedrai lo stack trace nella scheda Logs. Il problema più comune alla prima distribuzione è che DATABASE_URL punti a un database inesistente. Risolvilo creando un'istanza PostgreSQL in Coolify (vedi il passaggio 4) e sostituendo DATABASE_URL.
15 minuti, a partire dal momento in cui ordini il VPS. Nell'esempio originale, questo flusso ha richiesto 12–18 minuti su un server appena installato.
## Come configurare un dominio personalizzato e HTTPS
Punto chiave
Un dominio personalizzato si collega in 3 passaggi: crea un record DNS A che punta all'indirizzo IP del server, inserisci il tuo dominio nella Configuration di Coolify al posto del dominio temporaneo, abilita Automatic HTTPS e fai clic su Redeploy. Let's Encrypt emetterà automaticamente un certificato SSL 2–3 minuti dopo la propagazione DNS (di solito 5–30 minuti). Il requisito essenziale è che il DNS sia già risolto quando fai clic su Redeploy; altrimenti la convalida di Let's Encrypt fallirà e dovrai aspettare 12 minuti prima del tentativo successivo.
**Passaggio 1. Crea un record DNS A nel pannello di controllo del tuo registrar.**
Gli esempi originali usano domini ospitati su Reg.ru, Beget o Timeweb. La procedura è la stessa:
| Tipo di record | Nome | Valore |
|------------|---------------------------|------------------------|
| A | `app` (o `@` per il dominio radice) | `1.2.3.4` (IP del server) |
Salvalo, apri una console e controlla:
```bash
dig app.example.com +short
# Should return 1.2.3.4
```
Se non restituisce nulla o restituisce un IP diverso, il DNS non si è ancora propagato. Attendi 5–30 minuti.
**Passaggio 2. Inserisci il tuo dominio in Coolify.**
Nell'applicazione, apri la scheda **Configuration → General**. Nel campo **Domains**, sostituisci l’URL temporaneo copiato da Coolify con `https://app.example.com`, usando il tuo dominio configurato. Abilita **Automatic HTTPS** (di solito è già abilitato per impostazione predefinita).
Salva e fai clic su **Redeploy**.
**Passaggio 3. Attendi il certificato Let's Encrypt.**
I log di build mostreranno:
```
[stage: ssl] Requesting Let's Encrypt cert for app.example.com
[stage: ssl] HTTP challenge sent to /.well-known/acme-challenge/xxx
[stage: ssl] Validation passed, cert issued
[stage: ssl] Cert installed, HTTPS enabled
```
In 2–3 minuti, il tuo sito sarà disponibile su `https://app.example.com` con un lucchetto verde nella barra degli indirizzi.
Cosa può andare storto con Let's Encrypt (i 3 problemi principali della [guida ufficiale alla risoluzione dei problemi](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)):
1. **La porta 80 è chiusa nel firewall.** Let's Encrypt convalida tramite una richiesta HTTP: invia una richiesta a `http://app.example.com/.well-known/acme-challenge/xxx`. La convalida non riuscirà senza la porta 80. Aprila nel firewall del provider.
2. **Il proxy di Cloudflare è abilitato (nuvola arancione).** Intercetta la richiesta di Let's Encrypt e restituisce una propria pagina segnaposto: la convalida fallisce. La soluzione è passare a «DNS only» (nuvola grigia) o configurare una challenge DNS-01 tramite l'API di Cloudflare.
3. **Il DNS non si è ancora propagato.** Se hai creato un record A 30 secondi fa e hai fatto subito clic su Redeploy, Let's Encrypt non vedrà il tuo dominio. Attendi 5–30 minuti affinché il DNS si propaghi tra i server.
Limite di frequenza di Let's Encrypt: **5 tentativi non riusciti per dominio ogni ora**, con ripristino al ritmo di 1 ogni 12 minuti. Se raggiungi il limite, non fare clic su Redeploy 10 volte di seguito: controlla i log, risolvi il problema e riprova tra 12 minuti.
## Come gestire Coolify con l’agente AI Claude Code tramite MCP? {#come-gestisce-claude-code-coolify-tramite-mcp}
Punto chiave
Tramite il Model Context Protocol, Claude Code ottiene accesso diretto all'API di Coolify: puoi dire «distribuisci questa applicazione» per avviare una build, controllare lo stato, leggere i log o aggiornare le variabili d'ambiente. Ci sono tre opzioni: forsonny/Coolify-MCP-Server (di base, 7 categorie di operazioni), dazeb/coolify-mcp-enhanced (oltre 15 strumenti aggiuntivi con distribuzione di database in un clic) e ajmcclary/Coolify-Manager (una Claude Skill basata sulla CLI ufficiale). A partire da v4.1.0 (18 maggio 2026), Coolify offre un endpoint MCP nativo senza server di terze parti, ma per ora è in sola lettura.
Il Model Context Protocol (MCP) è uno standard di Anthropic che consente a Claude Code di comunicare con sistemi esterni (per maggiori informazioni, consulta la [guida ai server MCP](https://ailoot.ai/blog/it/mcp-servers-claude-code/)). Collega un server MCP e Claude riceverà un insieme di strumenti che può invocare. Per Coolify esistono tre server già pronti, più un'opzione nativa.
**Opzione 1. forsonny/Coolify-MCP-Server-for-Claude-Code — di base.**
Cosa può fare:
- **Applicazioni:** creare, avviare, arrestare, riavviare
- **Servizi:** elencare, creare, avviare/arrestare/riavviare
- **Distribuzioni:** visualizzare quelle in esecuzione, recuperare tramite UUID
- **Team e membri:** elencare, ottenere informazioni
- **Chiavi SSH:** elencare, creare
- **Variabili d'ambiente:** CRUD completo per app e servizi
- **Informazioni sui server:** domini per server, stato, versione
Installazione:
```bash
git clone ''
cd Coolify-MCP-Server-for-Claude-Code
npm install
npm run build
# In .env:
# COOLIFY_BASE_URL=https://coolify.example.com
# COOLIFY_API_TOKEN=[from Coolify Settings → API Tokens]
npm run setup # automatically configures Claude Code
```
Dopodiché, in Claude Code puoi scrivere:
```
Mostrami lo stato dell'applicazione my-vibe-app in Coolify e le 3 distribuzioni più recenti.
```
Claude restituirà una tabella.
**Opzione 2. dazeb/coolify-mcp-enhanced — avanzata (consigliata).**
Cosa aggiunge alla dotazione di base:
- **Distribuzione di PostgreSQL / Redis / MinIO in un clic** tramite AI: chiedi «configura Postgres per me» e crea un container restituendo DATABASE_URL
- **Monitoraggio in tempo reale + utilizzo delle risorse** — CPU/RAM per ogni applicazione in tempo reale
- **Aggiornamenti in blocco della configurazione env** — aggiorna 20 variabili con un comando
- **Supporto a Docker Compose** — distribuisce applicazioni composte da più servizi
Configurazione per Claude Code (`.mcp.json` nella radice del progetto):
```json
{
"mcpServers": {
"coolify-enhanced": {
"command": "node",
"args": ["/path/to/coolify-mcp-enhanced/dist/index.js"],
"env": {
"COOLIFY_ACCESS_TOKEN": "your-token-here",
"COOLIFY_BASE_URL": "https://coolify.example.com"
}
}
}
}
```
**Opzione 3. ajmcclary/Coolify-Manager — una Claude Skill basata sulla CLI.**
Non è un server MCP, ma una Claude Code Skill che avvolge la CLI ufficiale di Coolify. Include:
- Diagnostica dello stato di servizi e container
- Diagnostica dei certificati SSL
- Supporto a più istanze (se hai diversi server Coolify)
- Procedure per la risoluzione dei problemi
Installazione: scarica la skill e inseriscila in `~/.claude/skills/coolify-manager/`. Claude Code la rileverà e la proporrà per le attività pertinenti.
**Opzione 4 (nuova a maggio 2026). MCP nativo in Coolify v4.1.0.**
Il changelog di v4.1.0, datato 18 maggio 2026, dice:
> Aggiunto il supporto MCP a livello di istanza con strumenti di sola lettura per le risorse Coolify e per API/interfaccia utente.
Coolify ora offre un proprio endpoint MCP: puoi collegare Claude Code direttamente senza server di terze parti. Per ora è **in sola lettura** (elenchi di applicazioni, stati, configurazioni), senza operazioni di modifica. Ma basta per la maggior parte delle attività, come «dimmi dell'infrastruttura».
Collegalo tramite `.mcp.json`:
```json
{
"mcpServers": {
"coolify-native": {
"url": "https://coolify.example.com/api/v1/mcp",
"headers": {
"Authorization": "Bearer "
}
}
}
}
```
Attendi il pieno accesso in scrittura nell'MCP nativo in v4.2 o v4.3: il team di Coolify lo ha promesso entro la fine del 2026.
## 5 problemi alla prima distribuzione e come evitarli
Punto chiave
Gli errori più comuni alla prima distribuzione sono RAM insufficiente, porta 80 chiusa, proxy Cloudflare che interrompe Let's Encrypt, UFW che non protegge Docker e scelta di PAT invece di GitHub App. Sono tutti trattati nella documentazione ufficiale, ma senza esperienza pratica è facile incontrarli. Di seguito trovi una lista di controllo in 5 punti basata sull'esperienza originale della prima installazione di Coolify.
**Problema 1: meno di 2 GB di RAM — l'installazione fallisce con OOM.**
Sintomo: `curl install.sh` arriva a `docker pull coolify/coolify`, si blocca al 70%, poi il processo viene terminato con `Killed (signal 9)`. I log di `dmesg | tail` mostrano `Out of memory: Killed process`.
Soluzione:
```bash
# Crea un file swap da 4 GB per risolvere temporaneamente il problema
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```
A lungo termine, passa a 4 GB di RAM. Coolify funziona con lo swap, ma le build di progetti Next.js grandi potrebbero fallire.
**Problema 2: UFW è abilitato, ma Docker continua ad aprire porte.**
Sintomo: hai abilitato UFW e chiuso tutte le porte tranne la 22, ma la tua applicazione è ancora accessibile da Internet su una porta casuale (per esempio 3000).
Il motivo, secondo la [documentazione ufficiale](https://coolify.io/docs/knowledge-base/server/firewall):
Coolify funziona su Docker, che usa regole iptables basate su NAT e può aggirare i firewall Linux tradizionali come UFW.
— Documentazione di Coolify (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Soluzione: usa il **firewall nel pannello di controllo del provider**, non UFW. Timeweb / Selectel / Aeza hanno una sezione «Firewall» o «Network → Firewall» in cui configuri le regole a livello di rete virtuale: vengono applicate prima che i pacchetti raggiungano Docker.
Un'alternativa è ufw-docker, uno script che modifica UFW per renderlo compatibile con Docker. È però più complicato che fare clic nel pannello di controllo.
**Problema 3: il proxy Cloudflare (nuvola arancione) interrompe Let's Encrypt.**
Sintomo: dopo Redeploy, i log mostrano `Let's Encrypt validation failed - challenge returned 403`.
Motivo: Cloudflare inoltra la richiesta HTTP di Let's Encrypt e restituisce una propria pagina anziché il file della challenge.
Soluzione — scegli una delle due opzioni:
1. **Passa a «DNS only»** (la nuvola grigia in Cloudflare). Svantaggio: perdi la CDN e la protezione di Cloudflare.
2. **Configura una challenge DNS-01 tramite l'API di Cloudflare.** In Coolify, vai su Settings → SSL Configuration, seleziona il provider Cloudflare e inserisci un token API con le autorizzazioni Zone:Read e DNS:Edit. Let's Encrypt convaliderà tramite un record TXT invece che HTTP.
La seconda opzione è più complicata da configurare, ma mantiene il proxy Cloudflare.
**Problema 4: PAT invece di GitHub App — le anteprime delle PR non funzionano.**
Sintomo: hai collegato GitHub tramite Personal Access Token; tutto funziona, ma per le PR non vengono create distribuzioni di anteprima. Hai aperto una PR su GitHub, ma in Coolify non è comparso nulla.
Motivo: le anteprime delle PR sono una funzionalità esclusiva di GitHub App. PAT non riceve gli eventi `pull_request` tramite webhook.
Soluzione: ricollega GitHub tramite App. Sources → Add → GitHub App → completa la procedura guidata. Puoi eliminare la vecchia fonte PAT.
**Problema 5: «Coolify == Vercel» non è del tutto vero.**
Cosa **non fa** Coolify di serie:
| Vercel | Coolify | Cosa fare |
|----|----|----|
| CDN globale | No | Metti Cloudflare davanti (gratuito per i contenuti statici) |
| Incremental Static Regeneration | No | `revalidatePath` funziona solo sul tuo server |
| Ottimizzazione delle immagini | No | Usa `next/image` con un loader locale o Cloudflare Images |
| Scalabilità automatica durante i picchi | No | Scala manualmente; passa a un VPS superiore |
| Edge Functions | No | Usa normali route API |
Se il tuo progetto è un SaaS ad alto traffico con un pubblico globale e requisiti di latenza di \< 100 ms nel mondo, Coolify non fa al caso tuo: scegli Vercel Enterprise. Se fai vibe coding con un MVP che stai testando con 100–1,000 utenti al giorno, Coolify copre tutto.
Da un'onesta analisi del self-hosting:
I 15 minuti del titolo di questa guida si riferiscono al percorso senza intoppi per la prima distribuzione di un progetto. Una configurazione completa dell'infrastruttura con monitoraggio, backup e avvisi richiede una o due serate. Sii sincero con te stesso.
## Quanto risparmierai in un anno rispetto a Vercel?
Punto chiave
C'è un «costo nascosto in tempo» di 5–10 ore per la configurazione iniziale e 1–2 ore al mese per la manutenzione.
Le cifre Vercel seguenti sono stime degli scenari di maggio 2026, non preventivi attuali. Sono solo un lato del confronto. Coolify autonomo non ha costo di licenza, ma VPS, backup, storage, traffico e gestione costano. Richiedi un preventivo compatibile con i requisiti: qui non è fornito un prezzo numerico del VPS e quindi non è dimostrabile un risparmio fisso.
Sia **C** la fattura mensile complessiva per VPS scelto, backup, traffico extra, monitoraggio ed eventuale dashboard pagata, contando ogni spesa una volta. Sia **r** il costo orario della gestione nella stessa valuta. La stima dell’articolo è di 5–10 ore iniziali e 1–2 al mese: **17–34 ore nel primo anno** e **12–24 nei successivi**.
| Scenario | Stima Vercel/mese | Vercel/anno | Infrastruttura Coolify/mese | TCO Coolify primo anno, lavoro incluso | Risparmio nel primo anno |
|----|----|----|----|----|----|
| Un prototipo, 100,000 visite/mese | $20 base + ~$5 banda = $25 | $300 | C | 12C + (17–34)r | $300 − 12C − (17–34)r |
| Cinque progetti su un VPS | $20 base + $30 banda/funzioni = $50 | $600 | C | 12C + (17–34)r | $600 − 12C − (17–34)r |
| Tre sviluppatori, cinque progetti | $60 posti + $30 banda = $90 | $1,080 | C | 12C + (17–34)r | $1,080 − 12C − (17–34)r |
Usa un C diverso per scenario se cambiano le dimensioni del server. Ripartendo la configurazione su 12 mesi, l’equivalente mensile del primo anno è **C + (17–34)r/12**. Il TCO successivo è **12C + (12–24)r**. Le formule confrontano la stima Vercel con la gestione autonoma; includi costi operativi comparabili anche per Vercel. Un risparmio negativo significa che l’hosting autonomo costa di più con quei dati. Non contare di nuovo l’intero stipendio dello stesso tecnico se è già incluso in r.
Prima del passaggio ricava C da un preventivo reale e dal piano backup, scegli r e confronta l’utilizzo effettivo per un mese. Senza questi dati, l’articolo offre un modello di costo, non un risparmio in dollari dimostrato.
Il vantaggio principale non sono i soldi. Quando passi a Coolify, **scompare la categoria «dipendente dalle politiche di pagamento altrui»**. Le carte virtuali con una commissione del 20% non servono più.
Coolify non è una versione più economica di Vercel. È una categoria di prodotto diversa: possiedi l'infrastruttura, te ne assumi la responsabilità e risparmi accettandone la complessità.
Se distribuire un prototipo è la prima attività che svolgi dopo la generazione in Claude Code, allora gestire l'ambiente (env, segreti, attività pianificate, backup) fa parte della [**context engineering**](https://ailoot.ai/blog/it/context-engineering/). Senza una struttura che indichi «dove si trova ogni cosa», Claude si perde e tu perdi tempo a ogni modifica. La configurazione completa include: **clone AI** ([Skills](https://ailoot.ai/blog/it/claude-code-skills-library/) e [Subagents](https://ailoot.ai/blog/it/claude-code-subagents/) adattati alla tua metodologia) + [**Second Brain**](https://ailoot.ai/blog/it/claude-code-second-brain/) (la base di conoscenza del progetto) + **Context Engineering** ([Plan Mode](https://ailoot.ai/blog/it/claude-code-plan-mode/), `/compact`, ambiente di esecuzione). Sono i **3 pilastri** senza i quali l'AI ha allucinazioni.
### Fonti
- [Documentazione ufficiale di Coolify: introduzione](https://coolify.io/docs/get-started/introduction)
- [Guida all'installazione di Coolify](https://coolify.io/docs/get-started/installation)
- [Panoramica dei build pack di Coolify](https://coolify.io/docs/applications/build-packs/overview)
- [Knowledge base sul firewall di Coolify](https://coolify.io/docs/knowledge-base/server/firewall)
- [Risoluzione dei problemi di Let's Encrypt in Coolify](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)
- [Prezzi di Coolify](https://coolify.io/pricing)
- [Coolify su GitHub: release v4.1.0](https://github.com/coollabsio/coolify/releases)
- [Panoramica di Claude Code](https://code.claude.com/docs/en/overview)
- [VPS Timeweb Cloud](https://timeweb.cloud/services/vds-vps)
- [VPS FirstVDS](https://firstvds.ru/products/vds_vps_hosting)
- [VPS/VDS Selectel](https://selectel.ru/services/cloud/vps-vds/)
- [Prezzi di Vercel](https://vercel.com/pricing)
Il flusso completo di gestione del contesto: **clone AI + Second Brain + Context Engineering**.
Altri materiali sono disponibili su [Ailoot](https://ailoot.ai/).
## Domande frequenti
### Quale URL deve restituire JSON dopo il deployment?
Copia l’URL applicativo mostrato in Domains da Coolify e apri il percorso /api/users. La radice è la home page; /api/users è l’endpoint JSON definito nel progetto di esempio.
### Come calcolo se l’hosting autonomo fa risparmiare?
Somma in C il costo mensile di VPS, backup, storage, traffico, monitoraggio ed eventuale dashboard. Il TCO del primo anno è 12C più 17–34 ore al tuo costo orario: confrontalo con la stima Vercel annuale, includendo costi operativi comparabili da entrambi i lati.
## Ailoot · L’azienda e il suo portafoglio di progetti
Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.
L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.
Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.