
Kubernetes CI/CD: elke commit een image, elke release een commit
Een pipeline die met kubectl apply naar productie schrijft, werkt tot de dag dat iemand wil weten wat er nu eigenlijk draait. Wij scheiden het: CI bouwt, test, scant en pusht een image. Git beschrijft wat er draait. Argo CD zorgt dat het cluster daarmee overeenkomt, en Argo Rollouts rolt de nieuwe versie gecontroleerd uit. Het vaste team bouwt de pipeline en houdt hem draaiende.
- Eén image per commit, dezelfde voor staging en productie
- Geen clustersleutels in je CI: deployen gaat via Git
- Canary of blue-green met automatische rollback op metrics
Wat is CI/CD naar Kubernetes, en wat is er anders dan bij een VPS?
CI/CD naar Kubernetes is de keten die van een commit een draaiende versie in je cluster maakt. Continuous integration bouwt en test de code en levert een container-image op. Continuous delivery zet dat image in een omgeving. Bij Kubernetes is het eindproduct van CI dus niet een map met bestanden op een server, maar een onveranderlijk image in een registry.
Bij een klassieke Magento- of Laravel-deploy op een VPS doet de deploy veel werk op de server: composer install, assets bouwen, static content deployen, symlink omzetten. Op Kubernetes gebeurt dat allemaal in de build. Het image bevat de complete applicatie. Een deploy is daarna alleen nog: vertel het cluster welk image er moet draaien. Daardoor is terugrollen ook alleen een kwestie van het vorige image.
Op deze pagina beschrijven we hoe wij die keten bouwen: images bouwen in GitHub Actions of GitLab CI, de registry, tags en digests, hoe een nieuw image in Git terechtkomt, uitrollen met Argo CD en Argo Rollouts, en preview-omgevingen per branch. Plus waar het meer kost dan het oplevert.
De pipeline: van commit tot productie
Elke stap heeft één taak en één eigenaar. CI raakt het cluster niet aan; Argo CD bouwt niets.
| Stap | Waar | Wat er gebeurt | Let op |
|---|---|---|---|
| Test | GitHub Actions of GitLab CI | Unit- en integratietests, static analysis, coding standards | Faalt dit, dan wordt er geen image gebouwd |
| Build | CI-runner met BuildKit | Multi-stage Dockerfile: dependencies, assets, compilatie, runtime-image | Layer-cache bepaalt of een build twee of twintig minuten duurt |
| Scan | Trivy in de pipeline | CVE's in het image en de dependencies, met afgesproken drempels | Pin de scanner en de Action op een vaste versie of commit-SHA |
| Push en sign | Container registry | Image met tag op basis van commit of release, plus handtekening of attestatie | Tags immutable maken in de registry, zodat een tag nooit iets anders gaat betekenen |
| Release in Git | Config-repository | Nieuwe tag of digest in de values of kustomization van de omgeving | Via een pull request of via Argo CD Image Updater |
| Sync | Argo CD | Cluster in lijn brengen met Git, migraties als PreSync-hook | Sync waves bepalen de volgorde: secrets, migratie, web, workers |
| Rollout | Argo Rollouts | Canary of blue-green met analyse op foutpercentage en latency | Twee versies tegelijk tegen dezelfde database; je schema moet dat aankunnen |
Plan een vrijblijvend gesprek over je project
Een half uur via video met de mensen die het werk ook echt doen. Kies hieronder een moment dat jou past.
- Direct met het vaste team, geen tussenlagen
- Concrete feedback op je huidige situatie of plannen
- Eerlijk advies, ook als het antwoord "niet doen" is
- Indicatie van kosten en tijdlijn
Plan een gratis Tech Check
Vrijblijvend jouw uitdagingen bespreken
Of bel direct: 0591-239 299
Images bouwen: GitHub Actions of GitLab CI
Op GitHub Actions bouwen we met docker/setup-buildx-action en docker/build-push-action. BuildKit draait de multi-stage build en bewaart de layer-cache in de GitHub Actions-cache of in de registry. Een wijziging in alleen PHP-code bouwt dan niet opnieuw de composer-dependencies en de frontend-assets. Authenticatie naar AWS, Azure of Google Cloud gaat via OIDC, zonder statische sleutels in je repository-secrets.
Op GitLab CI was Kaniko lange tijd de standaard om zonder Docker-daemon te bouwen. Google heeft de Kaniko-repository in juni 2025 gearchiveerd. Er bestaan forks, maar voor nieuwe pipelines kiezen we liever BuildKit in rootless modus of Buildah. GitLab heeft een eigen container registry per project, dus push en pull blijven in hetzelfde systeem.
Wat er in het image komt, verschilt per platform. Voor Laravel: composer install zonder dev-dependencies, de frontend-build met Vite in een aparte Node-stage, route- en view-cache in de build, en config:cache pas bij het opstarten, omdat die van environment-variabelen afhangt. Voor Magento: setup:di:compile en setup:static-content:deploy in de build, zodat een pod in seconden start in plaats van minuten. Dat vraagt een build-stap met de juiste config.php en themalijst, maar zonder databaseverbinding. Een image bouw je één keer en promoot je door de omgevingen. Opnieuw bouwen voor productie betekent dat je iets anders uitrolt dan je getest hebt.
De registry: waar je images wonen
Een registry is meer dan opslag. Het is de plek waar je bepaalt wat het cluster mag draaien.
GitHub Container Registry of GitLab Registry
Dichtbij je code en je pipeline, met rechten die aansluiten op je repository. Argo CD en je nodes halen het image daar direct op.
Lees verder →Registry van je cloud
ECR, Artifact Registry of ACR in dezelfde regio als je cluster. Pullen gaat via de identiteit van de nodes, zonder pull-secrets.
Lees verder →Harbor of een eigen registry
Zinvol als je op eigen servers of bij een Europese aanbieder zonder registry draait. Wel weer een component die je moet beheren en back-uppen.
Lees verder →Beveiliging en opruimen
Immutable tags, scans bij push, alleen je eigen registry toestaan via Kyverno en een retentiebeleid zodat oude images niet eeuwig opslag kosten.
Lees verder →Tags en digests: wat er echt draait
De tag latest heeft in een productiecluster niets te zoeken. Twee pods met dezelfde tag kunnen verschillende images draaien, afhankelijk van wanneer de node het image ophaalde. Terugrollen naar latest kan niet, want latest is al het nieuwe image. Wij taggen op de commit-SHA, of op een releaseversie met de SHA erin, zoals 2026.10.3-a1b2c3d.
Een tag is een verwijzing die kan veranderen. Een digest, de sha256-hash van het image, kan dat niet. Daarom maken we tags immutable in de registry, en zetten we in productie bij voorkeur de digest in de manifests. In Helm kan dat met een apart digest-veld naast de tag; Kustomize ondersteunt het via het images-blok. Je ziet in Git dan precies welk image er draait, en een Kyverno-policy kan afdwingen dat productie alleen images met een digest accepteert.
Hetzelfde geldt voor alles wat je pipeline zelf gebruikt. In maart 2026 overschreven aanvallers vrijwel alle versietags van de GitHub Action van Trivy met code die credentials stal. Wie de action op een commit-SHA had gepind, had er geen last van. Sinds augustus 2025 kun je SHA-pinning afdwingen in de Actions-policy van je GitHub-organisatie. Dat zetten we standaard aan.
Van nieuw image naar Git: pull request of Argo CD Image Updater
Bij GitOps beschrijft Git wat er draait. Een nieuw image moet dus in Git landen. Daar zijn twee gangbare routes voor.
Onze standaard: staging volgt automatisch, productie gaat via een pull request. Een merge in de config-repository is daarmee je releaseknop, met een auditspoor voor wie wat wanneer heeft uitgerold. Argo CD Image Updater zetten we in als een omgeving altijd de nieuwste build moet draaien. Let bij een upgrade naar Image Updater v1.x op die overstap van annotaties naar een eigen resource; oude configuratie werkt dan niet meer.
| Aanpak | Hoe het werkt | Sterk in | Minder sterk in |
|---|---|---|---|
| Pull request vanuit CI | Na een geslaagde build past de pipeline de tag of digest aan in de config-repository, als commit of pull request | Volledig zichtbaar en reviewbaar; productie vraagt een goedkeuring | De pipeline heeft schrijfrechten op de config-repository nodig |
| Argo CD Image Updater | Controller kijkt in de registry naar nieuwe tags volgens een regel, zoals semver of de nieuwste build, en schrijft terug naar Git | Weinig pipeline-code; handig voor staging en omgevingen die automatisch mogen volgen | Minder controle per release; vanaf v1.0 gaat configuratie via een ImageUpdater-resource in plaats van annotaties |
| Direct kubectl of helm upgrade vanuit CI | Pipeline praat rechtstreeks met de API van het cluster | Snel op te zetten | Clustersleutels in CI, geen bron van waarheid, drift tussen Git en cluster |
Uitrollen met Argo CD en Argo Rollouts
Argo CD synct de config-repository naar het cluster. Migraties draaien als Job met een PreSync-hook: faalt de migratie, dan stopt de sync en blijft de huidige versie draaien. Met sync waves bepalen we de volgorde, bijvoorbeeld eerst ExternalSecrets, dan de migratie, dan de web-pods en als laatste de queue-workers. Bij Magento komt setup:upgrade op die plek, met een strategie voor de korte periode waarin oude code tegen een nieuw schema draait.
Een gewone Deployment doet een rolling update: pods worden één voor één vervangen. Argo Rollouts vervangt de Deployment door een Rollout-resource met een strategie. Bij canary krijgt de nieuwe versie eerst een klein deel van het verkeer, dan meer. Met een AnalysisTemplate controleert Rollouts tussen de stappen Prometheus-metrics zoals het percentage 5xx-responses of de p95-responstijd. Gaat dat over de grens, dan rolt Rollouts zelf terug. Bij blue-green draait de nieuwe versie volledig naast de oude, test je via een preview-Service en schakel je in één keer om.
Voor precieze verkeersverdeling gebruikt Rollouts de traffic router van je ingresslaag. Met de Gateway API gaat dat via de officiële plugin, die de gewichten in een HTTPRoute aanpast. Zonder traffic router verdeelt Rollouts het verkeer via het aantal pods, wat grover is. Canary vraagt wel iets van je applicatie: twee versies draaien tegelijk tegen dezelfde database, cache en queue. Voor Laravel werkt dat goed met migraties volgens expand en contract. Voor Magento met schemawijzigingen is blue-green of een korte canary vaak verstandiger.
Preview-omgevingen per branch
Een preview-omgeving is een tijdelijke kopie van je applicatie per pull request, met een eigen URL. De product owner klikt erdoor voordat er iets gemerged is. Met de pull request-generator van een Argo CD ApplicationSet gaat dat automatisch: Argo CD ziet een open pull request, maakt een Application in een eigen namespace met het image van die branch, en ruimt alles op zodra de pull request sluit.
Voor Laravel is dat goed te doen. Een kleine database met seed-data, een eigen Valkey-database of prefix, en de queue-workers op één replica. Voor Magento is het zwaarder: een volledige shop met OpenSearch, Varnish en een bruikbare catalogus kost per preview flink wat geheugen en opstarttijd. Daar werken we vaak met een gedeelde staging-database met geanonimiseerde data, of met previews alleen op aanvraag via een label op de pull request.
Previews kosten capaciteit zolang ze bestaan. We zetten er resource limits en een maximale levensduur op, en laten de cluster-autoscaler of Karpenter nodes weer afschalen als er geen previews meer draaien. Gebruik nooit productiedata met klantgegevens in een preview.
Wanneer een eenvoudiger deploy beter past
Eén Magento-shop op managed hosting
Een deploy met een build-stap en symlinks op goede managed hosting is eenvoudiger en goedkoper dan een cluster met GitOps. Prima te automatiseren met GitHub Actions.
Lees verder →Laravel zonder platformteam
Forge of Laravel Cloud regelen deploys, queues en de scheduler zonder dat je een cluster hoeft te beheren.
Lees verder →Meerdere apps en omgevingen
Draai je meerdere shops of services met staging, acceptatie en previews, dan betaalt dezelfde pipeline voor alles zich wel terug.
Lees verder →Charts en manifests op orde
Een goede pipeline staat of valt met nette Helm-charts of Kustomize-overlays per omgeving.
Lees verder →Zo bouwen we je Kubernetes CI/CD
Zes stappen, met het vaste team dat de pipeline daarna ook onderhoudt.
- 1
Inventarisatie
Hoe deploy je nu, welke omgevingen zijn er, welke stappen gebeuren handmatig en waar gaat het mis. Uitkomst: de doelpipeline en wat er vervalt.
- 2
Dockerfile en build
Multi-stage Dockerfile per applicatie, met compilatie en assets in de build, layer-cache en een image dat non-root draait.
- 3
Registry en beveiliging
Registry inrichten met immutable tags, Trivy-scan in de pipeline, signing of attestaties, OIDC naar de cloud en SHA-pinning van Actions.
- 4
GitOps-koppeling
Config-repository met Helm of Kustomize per omgeving, Argo CD-applicaties, sync waves voor migraties en de release-flow via pull requests of Image Updater.
- 5
Progressive delivery
Argo Rollouts met canary of blue-green waar het past, AnalysisTemplates op je eigen metrics en een geteste rollback.
- 6
Previews en overdracht
Preview-omgevingen per pull request waar ze waarde toevoegen, documentatie van de flow en een eerste releases samen met je team.
Wat je opgeleverd krijgt
- Multi-stage Dockerfiles per applicatie, gedocumenteerd
- CI-pipeline in GitHub Actions of GitLab CI met test, build, scan, push en sign
- Registry met immutable tags, retentiebeleid en toegangsregels
- Config-repository met Helm-values of Kustomize-overlays per omgeving
- Argo CD-applicaties met sync waves en migraties als hook
- Release-flow via pull request of Argo CD Image Updater
- Argo Rollouts met analyse en automatische rollback
- Preview-omgevingen per pull request, met opruimregels
Waarom Coding.nl voor Kubernetes CI/CD
We kennen de build van Magento en Laravel
DI-compilatie, static content, Vite-builds en migraties: we weten welke stap in het image hoort en welke bij de deploy.
Geen tussenlagen
Je spreekt direct met de mensen die de pipeline bouwen. Een rode build bespreek je met wie hem kan oplossen.
Alles in Git
Pipeline, manifests en releases staan in Git. Je ziet wie wat heeft uitgerold en kunt elke release terugdraaien.
Eerlijk advies
Een eenvoudige deploy op managed hosting is soms het betere antwoord. Hypernode Silver Partner, dus we kennen dat alternatief van binnenuit.

Verder lezen
- ›Canary- en blue-green deploys met Argo Rollouts
- ›Argo CD sync waves en hooks: migraties veilig uitrollen
- ›Magento deployen op Kubernetes zonder downtime
- ›Helm-chart voor je Laravel-app: structuur, values en valkuilen
- ›Magento 2 CI/CD pipeline opzetten met GitHub Actions
- ›Software supply chain: Composer, npm en CI als ingang naar je webshop
- ›Laravel op Kubernetes: Horizon, queues en scheduler inrichten
- ›Magento 2 en Docker — lokale development setup die werkt
Veelgestelde vragen
Van handmatige deploys naar een pipeline die je vertrouwt?
Plan een gesprek over je huidige deploy. We kijken naar je builds, omgevingen en releases en vertellen eerlijk welke stappen in een Kubernetes CI/CD-pipeline voor jou opleveren, en welke je beter laat zoals ze zijn.