Een eigen Platform-as-a-Service met Coolify

Code ontwikkelen, bij Git inchecken en achterover leunen. Dat is wat Platform-as-a-Service aanbieders beloven aan (web)ontwikkelaars. Met het complete opensourcepakket Coolify word je je eigen PaaS-exploitant en start je zelf ontwikkelde en externe software op je eigen servers met overzichtelijke onderhoudskosten.

Front-endontwikkelaars ontwikkelen webinterfaces, back-end­ontwikkelaars schrijven de bijbehorende API, serverbeheerders ­zorgen voor de webservers en database­beheerders onderhouden de nodige databasebeheersystemen zoals Maria DB en PostgreSQL.

Klinkt dat niet als iets uit lang vervlogen tijden? Wat ooit heel gewoon was, namelijk een scheiding tussen ontwikkeling (development) en beheer (operations), is bij veel organisaties al lang niet meer ­gebruikelijk. Er is een nieuwe cultuur in veel IT-afdelingen ontstaan, waarbij develop­ment- en operations-teams zijn veranderd in DevOps-teams.

Van veel voormalige webontwikkelaars wordt tegenwoordig verwacht dat ze ook voor het back-end zorgen, hun applicatie inclusief database zelf op de serverinfrastructuur draaien en updates snel uitvoeren. Met een schouderophalend ‘Werkt op mijn machine, de rest moeten de beheerders doen’ kan geen enkele ontwikkelaar zich vandaag de dag meer aan zijn (nieuwe) verantwoordelijkheid onttrekken.

Dankzij containers (met Docker, Podman of Kubernetes), CI/CD-systemen (zoals GitHub Actions, Jenkins en GitLab CI/CD) en versiebeheer (bijna altijd Git) is die taak aanzienlijk minder angstaan­jagend geworden. Een container die op een eigen machine draait, gedraagt zich op een server doorgaans identiek.

Voor webontwikkelaars die zich op hun kerntaak willen concentreren, blijft er echter nog steeds administratief werk over. Ook gecontaineriseerde applicaties moeten namelijk worden aangesloten, gemonitord en bijgewerkt. Als oplossing voor dat probleem zijn Platform-as-a-­Service-aanbiedingen (PaaS) met namen als Heroku, Netlify, Vercel, Google Cloud Run en AWS Amplify in opkomst.

Hun belofte: stel de applicatie eenmaal in, check vervolgens alleen nog maar code bij Git in en denk verder niet na over implementatie of gebruik. Wat in de Git-repository staat, wordt automatisch verpakt en ergens op servers in de cloud uitgevoerd.

Dergelijke complete PaaS-aanbieders zijn handig, maar ook volledig in Amerikaanse handen: zelfs als je niet voor de eigen PaaS-producten van AWS of Google kiest, maar voor een van de andere, draait de software uiteindelijk bijna altijd toch bij een van die hyperscalers waar ook de andere aanbieders hun servers huren. En als je eenmaal klant bent bij een dergelijke aanbieder, moet je latere prijsverhogingen accepteren.

Als je het comfort van PaaS wilt hebben en je onafhankelijkheid wilt behouden, heb je PaaS-software nodig die je zelf kunt exploiteren. Voor volledige autonomie kan die het beste onder een opensourcelicentie beschikbaar zijn.

Dat is precies wat het Coolify-project biedt, dat onder andere wordt ondersteund door Europese serverproviders. Om de werking van een zelf te beheren PaaS-infrastructuur te demonstreren, laat dit artikel zien hoe je van een kale server naar een kant-en-klaar platform gaat dat automatisch een JavaScript-webapplicatie levert en bijwerkt.

Als server voor Coolify kan alles dienen wat een (gevirtualiseerde) Linux kan starten, of dat nu x64- of ARM-architectuur is. Schaf naar eigen voorkeur en behoefte een Raspberry Pi (vanaf 4) aan, start een virtuele machine op je eigen hardware of huur een server bij een hoster. Die moet minimaal 2 GB RAM en 2 (virtuele) kernen hebben.

Ook bij de keuze van de Linux-­distributie stelt Coolify geen hoge eisen: Debian, Ubuntu, Red Hat, Arch, Alpine – de keuze is aan jou.

Coolify is er ook op voorbereid dat je eisen groeien en dat één server niet meer voldoende is: een instantie waarop de ­Coolify-beheerinterface draait, kan meerdere servers op afstand bedienen en daarop containers starten. Ook het bouwen van containerimages kan aan een aparte server worden uitbesteed.

