november 2026
Coolify in Production
Waarom Nashua Coolify onderschrijft, en hoe wij het bouwen: een geharde Ubuntu LTS-host, de Coolify-installer, CrowdSec met Traefik AppSec, Docker en Kubernetes, en een Claude Code- en GitHub-pijplijn voor CI/CD.
Samenvatting
Coolify is een open-source, zelf-gehost platform dat een gewone Linux-server verandert in een deploymentplatform met het gemak van een managed cloud en zonder enige lock-in. Bij Nashua onderschrijven wij het als dé manier om je eigen hosting te bezitten, en dit is het praktijkartikel achter die aanbeveling: een complete, uitgesproken build. Wij beginnen met een geharde Ubuntu LTS-host, installeren Coolify, en plaatsen er een echte beveiligingsrand voor met CrowdSec en de Traefik AppSec-webapplicatiefirewall. Wij laten zien hoe workloads werkelijk draaien, Docker eerst, omdat dat is wat Coolify orkestreert, en Kubernetes eerlijk, omdat dat een andere beslissing is. En wij knopen de ontwikkellus aaneen die het platform de moeite waard maakt: Claude Code om te bouwen, GitHub voor review en continuous integration, en Coolify voor continue deployment, zodat een commit een geteste, draaiende service wordt zonder dat een mens een server aanraakt. Het is een soevereine werkplek voor je eigen software, en Nashua bouwt, beveiligt en draait die.
Trefwoorden: Coolify; zelf-gehoste PaaS; Ubuntu LTS; serverhardening; CrowdSec; Traefik; AppSec; webapplicatiefirewall; Docker; Docker Swarm; Kubernetes; Claude Code; GitHub; CI/CD; continue deployment; vibe coding; digitale soevereiniteit; DevOps; infrastructuur als dienst
1. Inleiding
Een ontwikkelteam staat tegenwoordig voor een keuze die vroeger eenvoudig was. Je kunt een managed platform huren, Heroku, Vercel, Render en hun soortgenoten, en een deploy krijgen bij elke push, in ruil voor een rekening per gebruiker en per service die zich opstapelt en een afhankelijkheid die je niet beheerst. Of je kunt je eigen servers draaien en accepteren dat je nu verantwoordelijk bent voor het ongedifferentieerde zware werk dat de managed platforms verbergen: provisioning, reverse proxies, TLS-certificaten, buildpipelines, rollbacks en de rest. Jarenlang won de eerste optie standaard, omdat de tweede werkelijk te veel werk was.
Die rekensom is veranderd, en wat haar veranderde is Coolify. Coolify is een open-source, zelf-gehost platform dat bovenop Docker zit en een gewone Linux-server de ergonomie van een managed cloud geeft: verbind een Git-repository, en het bouwt je applicatie, draait die in een container, zet die achter een reverse proxy, verstrekt en vernieuwt het TLS-certificaat ervan, en redeployt die bij elke push. Het doet voor je eigen software wat Nextcloud doet voor je bestanden en samenwerking: het laat je het platform bezitten in plaats van het te huren. Daarom onderschrijft Nashua het, en dit artikel is de build achter de aanbeveling.
Dit is een praktijkartikel, geen overzichtsstudie. Het is een uitgesproken, end-to-end recept om Coolify op te zetten zoals wij het voor een klant zouden draaien, en het is bewust concreet. Wij harden een Ubuntu LTS-host (paragraaf 3), installeren Coolify en beveiligen de control plane ervan (paragraaf 4), en plaatsen er een echte beveiligingsrand voor met CrowdSec en de Traefik AppSec-webapplicatiefirewall (paragraaf 5). Wij zijn helder over workloads: Docker is wat Coolify orkestreert en wat de meeste teams zouden moeten gebruiken (paragraaf 6), en Kubernetes is een afzonderlijke, zwaardere beslissing die wij eerlijk behandelen in plaats van als een vinkje (paragraaf 7). Ten slotte knopen wij de lus aaneen die het geheel laat renderen: Claude Code, GitHub en continue deployment (paragraaf 8), voordat wij een woord wijden aan het draaien ervan (paragraaf 9). Figuur 1 toont de vorm van het resultaat.
2. Waarom Nashua Coolify onderschrijft
Ons standpunt over de digitale werkplek, elders uiteengezet, is dat een organisatie de gereedschappen waarvan zij afhankelijk is zou moeten bezitten in plaats van ze onbepaald te huren op voorwaarden die zij niet zelf bepaalt. Hetzelfde argument geldt met volle kracht voor de plek waar je eigen software draait. Een managed applicatieplatform is een gemakkelijke huisbaas, en zoals elke huisbaas bezit het het gebouw, bepaalt het de huur en kan het beide veranderen.
Coolify beantwoordt dat zonder het gemak op te geven. Het is open source, gelicentieerd zodat je het kunt lezen, draaien en uitbreiden. Het draait op hardware die je kiest, in een land dat je kiest, onder een recht dat je kiest, wat het een soeverein platform maakt in precies de zin die ertoe doet voor de GDPR en NIS2. De kosten ervan zijn de kosten van een server en het werk om die goed te draaien, niet een lijfrente per gebruiker die meegroeit met je succes. En het is geen speelgoed: het beheert builds, deployments, databases, TLS, back-ups en previews over één server of vele, met een webinterface die een team daadwerkelijk kan gebruiken. Voor een organisatie die er al waarde aan hecht haar data te bezitten, is het bezitten van het platform waarop haar software draait dezelfde beslissing tweemaal genomen. Daarom onderschrijven wij het, en daarom zijn wij bereid onze naam aan een build-gids ervoor te verbinden.
3. De host: een geharde Ubuntu LTS-server
Alles begint met de server, en de server begint met een long-term-support besturingssysteem. Wij bouwen op Ubuntu LTS omdat het het platform is waarop Coolify, Docker en het bredere ecosysteem zich het eerst richten en dat zij het langst ondersteunen. Op het moment van schrijven deployen wij voor productie op Ubuntu 24.04 LTS: het is beproefd, en het wordt met beveiligingsupdates ondersteund tot in 2029. Ubuntu 26.04 LTS is beschikbaar voor nieuwe builds die de langere horizon willen; wij laten een point release eerst bezinken voordat wij een LTS onder de productieworkload van een klant zetten. Twee cores, 2 GB RAM en 10 GB schijf zijn de gedocumenteerde ondergrens voor Coolify; wij schalen daarvandaan op, omdat builds vraatzuchtig zijn en speelruimte goedkoop is.
Een verse server is geen veilige server. Voordat Coolify die aanraakt, brengen wij hem volledig bij en installeren wij de gereedschappen die hem actueel en bewaakt houden:
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y ufw fail2ban \
unattended-upgrades
Vervolgens maken wij een niet-geprivilegieerde beheergebruiker aan en stoppen wij met het rechtstreeks gebruiken van root:
sudo adduser deploy
sudo usermod -aG sudo deploy
3.1 SSH op slot zetten
De waardevolste hardeningstap is om externe aanmelding te laten afhangen van een sleutel, niet van een wachtwoord, en het root-account een externe shell volledig te ontzeggen. Kopieer je publieke sleutel naar de nieuwe gebruiker met ssh-copy-id deploy@your-server, bevestig dat je er mee kunt inloggen, en schrijf dan een drop-in die de zwakkere opties uitsluit:
# /etc/ssh/sshd_config.d/99-hardening.conf
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
Herlaad de daemon met sudo systemctl restart ssh, en houd je huidige sessie open totdat een tweede sessie bewijst dat de sleutel werkt. Met wachtwoorden uitgeschakeld houdt het leeuwendeel van de geautomatiseerde SSH-aanvallen eenvoudigweg op ertoe te doen, en fail2ban handelt de ruis af die overblijft.
3.2 Een standaard-weigeren firewall
De host zou alleen het verkeer moeten accepteren dat hij moet. Wij gebruiken de uncomplicated firewall om standaard al het inkomende te weigeren en openen dan de drie deuren die het platform nodig heeft: SSH voor ons, en HTTP en HTTPS voor de applicaties die Coolify zal serveren.
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
Let op wat wij niet openen: poort 8000, waar het Coolify-dashboard luistert. De control plane heeft niets te zoeken op het publieke internet, en paragraaf 4 legt uit hoe wij die bereiken zonder die bloot te stellen.
3.3 Patchen terwijl je slaapt
Een server die actueel is, is een server die niet kwetsbaar is voor de exploit van vorige maand. Wij laten Ubuntu beveiligingsupdates automatisch en onbeheerd toepassen:
sudo dpkg-reconfigure \
-plow unattended-upgrades
Dit, een SSH-deur met alleen een sleutel, een standaard-weigeren firewall en fail2ban vormen de basis. Ze zijn niet exotisch, en dat is precies het punt: de meeste inbreuken maken misbruik van de afwezigheid van het gewone, niet van de aanwezigheid van het ingenieuze. Voor gereguleerde klanten gaan wij verder, naar een erkende benchmark zoals de CIS Ubuntu-baseline, maar de bovenstaande stappen zijn die waarmee geen enkele server zonder zou mogen starten.
4. Coolify installeren
Met een geharde host op zijn plaats is Coolify zelf bijna een anticlimax. Eén commando, uitgevoerd als geprivilegieerde gebruiker, installeert Docker als die ontbreekt, haalt de Coolify-services op en start ze:
curl -fsSL \
https://cdn.coollabs.io/coolify/install.sh \
| sudo bash
Als het klaar is, luistert het dashboard op poort 8000, en heeft Coolify ook zijn eigen reverse proxy gestart. Standaard is die proxy Traefik, wat zeer belangrijk is voor de volgende paragraaf, want het is de Traefik-instantie die wij zullen bewapenen met een firewall.
4.1 Beveilig eerst de control plane
Bereik vóór alles anders het dashboard en maak het beheerdersaccount aan, onmiddellijk, zodat niemand anders het doet. Omdat wij poort 8000 niet op de firewall hebben geopend, bereiken wij het via een SSH-tunnel vanaf onze eigen machine in plaats van over het internet:
ssh -L 8000:localhost:8000 deploy@your-server
Nu is http://localhost:8000 in je browser het dashboard, dat volledig binnen de versleutelde SSH-sessie reist. Maak de beheerdersgebruiker aan, geef het dashboard vervolgens zijn eigen domein en TLS-certificaat via Coolify’s eigen instellingen, zodat het doorlopende beheer een echte HTTPS-URL gebruikt die door de proxy beschermd wordt in plaats van een tunnel. Het principe is eenvoudig en het is het principe dat de meeste self-hosters verkeerd doen: het ding dat al je andere dingen kan deployen is het gevoeligste oppervlak dat je draait, dus het is het laatste wat je blootstelt en het eerste wat je beschermt.
5. De beveiligingsrand: CrowdSec en Traefik AppSec
Een platform dat publieke webapplicaties deployt heeft een beveiligingsrand nodig, iets tussen het open internet en je containers dat verzoeken inspecteert, het overduidelijk vijandige blokkeert, en leert. Omdat Coolify Traefik als zijn proxy draait, kunnen wij precies dat toevoegen zonder nog een bewegend onderdeel te introduceren, met behulp van CrowdSec.
CrowdSec is een open-source beveiligingsengine met twee helften die hier van belang zijn. Het leest logs en beslist welke bronnen zich kwaadaardig gedragen, en het deelt die oordelen binnen een wereldwijde gemeenschap, zodat je server profiteert van aanvallen die bij alle anderen gezien zijn. En het levert een AppSec-component: een webapplicatiefirewall, gebouwd op de Coraza-engine en in staat de OWASP Core Rule Set te draaien, die de inhoud van verzoeken inspecteert en exploitpogingen inline blokkeert, voordat zij je applicatie bereiken. Installeer de agent, voeg dan de collecties firewallregels toe:
curl -s https://install.crowdsec.net | sudo sh
sudo apt install -y crowdsec
sudo cscli collections install \
crowdsecurity/appsec-virtual-patching
sudo cscli collections install \
crowdsecurity/appsec-generic-rules
Zet de AppSec-listener aan door een acquisitiebestand toe te voegen dat CrowdSec opdraagt de firewall op poort 7422 te serveren:
# /etc/crowdsec/acquis.d/appsec.yaml
listen_addr: 0.0.0.0:7422
appsec_config: crowdsecurity/appsec-default
name: appsec
source: appsec
labels:
type: appsec
Genereer vervolgens een API-sleutel die Traefik zal gebruiken om CrowdSec te raadplegen, en herstart de agent:
sudo cscli bouncers add traefik-bouncer
sudo systemctl restart crowdsec
5.1 Traefik bewapenen
De verbinding tussen Traefik en CrowdSec is een community-plugin, de CrowdSec Bouncer Traefik Plugin, die de onderhouden weg naar de AppSec-firewall is. Die laadt als experimentele plugin in Traefik’s statische configuratie:
# traefik static config
experimental:
plugins:
bouncer:
moduleName: github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
version: v1.8.2
en het wordt een middleware in de dynamische configuratie, gericht op beide helften van CrowdSec: de beslissings-API op poort 8080 en de AppSec-firewall op poort 7422, met de sleutel die je zojuist hebt gegenereerd. Het op true zetten van crowdsecAppsecEnabled is wat de webapplicatiefirewall aanzet:
# traefik dynamic config
http:
middlewares:
crowdsec:
plugin:
bouncer:
enabled: true
crowdsecMode: live
crowdsecAppsecEnabled: true
crowdsecAppsecHost: 172.17.0.1:7422
crowdsecLapiHost: 172.17.0.1:8080
crowdsecLapiKey: YOUR_BOUNCER_KEY
Het hostadres 172.17.0.1 is de Docker-bridge-gateway, de manier waarop een container de CrowdSec-agent bereikt die op de host draait; pas het aan als jouw netwerk afwijkt. Omdat Coolify Traefik beheert, gaan deze snippets in de proxyconfiguratie die Coolify blootstelt in plaats van een handmatig gedraaide Traefik, en koppel je vervolgens de crowdsec-middleware aan een service via diens Traefik-labels in het Coolify-dashboard. Dit is een gevorderde stap, en het is er een die wij het vaakst opzetten en vervolgens voor klanten draaien, maar het resultaat is het waard: elk publiek verzoek passeert nu een door de massa geïnformeerde reputatiecontrole en een echte webapplicatiefirewall voordat het een regel van je code bereikt.
6. Workloads draaien met Docker
Coolify is in de kern een vriendelijk gezicht over Docker, en Docker is hoe de overweldigende meerderheid van de workloads erop zou moeten draaien. Je schrijft zelden met de hand containerleidingwerk. Je wijst Coolify naar een Git-repository, en het detecteert hoe het project gebouwd moet worden (via Nixpacks, of je eigen Dockerfile als je die aanlevert), produceert een image, en draait die als een container waar Traefik met automatische TLS naartoe routeert. Databases, caches en andere ondersteunende services, PostgreSQL, Redis, MySQL en meer, zijn één-klik-resources die Coolify provisioneert en verbindt. Omgevingsvariabelen, persistente volumes, health checks en geplande taken zijn allemaal dashboardzaken in plaats van YAML-archeologie.
Wanneer één server niet genoeg is, schaalt Coolify uit naar meerdere met Docker Swarm, Dockers eigen clustering, zodat hetzelfde model, containers achter een proxy, zich uitstrekt over een handvol nodes zonder verandering in hoe je erover denkt. Voor de grote meerderheid van de teams is een enkele goed gespecificeerde host of een kleine Swarm geen compromis op weg naar iets serieus; het is het juiste antwoord, en het is aanzienlijk minder om te draaien dan het alternatief.
7. Wanneer Kubernetes, en wanneer niet
Eerlijkheid telt hier meer dan hype, dus wij zijn er duidelijk over. Coolify orkestreert Docker en Docker Swarm; het orkestreert Kubernetes in zijn stabiele product niet native. Native Kubernetes-ondersteuning is besproken en geprototypeerd, maar op het moment van schrijven is het niet iets waarop wij het productieplatform van een klant binnen Coolify zouden inzetten.
Dat is niet de beperking die het eerst lijkt, want de meeste teams hebben Kubernetes niet nodig. Kubernetes verdient zijn aanzienlijke operationele kosten wanneer je werkelijk multi-node scheduling, fijnmazige autoscaling en het uitgestrekte ecosysteem van operators en controllers dat het veronderstelt nodig hebt, doorgaans op een schaal en met een platformteam die daarbij passen. Onder die drempel is het een belasting betaald in complexiteit voor capaciteit die je niet gebruikt.
Onze richtlijn is dus een beslissing, geen standaard. Draai je workloads op Coolify met Docker, en Swarm wanneer je één node ontgroeit; dat dekt de meeste organisaties volledig. Als en wanneer je werkelijk Kubernetes nodig hebt, draai het dan als wat het is, een afzonderlijk, toegewijd cluster, k3s waar de voetafdruk klein moet blijven of een volledige distributie waar dat niet hoeft, geprovisioneerd en gedraaid op zijn eigen voorwaarden in plaats van vastgeschroefd aan het gemaksplatform. Het goede nieuws is dat het beveiligingspatroon ongewijzigd overgaat: Kubernetes-ingress draait gewoonlijk ook op Traefik, en dezelfde CrowdSec AppSec-firewall bewaakt het. Je leert beveiliging niet opnieuw om van orkestrator te wisselen; je leert operations opnieuw, wat precies de kosten zijn om af te wegen.
8. De ontwikkellus: Claude Code, GitHub en CI/CD
Een deploymentplatform is alleen de moeite waard als het erop krijgen van code moeiteloos en veilig is. Dit is waar Coolify ophoudt een hostingtool te zijn en de laatste schakel wordt in een keten die bij het toetsenbord begint, en het is het deel van de build dat verandert hoe een team van dag tot dag werkt.
De lus verloopt als volgt. Je bouwt met Claude Code, beschrijft wat je wilt en beoordeelt, draait en verfijnt wat het schrijft, de praktijk die vibe coding is gaan heten. Het moeilijke deel van die praktijk, zoals wij elders hebben betoogd, is niet het genereren van code maar het verifiëren ervan, dus de lus is rond verificatie gebouwd. Claude Code commit en pusht naar GitHub. De push opent een pull request, en GitHub draait er continuous integration tegenaan: je tests, je linter, je typechecker en je build, als een poort die een wijziging moet passeren voordat die mag mergen. Een minimale poort is een paar regels:
# .github/workflows/ci.yml
name: ci
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 22
- run: npm ci
- run: npm test
Vereis dat die controle slaagt op je beschermde branch, en geen enkele ongeverifieerde wijziging kan productie bereiken. Nu sluit Coolify de lus. Je installeert de Coolify GitHub App eenmalig, onder de bronnen van het dashboard, en schakelt automatische deployment voor het project in. Vanaf dat moment vuurt een merge naar je productiebranch een webhook af, en bouwt Coolify de nieuwe commit en deployt die, zonder dat een mens een server aanraakt. Pull requests kunnen hun eigen preview-deployments krijgen, een live-URL per branch, zodat een wijziging draaiend beoordeeld wordt in plaats van louter gelezen. Secrets leven in Coolify’s omgevingsvariabelen, niet in de repository, en een slechte release is één klik om terug te rollen naar de vorige image.
Het resultaat is de best-of-breed keten waarop wij onze eigen producten bouwen, samengesteld uit onderdelen die elk één ding goed doen: Claude Code genereert, GitHub verifieert en bewaakt de poort, Coolify deployt, en CrowdSec bewaakt. Geen enkele leverancier bezit het geheel ervan, elke schakel is open of vervangbaar, en wat het voortbrengt is een weg van een idee naar een geteste, draaiende, verdedigde service die een klein team met vertrouwen kan draaien.
9. Het draaien ervan
Een platform is niet af wanneer het gebouwd is; het is af wanneer het goed gedraaid wordt. Coolify houdt zichzelf en zijn deployments bij te werken vanuit het dashboard, maakt geplande back-ups van zijn databases naar S3-compatibele opslag, stuurt meldingen naar e-mail, Slack of het chatgereedschap dat je toch al in de gaten houdt, en toont het resourcegebruik van de server en zijn containers. De geharde host eronder vereist nog steeds dat zijn patches worden toegepast, zijn firewall wordt herzien en zijn CrowdSec-beslissingen worden bewaakt. Niets hiervan is zwaar, maar alles ervan is noodzakelijk, en het is juist de doorlopende verantwoordelijkheid die een managed service bestaat om te dragen. Het is het deel van het Coolify-verhaal dat Nashua het vaakst voor een klant in eigendom heeft: wij bouwen het platform, beveiligen de rand ervan, knopen de pijplijn aaneen, en blijven dan om het te draaien.
10. Conclusie
Het bezitten van het platform waarop je software draait betekende vroeger kiezen tussen gemak en controle. Coolify beëindigt die afruil: het geeft een server die je bezit de ergonomie van een cloud die je niet bezit. Zet het op een geharde Ubuntu LTS-host, bewaak het met CrowdSec en de Traefik AppSec-firewall, draai je workloads op Docker met een helder hoofd over wanneer Kubernetes zijn kosten waard is, en verbind het met Claude Code en GitHub, en je hebt een soevereine, veilige, geautomatiseerde weg van een commit naar een draaiende service. Daarom onderschrijft Nashua Coolify, en het is wat wij bouwen, beveiligen en draaien voor organisaties die liever hun platform bezitten dan het huren. Bezit het thuis van je software. Praat met ons.
Referenties
Coolify (2026). Coolify documentation: installation and core concepts. https://coolify.io/docs
coolLabs (2026). Coolify installation script. https://cdn.coollabs.io/coolify/install.sh
CrowdSec (2026). Application Security (AppSec) WAF QuickStart for Traefik. https://docs.crowdsec.net/docs/appsec/quickstart/traefik
Lerebourg, M. (2026). CrowdSec Bouncer Traefik Plugin. https://github.com/maxlerebourg/crowdsec-bouncer-traefik-plugin
Traefik Labs (2026). Traefik Proxy documentation. https://doc.traefik.io/traefik/
OWASP Foundation (2026). OWASP Coraza Web Application Firewall. https://coraza.io/
OWASP Foundation (2026). OWASP CRS (Core Rule Set). https://coreruleset.org/
Canonical (2026). Ubuntu 24.04 LTS (Noble Numbat) release notes. https://releases.ubuntu.com/24.04/
Center for Internet Security (2026). CIS Ubuntu Linux Benchmark. https://www.cisecurity.org/benchmark/ubuntu_linux
Docker, Inc. (2026). Docker documentation. https://docs.docker.com/
The Kubernetes Authors (2026). Kubernetes documentation. https://kubernetes.io/docs/
GitHub (2026). GitHub Actions documentation. https://docs.github.com/actions
Anthropic (2026). Claude Code documentation. https://code.claude.com/docs
