# Coolify och Claude Code: Driftsätt ett projekt på din egen VPS > Installera Coolify, ansluta GitHub, driftsätta Next.js, domän och HTTPS, MCP, VPS-krav och felsökning. Tekniska priser i dollar och ursprungliga begränsningar. Source: https://ailoot.ai/blog/sv/coolify-claude-code-deploy/ Canonical: https://ailoot.ai/blog/sv/coolify-claude-code-deploy/ Language: sv Publisher: Ailoot (https://ailoot.ai/) Translation: guide-087 Revision: sha256-105e09752e718fcfd2773cc0945df147e5623b81d27f756ef216ed80cbc2334f
[Ailoot-dokumentation](https://ailoot.ai/docs/) — referensmaterial för arbete med tjänsten.
## Plattformens begränsningar och betalningsvillkor 2026
Det viktigaste Gratisplaner fungerar tills du för första gången överskrider en gräns; därefter krävs ett internationellt kort. Heroku stängde sin gratisnivå för alla 2022 och gick in i underhållsläge i februari 2026. Med självhostade Coolify äger du servern; det finns ingen fakturering per användare och ingen inlåsning till leverantören.
Ett typiskt scenario för en vibe-coder 2026: du bygger en MVP i Cursor eller Claude Code under en kväll, flyttar den till ett GitHub-repository, öppnar vercel.com → ansluter repositoryt → kommer till prenumerationsskärmen → anger ditt kort → får `Transaction declined`. Det här är inget fel eller ett tillfälligt avbrott. Railway, Render, Heroku — det är samma historia. Heroku stängde faktiskt sin gratisnivå för alla 2022, och i februari 2026 gick projektet in i underhållsläge — inga nya funktioner och inga nya Enterprise-avtal. För en användare med ett kort som inte stöds innebär det: ”dörren är stängd; gå runt via en mellanhand som tar 20 % i provision.” Du kan betala med virtuella Visa-kort i Kazakstan eller via företagstjänster för betalningar. Men det innebär +20 % på priset, +30 minuter för varje transaktion och risken att ditt konto blockeras när betalningsförmedlaren upptäcker en avvikelse mellan länder. Det ursprungliga exemplet omfattade tre försök — med Vercel Pro, Railway och Render. ## Vad är Coolify och hur fungerar en självhostad plattform?
Det viktigaste Coolify är en självhostningsbar PaaS med öppen källkod och ett direkt alternativ till Heroku, Vercel och Netlify. Den installeras med ett enda curl-kommando på valfri VPS med Ubuntu. Under huven använder den Docker + Traefik för omvänd proxy och Let's Encrypt för HTTPS. Den stöder GitHub-integration, webhooks för automatiska driftsättningar, S3-säkerhetskopior och 280+ tjänster som kan installeras med ett klick (PostgreSQL, Redis, MinIO). Den självhostade versionen är gratis för alltid utan begränsningar. Den har 55,800 stjärnor på GitHub och licensen Apache-2.0.
Coolify är ett projekt med öppen källkod, byggt med Laravel + Docker, som förvandlar en tom VPS till en plattform för driftsättning av applikationer. Installera Coolify en gång och gör sedan allt annat via webbgränssnittet: anslut GitHub, välj ett repository och klicka på Deploy. Den officiella dokumentationen sammanfattar det kort och precist:

Coolify är ett alternativ med öppen källkod som du kan självhosta till Heroku / Netlify / Vercel, osv.

— Coolifys GitHub README, https://github.com/coollabsio/coolify
Under huven består Coolify av fyra delar: 1. **Webbgränssnitt byggt med Laravel 12 + Livewire 3 + Tailwind v4** — en kontrollpanel för att hantera dina applikationer. 2. **Docker + Docker Compose** — varje applikation körs i en container, isolerad från de andra. 3. **Omvänd proxy (Traefik eller Caddy)** — tar emot inkommande HTTP/HTTPS-trafik och dirigerar den till containrar. 4. **Let's Encrypt-integration** — utfärdar och förnyar SSL-certifikat automatiskt för alla domäner. Viktiga funktioner som gör Coolify funktionellt jämförbar med Vercel: | Funktion | Vercel | Coolify | |----|----|----| | Automatisk driftsättning vid git-push | ✅ | ✅ (via GitHub-webhook) | | Gratis HTTPS | ✅ | ✅ (Let's Encrypt) | | Förhandsgranskningar av PR-driftsättningar | ✅ | ✅ (via GitHub App) | | Gränssnitt för miljövariabler | ✅ | ✅ | | Säkerhetskopiering av databaser | ❌ (inga egna databaser) | ✅ (till S3-kompatibel lagring) | | PostgreSQL / Redis / MongoDB | \$20+/månad vardera | ✅ Ett klick, gratis | | Schemalagda jobb (cron) | ❌ | ✅ (cron-syntax) | | Fakturering per användare | \$20/användare/månad | Ingen | | Inlåsning till leverantör | Hög (Edge Functions, ISR) | Ingen (din Docker) | | Global CDN | ✅ | ❌ (bara din VPS) | En global CDN är det enda Coolify inte har direkt från start. Det är det ärliga svaret. Om ditt projekt har en global målgrupp och du behöver minska fördröjningen för användare i USA och Europa kan du lägga Cloudflare framför; det är gratis för statiskt innehåll. Pris: **den självhostade versionen är gratis för alltid** utan begränsningar för antal applikationer, servrar eller driftsättningar. Coolify Cloud finns för \$5/månad för 2 servrar + \$3 för varje ytterligare server — men servrarna är fortfarande dina; Coolify Cloud är bara värd för kontrollpanelen. Den senaste versionen är **v4.1.0 från 18 maj 2026**. Bland de nya funktionerna finns byggpaketet Railpack i beta, granskningsloggning, konfigurationsskillnader mellan driftsättningar och en inbyggd MCP-endpoint (skrivskyddad). Källa: [GitHub-releaser](https://github.com/coollabsio/coolify/releases). ## Vilken VPS ska du skaffa för Coolify 2026?
Det viktigaste Coolify kräver minst 2 vCPU, 2 GB RAM, 30 GB SSD och Ubuntu LTS (20.04, 22.04 eller 24.04). En sådan VPS kan utan problem köra 3–5 vibe-coding-projekt parallellt.
Coolifys minimikrav kommer direkt från [den officiella dokumentationen](https://coolify.io/docs/get-started/installation): | Parameter | Minimum | Rekommenderat | |-------------|----------------------------------|---------------------------| | CPU | 2 kärnor | 2–4 kärnor | | RAM | 2 GB | 4 GB (med utrymme för byggen) | | Lagring | 30 GB | 50–80 GB (för avbildningar + databaser) | | Arkitektur | AMD64 eller ARM64 (64-bitars) | AMD64 | | OS | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS | | Root | Krävs | Via SSH-nyckel, inte lösenord | Minimumet — 2 GB RAM — är en **absolut nedre gräns**. Med 1 GB kommer installationsprogrammet fram till Docker, får slut på minne (OOM) och hänger sig. Snåla inte med RAM. Priskällor: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting) och [Selectel](https://selectel.ru/services/cloud/vps-vds/). Om du behöver mer kraft (en databas på 100 GB, flera Postgres-instanser) ska du skaffa Aeza Dedicated. Vad du INTE ska skaffa: - **Delad VPS med 512 MB–1 GB RAM** — inte ens tillräckligt för Coolify. Den är avsedd för statiska webbplatser på nginx, inte för en PaaS. Vill du inte bara konfigurera driftsättning, utan även bygga en **konfiguration som gör Claude pålitlig**? Coolify är ett verktyg för körning, men utan strukturerat sammanhang ([`CLAUDE.md`](https://ailoot.ai/blog/sv/claude-md-template/), en [second brain](https://ailoot.ai/blog/sv/claude-code-second-brain/) och [kontextteknik](https://ailoot.ai/blog/sv/context-engineering/)) kommer Claude fortfarande att hallucinera vid långa uppgifter. Den fullständiga konfigurationen innehåller alla tre: **AI-klon + Second Brain + Context Engineering** — den här kombinationen gör Claude till ”en assistent som hallucinera” ett pålitligt verktyg. ## Så installerar du Coolify på 5 minuter
Det viktigaste Installationen görs med ett enda curl-kommando från dokumentationen. När det körs visas ett webbgränssnitt på port 8000. Där skapar du den första administratörsanvändaren och ser en tom kontrollpanel. Den faktiska tiden från en tom Ubuntu-installation till att Coolify körs är 5–7 minuter, varav 3–4 minuter går åt till `apt-get install docker`. Skriptet hämtar de nödvändiga beroendena och konfigurerar Docker självt; allt du behöver göra är att vänta tills det är klart.
**Steg 1. Anslut till VPS:en via SSH.** När du har skapat en VPS hos leverantören skickas serverns IP-adress och root-lösenord till dig via e-post eller visas i kontrollpanelen. Anslut från din lokala dator: ```bash ssh root@1.2.3.4 ``` Om leverantören gav dig en SSH-nyckel i stället för ett lösenord ansluter du med `-i path/to/key`. Från och med nu utgår jag från att du har en ny Ubuntu 22.04- eller 24.04 LTS-installation. **Steg 2. Kör Coolifys installationskommando.** Ett kommando från [den officiella dokumentationen](https://coolify.io/docs/get-started/installation): ```bash curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash ``` Skriptet gör tre saker: 1. Kontrollerar systemet (Ubuntu LTS? root? AMD64?) 2. Installerar Docker och Docker Compose om de inte redan är installerade 3. Hämtar Coolify-avbildningarna (`coolify/coolify`, `coolify/realtime`, `traefik`) och kör dem i bakgrunden via docker-compose Det tar 3–5 minuter. Du ser `apt-get`-loggar rulla förbi, följt av `docker pull`. När du ser `Coolify v4.1.0 is now running` går du vidare till steg 3. **Steg 3. Öppna webbgränssnittet.** Öppna detta i webbläsaren: ``` http://1.2.3.4:8000 ``` Coolify visar en installationsguide — ett formulär för att skapa den första användaren. Ange en e-postadress och ett lösenord och spara. Den här användaren blir automatiskt administratör; du behöver inga andra användare än. När du har sparat kommer du till en tom kontrollpanel: en sidopanel till vänster med Resources / Projects / Servers / Sources / Notifications / Settings och en uppmaning i mitten om att ”Add your first resource”. **Steg 4. Öppna portar i leverantörens brandvägg (inte UFW).** Coolify kör redan, men utifrån är bara port 8000 (kontrollpanelen) tillgänglig. För att användare ska kunna nå dina applikationer måste du öppna portarna 80 (HTTP) och 443 (HTTPS): | Port | Syfte | |----|----| | 22 | SSH-åtkomst till servern | | 80 | Tar emot HTTP-trafik, krävs för Let's Encrypt-validering | | 443 | Tar emot användarnas HTTPS-trafik | | 8000 | Coolifys kontrollpanel (vi stänger den när vi har konfigurerat en anpassad domän för kontrollpanelen) | En viktig fallgrop som nämns i den officiella dokumentationen:

Docker använder NAT-baserade iptables-regler som kan kringgå traditionella Linux-brandväggar som UFW.

— Coolify-dokumentation (brandvägg), https://coolify.io/docs/knowledge-base/server/firewall
Det innebär att även om du aktiverar UFW och stänger alla portar kommer Docker ändå att exponera sina containrar via iptables. UFW är värdelöst här. Lösningen är att **öppna och stänga portar i leverantörens kontrollpanel**, inte via UFW. Hos Timeweb / Selectel / Aeza gör du detta i webbkontrollens avsnitt ”Network → Firewall”. **Steg 5 (valfritt). Koppla kontrollpanelen till din domän.** Om du vill besöka `https://coolify.example.com` i stället för `http://1.2.3.4:8000` skapar du en DNS A-post `coolify.example.com → 1.2.3.4`, går till **Settings → Instance Settings → Instance Domain** i Coolify, anger din underdomän och sparar. Coolify begär ett Let's Encrypt-certifikat och laddar om kontrollpanelen via HTTPS en minut senare. Därefter kan du stänga port 8000 i brandväggen — kontrollpanelen blir tillgänglig via HTTPS på standardporten 443. ## Så ansluter du GitHub: App eller PAT?
Det viktigaste Coolify stöder två sätt att ansluta till GitHub: **GitHub App** (rekommenderas) och **Personal Access Token (PAT)**. Använd GitHub App: installationen tar 5 minuter med guiden, PR-förhandsvisningar fungerar och behörigheter kan begränsas noggrant på repositorynivå. PAT är ett föråldrat alternativ för äldre specialfall; det saknar förhandsgranskning av driftsättningar och medför risk för global åtkomst till alla dina repositories. Den officiella dokumentationen säger rakt ut: ”för 95% av användarna är GitHub App det rätta valet.”
I Coolify går du till **Sources → + Add → GitHub App**. Coolify visar en guide med tre skärmar: 1. **Namn och beskrivning** — ge källan ett namn (ange `github-main`) och lägg eventuellt till en beskrivning. 2. **Konfigurera på GitHub** — en knapp som tar dig till GitHub.com och automatiskt öppnar ett formulär för att skapa en GitHub App med rätt behörigheter. 3. **Bekräfta** — när du har kommit tillbaka från GitHub klickar du på ”Save”. I det andra steget ber GitHub dig bekräfta de behörigheter som Coolify begär: | Behörighet | Nivå | Syfte | |-----------------|------------|----------------------------------------------| | Contents | Skrivskyddad | Klona repositoryt | | Pull Requests | Läs och skriv | Skapa förhandsgranskningar av driftsättningar och kommentera PR:er | | E-postadresser | Skrivskyddad | Identifiera commits | | Metadata | Skrivskyddad | Lista repositories | Det här är **minimala behörigheter** — GitHub App kan inte se dina privata nycklar, kan inte skriva till `main` och kan inte komma åt repositories som du inte uttryckligen har anslutit. Ur den officiella dokumentationen: Personal Access Token (PAT) är den gamla metoden; jag **rekommenderar att inte använda den**. Nackdelar: - PAT ger global åtkomst till alla dina repositories (även privata) - Förhandsgranskningar av PR:er fungerar inte — den funktionen finns bara i GitHub App - Tokenen gäller länge (90 dagar, ett år eller på obestämd tid) — om den läcker ut är det illa Använd PAT endast om du arbetar med ett organisationsrepository där säkerhetspolicyn förbjuder GitHub Apps och det inte finns någon väg runt det. När du har sparat källan i Coolify ser du GitHub App i kontrollpanelen tillsammans med en lista över anslutna repositories. När du skapar en ny applikation kan du välja vilket som helst av dem med ett klick. ## Så driftsätter du ett Next.js-projekt från Claude Code i 6 steg
Det viktigaste Hela vägen från en tom Claude Code-konfiguration till en aktiv webbplats: 1) kör `claude` i en tom mapp, beskriv projektet och låt Claude skapa koden; 2) kör `git init && git remote add` (Claude kan själv göra detta via ett slash-kommando); 3) skicka upp till GitHub; 4) välj ”+ New Resource → Application” i Coolify och välj repositoryt; 5) lägg till miljövariabler; 6) klicka på Deploy. Coolify känner igen Next.js, väljer byggpaketet Nixpacks, bygger en Docker-avbildning på 3–5 minuter och ger dig en tillfällig domän med HTTPS direkt från start.
**Steg 1. Beskriv projektet för Claude Code i en tom mapp.** ```bash mkdir my-vibe-app cd my-vibe-app git init claude ``` I sessionen: ``` Bygg ett Next.js 14 app router-projekt: - en startsida med en lista över användare - /api/users-endpointen returnerar en array från databasen - Postgres via Prisma - Tailwind för stilar - .env.example med DATABASE_URL - README.md med instruktioner för att köra projektet ``` Claude skapar filstrukturen, package.json, prisma/schema.prisma och .env.example. Be också: ``` Skapa en Dockerfile för produktionsbyggen och en .dockerignore. ``` Detta är valfritt — Coolify bygger med Nixpacks även utan en Dockerfile. Men en Dockerfile ger dig kontroll över processen och går snabbare för större projekt. **Steg 2. Skapa ett GitHub-repository och skicka upp det.** Du kan göra detta manuellt via GitHub-gränssnittet + `git remote add origin ...`, men Claude Code kan göra det själv: ``` /commit-push-pr Första Next.js-appen skapad med Claude Code ``` Eller säg bara: ”Committa allt och skicka upp det till ett nytt repository `my-vibe-app` under mitt konto.” Claude använder CLI-verktyget `gh` för att skapa ett privat (eller offentligt) repository och göra den första pushen. Källa: [officiellt Claude Code-kommando](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md). **Steg 3. Skapa en Application i Coolify.** Klicka på **+ New → Application** i Coolifys kontrollpanel. Ett formulär öppnas: 1. **Source** — välj `github-main` (GitHub App som du anslöt i föregående H2) 2. **Repository** — välj `my-vibe-app` från listan 3. **Branch** — `main` 4. **Build Pack** — Coolify känner igen det automatiskt. Finns en Dockerfile använder det `dockerfile`. Annars används `nixpacks`. Du kan åsidosätta valet manuellt. 5. **Domain** — behåll det föreslagna värdet (en kostnadsfri tjänst för wildcard-DNS) tills vidare; det är tillfälligt och du byter ut det mot ditt eget senare 6. **Port** — `3000` för Next.js som standard Spara. **Steg 4. Lägg till miljövariabler.** Öppna fliken **Environment Variables** i den skapade applikationen. Lägg till variablerna en i taget: ``` DATABASE_URL=postgresql://user:pass@db-host:5432/mydb NODE_ENV=production ANTHROPIC_API_KEY=sk-ant-... ``` Om du inte har någon databas kan du skapa en direkt i Coolify: **+ New → Database → PostgreSQL**. Coolify startar en Postgres-container på 30 sekunder och tillhandahåller en intern DATABASE_URL i formatet `postgresql://postgres@postgres-xyz:5432/postgres` — lägg in den i applikationen. Alla variabler krypteras i Coolify-databasen och visas inte i byggloggar. **Steg 5. Klicka på Deploy.** Uppe till höger finns en blå Deploy-knapp. Live-loggar visas på fliken 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 for xxx [stage: ssl] Let's Encrypt cert issued for xxx ``` Det första bygget tar 3–5 minuter (det hämtar Node-basavbildningen och installerar beroenden). Senare byggen tar 60–90 sekunder tack vare cachelagring av Docker-lager. När statusen ändras till **Running** kopierar du applikationsadressen i Coolifys **Domains**-fält och öppnar exakt den adressen i webbläsaren. Använd värdet som `` nedan; etiketten i vinkelparenteser är en platshållare, inte en riktig adress. Startsidan ska visas med HTTPS direkt från start. Coolify använder en gratis wildcard-DNS-tjänst för tillfälliga domäner så att du kan öppna webbplatsen direkt utan att konfigurera egen DNS. **Steg 6. Kontrollera att allt fungerar.** Öppna applikationsadressen från föregående steg med `/api/users` tillagd, till exempel `/api/users` utan dubbla snedstreck. Det är JSON-slutpunkten från steg 1; rotadressen är startsidan. Om du får ett 500-fel ser du stackspårningen på fliken Logs. Det vanligaste problemet vid den första driftsättningen är att DATABASE_URL pekar på en databas som inte finns. Lös det genom att skapa en PostgreSQL-instans i Coolify (se steg 4 ovan) och ersätta DATABASE_URL. 15 minuter från det att du beställer VPS:en. I det ursprungliga exemplet tog arbetsflödet 12–18 minuter på en ny server. ## Så konfigurerar du en anpassad domän och HTTPS
Det viktigaste En anpassad domän ansluts i tre steg: skapa en DNS A-post som pekar på serverns IP, ange din domän i Coolifys konfiguration i stället för en gratis wildcard-DNS-tjänst, aktivera Automatic HTTPS och klicka på Redeploy. Let's Encrypt utfärdar automatiskt ett SSL-certifikat 2–3 minuter efter DNS-propagation (vanligtvis 5–30 minuter). Det viktigaste kravet är att DNS redan måste slå upp rätt adress när du klickar på Redeploy; annars misslyckas Let's Encrypt-valideringen och du måste vänta 12 minuter till nästa försök.
**Steg 1. Skapa en DNS A-post i registratorns kontrollpanel.** De ursprungliga exemplen använder domäner hos Reg.ru, Beget eller Timeweb. Processen är densamma: | Posttyp | Namn | Värde | |------------|---------------------------|------------------------| | A | `app` (eller `@` för rotdomänen) | `1.2.3.4` (server-IP) | Spara, öppna en konsol och kontrollera: ```bash dig app.example.com +short # Ska returnera 1.2.3.4 ``` Om inget returneras eller IP-adressen är en annan har DNS inte propagerats ännu. Vänta 5–30 minuter. **Steg 2. Ange din domän i Coolify.** Öppna fliken **Configuration → General** i applikationen. I fältet **Domains** ersätter du den tillfälliga applikationsadressen som kopierats från Coolify med `https://app.example.com` (med din egen konfigurerade domän). Aktivera **Automatic HTTPS** (det är vanligtvis aktiverat som standard). Spara och klicka på **Redeploy**. **Steg 3. Vänta på Let's Encrypt-certifikatet.** Byggloggarna visar: ``` [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 ``` Om 2–3 minuter är webbplatsen tillgänglig på `https://app.example.com` med ett grönt hänglås i adressfältet. Vad som kan gå fel med Let's Encrypt (de 3 vanligaste problemen enligt [den officiella felsökningsguiden](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)): 1. **Port 80 är stängd i brandväggen.** Let's Encrypt validerar med en HTTP-utmaning — den skickar en förfrågan till `http://app.example.com/.well-known/acme-challenge/xxx`. Valideringen kan inte lyckas utan port 80. Öppna den i leverantörens brandvägg. 2. **Cloudflare-proxy är aktiverad (orange moln).** Den fångar upp Let's Encrypt-förfrågan och returnerar sin egen platshållarsida — valideringen misslyckas. Lösningen är att byta till ”DNS only” (grått moln) eller konfigurera en DNS-01-utmaning via Cloudflare API. 3. **DNS har inte propagerats ännu.** Om du skapade en A-post för 30 sekunder sedan och omedelbart klickade på Redeploy kommer Let's Encrypt inte att hitta din domän. Vänta 5–30 minuter på att DNS propageras mellan servrar. Let's Encrypts hastighetsgräns: **5 misslyckade försök per timme för en domän**, med återställningstakt på 1 var 12:e minut. Om du når gränsen ska du inte klicka på Redeploy 10 gånger i rad; kontrollera loggarna, åtgärda problemet och försök igen om 12 minuter. ## Hur hanterar Claude Code Coolify via MCP?
Det viktigaste Med Model Context Protocol får Claude Code direkt åtkomst till Coolify API — du kan säga ”driftsätt den här applikationen” för att starta ett bygge, kontrollera status, läsa loggar eller uppdatera miljövariabler. Det finns tre alternativ: forsonny/Coolify-MCP-Server (grundläggande, 7 operationskategorier), dazeb/coolify-mcp-enhanced (15+ extra verktyg med driftsättning av databaser med ett klick) och ajmcclary/Coolify-Manager (en Claude Skill byggd kring den officiella CLI:n). Från och med v4.1.0 (18 maj 2026) tillhandahåller Coolify en inbyggd MCP-endpoint utan tredjepartsservrar — men den är skrivskyddad än så länge.
Model Context Protocol (MCP) är en standard från Anthropic som låter Claude Code kommunicera med externa system (se [guiden till MCP-servrar](https://ailoot.ai/blog/sv/mcp-servers-claude-code/) för mer). Anslut en MCP-server så får Claude en uppsättning verktyg som den kan anropa. Det finns tre färdiga servrar för Coolify och ett inbyggt alternativ. **Alternativ 1. forsonny/Coolify-MCP-Server-for-Claude-Code — grundläggande.** Det här kan den göra: - **Applications:** skapa, starta, stoppa, starta om - **Services:** lista, skapa, starta/stoppa/starta om - **Deployments:** visa pågående, hämta via UUID - **Teams & Members:** lista, hämta information - **SSH Keys:** lista, skapa - **Environment Variables:** fullständiga CRUD-operationer för appar och tjänster - **Server Insights:** domäner per server, hälsa, version Installation: ```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 # konfigurerar Claude Code automatiskt ``` Därefter kan du skriva detta i Claude Code: ``` Visa statusen för applikationen my-vibe-app i Coolify och de 3 senaste driftsättningarna. ``` Claude returnerar en tabell. **Alternativ 2. dazeb/coolify-mcp-enhanced — utökad (rekommenderas).** Det här tillför den grundläggande uppsättningen: - **Driftsättning av PostgreSQL / Redis / MinIO med ett klick** via AI — be ”konfigurera Postgres åt mig”, så skapar den en container och returnerar DATABASE_URL - **Övervakning i realtid + resursanvändning** — CPU/RAM för varje applikation i realtid - **Massuppdateringar av env-konfiguration** — uppdatera 20 variabler med ett kommando - **Stöd för Docker Compose** — driftsätt applikationer med flera tjänster Konfiguration för Claude Code (`.mcp.json` i projektroten): ```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" } } } } ``` **Alternativ 3. ajmcclary/Coolify-Manager — en Claude Skill byggd kring CLI:n.** Det är ingen MCP-server, utan en Claude Code Skill som omsluter den officiella Coolify CLI:n. Den innehåller: - Hälsodiagnostik för tjänster och containrar - Diagnostik av SSL-certifikat - Stöd för flera instanser (om du har flera Coolify-servrar) - Felsökningsrecept Installation: ladda ned skillen och placera den i `~/.claude/skills/coolify-manager/`. Claude Code hittar den och erbjuder den för relevanta uppgifter. **Alternativ 4 (nytt i maj 2026). Inbyggd MCP i Coolify v4.1.0.** Ändringsloggen för v4.1.0 daterad 18 maj 2026 säger: > Lade till MCP-stöd på instansnivå med skrivskyddade verktyg för Coolify-resurser och API/UI. Coolify tillhandahåller nu en egen MCP-endpoint — du kan ansluta Claude Code direkt utan tredjepartsservrar. Än så länge är den **skrivskyddad** (applikationslistor, statusar, konfigurationer), utan möjlighet att ändra något. Men det räcker för de flesta uppgifter, som ”berätta om infrastrukturen”. Anslut via `.mcp.json`: ```json { "mcpServers": { "coolify-native": { "url": "https://coolify.example.com/api/v1/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Vänta på fullständig skrivåtkomst i inbyggd MCP i v4.2 eller v4.3 — Coolify-teamet lovade det före utgången av 2026. ## 5 fallgropar vid den första driftsättningen — och hur du undviker dem
Det viktigaste De vanligaste felen vid den första driftsättningen är för lite RAM, en stängd port 80, att Cloudflare-proxy bryter Let's Encrypt, att UFW inte skyddar Docker och att man väljer PAT i stället för GitHub App. Allt behandlas i den officiella dokumentationen, men det är lätt att råka ut för problemen utan praktisk erfarenhet. Nedan finns en checklista med 5 punkter baserad på den ursprungliga erfarenheten av att installera Coolify för första gången.
**Fallgrop 1: Mindre än 2 GB RAM — installationen misslyckas med OOM.** Symtom: `curl install.sh` når `docker pull coolify/coolify`, hänger sig vid 70 % och processen dödas sedan med `Killed (signal 9)`. Loggarna från `dmesg | tail` visar `Out of memory: Killed process`. Lösning: ```bash # Skapa en växlingsfil på 4 GB för att tillfälligt lösa problemet 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 ``` På lång sikt bör du uppgradera till 4 GB RAM. Coolify fungerar med swap, men byggen av stora Next.js-projekt kan misslyckas. **Fallgrop 2: UFW är aktiverat, men Docker öppnar fortfarande portar.** Symtom: du aktiverade UFW och stängde alla portar utom 22, men applikationen är ändå tillgänglig från internet på någon slumpmässig port (som 3000). Orsaken enligt [den officiella dokumentationen](https://coolify.io/docs/knowledge-base/server/firewall):

Coolify körs på Docker, som använder NAT-baserade iptables-regler och kan kringgå traditionella Linux-brandväggar som UFW.

— Coolify-dokumentation (brandvägg), https://coolify.io/docs/knowledge-base/server/firewall
Lösning: använd **brandväggen i leverantörens kontrollpanel**, inte UFW. Timeweb / Selectel / Aeza har ett avsnitt som heter ”Firewall” eller ”Network → Firewall” där du konfigurerar regler på det virtuella nätverkets nivå — de gäller innan paketen når Docker. Ett alternativ är ufw-docker, ett skript som patchar UFW för kompatibilitet med Docker. Men det är mer komplicerat än att klicka i kontrollpanelen. **Fallgrop 3: Cloudflare-proxy (orange moln) bryter Let's Encrypt.** Symtom: efter Redeploy visar loggarna `Let's Encrypt validation failed - challenge returned 403`. Orsak: Cloudflare proxar Let's Encrypts HTTP-förfrågan och returnerar sin egen sida i stället för din utmaningsfil. Lösning — välj ett av två alternativ: 1. **Byt till ”DNS only”** (det grå molnet i Cloudflare). Nackdel: du förlorar Cloudflare CDN och skydd. 2. **Konfigurera en DNS-01-utmaning via Cloudflare API.** Gå till Settings → SSL Configuration i Coolify, välj Cloudflare-leverantören och ange en API-token med behörigheterna Zone:Read och DNS:Edit. Let's Encrypt validerar via en TXT-post i stället för HTTP. Det andra alternativet är mer komplicerat att konfigurera, men bevarar Cloudflare-proxyn. **Fallgrop 4: PAT i stället för GitHub App — PR-förhandsvisningar fungerar inte.** Symtom: du anslöt GitHub med en Personal Access Token; allt fungerar, men förhandsgranskningar av driftsättningar skapas inte för PR:er. Du öppnade en PR i GitHub, men inget dök upp i Coolify. Orsak: förhandsgranskningar av PR:er är en funktion som bara finns i GitHub App. PAT tar inte emot `pull_request`-händelser via en webhook. Lösning: anslut GitHub igen via App. Sources → Add → GitHub App → slutför guiden. Du kan ta bort den gamla PAT-källan. **Fallgrop 5: ”Coolify == Vercel” stämmer inte helt.** Det här gör Coolify **inte** direkt från start: | Vercel | Coolify | Vad du kan göra | |----|----|----| | Global CDN | Nej | Lägg Cloudflare framför (gratis för statiskt innehåll) | | Incremental Static Regeneration | Nej | `revalidatePath` fungerar bara på din server | | Bildoptimering | Nej | Använd `next/image` med en lokal loader eller Cloudflare Images | | Automatisk skalning vid trafiktoppar | Nej | Skala manuellt; uppgradera din VPS | | Edge Functions | Nej | Använd vanliga API-rutter | Om ditt projekt är en SaaS med hög trafik, en global målgrupp och latenskrav på \< 100 ms världen över passar Coolify inte; välj Vercel Enterprise. Om du är en vibe-coder med en MVP som du testar med 100–1,000 användare om dagen täcker Coolify allt. Från en ärlig självhostningsanalys:

Den dolda kostnaden är tid. Om du redan har erfarenhet av Docker, räkna med 5–10 timmar för den första konfigurationen.

— iShostings analys av självhosting
De 15 minuterna i guidens titel syftar på den smidiga vägen till den första driftsättningen av ett projekt. En fullständig infrastrukturkonfiguration med övervakning, säkerhetskopior och aviseringar tar en eller två kvällar. Var ärlig mot dig själv. ## Hur mycket sparar du på ett år jämfört med Vercel?
Det viktigaste Det finns en ”dold tidskostnad” på 5–10 timmar för den första konfigurationen och 1–2 timmar i månaden för underhåll.
Vercel-siffrorna nedan är artikelns scenariouppskattningar från maj 2026, inte aktuella offerter. De är bara ena sidan av jämförelsen. Egen drift av Coolify saknar licensavgift, men VPS, säkerhetskopior, lagring, trafik och driftarbete kostar fortfarande. Skaffa en offert som uppfyller kraven ovan; scenarierna innehöll inget numeriskt VPS-pris, så en fast besparing vore utan stöd. Låt **C** vara den totala månadsräkningen för vald VPS, säkerhetskopielagring, extra trafik, övervakning och eventuellt betalt administrationsalternativ. Räkna varje utgift en gång. Låt **r** vara timkostnaden för driftarbete, med samma valuta överallt. Artikelns tidsuppskattning är 5–10 timmar inledningsvis plus 1–2 timmar per månad: **17–34 timmar första året** och **12–24 timmar senare år**. | Scenario | Vercel-uppskattning/månad | Vercel/år | Coolify-infrastruktur/månad | Coolifys förstaårskostnad inklusive arbete | Första årets besparing mot Vercel | |----|----|----|----|----|----| | En prototyp, 100,000 besök/månad | 20 dollar grundpris + ~5 dollar bandbredd = 25 dollar | 300 dollar | C | 12C + (17–34)r | 300 dollar − 12C − (17–34)r | | Fem projekt på en VPS | 20 dollar grundpris + 30 dollar bandbredd/funktioner = 50 dollar | 600 dollar | C | 12C + (17–34)r | 600 dollar − 12C − (17–34)r | | Tre utvecklare, fem projekt | 60 dollar platser + 30 dollar bandbredd = 90 dollar | 1,080 dollar | C | 12C + (17–34)r | 1,080 dollar − 12C − (17–34)r | Använd olika C för varje scenario om arbetsbelastningarna kräver olika serverstorlekar. Fördela den inledande konfigureringstiden på 12 månader för månadsjämförelsen: första årets månadsmotsvarighet är **C + (17–34)r/12**. Senare års totalkostnad är **12C + (12–24)r**. Formlerna jämför den angivna Vercel-uppskattningen med egen drift; ta också med jämförbart driftarbete på Vercel-sidan. En negativ besparing betyder att egen drift kostar mer med dina indata. Räkna inte samma ingenjörs hela lön igen om r redan inkluderar den. Fyll i C från en verklig leverantörsoffert och säkerhetskopieplan, välj r och jämför faktisk användning under en månad före ett byte. Utan dessa indata stöder artikeln en kostnadsmodell, inte ett belopp för besparingen. Den främsta fördelen är inte pengarna. När du går över till Coolify **försvinner kategorin ”beroende av någon annans betalningspolicy”**. Virtuella mellanhandskort med 20 % provision behövs inte längre. Coolify är inte en billigare Vercel. Det är en annan typ av produkt: du äger infrastrukturen, tar ansvar för den och sparar pengar genom att acceptera dess komplexitet. Om driftsättning av en prototyp är din första uppgift efter att den har skapats i Claude Code ingår hantering av miljön (env, hemligheter, schemalagda jobb, säkerhetskopior) i [**kontextteknik**](https://ailoot.ai/blog/sv/context-engineering/). Utan en struktur för ”var allt finns” går Claude vilse och du förlorar tid vid varje ändring. Den fullständiga konfigurationen innehåller: **AI-klon** ([Skills](https://ailoot.ai/blog/sv/claude-code-skills-library/) och [Subagents](https://ailoot.ai/blog/sv/claude-code-subagents/) anpassade efter din metodik) + [**Second Brain**](https://ailoot.ai/blog/sv/claude-code-second-brain/) (projektets kunskapsbas) + **Context Engineering** ([Plan Mode](https://ailoot.ai/blog/sv/claude-code-plan-mode/), `/compact`, körmiljö). Det här är de **3 grundpelarna** som krävs för att AI inte ska hallucinera.
### Källor - [Coolifys officiella dokumentation: Introduktion](https://coolify.io/docs/get-started/introduction) - [Coolifys installationsguide](https://coolify.io/docs/get-started/installation) - [Översikt över Coolifys byggpaket](https://coolify.io/docs/applications/build-packs/overview) - [Coolifys kunskapsbas om brandväggar](https://coolify.io/docs/knowledge-base/server/firewall) - [Coolifys felsökning för Let's Encrypt](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working) - [Coolifys priser](https://coolify.io/pricing) - [Coolify på GitHub: versioner v4.1.0](https://github.com/coollabsio/coolify/releases) - [Översikt över Claude Code](https://code.claude.com/docs/en/overview) - [Timeweb Cloud VPS](https://timeweb.cloud/services/vds-vps) - [FirstVDS VPS](https://firstvds.ru/products/vds_vps_hosting) - [Selectel VPS/VDS](https://selectel.ru/services/cloud/vps-vds/) - [Vercels priser](https://vercel.com/pricing)
Det fullständiga kontextarbetsflödet: **AI-klon + Second Brain + Context Engineering**. Fler material finns på [Ailoot](https://ailoot.ai/). ## Frågor om den här guiden: Coolify och Claude Code: Driftsätt ett projekt på din egen VPS ### Vilken URL ska returnera JSON efter driftsättning? Kopiera applikationsadressen i Coolifys Domains-fält och öppna dess /api/users-sökväg. Rotadressen är startsidan; /api/users är JSON-slutpunkten som anges i exempelprojektet. ### Hur beräknar jag om egen drift sparar pengar? Summera månatliga avgifter för VPS, säkerhetskopior, lagring, trafik, övervakning och valfri administrationspanel i C. Första årets totalkostnad för egen drift är 12C plus 17–34 timmar till din timkostnad; jämför med scenariots årliga Vercel-uppskattning och ta med jämförbart driftarbete på båda sidor. ## Ailoot · Företaget och dess projektportfölj Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll. Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder. Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.