Om te beginnen volstaat één server waarop de beheerinterface en appli­caties samen draaien. Belangrijk: andere diensten kunnen beter niet op de server draaien, anders kunnen er bijvoorbeeld conflicten ontstaan rond geopende poorten.

We hebben gekozen voor een ­Ubuntu-server in een virtuele machine bij een hostingprovider. De voorbereidende werkzaamheden beginnen met het instellen van de firewall op de server zelf, afhankelijk van de provider in de interface van de hoster, of met het configureren van een aanwezige router als je de server op een eigen locatie gebruikt en met portforwarding werkt.

Coolify start een reverse-proxy, krijgt automatisch certificaten via Let’s Encrypt en stelt webapplicaties beschikbaar via HTTPS. Dat werkt alleen als de poorten 80 en 443 vanaf internet bereikbaar zijn.

Als je je server in je eigen netwerk met een dynamisch ip-adres van je ­provider gebruikt, moet je vooraf een DynDNS-dienst instellen als je vanaf elke locatie op internet toegang wilt hebben tot de server.

In het beste geval heb je ook een domein of ten minste een subdomein waarvan je de DNS-vermeldingen kunt beheren. Stel bij je DNS-provider een wildcard-vermelding in en laat die naar de Coolify-server verwijzen, bijvoorbeeld *.coolify.example.org. Dan zal de DNS elk willekeurig subdomein ervoor naar je server doorsturen, bijvoorbeeld test12345.coolify.example.org.

Coolify publiceert alle beheerde applicaties op subdomeinen. Als je de server achter een dynamisch IP-adres gebruikt en DynDNS toepast, kun je een ­CNAME-vermelding aanmaken die van je eigen domein naar het domein van de DynDNS-provider verwijst.

Als je geen domein bij de hand hebt en Coolify alleen wilt testen, is dat ook geen probleem. Dan gebruikt Coolify de dienst sslip.io om van het IP-adres een hostnaam te maken. Meer informatie over de basisprincipes van selfhosting en DNS-configuratie vind je bijvoorbeeld in ‘Het zelfhosting-compendium’, c’t 10/2025.

Poort 22 voor onderhoud op afstand via SSH kun je toegankelijk maken vanaf het internet. Voor de configuratie moet je ook poort 8000 kunnen bereiken. Daar draait de webinterface, waarin je de eerste stappen kunt uitvoeren en ervoor kunt zorgen dat die interface via HTTPS op poort 443 wordt geleverd.

Als je de server bij een hoster hebt gehuurd, moet je dus ook kort poort 8000 even openen. Als de server zich in hetzelfde netwerk als je computer bevindt, kun je lokaal toegang krijgen en portforwarding overslaan en hem via het lokale IP-adres instellen.

Daarnaast zijn nog de poorten 6000 voor realtime communicatie via web­sockets en 6001 om toegang te krijgen tot de commandline in de browser nodig. Je hebt die poorten niet nodig als je direct na het installeren de reverse-proxy inschakelt.

Als de poorten 80 en 443 in ieder geval bereikbaar zijn, kun je beginnen met het installeren via de commandline.
Coolify maakt dat zo eenvoudig mogelijk en de ontwikkelaars hebben een commando samengesteld dat een installatiescript downloadt. Dat maakt mappen aan, installeert Docker, start de benodigde containers en verbindt ze met elkaar:

Als je dat te onveilig vindt, kun je het installatiescript ook eerst downloaden, inspecteren en pas daarna uitvoeren – je moet sowieso vertrouwen hebben in ­Coolify en het team van ontwikkelaars.

De installatiewizard duurt ongeveer drie minuten, stelt geen vragen en rapporteert uitgebreid wat hij aan het doen is. Bovendien verkort hij de wachttijd met platte informaticagrappen. Vervolgens vraagt hij je om het installeren in de browser te voltooien. Open daarvoor, afhankelijk van het type server, het interne of externe IP-adres op poort 8000 in je browser, bijvoorbeeld http://192.168.178.50:8000 voor een server in het lokale netwerk.

De webinterface vraagt om een gebruikers­naam en wachtwoord. Als je vanaf internet toegang hebt, moet je het wachtwoord dan eenmalig onversleuteld verzenden – pas bij de volgende stap wordt HTTPS ingesteld.

Klik op Next om te beginnen, vervolgens op het servertype Localhost en ten slotte op Create new project!. Daarmee heb je de Coolify-server met de Docker-daemon op dezelfde server verbonden en de minimale configuratie met één server ingesteld.

