# Coolify és Claude Code: projekt telepítése a saját VPS-edre
> A Coolify telepítése, a GitHub csatlakoztatása, Next.js-deploy, domain és HTTPS, MCP, VPS-követelmények és hibaelhárítás. Dollárban megadott technikai árak és az eredeti korlátozások.
Source: https://ailoot.ai/blog/hu/coolify-claude-code-deploy/
Canonical: https://ailoot.ai/blog/hu/coolify-claude-code-deploy/
Language: hu
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-087
Revision: sha256-ef96770c1c304b71f5c31da8e79b39d25b038efc06cd20666b083919fee65337
[Ailoot-dokumentáció](https://ailoot.ai/docs/) — referenciaanyagok a szolgáltatás használatához.
## Platformkorlátozások és fizetési feltételek 2026-ban
Fő tanulság
Az ingyenes csomag addig használható, amíg először túl nem léped valamelyik korlátot; ezután nemzetközi bankkártyára van szükség. A Heroku 2022-ben mindenki számára megszüntette az ingyenes csomagját, és 2026 februárjában fenntartási üzemmódba lépett. Saját üzemeltetésű Coolify esetén a szerver a tiéd; nincs felhasználónkénti díj és nincs szolgáltatói kötöttség.
Egy tipikus 2026-os vibe-coder-forgatókönyv: egy este alatt elkészíted az MVP-t Cursorban vagy Claude Code-ban, áthelyezed egy GitHub-repozitóriumba, megnyitod a vercel.com oldalt → csatlakoztatod a repót → eléred az előfizetési képernyőt → megadod a bankkártyádat → megkapod a `Transaction declined` üzenetet.
Ez nem hiba vagy átmeneti szolgáltatáskiesés.
Railway, Render, Heroku — ugyanaz a történet. A Heroku ténylegesen 2022-ben mindenki számára megszüntette az ingyenes csomagját, 2026 februárjában pedig a projekt fenntartási üzemmódba lépett — nem érkeznek új funkciók, és új Enterprise-szerződéseket sem kötnek. Egy nem támogatott bankkártyával rendelkező felhasználó számára ez azt jelenti: „bezárult az ajtó; kerülj egy közvetítőn keresztül, amely 20% jutalékot számít fel.”
Fizethetsz kazahsztáni virtuális Visa-kártyákkal vagy vállalati fizetési szolgáltatásokkal. Ez azonban 20%-kal magasabb árat, minden tranzakciónál további 30 percet, valamint annak kockázatát jelenti, hogy a fizetési szolgáltató országeltérést észlel, és letiltja a fiókodat.
Az eredeti példa három próbálkozást mutatott be — a Vercel Pro, a Railway és a Render használatával.
## Mi az a Coolify, és hogyan működik egy saját üzemeltetésű platform?
Fő tanulság
A Coolify nyílt forráskódú, saját üzemeltetésű PaaS, amely közvetlen alternatívát kínál a Heroku, a Vercel és a Netlify helyett. Egyetlen curl-paranccsal telepíthető bármilyen Ubuntu rendszert futtató VPS-re. A motorháztető alatt Docker + Traefik szolgál fordított proxyként, a HTTPS-t pedig a Let's Encrypt biztosítja. Támogatja a GitHub-integrációt, az automatikus telepítést végző webhookokat, az S3-as biztonsági mentéseket és több mint 280, egy kattintással telepíthető szolgáltatást (PostgreSQL, Redis, MinIO). A saját üzemeltetésű verzió örökre ingyenes, korlátozások nélkül. A GitHubon 55,800 csillaga van, licencelése Apache-2.0.
A Coolify egy Laravel + Docker használatával készült nyílt forráskódú projekt, amely bármilyen üres VPS-t alkalmazástelepítési platformmá alakít. Telepítsd egyszer a Coolifyt, majd mindent mást a webes felületen végezz: csatlakoztasd a GitHubot, válassz egy repót, és kattints a Deploy gombra.
A hivatalos dokumentáció röviden és pontosan fogalmaz:
A Coolify nyílt forráskódú és saját üzemeltetésű alternatívája a Herokunak / Netlify-nak / Vercelnek stb.
— Coolify GitHub README, https://github.com/coollabsio/coolify
A motorháztető alatt a Coolify négy részből áll:
1. **Laravel 12 + Livewire 3 + Tailwind v4 alapú webes felület** — irányítópult az alkalmazások kezelésére.
2. **Docker + Docker Compose** — minden alkalmazás saját, a többitől elkülönített konténerben fut.
3. **Fordított proxy (Traefik vagy Caddy)** — fogadja a bejövő HTTP/HTTPS-forgalmat, és a konténerekhez irányítja.
4. **Let's Encrypt-integráció** — automatikusan kiállítja és megújítja az SSL-tanúsítványokat minden domainhez.
A Coolifyt funkcionálisan a Vercellel összehasonlíthatóvá tevő főbb jellemzők:
| Funkció | Vercel | Coolify |
|----|----|----|
| Automatikus telepítés git push esetén | ✅ | ✅ (GitHub-webhookon keresztül) |
| Ingyenes HTTPS | ✅ | ✅ (Let's Encrypt) |
| PR-előnézeti telepítések | ✅ | ✅ (GitHub Appon keresztül) |
| Környezeti változók kezelőfelülete | ✅ | ✅ |
| Adatbázis-mentések | ❌ (nincsenek saját adatbázisai) | ✅ (S3-kompatibilis tárhelyre) |
| PostgreSQL / Redis / MongoDB | \$20+/hó adatbázisonként | ✅ Egy kattintás, ingyenes |
| Ütemezett feladatok (cron) | ❌ | ✅ (cron-szintaxis) |
| Felhasználónkénti díj | \$20/felhasználó/hó | Nincs |
| Szolgáltatói kötöttség | Magas (Edge Functions, ISR) | Nulla (a saját Dockered) |
| Globális CDN | ✅ | ❌ (csak a saját VPS-ed) |
A globális CDN az egyetlen, amit a Coolify alapból nem tartalmaz. Ez az őszinte válasz. Ha a projektednek globális közönsége van, és csökkenteni szeretnéd az USA-ban és Európában élő felhasználók késleltetését, tegyél elé Cloudflare-t; statikus tartalomhoz ingyenes.
Ár: **a saját üzemeltetésű verzió örökre ingyenes**, az alkalmazások, szerverek és telepítések számának korlátozása nélkül. A Coolify Cloud havi \$5-ért érhető el 2 szerverhez, és minden további szerver \$3-ba kerül — maguk a szerverek azonban továbbra is a tieid; a Coolify Cloud csupán az irányítópultot üzemelteti.
A legújabb kiadás a **v4.1.0, 2026. május 18-i dátummal**. Az újdonságok közé tartozik a béta állapotú Railpack build pack, az auditnaplózás, a telepítések közötti konfiguráció-eltérések megjelenítése, valamint egy natív MCP-végpont (csak olvasási hozzáféréssel). Forrás: [GitHub-kiadások](https://github.com/coollabsio/coolify/releases).
## Milyen VPS-t válassz a Coolifyhoz 2026-ban?
Fő tanulság
A Coolify minimum 2 vCPU-t, 2 GB RAM-ot, 30 GB SSD-t és Ubuntu LTS-t igényel (20.04, 22.04 vagy 24.04). Egy ilyen VPS kényelmesen képes egyszerre 3–5 vibe-kódolt projektet futtatni.
A Coolify minimális követelményei közvetlenül a [hivatalos dokumentációból](https://coolify.io/docs/get-started/installation) származnak:
| Paraméter | Minimum | Ajánlott |
|-------------|----------------------------------|---------------------------|
| CPU | 2 mag | 2–4 mag |
| RAM | 2 GB | 4 GB (buildelési tartalékkal) |
| Tárhely | 30 GB | 50–80 GB (image-ekhez + adatbázisokhoz) |
| Architektúra | AMD64 vagy ARM64 (64 bites) | AMD64 |
| Operációs rendszer | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS |
| Root | Kötelező | SSH-kulccsal, nem jelszóval |
A minimum 2 GB RAM **abszolút alsó határ**. 1 GB-tal a telepítő eljut a Dockerig, memóriából kifogyó hibába (OOM) ütközik, majd lefagy. Ne spórolj a RAM-on.
Árforrások: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting), [Selectel](https://selectel.ru/services/cloud/vps-vds/).
Ha nagyobb teljesítményre van szükséged (100 GB-os adatbázis, több Postgres-példány), válaszd az Aeza Dedicatedet.
Amit NE válassz:
- **Megosztott VPS 512 MB–1 GB RAM-mal** — még a Coolifyhoz sem elég. Ez nginxes statikus webhelyekhez való, nem PaaS-hoz.
Nemcsak a telepítést szeretnéd beállítani, hanem **megbízhatóvá is tennéd Claude működését**? A Coolify végrehajtóeszköz, de strukturált kontextus ([`CLAUDE.md`](https://ailoot.ai/blog/hu/claude-md-template/), egy [második agy](https://ailoot.ai/blog/hu/claude-code-second-brain/) és [kontextustervezés](https://ailoot.ai/blog/hu/context-engineering/)) nélkül Claude továbbra is hallucinálni fog a hosszú feladatok során. A teljes összeállítás mindhármat tartalmazza: **AI-klón + Második Agy + Kontextustervezés** — ez a kombináció alakítja Claude-ot „hallucináló asszisztensből” megbízható eszközzé.
## A Coolify telepítése 5 perc alatt
Fő tanulság
A telepítéshez egyetlen, a dokumentációból vett curl-parancs szükséges. Az indítás után megjelenik a webes felület a 8000-es porton. Itt létrehozhatod az első adminfelhasználót, és egy üres irányítópult fogad. Egy üres Ubuntu-telepítéstől a futó Coolifyig ténylegesen 5–7 perc telik el, ebből 3–4 percet az `apt-get install docker` vesz igénybe. A szkript beszerzi a szükséges függőségeket, és maga konfigurálja a Dockert; neked csak meg kell várnod, amíg végez.
**1. lépés: Csatlakozz a VPS-hez SSH-n keresztül.**
Miután létrehoztad a VPS-t a szolgáltatónál, a szerver IP-címe és a root jelszó e-mailben vagy a vezérlőpulton jelenik meg. Csatlakozz a saját gépedről:
```bash
ssh root@1.2.3.4
```
Ha a szolgáltató jelszó helyett SSH-kulcsot adott, a `-i path/to/key` használatával csatlakozz. A továbbiakban abból indulunk ki, hogy egy friss Ubuntu 22.04 vagy 24.04 LTS-telepítést használsz.
**2. lépés: Futtasd a Coolify telepítőparancsát.**
Egyetlen parancs a [hivatalos dokumentációból](https://coolify.io/docs/get-started/installation):
```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
```
A szkript három dolgot végez:
1. Ellenőrzi a rendszert (Ubuntu LTS? root? AMD64?)
2. Telepíti a Dockert és a Docker Compose-t, ha még nincsenek telepítve
3. Letölti a Coolify image-eit (`coolify/coolify`, `coolify/realtime`, `traefik`), majd docker-compose segítségével a háttérben futtatja őket
Ez 3–5 percet vesz igénybe. Látni fogod az `apt-get` naplóit, majd a `docker pull` folyamatot. Amikor megjelenik a `Coolify v4.1.0 is now running` üzenet, lépj tovább a 3. lépésre.
**3. lépés: Nyisd meg a webes felületet.**
Nyisd meg ezt a böngésződben:
```
http://1.2.3.4:8000
```
A Coolify beállítóvarázslót jelenít meg — egy űrlapot az első felhasználó létrehozásához. Add meg az e-mail-címedet és a jelszavadat, majd mentsd el. Ez a felhasználó automatikusan adminisztrátori jogosultságot kap; egyelőre nincs szükséged más felhasználókra.
Mentés után egy üres irányítópultra jutsz: bal oldalt egy oldalsávval, benne a Resources / Projects / Servers / Sources / Notifications / Settings menüpontokkal, középen pedig az „Add your first resource” felszólítással.
**4. lépés: Nyisd meg a portokat a szolgáltató tűzfalán (ne az UFW-ben).**
A Coolify már fut, de kívülről csak a 8000-es port (az irányítópult) érhető el. Ahhoz, hogy a felhasználók elérjék az alkalmazásaidat, nyisd meg a 80-as (HTTP) és a 443-as (HTTPS) portot:
| Port | Rendeltetés |
|----|----|
| 22 | SSH-hozzáférés a szerverhez |
| 80 | HTTP-forgalom fogadása, a Let's Encrypt-ellenőrzéshez szükséges |
| 443 | A felhasználók HTTPS-forgalmának fogadása |
| 8000 | Coolify-irányítópult (a saját domain beállítása után lezárjuk ezt a portot) |
A hivatalos dokumentáció fontos buktatóra hívja fel a figyelmet:
A Docker NAT-alapú iptables-szabályokat használ, amelyek megkerülhetik a hagyományos Linux-tűzfalakat, például az UFW-t.
— Coolify-dokumentáció (tűzfal), https://coolify.io/docs/knowledge-base/server/firewall
Ez azt jelenti, hogy az UFW engedélyezése és az összes port lezárása esetén is a Docker továbbra is elérhetővé teszi a konténereit az iptablesen keresztül. Az UFW itt haszontalan. A megoldás az, hogy **a portokat a szolgáltató vezérlőpultján nyisd meg és zárd le**, ne az UFW-n keresztül. A Timeweb / Selectel / Aeza esetében ezt a webes konzol „Network → Firewall” részében teheted meg.
**5. lépés (opcionális): Rendeld a vezérlőpultot a domainedhez.**
Ha a `http://1.2.3.4:8000` helyett a `https://coolify.example.com` címen szeretnéd elérni, hozz létre egy `coolify.example.com → 1.2.3.4` DNS A rekordot, a Coolifyban lépj a **Settings → Instance Settings → Instance Domain** menüpontra, add meg az aldomainedet, majd mentsd el. A Coolify Let's Encrypt-tanúsítványt kér, és egy perccel később HTTPS-en tölti újra az irányítópultot.
Ezután lezárhatod a 8000-es portot a tűzfalon — az irányítópult a szabványos 443-as porton, HTTPS-en lesz elérhető.
## A GitHub csatlakoztatása: App vagy PAT?
Fő tanulság
A Coolify két módon támogatja a GitHubhoz csatlakozást: **GitHub App** (ajánlott) és **Personal Access Token (PAT)**. Használd a GitHub Appot: a varázslóval a beállítása 5 percet vesz igénybe, működnek a PR-előnézetek, és a jogosultságok pontosan, repószinten korlátozhatók. A PAT elavult megoldás régi esetekhez; nem támogat előnézeti telepítéseket, és az összes repódhoz globális hozzáférést biztosíthat. A hivatalos dokumentáció egyenesen kimondja: „a felhasználók 95%-ának a GitHub App a megfelelő választás.”
A Coolifyban lépj a **Sources → + Add → GitHub App** menüpontra. A Coolify egy háromképernyős varázslót jelenít meg:
1. **Name & description** — nevezd el a forrást (írd be, hogy `github-main`), és igény szerint adj hozzá leírást.
2. **Configure on GitHub** — a gomb a GitHub.com oldalára visz, és automatikusan megnyitja a megfelelő jogosultságokkal rendelkező GitHub App létrehozására szolgáló űrlapot.
3. **Confirm** — miután visszatértél a GitHubról, kattints a „Save” gombra.
A második lépésben a GitHub megkér, hogy erősítsd meg a Coolify által kért jogosultságokat:
| Jogosultság | Szint | Cél |
|-----------------|------------|----------------------------------------------|
| Contents | Csak olvasás | A repó klónozása |
| Pull Requests | Olvasás és írás | Előnézeti telepítések létrehozása és megjegyzések hozzáadása a PR-ekhez |
| Email addresses | Csak olvasás | Commitok azonosítása |
| Metadata | Csak olvasás | Repók listázása |
Ezek **minimális jogosultságok** — a GitHub App nem láthatja a privát kulcsaidat, nem írhat a `main` ágra, és nem férhet hozzá azokhoz a repókhoz, amelyeket nem csatlakoztattál kifejezetten.
A hivatalos dokumentációból:
A Personal Access Token (PAT) a régi módszer; **nem ajánlom a használatát**. Hátrányai:
- A PAT az összes repódhoz hozzáférést biztosít (beleértve a privát repókat is)
- A PR-előnézetek nem működnek — ez a funkció kizárólag a GitHub Appban érhető el
- A token sokáig érvényes (90 napig, egy évig vagy korlátlan ideig) — ha kiszivárog, az komoly baj
Csak akkor használj PAT-ot, ha olyan szervezeti repóval dolgozol, amelynek biztonsági szabályzata tiltja a GitHub Appokat, és nincs más megoldás.
Miután elmentetted a forrást a Coolifyban, az irányítópulton megjelenik a GitHub App és a csatlakoztatott repók listája. Új alkalmazás létrehozásakor bármelyiket kiválaszthatod egyetlen kattintással.
## Next.js-projekt telepítése Claude Code-ból 6 lépésben
Fő tanulság
A teljes folyamat az üres Claude Code-beállítástól az élő webhelyig: 1) futtasd a `claude` parancsot egy üres mappában, írd le a projektet, Claude pedig létrehozza a kódot; 2) futtasd a `git init && git remote add` parancsot (Claude ezt maga is megteheti egy perjeles paranccsal); 3) pushold a GitHubra; 4) válaszd a Coolifyban a „+ New Resource → Application” lehetőséget, majd a repót; 5) add meg a környezeti változókat; 6) kattints a Deploy gombra. A Coolify felismeri a Next.js-t, kiválasztja a Nixpacks build packet, 3–5 perc alatt Docker-image-et készít, és HTTPS-t alapértelmezetten biztosító, ideiglenes, `xxx` formátumú domaint ad.
**1. lépés: Írd le a projektet Claude Code-nak egy üres mappában.**
```bash
mkdir my-vibe-app
cd my-vibe-app
git init
claude
```
A munkamenetben:
```
Build a Next.js 14 app router project:
- a home page with a list of users
- /api/users endpoint returns an array from the database
- Postgres via Prisma
- Tailwind for styles
- .env.example with DATABASE_URL
- README.md with instructions for running the project
```
Claude létrehozza a fájlstruktúrát, a package.json fájlt, a prisma/schema.prisma fájlt és az .env.example fájlt. Kérd meg erre is:
```
Create a Dockerfile for production builds and a .dockerignore.
```
Ez opcionális — a Coolify Dockerfile nélkül is Nixpacks segítségével buildel. A Dockerfile azonban irányítást biztosít a folyamat felett, és nagyobb projekteknél gyorsabb.
**2. lépés: Hozz létre egy GitHub-repót, majd pushold oda a projektet.**
Ezt manuálisan is elvégezheted a GitHub UI + `git remote add origin ...` használatával, de Claude Code is meg tudja csinálni:
```
/commit-push-pr Initial Next.js app generated with Claude Code
```
Vagy egyszerűen mondd ezt: „Commit everything and push it to a new repository `my-vibe-app` under my account.” Claude a `gh` CLI-vel privát (vagy nyilvános) repót hoz létre, és elvégzi az első push-t. Forrás: [hivatalos Claude Code-parancs](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md).
**3. lépés: Hozz létre egy Applicationt a Coolifyban.**
A Coolify irányítópultján kattints a **+ New → Application** lehetőségre. Megnyílik egy űrlap:
1. **Source** — válaszd a `github-main` elemet (az előző H2-ben csatlakoztatott GitHub Appot)
2. **Repository** — válaszd ki a `my-vibe-app` repót a listából
3. **Branch** — `main`
4. **Build Pack** — a Coolify automatikusan felismeri. Ha van Dockerfile, a `dockerfile` értéket használja. Ellenkező esetben a `nixpacks` értéket használja. Ezt manuálisan felülírhatod.
5. **Domain** — egyelőre hagyd meg a javasolt értéket (`xxx`); ideiglenes, később lecseréled a sajátodra
6. **Port** — Next.js esetén alapértelmezés szerint `3000`
Mentsd el.
**4. lépés: Add meg a környezeti változókat.**
A létrehozott alkalmazásban nyisd meg az **Environment Variables** lapot. Egyenként add hozzá a változókat:
```
DATABASE_URL=postgresql://user:pass@db-host:5432/mydb
NODE_ENV=production
ANTHROPIC_API_KEY=sk-ant-...
```
Ha nincs adatbázisod, hozz létre egyet közvetlenül a Coolifyban: **+ New → Database → PostgreSQL**. A Coolify 30 másodperc alatt elindít egy Postgres-konténert, és megad egy belső DATABASE_URL-t `postgresql://postgres:pass@postgres-xyz:5432/postgres` formában — ezt add meg az alkalmazásnak.
Minden változót titkosít a Coolify-adatbázis, és nem jeleníti meg a buildnaplókban.
**5. lépés: Kattints a Deploy gombra.**
A jobb felső sarokban egy kék Deploy gomb látható. Az élő naplók a Logs lapon jelennek meg:
```
[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 for xxx
[stage: ssl] Let's Encrypt cert issued for xxx
```
Az első build 3–5 percet vesz igénybe (letölti az alap Node-image-et és telepíti a függőségeket). A későbbi buildelések 60–90 másodpercig tartanak a Docker-rétegek gyorsítótárazásának köszönhetően.
Amikor az állapot **Running** értékre vált, másold a Coolify **Domains** mezőjében látható alkalmazás-URL-t, és pontosan azt nyisd meg böngészőben. Alább ez az érték legyen az ``; a szögletes zárójelezés helyőrző, nem valódi cím. Meg kell jelennie a kezdőlapodnak, alapértelmezett HTTPS-szel. Egy ingyenes wildcard DNS-szolgáltatás minden IP-címet tartalmazó aldomaint felold (`1-2-3-4` → `1.2.3.4`). A Coolify ideiglenes domainekhez használja, hogy saját DNS konfigurálása nélkül azonnal megnyithasd a webhelyet.
**6. lépés: Ellenőrizd, hogy minden működik-e.**
Az előző lépés alkalmazás-URL-jét a `/api/users` útvonallal nyisd meg, például `/api/users`, a perjel megkettőzése nélkül. Ez az 1. lépésben létrehozott JSON-végpont; az alkalmazás gyökér-URL-je a kezdőlap. Ha 500-as hiba jelenik meg, a stack trace a Logs lapon látható. Az első telepítés leggyakoribb problémája, hogy a DATABASE_URL nem létező adatbázisra mutat. Javítsd úgy, hogy létrehozol egy PostgreSQL-példányt a Coolifyban (lásd a fenti 4. lépést), majd lecseréled a DATABASE_URL értékét.
15 perc, a VPS megrendelésének pillanatától számítva. Az eredeti példában ez a folyamat friss szerveren 12–18 percet vett igénybe.
## Saját domain és HTTPS beállítása
Fő tanulság
Egy saját domain 3 lépésben kapcsolható össze: hozz létre egy DNS A rekordot, amely a szerver IP-címére mutat, a Coolify konfigurációjában a wildcard DNS helyett add meg a domainedet, engedélyezd az Automatic HTTPS-t, majd kattints a Redeploy gombra. A Let's Encrypt automatikusan SSL-tanúsítványt állít ki 2–3 perccel a DNS-propagáció után (ami általában 5–30 perc). A legfontosabb követelmény, hogy a DNS már a Redeploy gombra kattintáskor feloldódjon; máskülönben a Let's Encrypt ellenőrzése sikertelen lesz, és a következő próbálkozásig 12 percet kell várnod.
**1. lépés: Hozz létre egy DNS A rekordot a regisztrátor vezérlőpultján.**
Az eredeti példák Reg.ru, Beget vagy Timeweb tárhelyen lévő domaineket használnak. A folyamat ugyanaz:
| Rekordtípus | Név | Érték |
|------------|---------------------------|------------------------|
| A | `app` (vagy `@` a gyökérdomainhez) | `1.2.3.4` (szerver IP-címe) |
Mentsd el, nyiss meg egy konzolt, és ellenőrizd:
```bash
dig app.example.com +short
# A várt eredmény: 1.2.3.4
```
Ha semmit vagy másik IP-címet ad vissza, a DNS még nem propagálódott. Várj 5–30 percet.
**2. lépés: Add meg a domainedet a Coolifyban.**
Az alkalmazásban nyisd meg a **Configuration → General** lapot. A **Domains** mezőben a Coolifyból másolt ideiglenes alkalmazás-URL-t cseréld `https://app.example.com` értékre, a saját beállított domained használatával. Engedélyezd az **Automatic HTTPS** beállítást (ez általában alapértelmezés szerint be van kapcsolva).
Mentsd el, majd kattints a **Redeploy** gombra.
**3. lépés: Várd meg a Let's Encrypt-tanúsítványt.**
A buildnaplókban ez jelenik meg:
```
[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
```
2–3 perc múlva a webhelyed a `https://app.example.com` címen lesz elérhető, a címsorban zöld lakat ikonnal.
Mi okozhat gondot a Let's Encrypt használatakor (a [hivatalos hibaelhárítási útmutató](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working) 3 leggyakoribb problémája):
1. **A 80-as port le van zárva a tűzfalon.** A Let's Encrypt HTTP-challenge-dzsel ellenőriz — kérést küld a `http://app.example.com/.well-known/acme-challenge/xxx` címre. A 80-as port nélkül az ellenőrzés nem sikerül. Nyisd meg a szolgáltató tűzfalán.
2. **A Cloudflare-proxy aktív (narancssárga felhő).** Elfogja a Let's Encrypt kérését, és a saját helyőrzőoldalát adja vissza — az ellenőrzés sikertelen lesz. A megoldás a „DNS only” (szürke felhő) beállításra váltás, vagy egy DNS-01 challenge konfigurálása a Cloudflare API-n keresztül.
3. **A DNS még nem propagálódott.** Ha 30 másodperce hoztál létre A rekordot, és azonnal a Redeploy gombra kattintottál, a Let's Encrypt még nem fogja látni a domainedet. Várj 5–30 percet, amíg a DNS propagálódik a szerverek között.
A Let's Encrypt sebességkorlátja: **óránként 5 sikertelen próbálkozás egy domainre**, a korlátozás pedig 12 percenként 1 próbálkozással oldódik fel. Ha eléred a korlátot, ne kattints egymás után 10-szer a Redeploy gombra; nézd meg a naplókat, javítsd ki a problémát, majd 12 perc múlva próbáld újra.
## Hogyan kezeli Claude Code a Coolifyt MCP-n keresztül?
Fő tanulság
A Model Context Protocol segítségével Claude Code közvetlen hozzáférést kap a Coolify API-hoz — mondhatod neki, hogy „telepítsd ezt az alkalmazást”, és elindítja a buildet, ellenőrzi az állapotot, elolvassa a naplókat vagy frissíti a környezeti változókat. Három lehetőség van: forsonny/Coolify-MCP-Server (alap, 7 műveleti kategória), dazeb/coolify-mcp-enhanced (15+ további eszköz, köztük egykattintásos adatbázis-telepítés) és ajmcclary/Coolify-Manager (a hivatalos CLI köré épített Claude Skill). A v4.1.0-től (2026. május 18.) a Coolify külső szerverek nélkül használható natív MCP-végpontot kínál — ez azonban egyelőre csak olvasási hozzáférést biztosít.
A Model Context Protocol (MCP) az Anthropic szabványa, amely lehetővé teszi, hogy Claude Code külső rendszerekkel kommunikáljon (további információért lásd az [MCP-szerverekről szóló útmutatót](https://ailoot.ai/blog/hu/mcp-servers-claude-code/)). Csatlakoztass egy MCP-szervert, és Claude megkapja a meghívható eszközök készletét. A Coolifyhoz három kész szerver és egy natív lehetőség érhető el.
**1. lehetőség: forsonny/Coolify-MCP-Server-for-Claude-Code — alap.**
Amire képes:
- **Applications:** létrehozás, indítás, leállítás, újraindítás
- **Services:** listázás, létrehozás, indítás/leállítás/újraindítás
- **Deployments:** futó telepítések megtekintése, lekérés UUID alapján
- **Teams & Members:** listázás, információk lekérése
- **SSH Keys:** listázás, létrehozás
- **Environment Variables:** teljes CRUD az alkalmazások és szolgáltatások esetén
- **Server Insights:** szerverenkénti domainek, állapot, verzió
Telepítés:
```bash
git clone ''
cd Coolify-MCP-Server-for-Claude-Code
npm install
npm run build
# A .env fájlban:
# COOLIFY_BASE_URL=https://coolify.example.com
# [a Coolify Settings → API Tokens menüpontjából]
npm run setup # automatikusan konfigurálja a Claude Code-ot
```
Ezután ezt írhatod Claude Code-ba:
```
Show the status of the my-vibe-app application in Coolify and the 3 latest deployments.
```
Claude táblázatot ad vissza.
**2. lehetőség: dazeb/coolify-mcp-enhanced — kibővített (ajánlott).**
Az alapkészleten felüli funkciók:
- **PostgreSQL / Redis / MinIO telepítése egy kattintással** AI-on keresztül — kérd, hogy „állíts be nekem Postgrest”, és létrehoz egy konténert, majd visszaadja a DATABASE_URL-t
- **Valós idejű megfigyelés + erőforrás-használat** — minden alkalmazás CPU- és RAM-használata valós időben
- **Tömeges env-konfigurációfrissítés** — 20 változó frissítése egy paranccsal
- **Docker Compose-támogatás** — több szolgáltatásból álló alkalmazások telepítése
Claude Code-konfiguráció (`.mcp.json` a projekt gyökerében):
```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"
}
}
}
}
```
**3. lehetőség: ajmcclary/Coolify-Manager — CLI köré épített Claude Skill.**
Ez nem MCP-szerver, hanem a hivatalos Coolify CLI-t becsomagoló Claude Code Skill. A következőket tartalmazza:
- Szolgáltatások és konténerek állapotdiagnosztikája
- SSL-tanúsítványok diagnosztikája
- Több példány támogatása (ha több Coolify-szervered van)
- Hibaelhárítási receptek
Telepítés: töltsd le a skillt, és helyezd a `~/.claude/skills/coolify-manager/` könyvtárba. Claude Code felismeri, és felajánlja a releváns feladatoknál.
**4. lehetőség (újdonság 2026 májusában): natív MCP a Coolify v4.1.0-ban.**
A 2026. május 18-i dátumú v4.1.0-s változásnapló szerint:
> Példányszintű MCP-támogatás hozzáadása csak olvasásra szolgáló eszközökkel a Coolify-erőforrásokhoz és az API/UI-hoz.
A Coolify most saját MCP-végpontot biztosít — Claude Code közvetlenül csatlakoztatható, külső szerverek nélkül. Egyelőre **csak olvasásra** használható (alkalmazáslisták, állapotok, konfigurációk), módosítási műveletek nincsenek. Az olyan feladatokhoz azonban elegendő, mint „mesélj az infrastruktúráról”.
Csatlakoztatás `.mcp.json` segítségével:
```json
{
"mcpServers": {
"coolify-native": {
"url": "https://coolify.example.com/api/v1/mcp",
"headers": {
"Authorization": "Bearer "
}
}
}
}
```
Várd meg, amíg a natív MCP v4.2 vagy v4.3 verziójában teljes írási hozzáférés is elérhető lesz — a Coolify csapata 2026 végére ígérte.
## 5 buktató az első telepítés során — és hogyan kerüld el őket
Fő tanulság
Az első telepítés leggyakoribb hibái: kevés RAM, lezárt 80-as port, a Let's Encryptet megakasztó Cloudflare-proxy, a Dockert védeni képtelen UFW, valamint a GitHub App helyett választott PAT. Mindegyikről szó esik a hivatalos dokumentációban, de gyakorlati tapasztalat nélkül könnyű beléjük futni. Az alábbi, 5 pontos ellenőrzőlista a Coolify első telepítésének eredeti tapasztalataira épül.
**1. buktató: 2 GB-nál kevesebb RAM — a telepítés OOM-mal meghiúsul.**
Tünet: a `curl install.sh` eljut a `docker pull coolify/coolify` lépésig, 70%-nál megakad, majd a folyamat leáll `Killed (signal 9)` üzenettel. A `dmesg | tail` naplójában az `Out of memory: Killed process` látható.
Megoldás:
```bash
# 4 GB-os swapfájl létrehozása a probléma ideiglenes megoldásához
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
```
Hosszú távon bővítsd a RAM-ot 4 GB-ra. A Coolify swap használatával is működik, de nagy Next.js-projektek buildelése meghiúsulhat.
**2. buktató: Az UFW engedélyezve van, de a Docker továbbra is megnyitja a portokat.**
Tünet: engedélyezted az UFW-t, és a 22-es port kivételével minden portot lezártál, de az alkalmazás még mindig elérhető az internet felől valamelyik véletlenszerű porton (például a 3000-esen).
Az [hivatalos dokumentációban](https://coolify.io/docs/knowledge-base/server/firewall) leírt ok:
A Coolify Dockerben fut, amely NAT-alapú iptables-szabályokat használ, és megkerülheti a hagyományos Linux-tűzfalakat, például az UFW-t.
— Coolify-dokumentáció (tűzfal), https://coolify.io/docs/knowledge-base/server/firewall
Megoldás: használd **a szolgáltatód vezérlőpultjának tűzfalát**, ne az UFW-t. A Timeweb / Selectel / Aeza „Firewall” vagy „Network → Firewall” menüpontjában a virtuális hálózat szintjén állíthatod be a szabályokat — ezek még azelőtt érvényesülnek, hogy a csomagok elérnék a Dockert.
Alternatíva az ufw-docker, egy olyan szkript, amely a Dockerrel való kompatibilitás érdekében módosítja az UFW-t. Ez azonban bonyolultabb annál, mint hogy rákattints a vezérlőpulton a megfelelő beállításra.
**3. buktató: A Cloudflare-proxy (narancssárga felhő) megakasztja a Let's Encryptet.**
Tünet: a Redeploy után a naplókban ez látható: `Let's Encrypt validation failed - challenge returned 403`.
Ok: a Cloudflare proxyn keresztül irányítja a Let's Encrypt HTTP-kérését, és a challenge-fájl helyett a saját oldalát adja vissza.
Megoldás — válassz a két lehetőség közül:
1. **Válts „DNS only” módra** (a szürke felhő a Cloudflare-ben). Hátránya: elveszíted a Cloudflare CDN-jét és védelmét.
2. **Állíts be DNS-01 challenge-et a Cloudflare API-n keresztül.** A Coolifyban lépj a Settings → SSL Configuration menüpontra, válaszd a Cloudflare-szolgáltatót, majd adj meg egy Zone:Read és DNS:Edit jogosultságú API-tokent. A Let's Encrypt HTTP helyett TXT rekordon keresztül ellenőriz.
A második lehetőség beállítása bonyolultabb, de megőrzi a Cloudflare-proxyt.
**4. buktató: GitHub App helyett PAT — a PR-előnézetek nem működnek.**
Tünet: Personal Access Token használatával csatlakoztattad a GitHubot; minden működik, de a PR-ekhez nem készülnek előnézeti telepítések. Megnyitottál egy PR-t a GitHubon, de semmi sem jelent meg a Coolifyban.
Ok: a PR-előnézetek a GitHub App kizárólagos funkciói. A PAT nem kap `pull_request` eseményeket webhookon keresztül.
Megoldás: csatlakoztasd újra a GitHubot az App segítségével. Sources → Add → GitHub App → fejezd be a varázslót. A régi PAT-forrást törölheted.
**5. buktató: A „Coolify == Vercel” állítás nem teljesen igaz.**
Amit a Coolify **nem tud** alapból:
| Vercel | Coolify | Teendő |
|----|----|----|
| Globális CDN | Nincs | Tegyél elé Cloudflare-t (statikus tartalomhoz ingyenes) |
| Incremental Static Regeneration | Nincs | A `revalidatePath` csak a saját szervereden működik |
| Képoptimalizálás | Nincs | Használd a `next/image` komponenst helyi loaderrel vagy Cloudflare Images szolgáltatással |
| Automatikus skálázás forgalmi csúcsok alatt | Nincs | Skálázz manuálisan; bővítsd a VPS-t |
| Edge Functions | Nincs | Használj hagyományos API-útvonalakat |
Ha a projekted nagy forgalmú SaaS globális közönséggel és világszerte \< 100 ms-os késleltetési követelménnyel, a Coolify nem megfelelő; válaszd a Vercel Enterprise-t. Ha vibe-coder vagy, és napi 100–1,000 felhasználóval tesztelsz egy MVP-t, a Coolify minden szükségeset biztosít.
Egy őszinte saját üzemeltetésről szóló elemzésből:
Az útmutató címében szereplő 15 perc az egyetlen projekt első telepítésének problémamentes útjára vonatkozik. A teljes infrastruktúra beállítása megfigyeléssel, biztonsági mentésekkel és riasztásokkal egy-két estét vesz igénybe. Légy őszinte magaddal.
## Mennyit takaríthatsz meg egy év alatt a Vercelhez képest?
Fő tanulság
Létezik egy „rejtett időadó” is: a kezdeti beállítás 5–10 óra, a karbantartás pedig havonta 1–2 óra.
Az alábbi Vercel-adatok a cikk 2026. májusi forgatókönyv-becslései, nem aktuális ajánlatok. Csak az összevetés egyik oldalát adják. A saját üzemeltetésű Coolify licencdíjmentes, de a VPS, mentés, tárhely, forgalom és üzemeltetés továbbra is pénzbe kerül. A fenti követelményeknek megfelelő ajánlatot kérj; ezekhez a forgatókönyvekhez nem kaptunk számszerű VPS-árat, ezért rögzített megtakarítást nem lehet alátámasztani.
Legyen **C** a választott VPS, mentési tárhely, többletforgalom, monitorozás és fizetős kezelőfelület teljes havi infrastruktúra-számlája. Minden költséget egyszer vegyél fel. Legyen **r** az üzemeltetési munkád óraköltsége, végig azonos pénznemben. A cikk időbecslése kezdetben 5–10 óra, majd havonta 1–2 óra: **az első évben 17–34 óra**, a későbbi években **12–24 óra**.
| Forgatókönyv | Havi Vercel-becslés | Vercel/év | Coolify-infrastruktúra/hó | Coolify első éves TCO munkával | Első éves megtakarítás a Vercelhez képest |
|----|----|----|----|----|----|
| Egy prototípus, havi 100,000 látogatás | $20 alap + ~$5 sávszélesség = $25 | $300 | C | 12C + (17–34)r | $300 − 12C − (17–34)r |
| Öt projekt egy VPS-en | $20 alap + $30 sávszélesség/funkció = $50 | $600 | C | 12C + (17–34)r | $600 − 12C − (17–34)r |
| Három fejlesztő, öt projekt | $60 felhasználók + $30 sávszélesség = $90 | $1,080 | C | 12C + (17–34)r | $1,080 − 12C − (17–34)r |
Eltérő szerverméretet igénylő terheléseknél külön C-t használj. Havi összevetéshez a kezdeti időt 12 hónapra oszd: az első év havi megfelelője **C + (17–34)r/12**. A későbbi éves TCO **12C + (12–24)r**. A képletek a megadott Vercel-becslést vetik össze a saját üzemeltetés kiadásaival; a Vercel oldalán is add hozzá a hasonló üzemeltetési munkát. A negatív megtakarítás a saját bemeneteiddel drágább saját üzemeltetést jelent. Ne számold újra ugyanannak a mérnöknek a teljes bérét, ha r már tartalmazza.
Váltás előtt töltsd ki C-t valódi szolgáltatói ajánlatból és mentési tervből, válassz r-t, és egy hónap tényleges használatát hasonlítsd össze. E bemenetek nélkül a cikk költségmodellt ad, nem dollárban igazolt megtakarítást.
A Coolify nem egy olcsóbb Vercel. Más termékkategória: a tiéd az infrastruktúra, te felelsz érte, és a komplexitás elfogadásával takarítasz meg pénzt.
Ha a Claude Code-ban létrehozott prototípus telepítése az első feladatod, a környezet kezelése (env, titkok, ütemezett feladatok, biztonsági mentések) a [**kontextustervezés**](https://ailoot.ai/blog/hu/context-engineering/) része. Ha nincs struktúra arra, hogy „mi hol található”, Claude eltéved, és minden módosításnál időt veszítesz. A teljes összeállítás a következőket tartalmazza: **AI-klón** (a módszertanodhoz szabott [Skills](https://ailoot.ai/blog/hu/claude-code-skills-library/) és [Subagents](https://ailoot.ai/blog/hu/claude-code-alugynokok/)) + [**Második Agy**](https://ailoot.ai/blog/hu/claude-code-second-brain/) (a projekt tudásbázisa) + **Kontextustervezés** ([Plan Mode](https://ailoot.ai/blog/hu/claude-code-plan-mode/), `/compact`, végrehajtási környezet). Ez az a **3 pillér**, amelyek nélkül az AI hallucinál.
A teljes kontextus-munkafolyamat: **AI-klón + Második Agy + Kontextustervezés**.
További anyagok az [Ailooton](https://ailoot.ai/) érhetők el.
## Kérdések és válaszok: Coolify és Claude Code: projekt telepítése a saját VPS-edre
### Melyik URL-nek kell JSON-t adnia a telepítés után?
Másold a Coolify Domains mezőjében látható alkalmazás-URL-t, és annak /api/users útvonalát nyisd meg. A gyökér-URL a kezdőlap; a /api/users a mintaprojektben meghatározott JSON-végpont.
### Hogyan számítsam ki, megtakarítok-e a saját üzemeltetéssel?
A havi VPS-, mentési, tárhely-, forgalmi, monitorozási és opcionális kezelőfelület-díjakat add össze C-be. Az első éves sajátüzemeltetési TCO 12C plusz 17–34 óra a saját óraköltségeddel; ezt a forgatókönyv éves Vercel-becslésével hasonlítsd össze, mindkét oldalon a megfelelő üzemeltetési költségekkel.
## Ailoot · A vállalat és projektportfóliója
Az Ailoot felhalmozott működési tapasztalatra, széles ügyfélkörre, stabil szolgáltatásra és folyamatos KPI-ellenőrzésre épít.
A vállalat és projektportfóliója: ügyfelek milliói; havi értékesítés milliárdos nagyságrendben.
Az Ailoot ezt a működési tapasztalatot használja az ügyfelek termékeiben, ágenseiben, alkalmazásaiban és automatizálásaiban elérhető AI-funkciók API-hozzáféréséhez.