# Coolify og Claude Code: Deploy et projekt på din egen VPS > Installation af Coolify, tilslutning af GitHub, deployment af Next.js, domæne og HTTPS, MCP, VPS-krav og fejlfinding. Tekniske priser i dollar og oprindelige begrænsninger. Source: https://ailoot.ai/blog/da/coolify-claude-code-deploy/ Canonical: https://ailoot.ai/blog/da/coolify-claude-code-deploy/ Language: da Publisher: Ailoot (https://ailoot.ai/) Translation: guide-087 Revision: sha256-4946347e948a2db44a8d12fb9f13f646ec8acdcde61400957b73dc22a3f875fa
[Ailoot-dokumentation](https://ailoot.ai/docs/) — referencemateriale til arbejde med tjenesten.
## Platformens begrænsninger og betalingsvilkår i 2026
Vigtigste pointe Gratisabonnementer fungerer, indtil du overskrider en grænse for første gang; derefter kræves et internationalt kort. Heroku lukkede sin gratisversion for alle i 2022 og gik i vedligeholdelsestilstand i februar 2026. Med selvhostet Coolify ejer du serveren; der er ingen betaling pr. bruger og ingen leverandørbinding.
Et typisk vibe-coder-scenarie i 2026: Du bygger en MVP i Cursor eller Claude Code på en aften, flytter den til et GitHub-repository, åbner vercel.com → tilslutter repositoryet → når skærmen for abonnement → indtaster dit kort → får `Transaction declined`. Det er ikke en fejl eller et midlertidigt udfald. Railway, Render, Heroku — det er samme historie. Heroku lukkede faktisk sin gratisversion for alle i 2022, og i februar 2026 gik projektet i vedligeholdelsestilstand — ingen nye funktioner og ingen nye Enterprise-aftaler. For en bruger med et kort, der ikke understøttes, betyder det: “Døren er lukket; gå udenom via en mellemmand, der tager 20 % i provision.” Du kan betale via virtuelle Visa-kort i Kasakhstan eller betalingstjenester til virksomheder. Men det betyder +20 % på prisen, +30 minutter for hver transaktion og risiko for, at din konto bliver blokeret, når betalingsformidleren ser, at landene ikke stemmer overens. Det oprindelige eksempel omfattede tre forsøg — på Vercel Pro, Railway og Render. ## Hvad er Coolify, og hvordan fungerer en selvhostet platform?
Vigtigste pointe Coolify er en open source-PaaS, der kan selvhostes, og et direkte alternativ til Heroku, Vercel og Netlify. Den installeres med én curl-kommando på enhver VPS med Ubuntu. Under motorhjelmen bruger den Docker + Traefik til reverse proxy og Let's Encrypt til HTTPS. Den understøtter GitHub-integration, webhooks til automatiske deployments, S3-sikkerhedskopier og 280+ tjenester, der kan installeres med ét klik (PostgreSQL, Redis, MinIO). Den selvhostede version er gratis for altid uden begrænsninger. Den har 55,800 stjerner på GitHub og en Apache-2.0-licens.
Coolify er et open source-projekt bygget med Laravel + Docker, der forvandler enhver tom VPS til en platform til deployment af applikationer. Installer Coolify én gang, og gør derefter alt andet via webgrænsefladen: tilslut GitHub, vælg et repository, og klik på Deploy. Den officielle dokumentation udtrykker det kort og præcist:

Coolify er et open source-alternativ til Heroku / Netlify / Vercel osv., som du kan selvhoste.

— Coolifys GitHub-README, https://github.com/coollabsio/coolify
Under motorhjelmen består Coolify af fire dele: 1. **Webgrænseflade bygget med Laravel 12 + Livewire 3 + Tailwind v4** — et kontrolpanel til administration af dine applikationer. 2. **Docker + Docker Compose** — hver applikation kører i en container, isoleret fra de andre. 3. **Reverse proxy (Traefik eller Caddy)** — modtager indgående HTTP/HTTPS-trafik og videresender den til containere. 4. **Let's Encrypt-integration** — udsteder og fornyer automatisk SSL-certifikater for alle domæner. Vigtige funktioner, der gør Coolify funktionelt sammenlignelig med Vercel: | Funktion | Vercel | Coolify | |----|----|----| | Automatisk deployment ved git-push | ✅ | ✅ (via GitHub-webhook) | | Gratis HTTPS | ✅ | ✅ (Let's Encrypt) | | PR-preview-deployments | ✅ | ✅ (via GitHub App) | | Brugergrænseflade til miljøvariabler | ✅ | ✅ | | Sikkerhedskopiering af databaser | ❌ (ingen egne databaser) | ✅ (til S3-kompatibel lagring) | | PostgreSQL / Redis / MongoDB | \$20+/måned hver | ✅ Ét klik, gratis | | Planlagte opgaver (cron) | ❌ | ✅ (cron-syntaks) | | Betaling pr. bruger | \$20/bruger/måned | Ingen | | Leverandørbinding | Høj (Edge Functions, ISR) | Ingen (din Docker) | | Global CDN | ✅ | ❌ (kun din VPS) | En global CDN er det eneste, Coolify ikke inkluderer fra start. Det er det ærlige svar. Hvis dit projekt har et globalt publikum, og du har brug for at reducere svartiden for brugere i USA og Europa, kan du sætte Cloudflare foran; det er gratis for statisk indhold. Pris: **Den selvhostede version er gratis for altid** uden begrænsninger på antallet af applikationer, servere eller deployments. Coolify Cloud fås for \$5/måned for 2 servere + \$3 for hver ekstra server — men serverne er stadig dine; Coolify Cloud hoster blot kontrolpanelet. Den seneste udgivelse er **v4.1.0 fra 18. maj 2026**. Nye funktioner omfatter buildpakken Railpack i beta, revisionslogning, konfigurationsforskelle mellem deployments og et indbygget MCP-endpoint (skrivebeskyttet). Kilde: [GitHub-udgivelser](https://github.com/coollabsio/coolify/releases). ## Hvilken VPS skal du vælge til Coolify i 2026?
Vigtigste pointe Coolify kræver mindst 2 vCPU, 2 GB RAM, 30 GB SSD og Ubuntu LTS (20.04, 22.04 eller 24.04). En VPS som denne kan uden problemer køre 3–5 vibe-kodede projekter parallelt.
Coolifys minimumskrav kommer direkte fra [den officielle dokumentation](https://coolify.io/docs/get-started/installation): | Parameter | Minimum | Anbefalet | |-------------|----------------------------------|---------------------------| | CPU | 2 kerner | 2–4 kerner | | RAM | 2 GB | 4 GB (med plads til builds) | | Lagerplads | 30 GB | 50–80 GB (til images + databaser) | | Arkitektur | AMD64 eller ARM64 (64-bit) | AMD64 | | OS | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS | | Root | Påkrævet | Via SSH-nøgle, ikke adgangskode | Minimumskravet — 2 GB RAM — er en **hård nedre grænse**. Med 1 GB når installationsprogrammet frem til Docker, løber tør for hukommelse (OOM) og går i stå. Spar ikke på RAM. Priskilder: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting) og [Selectel](https://selectel.ru/services/cloud/vps-vds/). Hvis du har brug for mere kraft (en database på 100 GB, flere Postgres-instanser), skal du vælge Aeza Dedicated. Hvad du IKKE skal vælge: - **Delt VPS med 512 MB–1 GB RAM** — ikke engang nok til Coolify. Den er til statiske websites på nginx, ikke til en PaaS. Vil du ikke kun konfigurere deployment, men også bygge en **opsætning, der gør Claude pålidelig**? Coolify er et værktøj til udførelse, men uden struktureret kontekst ([`CLAUDE.md`](https://ailoot.ai/blog/da/claude-md-template/), en [second brain](https://ailoot.ai/blog/da/claude-code-second-brain/) og [context engineering](https://ailoot.ai/blog/da/context-engineering/)) vil Claude stadig hallucinere på lange opgaver. Den komplette opsætning omfatter alle tre: **AI-klon + Second Brain + Context Engineering** — denne kombination gør Claude fra “en assistent, der hallucinerer” til et pålideligt værktøj. ## Sådan installerer du Coolify på 5 minutter
Vigtigste pointe Installationen udføres med én curl-kommando fra dokumentationen. Når den starter, vises en webgrænseflade på port 8000. Her opretter du den første adminbruger og får vist et tomt kontrolpanel. Den faktiske tid fra en tom Ubuntu-installation til Coolify kører, er 5–7 minutter, hvoraf 3–4 minutter går til `apt-get install docker`. Scriptet henter de nødvendige afhængigheder og konfigurerer selv Docker; du skal bare vente, til det er færdigt.
**Trin 1. Opret forbindelse til VPS'en via SSH.** Når du har oprettet en VPS hos udbyderen, får du serverens IP-adresse og root-adgangskode på e-mail eller i kontrolpanelet. Opret forbindelse fra din lokale maskine: ```bash ssh root@1.2.3.4 ``` Hvis udbyderen gav dig en SSH-nøgle i stedet for en adgangskode, skal du oprette forbindelse med `-i path/to/key`. Herfra forudsætter jeg, at du har en ren Ubuntu 22.04- eller 24.04 LTS-installation. **Trin 2. Kør Coolifys installationskommando.** Én kommando fra [den officielle dokumentation](https://coolify.io/docs/get-started/installation): ```bash curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash ``` Scriptet gør tre ting: 1. Kontrollerer systemet (Ubuntu LTS? root? AMD64?) 2. Installerer Docker og Docker Compose, hvis de ikke allerede er installeret 3. Henter Coolify-images (`coolify/coolify`, `coolify/realtime`, `traefik`) og kører dem i baggrunden via docker-compose Det tager 3–5 minutter. Du vil se `apt-get`-logfiler rulle forbi efterfulgt af `docker pull`. Når du ser `Coolify v4.1.0 is now running`, skal du gå til trin 3. **Trin 3. Åbn webgrænsefladen.** Åbn dette i din browser: ``` http://1.2.3.4:8000 ``` Coolify viser en opsætningsguide — en formular til oprettelse af den første bruger. Indtast en e-mailadresse og en adgangskode, og gem dem. Denne bruger bliver automatisk admin; du behøver ikke flere brugere endnu. Når du har gemt, lander du på et tomt kontrolpanel: en sidemenu til venstre med Resources / Projects / Servers / Sources / Notifications / Settings og en prompt i midten om at “Add your first resource.” **Trin 4. Åbn porte i udbyderens firewall (ikke UFW).** Coolify kører allerede, men udefra er kun port 8000 (kontrolpanelet) tilgængelig. For at brugerne kan nå dine applikationer, skal du åbne port 80 (HTTP) og 443 (HTTPS): | Port | Formål | |----|----| | 22 | SSH-adgang til serveren | | 80 | Modtager HTTP-trafik, påkrævet til Let's Encrypt-validering | | 443 | Modtager brugernes HTTPS-trafik | | 8000 | Coolifys kontrolpanel (vi lukker den efter konfiguration af et brugerdefineret domæne til kontrolpanelet) | En vigtig faldgrube fra den officielle dokumentation:

Docker bruger NAT-baserede iptables-regler, som kan omgå traditionelle Linux-firewalls som UFW.

— Coolify-dokumentation (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Det betyder, at selv hvis du aktiverer UFW og lukker alle porte, vil Docker stadig eksponere sine containere via iptables. UFW er ubrugelig her. Løsningen er at **åbne og lukke porte i udbyderens kontrolpanel**, ikke via UFW. Hos Timeweb / Selectel / Aeza gør du dette i webkonsollens afsnit “Network → Firewall”. **Trin 5 (valgfrit). Tilknyt kontrolpanelet til dit domæne.** Hvis du vil besøge `https://coolify.example.com` i stedet for `http://1.2.3.4:8000`, skal du oprette en DNS A-record `coolify.example.com → 1.2.3.4`, gå til **Settings → Instance Settings → Instance Domain** i Coolify, indtaste dit subdomæne og gemme. Coolify anmoder om et Let's Encrypt-certifikat og genindlæser kontrolpanelet via HTTPS et minut senere. Derefter kan du lukke port 8000 i firewallen — kontrolpanelet vil være tilgængeligt via HTTPS på standardport 443. ## Sådan tilslutter du GitHub: App eller PAT?
Vigtigste pointe Coolify understøtter to måder at tilslutte GitHub på: **GitHub App** (anbefalet) og **Personal Access Token (PAT)**. Brug GitHub App: Opsætningen tager 5 minutter med guiden, PR-previews fungerer, og tilladelser kan afgrænses præcist på repositoryniveau. PAT er en forældet mulighed til ældre særtilfælde; den har ingen preview-deployments og indebærer risiko for global adgang til alle dine repositories. Den officielle dokumentation siger det direkte: “For 95% af brugerne er GitHub App det rigtige valg.”
I Coolify skal du gå til **Sources → + Add → GitHub App**. Coolify viser en guide med tre skærmbilleder: 1. **Navn og beskrivelse** — navngiv kilden (indtast `github-main`), og tilføj eventuelt en beskrivelse. 2. **Konfigurer på GitHub** — en knap, der sender dig til GitHub.com og automatisk åbner en formular til oprettelse af en GitHub App med de korrekte tilladelser. 3. **Bekræft** — når du er vendt tilbage fra GitHub, skal du klikke på “Save”. I andet trin beder GitHub dig bekræfte de tilladelser, Coolify anmoder om: | Tilladelse | Niveau | Formål | |-----------------|------------|----------------------------------------------| | Contents | Skrivebeskyttet | Klone repositoryet | | Pull Requests | Læs og skriv | Oprette preview-deployments og kommentere på PR'er | | E-mailadresser | Skrivebeskyttet | Identificere commits | | Metadata | Skrivebeskyttet | Vise repositories | Dette er **minimumstilladelser** — GitHub App kan ikke se dine private nøgler, kan ikke skrive til `main` og kan ikke få adgang til repositories, du ikke udtrykkeligt har tilsluttet. Fra den officielle dokumentation: Personal Access Token (PAT) er den gamle metode; jeg **anbefaler, at du ikke bruger den**. Ulemper: - PAT giver global adgang til alle dine repositories (herunder private) - PR-previews fungerer ikke — funktionen er forbeholdt GitHub App - Tokenet gælder i lang tid (90 dage, et år eller ubegrænset) — hvis det lækker, er det et problem Brug kun PAT, hvis du arbejder med et organisationsrepository, hvor sikkerhedspolitikken forbyder GitHub Apps, og der ikke findes nogen løsning. Når du har gemt kilden i Coolify, kan du se GitHub App i kontrolpanelet med en liste over tilsluttede repositories. Når du opretter en ny applikation, kan du vælge et af dem med ét klik. ## Sådan deployer du et Next.js-projekt fra Claude Code i 6 trin
Vigtigste pointe Hele vejen fra en tom Claude Code-opsætning til et aktivt website: 1) Kør `claude` i en tom mappe, beskriv projektet, og lad Claude generere koden; 2) kør `git init && git remote add` (Claude kan selv gøre det via en slash-kommando); 3) push til GitHub; 4) vælg “+ New Resource → Application” i Coolify, og vælg repositoryet; 5) tilføj miljøvariabler; 6) klik på Deploy. Coolify registrerer, at det er Next.js, vælger buildpakken Nixpacks, bygger et Docker-image på 3–5 minutter og giver dig et midlertidigt domæne med HTTPS fra start.
**Trin 1. Beskriv projektet for Claude Code i en tom mappe.** ```bash mkdir my-vibe-app cd my-vibe-app git init claude ``` I sessionen: ``` Byg et Next.js 14 app router-projekt: - en startside med en liste over brugere - /api/users-endpointet returnerer et array fra databasen - Postgres via Prisma - Tailwind til styling - .env.example med DATABASE_URL - README.md med instruktioner til at køre projektet ``` Claude genererer filstrukturen, package.json, prisma/schema.prisma og .env.example. Bed også om: ``` Opret en Dockerfile til produktionsbuilds og en .dockerignore. ``` Det er valgfrit — Coolify bygger med Nixpacks, selv uden en Dockerfile. Men en Dockerfile giver dig kontrol over processen og er hurtigere for større projekter. **Trin 2. Opret et GitHub-repository, og push til det.** Du kan gøre det manuelt via GitHub-brugerfladen + `git remote add origin ...`, men Claude Code kan gøre det selv: ``` /commit-push-pr Første Next.js-app genereret med Claude Code ``` Eller sig bare: “Commit det hele, og push det til et nyt repository `my-vibe-app` under min konto.” Claude bruger `gh`-CLI'en til at oprette et privat (eller offentligt) repository og foretage det første push. Kilde: [officiel Claude Code-kommando](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md). **Trin 3. Opret en Application i Coolify.** Klik på **+ New → Application** i Coolifys kontrolpanel. En formular åbnes: 1. **Source** — vælg `github-main` (GitHub App'en, du tilsluttede i det foregående H2) 2. **Repository** — vælg `my-vibe-app` fra listen 3. **Branch** — `main` 4. **Build Pack** — Coolify registrerer det automatisk. Hvis der findes en Dockerfile, bruger den `dockerfile`. Ellers bruger den `nixpacks`. Du kan tilsidesætte dette manuelt. 5. **Domain** — behold den foreslåede værdi indtil videre; den er midlertidig, og du erstatter den med din egen senere 6. **Port** — `3000` som standard til Next.js Gem. **Trin 4. Tilføj miljøvariabler.** Åbn fanen **Environment Variables** i den oprettede applikation. Tilføj variablerne én ad gangen: ``` DATABASE_URL=postgresql://user:pass@db-host:5432/mydb NODE_ENV=production ANTHROPIC_API_KEY=sk-ant-... ``` Hvis du ikke har en database, kan du oprette en direkte i Coolify: **+ New → Database → PostgreSQL**. Coolify starter en Postgres-container på 30 sekunder og viser en intern DATABASE_URL i formatet `postgresql://postgres@postgres-xyz:5432/postgres` — indsæt den i din applikation. Alle variabler krypteres i Coolify-databasen og vises ikke i buildlogs. **Trin 5. Klik på Deploy.** Øverst til højre er der en blå Deploy-knap. Live-logs vises under fanen 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ørste build tager 3–5 minutter (det henter Node-basis-imaget og installerer afhængigheder). Senere builds tager 60–90 sekunder takket være Docker-lagcaching. Når status ændres til **Running**, skal du kopiere applikations-URL’en fra Coolifys felt **Domains** og åbne præcis den URL i browseren. Brug værdien som `` nedenfor; betegnelsen i vinkelparenteser er en pladsholder, ikke en rigtig adresse. Din startside bør vises med HTTPS fra start. En gratis wildcard-DNS-tjeneste slår ethvert subdomæne op, som indeholder en IP-adresse (`1-2-3-4.` → `1.2.3.4`). Coolify bruger den til midlertidige domæner, så du kan åbne websitet med det samme uden at konfigurere din egen DNS. **Trin 6. Kontrollér, at alt fungerer.** Åbn applikations-URL’en fra forrige trin med `/api/users` tilføjet, for eksempel `/api/users` uden dobbelt skråstreg. Det er JSON-endpointet fra trin 1; applikationens rod-URL er startsiden. Hvis der opstår en 500-fejl, kan du se stacktracen under fanen Logs. Det mest almindelige problem ved første deployment er, at DATABASE_URL peger på en database, der ikke findes. Løs det ved at oprette en PostgreSQL-instans i Coolify (se trin 4 ovenfor) og erstatte DATABASE_URL. 15 minutter fra det øjeblik, du bestiller VPS'en. I det oprindelige eksempel tog arbejdsgangen 12–18 minutter på en ny server. ## Sådan konfigurerer du et brugerdefineret domæne og HTTPS
Vigtigste pointe Et brugerdefineret domæne tilsluttes i 3 trin: Opret en DNS A-record, der peger på serverens IP, indtast dit domæne i Coolifys konfiguration i stedet for det midlertidige domæne, aktivér Automatic HTTPS, og klik på Redeploy. Let's Encrypt udsteder automatisk et SSL-certifikat 2–3 minutter efter DNS-propagation (normalt 5–30 minutter). Det afgørende krav er, at DNS allerede skal pege korrekt, når du klikker på Redeploy; ellers mislykkes Let's Encrypt-valideringen, og du må vente 12 minutter til næste forsøg.
**Trin 1. Opret en DNS A-record i din registrators kontrolpanel.** De oprindelige eksempler bruger domæner hos Reg.ru, Beget eller Timeweb. Fremgangsmåden er den samme: | Recordtype | Navn | Værdi | |------------|---------------------------|------------------------| | A | `app` (eller `@` for roden) | `1.2.3.4` (serverens IP) | Gem den, åbn en konsol, og kontrollér: ```bash dig app.example.com +short # Bør returnere 1.2.3.4 ``` Hvis der ikke returneres noget, eller IP-adressen er en anden, er DNS endnu ikke propageret. Vent 5–30 minutter. **Trin 2. Indtast dit domæne i Coolify.** Åbn fanen **Configuration → General** i applikationen. I feltet **Domains** skal du erstatte den midlertidige applikations-URL kopieret fra Coolify med `https://app.example.com` (med dit eget konfigurerede domæne). Aktivér **Automatic HTTPS** (det er som regel aktiveret som standard). Gem, og klik på **Redeploy**. **Trin 3. Vent på Let's Encrypt-certifikatet.** Buildlogs viser: ``` [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 minutter vil dit website være tilgængeligt på `https://app.example.com` med en grøn hængelås i adresselinjen. Hvad der kan gå galt med Let's Encrypt (de 3 største problemer fra [den officielle fejlfindingsvejledning](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)): 1. **Port 80 er lukket i firewallen.** Let's Encrypt validerer med en HTTP-challenge — den sender en forespørgsel til `http://app.example.com/.well-known/acme-challenge/xxx`. Valideringen lykkes ikke uden port 80. Åbn den i udbyderens firewall. 2. **Cloudflare-proxy er aktiveret (orange sky).** Den opfanger Let's Encrypt-forespørgslen og returnerer sin egen pladsholderside — valideringen mislykkes. Løsningen er at skifte til “DNS only” (grå sky) eller konfigurere en DNS-01-challenge via Cloudflare API. 3. **DNS er endnu ikke propageret.** Hvis du oprettede en A-record for 30 sekunder siden og straks klikkede på Redeploy, kan Let's Encrypt ikke se dit domæne. Vent 5–30 minutter på, at DNS propagerer på tværs af servere. Let's Encrypts hastighedsgrænse: **5 mislykkede forsøg i timen for ét domæne**, med genopretning på 1 forsøg hver 12. minut. Hvis du rammer grænsen, skal du ikke klikke på Redeploy 10 gange i træk; kontrollér loggene, løs problemet, og prøv igen om 12 minutter. ## Hvordan administrerer Claude Code Coolify via MCP?
Vigtigste pointe Via Model Context Protocol får Claude Code direkte adgang til Coolify API — du kan sige “deploy denne applikation” for at starte et build, kontrollere status, læse logs eller opdatere miljøvariabler. Der er tre muligheder: forsonny/Coolify-MCP-Server (grundlæggende, 7 operationskategorier), dazeb/coolify-mcp-enhanced (15+ ekstra værktøjer med deployment af databaser med ét klik) og ajmcclary/Coolify-Manager (en Claude Skill bygget omkring den officielle CLI). Fra og med v4.1.0 (18. maj 2026) leverer Coolify et indbygget MCP-endpoint uden tredjepartsservere — men det er skrivebeskyttet indtil videre.
Model Context Protocol (MCP) er en standard fra Anthropic, der lader Claude Code kommunikere med eksterne systemer (se [vejledningen til MCP-servere](https://ailoot.ai/blog/da/mcp-servers-claude-code/) for mere). Tilslut en MCP-server, så får Claude et sæt værktøjer, den kan kalde. Der findes tre færdige servere til Coolify plus én indbygget mulighed. **Mulighed 1. forsonny/Coolify-MCP-Server-for-Claude-Code — grundlæggende.** Det kan den gøre: - **Applications:** oprette, starte, stoppe, genstarte - **Services:** liste, oprette, starte/stoppe/genstarte - **Deployments:** vise igangværende, hente efter UUID - **Teams & Members:** liste, hente oplysninger - **SSH Keys:** liste, oprette - **Environment Variables:** fuld CRUD for apps og tjenester - **Server Insights:** domæner pr. server, tilstand, 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 # konfigurerer Claude Code automatisk ``` Derefter kan du skrive dette i Claude Code: ``` Vis status for applikationen my-vibe-app i Coolify og de 3 seneste deployments. ``` Claude returnerer en tabel. **Mulighed 2. dazeb/coolify-mcp-enhanced — udvidet (anbefalet).** Det tilføjer følgende til grundpakken: - **Deployment af PostgreSQL / Redis / MinIO med ét klik** via AI — bed den om at “sætte Postgres op for mig”, så opretter den en container og returnerer DATABASE_URL - **Overvågning i realtid + ressourceforbrug** — CPU/RAM for hver applikation i realtid - **Masseopdatering af env-konfiguration** — opdater 20 variabler med én kommando - **Docker Compose-understøttelse** — deploy applikationer med flere tjenester Konfiguration til Claude Code (`.mcp.json` i projektets rodmappe): ```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" } } } } ``` **Mulighed 3. ajmcclary/Coolify-Manager — en Claude Skill bygget omkring CLI'en.** Det er ikke en MCP-server, men en Claude Code Skill, der indpakker den officielle Coolify CLI. Den omfatter: - Sundhedsdiagnostik for tjenester og containere - Diagnostik af SSL-certifikater - Understøttelse af flere instanser (hvis du har flere Coolify-servere) - Fejlfindingsopskrifter Installation: Download skillen, og læg den i `~/.claude/skills/coolify-manager/`. Claude Code finder den og tilbyder den til relevante opgaver. **Mulighed 4 (ny i maj 2026). Indbygget MCP i Coolify v4.1.0.** Ændringsloggen for v4.1.0, dateret 18. maj 2026, siger: > Tilføjet MCP-understøttelse på instansniveau med skrivebeskyttede værktøjer til Coolify-ressourcer og API/UI. Coolify tilbyder nu sit eget MCP-endpoint — du kan tilslutte Claude Code direkte uden tredjepartsservere. Indtil videre er det **skrivebeskyttet** (applikationslister, statusser, konfigurationer) uden mulighed for ændringer. Men det er nok til de fleste opgaver som “fortæl mig om infrastrukturen”. Tilslut via `.mcp.json`: ```json { "mcpServers": { "coolify-native": { "url": "https://coolify.example.com/api/v1/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Vent på fuld skriveadgang i den indbyggede MCP i v4.2 eller v4.3 — Coolify-teamet lovede det inden udgangen af 2026. ## 5 faldgruber ved din første deployment — og hvordan du undgår dem
Vigtigste pointe De hyppigste fejl ved den første deployment er for lidt RAM, en lukket port 80, Cloudflare-proxy, der ødelægger Let's Encrypt, UFW, der ikke beskytter Docker, og valg af PAT i stedet for GitHub App. De er alle beskrevet i den officielle dokumentation, men det er let at støde på dem uden praktisk erfaring. Nedenfor er en tjekliste med 5 punkter, der bygger på den oprindelige erfaring med at installere Coolify for første gang.
**Faldgrube 1: Under 2 GB RAM — installationen mislykkes med OOM.** Symptom: `curl install.sh` når `docker pull coolify/coolify`, går i stå ved 70 %, og processen bliver derefter afsluttet med `Killed (signal 9)`. Loggene fra `dmesg | tail` viser `Out of memory: Killed process`. Løsning: ```bash # Opret en swapfil på 4 GB for midlertidigt at løse 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ængere sigt bør du opgradere til 4 GB RAM. Coolify fungerer med swap, men builds af store Next.js-projekter kan mislykkes. **Faldgrube 2: UFW er aktiveret, men Docker åbner stadig porte.** Symptom: Du aktiverede UFW og lukkede alle porte undtagen 22, men din applikation er stadig tilgængelig fra internettet på en tilfældig port (for eksempel 3000). Årsagen, fra [den officielle dokumentation](https://coolify.io/docs/knowledge-base/server/firewall):

Coolify kører på Docker, som bruger NAT-baserede iptables-regler og kan omgå traditionelle Linux-firewalls som UFW.

— Coolify-dokumentation (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Løsning: Brug **firewallen i udbyderens kontrolpanel**, ikke UFW. Timeweb / Selectel / Aeza har et afsnit kaldet “Firewall” eller “Network → Firewall”, hvor du konfigurerer regler på det virtuelle netværksniveau — de gælder, før pakkerne når Docker. Et alternativ er ufw-docker, et script, der tilpasser UFW, så det fungerer sammen med Docker. Men det er mere kompliceret end at klikke i kontrolpanelet. **Faldgrube 3: Cloudflare-proxy (orange sky) ødelægger Let's Encrypt.** Symptom: Efter Redeploy viser loggene `Let's Encrypt validation failed - challenge returned 403`. Årsag: Cloudflare videresender Let's Encrypts HTTP-anmodning og returnerer sin egen side i stedet for din challenge-fil. Løsning — vælg én af to muligheder: 1. **Skift til “DNS only”** (den grå sky i Cloudflare). Ulempe: Du mister Cloudflare CDN og beskyttelse. 2. **Konfigurer en DNS-01-challenge via Cloudflare API.** Gå til Settings → SSL Configuration i Coolify, vælg Cloudflare som udbyder, og indtast et API-token med tilladelserne Zone:Read og DNS:Edit. Let's Encrypt validerer via en TXT-record i stedet for HTTP. Den anden mulighed er mere kompliceret at konfigurere, men bevarer Cloudflare-proxyen. **Faldgrube 4: PAT i stedet for GitHub App — PR-previews fungerer ikke.** Symptom: Du tilsluttede GitHub via en Personal Access Token; alt fungerer, men preview-deployments bliver ikke oprettet for PR'er. Du åbnede en PR i GitHub, men intet dukkede op i Coolify. Årsag: PR-previews er en funktion, der kun findes i GitHub App. PAT modtager ikke `pull_request`-hændelser via en webhook. Løsning: Tilslut GitHub igen via App. Sources → Add → GitHub App → gennemfør guiden. Du kan slette den gamle PAT-kilde. **Faldgrube 5: “Coolify == Vercel” er ikke helt rigtigt.** Det gør Coolify **ikke** fra start: | Vercel | Coolify | Hvad du skal gøre | |----|----|----| | Global CDN | Nej | Sæt Cloudflare foran (gratis for statisk indhold) | | Incremental Static Regeneration | Nej | `revalidatePath` fungerer kun på din server | | Billedoptimering | Nej | Brug `next/image` med en lokal loader eller Cloudflare Images | | Automatisk skalering ved spidsbelastning | Nej | Skalér manuelt; opgradér din VPS | | Edge Functions | Nej | Brug almindelige API-ruter | Hvis dit projekt er en SaaS med høj trafik, et globalt publikum og krav om en latenstid på \< 100 ms på verdensplan, passer Coolify ikke; vælg Vercel Enterprise. Hvis du er en vibe-coder med en MVP, du tester med 100–1,000 brugere om dagen, dækker Coolify alt. Fra en ærlig analyse af selvhosting:

Den skjulte omkostning er tid. Hvis du allerede har erfaring med Docker, skal du afsætte 5–10 timer til den indledende opsætning.

— iShostings analyse af selvhosting
De 15 minutter i guidens titel henviser til den problemfri vej til den første deployment af ét projekt. En komplet infrastrukturopsætning med overvågning, sikkerhedskopier og alarmer tager en aften eller to. Vær ærlig over for dig selv. ## Hvor meget sparer du på et år sammenlignet med Vercel? Vercel-tallene nedenfor er artiklens scenarieestimater fra maj 2026, ikke aktuelle tilbud. De er kun den ene side af sammenligningen. Selvhostet Coolify har ingen licensbetaling, men VPS, sikkerhedskopier, lager, trafik og drift koster stadig penge. Indhent et tilbud, der opfylder kravene ovenfor; scenarierne angiver ingen numerisk VPS-pris, så en fast besparelsespåstand ville være uden grundlag. Lad **C** være den samlede månedlige infrastrukturregning for den valgte VPS, backup-lager, ekstra trafik, overvågning og eventuel betalt kontrolpanelmulighed. Medregn hver udgift én gang. Lad **r** være din timepris for driftsarbejde med samme valuta overalt. Artiklens tidsestimat er 5–10 timer i starten plus 1–2 timer om måneden: **17–34 timer første år** og **12–24 timer i senere år**. | Scenarie | Vercel-estimat/måned | Vercel/år | Coolify-infrastruktur/måned | Coolify-TCO første år inklusive arbejde | Besparelse første år mod Vercel | |----|----|----|----|----|----| | Én prototype, 100.000 besøg/måned | 20 dollar grundpris + cirka 5 dollar båndbredde = 25 dollar | 300 dollar | C | 12C + (17–34)r | 300 dollar − 12C − (17–34)r | | Fem projekter på én VPS | 20 dollar grundpris + 30 dollar båndbredde/funktioner = 50 dollar | 600 dollar | C | 12C + (17–34)r | 600 dollar − 12C − (17–34)r | | Tre udviklere, fem projekter | 60 dollar pladser + 30 dollar båndbredde = 90 dollar | 1.080 dollar | C | 12C + (17–34)r | 1.080 dollar − 12C − (17–34)r | Brug et separat C til hvert scenarie, hvis arbejdsbelastningerne kræver forskellige serverstørrelser. Fordel startopsætningen over 12 måneder til en månedlig sammenligning: Første års månedlige ækvivalent er **C + (17–34)r/12**. TCO i senere år er **12C + (12–24)r**. Formlerne sammenligner det anførte Vercel-estimat med selvhostingudgifter; medregn også sammenlignelige driftsomkostninger på Vercel-siden. En negativ besparelse betyder, at selvhosting koster mere med dine input. Medregn ikke samme ingeniørs fulde løn igen, hvis r allerede indeholder den. Udfyld C fra et reelt udbydertilbud og en backupplan, vælg r, og sammenlign derefter faktisk brug over en måned før skift. Uden disse input underbygger artiklen en prismodel, ikke en besparelse i dollar. Et reelt eksempel fra MassiveGRIDs analyse (en aktiv virksomhedsapp): Den største fordel er ikke pengene. Når du skifter til Coolify, **forsvinder kategorien “afhængig af en andens betalingspolitik”**. Virtuelle formidlerkort med 20 % provision er ikke længere nødvendige. Coolify er ikke en billigere Vercel. Det er en anden kategori af produkt: Du ejer infrastrukturen, tager ansvar for den og sparer penge ved at acceptere dens kompleksitet. Hvis deployment af en prototype er din første opgave efter generering i Claude Code, er administration af miljøet (env, hemmeligheder, planlagte opgaver, sikkerhedskopier) en del af [**context engineering**](https://ailoot.ai/blog/da/context-engineering/). Uden en struktur for “hvor alting ligger”, farer Claude vild, og du spilder tid ved hver ændring. Den komplette opsætning omfatter: **AI-klon** ([Skills](https://ailoot.ai/blog/da/claude-code-skills-library/) og [Subagents](https://ailoot.ai/blog/da/claude-code-subagenter/) tilpasset din metode) + [**Second Brain**](https://ailoot.ai/blog/da/claude-code-second-brain/) (projektets vidensbase) + **Context Engineering** ([Plan Mode](https://ailoot.ai/blog/da/claude-code-plan-mode/), `/compact`, eksekveringsmiljø). Det er de **3 grundpiller**, som AI har brug for for ikke at hallucinere.
### Kilder - [Coolifys officielle dokumentation: Introduktion](https://coolify.io/docs/get-started/introduction) - [Coolifys installationsvejledning](https://coolify.io/docs/get-started/installation) - [Oversigt over Coolifys buildpakker](https://coolify.io/docs/applications/build-packs/overview) - [Coolifys vidensbase om firewall](https://coolify.io/docs/knowledge-base/server/firewall) - [Coolifys fejlfinding af Let's Encrypt](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working) - [Coolify-priser](https://coolify.io/pricing) - [Coolify på GitHub: udgivelser v4.1.0](https://github.com/coollabsio/coolify/releases) - [Oversigt over 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/) - [Vercel-priser](https://vercel.com/pricing)
Den komplette kontekstworkflow: **AI-klon + Second Brain + Context Engineering**. Flere materialer findes på [Ailoot](https://ailoot.ai/). ## Spørgsmål og svar ### Hvilken URL skal returnere JSON efter deployment? Kopiér applikations-URL’en fra Coolifys felt Domains, og åbn dens /api/users-sti. Rod-URL’en er startsiden; /api/users er JSON-endpointet angivet i eksempelprojektet. ### Hvordan beregner jeg, om selvhosting sparer penge? Læg månedlige udgifter til VPS, backup, lager, trafik, overvågning og eventuelt kontrolpanel sammen i C. Første års samlede selvhostingpris er 12C plus 17–34 timer til din timepris. Sammenlign med scenariets årlige Vercel-estimat, og medregn sammenlignelige driftsomkostninger på begge sider. ## Ailoot · Virksomheden og dens projektportefølje Ailoot bygger på solid driftserfaring, en stor kundebase, stabil service og løbende kontrol af KPI. Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder. Ailoot bruger denne driftserfaring til API-adgang til AI-funktioner i kundernes produkter, agenter, applikationer og automatiseringer.