Als je bij je DNS-provider een subdomein zoals coolify.example.org hebt ingesteld, kun je de webinterface meteen voorzien van HTTPS en een geldig TLS-certificaat. Klik hiervoor links in het menu op Settings.

Voer in het formulier onder Domain het volledige adres inclusief protocol in, bijvoorbeeld https://coolify.example.org. Daarnaast kun je je server een weergavenaam geven en het openbare IPv4- en IPv6-adres opslaan – voor zover die niet automatisch herkend zijn. Sla het formulier bovenaan op door op Save te klikken.

Vervolgens is het tijd om de reverse-proxy te starten, die de pagina via HTTPS levert. Klik in het menu aan de linkerkant op Servers en selecteer de lokale server. Ook daar kun je een weergavenaam opgeven.

De vermelding ‘IP Address/Domain’ mag je niet wijzigen – die vertelt Coolify waar het de Docker-host kan bereiken. In een 1-server-omgeving moet het zichzelf bereiken. In het tekstveld rechts mag je het Wildcard Domain wijzigen. Als je zoals hierboven beschreven een wildcard-DNS-vermelding hebt ingesteld, voer je daar het adres in het formaat https://coolify.example.org in.

Start vervolgens de reverse-proxy met de knop rechtsboven. Zonder verdere handmatige handelingen start Coolify een container met de Traefik-software, die vanaf dat moment inkomend verkeer ontvangt en certificaten verkrijgt.

Geef Traefik een paar seconden de tijd en probeer vervolgens op een nieuw tabblad het subdomein te bereiken. Als de DNS-vermeldingen, portforwards en firewallregels correct zijn ingesteld, zou de Coolify-interface je moeten verwelkomen en zou een slotpictogram op de adresbalk van je browser moeten aangeven dat de verbinding tot stand is gekomen met een geldig certificaat via TLS.

Als dat niet het geval is, kun je bij de interface die nog steeds op poort 8000 draait, controleren of Traefik fouten heeft geregistreerd. Klik op de laatst geopende pagina met de instellingen voor de server bovenaan op het tabblad Proxy en vervolgens links op Logs.

Zodra de levering via HTTPS verloopt, moet je poort 8000 en ook de poorten 6000 en 6001 van internet afsluiten. Verwijder eventuele portforwards in de router of firewallregels van je hoster.

Bovendien kun je Coolify direct zo configureren dat de poorten helemaal niet gebruikt worden. Maak daarvoor het bestand /data/coolify/ source/docker-­compose.custom.yml aan en plaats daarin het volgende fragment:

Voer vervolgens nogmaals het commando uit dat je voor het installeren hebt uitgevoerd. Het installatiescript neemt alleen de wijzigingen over en start de containers zonder de poorten. Omdat je het wachtwoord tot nu toe onversleuteld verzonden hebt, kun je de interface het beste rechtstreeks via HTTPS openen, links op Profile klikken en een nieuw wachtwoord bedenken. Voor de zekerheid.

Direct daaronder kun je de toegang beveiligen met een tweede factor via TOTP. Nog een waarschuwing als je een wachtwoordbeheerder gebruikt die in de browser geïntegreerd is: bij de interface toont Coolify bepaalde gevoelige informatie alleen als je op een oogpictogram naast een tekstveld klikt.

Wachtwoordbeheerders kunnen die velden daarom ten onrechte als wachtwoordvelden beschouwen en blijven vragen of je het opgeslagen wachtwoord voor het beheerdersaccount wilt wijzigen. Dan klik je al snel verkeerd. Als je je op die manier hebt buitengesloten omdat het juiste wachtwoord per ongeluk overschreven is, open je een SSH-sessie en voer je het volgende commando uit om het wachtwoord opnieuw in te stellen:

Dan is de server klaar om applicaties uit te voeren. Die kunnen op verschillende manieren ingesteld worden. Eén manier is via zogenaamde services. Dat zijn kant-en-klare applicaties waarvoor Coolify een catalogus bijhoudt: software zoals WordPress, Nextcloud, Immich en Syncthing is binnen enkele minuten klaar voor gebruik omdat er al kant-en-klare recepten voor bestaan.

Je kunt de installatie uitvoeren via een formulier dat achter de schermen de omgevingsvariabelen van een Docker Compose-compilatie wijzigt. Je kunt, maar hoeft je niet bezig te houden met de details van die voorbereide containers.

De werking wordt snel uitgelegd aan de hand van een praktisch voorbeeld: klik links in het menu op Projects. Bij de projecten kun je meerdere applicaties groeperen – als je Coolify gebruikt als bedrijf dat applicaties voor meerdere klanten wil leveren, kun je voor elke klant een project aanmaken.

Binnen projecten zijn er Environments – een omgeving met de naam production wordt meteen aangemaakt. Via het uitklapmenu bovenaan kun je andere omgevingen aanmaken, zoals development of staging, die bij veel ontwikkelteams gebruikelijk zijn en voorversies en experimenten bevatten.

Binnen de Environments zijn er Resources. Dat zijn de eigenlijke applicaties die je met Add New Resource aanmaakt. Kant-en-klare programma’s uit de catalogus vind je onder het kopje Services of via de zoekfunctie bovenaan.

Als voorbeeld dient de foto-opslagplaats Immich. Zoek het item, klik erop en laat alle standaardinstellingen staan. Als je rechtsboven op Deploy klikt, worden vier containers opgestart. Een logboekweergave toont wat er daar op de achtergrond allemaal voor gebeurt. Dat duurt minder dan een minuut.

Sluit de logboeken en zoek bovenaan in het midden van de pagina het tabblad Links. Daar vind je de link naar de ­applicatie – een subdomein van je wildcard-domein met de Service Name ervoor. Als je de link volgt, zou Immich zich direct via een HTTPS-kanaal moeten melden. Als dat niet het geval is, geef Traefik en Let’s Encrypt dan nog een paar seconden de tijd om een geldig certificaat in te stellen.

Je moet de eerste installatie van Immich snel voltooien, want wie het eerst komt, mag het beheerderswachtwoord toewijzen. Je hoeft je om Immich zelf niet druk te maken. Als je geïnteresseerd bent in fotobeheer, lees daar dan meer over in ‘Je eigen fotocloud met het opensource Immich’ c’t 12/2024.

Terug naar de Coolify-interface: in het configuratiescherm van een bron (in dit geval de containercompilatie van Immich) kun je ook achteraf omgevingsvariabelen wijzigen (zonder garantie dat de toepassing daar automatisch correct mee om kan gaan) en onder andere bepalen waar ge­­gevens moeten worden opgeslagen.

Een handige functie van Coolify: met Scheduled Tasks, die in het submenu aan de linkerkant staan, kun je taken definiëren die op gezette tijden in de containers uitgevoerd worden. Als de applicatie bijvoorbeeld een opruimcommando heeft dat regelmatig binnen de container moet worden uitgevoerd, kun je dat bijvoorbeeld automatisch ‘s nachts laten uitvoeren.

Dit artikel gaat slechts kort in op de tweede categorie bronnen die je aan een Environment kunt toevoegen, omdat die weinig uitleg behoeven: databases. Als je een database nodig hebt voor een kant-en-klare applicatie of een ontwikkelingsproject, vind je gangbare voorbeelden in de catalogus die wordt geopend zodra je een nieuwe bron aanmaakt.

PostgreSQL, MariaDB, MySQL, Redis, MongoDB en andere zijn met een paar klikken in te stellen. De interface voor het configureren ziet er hetzelfde uit als die je al kent van de kant-en-klare applicaties (services).

Het laatste deel van deze Coolify-introductie is bedoeld voor ontwikkelaars – voornamelijk van webapplicaties: ­Coolify kan zelfontwikkelde applicaties die in Git-repository’s staan, verpakken in Docker-containers en uitleveren. Als de code in de repository verandert, draait de bijgewerkte software kort daarna op de Coolify-server.

Om die functie uit te proberen, biedt Coolify een openbare repository met voorbeelden in tal van programmeertalen en frameworks – want wat er allemaal op de achtergrond moet gebeuren, verschilt van software tot software.

Het eenvoudigste voorbeeld is een statische HTML-pagina die door een webserver moet worden geleverd. Om het voorbeeld na te bootsen, navigeer je naar je omgeving en voeg je een nieuwe bron toe.

Helemaal bovenaan onder Applications vind je Public Repository. De repository met de voorbeelden staat op het adres https://github.com/coollabsio/coolify-examples/ en een statische pagina in de map static.

Voer het adres van de repository (met https://) in als Repository URL en start de installatie met Check Repository. Er wordt een klein formulier geopend waarin je eerst het type Build Pack moet selec­teren. Coolify gebruikt verschillende tech­nieken om de inhoud van een repository te verpakken.

Gebruik voor de statische pagina het type Static, voer de map /static in en klik op Continue. Op de volgende pagina moet je de branch wijzigen waarin Coolify de applicatie moet zoeken.

Klik links op Git Source en voer onder Branch v4.x in plaats van main in. Daar staan de voorbeelden voor de huidige Coolify-versie. Sla die wijziging op met de knop Save bovenaan en klik vervolgens rechtsboven op Deploy.

Je ziet live in de logs wat Coolify doet om de pagina te verpakken: het systeem bouwt een Docker-image op basis van nginx:alpine en plaatst het HTML-bestand daarin. Als dat klaar is, kun je de link naar de applicatie volgen – de statische website wordt gepubliceerd via HTTPS.

Alle repository’s die bij GitHub staan, worden automatisch bijgewerkt als er iets in de repository verandert. Als je voor je project een andere Git-hoster zoals GitLab gebruikt, moet je handmatig een webhook instellen. Dat is een adres op de Coolify-server dat GitLab activeert om te signaleren dat er iets is veranderd.

Het formulier om een dergelijke webhook aan te maken vind je links onder Webhooks. De documentatie van Coolify legt in detail uit hoe je de verbinding tot stand brengt.

Het automatisch leveren van statische pagina’s is al nuttig, maar ­Coolify kan nog meer: code automatisch compi­leren, transcompileren of op een andere manier ­verwerken, zodat die kan worden uitgeleverd. Ook daarvoor zijn er verschillende benaderingen: als je project al is voorzien van een Dockerfile, kan ­Coolify die gebruiken en containers­ ­bouwen.

Om dat uit te proberen, maak je een nieuwe applicatie aan vanuit de repository github.com/coollabsio/coolify-examples, ­selecteer je als Base Directory het pad /dockerfile en als Build Pack het type Dockerfile.

Maak vervolgens met Continue de applicatie aan en wijzig de branch zoals hierboven beschreven naar v4.x. Voer op de hoofdpagina van de instellingen als poort 80 in plaats van 3000 in. Vervolgens kan de applicatie gepubliceerd worden.

Als je geen Dockerfile hebt en je je ook niet wilt bezighouden met de fijne kneepjes van het verpakken van containers, biedt Coolify nog een andere optie en maakt het gebruik van het opensourceproject Nixpacks. Het herkent aan de hand van typische bestanden om welke programmeertaal het gaat en past vervolgens een standaardrecept toe om daaruit een Docker-image te bouwen.

In de meeste gevallen is geen extra configuratie nodig: een bestand met de naam package.json hoort bijvoorbeeld altijd bij een Node.js-project met de pakket­beheerder NPM en TypeScript of JavaScript. Dergelijke projecten bevatten meestal het commando npm run build, dat de voltooide applicatie bouwt. Dat is precies wat het standaardrecept van Nixpack uitvoert bij het containeriseren.

Als voorbeeld heeft Coolify onder andere een front-end met het framework Vue.js voorbereid. Om dat uit te proberen, maak je een nieuwe applicatie aan, gebruik je dezelfde repository, voer je als pad /vue/spa in, als type Nixpack en vink je het vakje naast Is it a static site? aan.

Je moet de branch weer wijzigen in v4.x, waarna ook die applicatie met een klik op Deploy de wereld in mag. Het hele proces duurt een paar seconden, waarna Coolify de taak aan Nixpack heeft gedelegeerd en het recept voor Node.js doorlopen is.

De voorbeeldrepository bevat nog meer miniprojecten voor diverse programmeertalen. Als je eigen projecten in Coolify met of zonder Nixpack wilt starten, kun je je daarop baseren.

Als je applicaties complexer zijn, kun je je verdiepen in de documentatie van Nixpack en afwijkingen van de standaard overschrijven met parameters. Of je bouwt zelf een Dockerfile die bij de code past.

Met die Coolify-basisuitrusting kun je aan de slag en je eigen PaaS-platform op elke gewenste infrastructuur starten. Als je Coolify wilt gebruiken om kant-en-klare applicaties zoals WordPress en Immich te starten, ben je binnen een uur klaar. Het verhuizen van bestaande, zelf ontwikkelde applicaties kan iets meer tijd kosten, maar dat kan de moeite waard zijn.

Als je Coolify de Docker-images laat bouwen, heb je niet per se een CI/CD-omgeving en een containerregister nodig dat automatisch code verpakt en beschikbaar stelt – Coolify doet dat gewoon voor je.

Als ontwikkelaar kun je je dan voor­namelijk concentreren op je code. Als je project of het ontwikkelteam groeit, is Coolify geen doodlopende weg: voeg dan meer servers toe aan de Coolify-server en start daar nieuwe applicaties op.

Jan Mahn en Noud van Kruysbergen