Kubernetes CI/CD

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.

StapWaarWat er gebeurtLet op
TestGitHub Actions of GitLab CIUnit- en integratietests, static analysis, coding standardsFaalt dit, dan wordt er geen image gebouwd
BuildCI-runner met BuildKitMulti-stage Dockerfile: dependencies, assets, compilatie, runtime-imageLayer-cache bepaalt of een build twee of twintig minuten duurt
ScanTrivy in de pipelineCVE's in het image en de dependencies, met afgesproken drempelsPin de scanner en de Action op een vaste versie of commit-SHA
Push en signContainer registryImage met tag op basis van commit of release, plus handtekening of attestatieTags immutable maken in de registry, zodat een tag nooit iets anders gaat betekenen
Release in GitConfig-repositoryNieuwe tag of digest in de values of kustomization van de omgevingVia een pull request of via Argo CD Image Updater
SyncArgo CDCluster in lijn brengen met Git, migraties als PreSync-hookSync waves bepalen de volgorde: secrets, migratie, web, workers
RolloutArgo RolloutsCanary of blue-green met analyse op foutpercentage en latencyTwee 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
Liever bellen? 0591-239 299
Beschikbaar deze week

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.

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.

AanpakHoe het werktSterk inMinder sterk in
Pull request vanuit CINa een geslaagde build past de pipeline de tag of digest aan in de config-repository, als commit of pull requestVolledig zichtbaar en reviewbaar; productie vraagt een goedkeuringDe pipeline heeft schrijfrechten op de config-repository nodig
Argo CD Image UpdaterController kijkt in de registry naar nieuwe tags volgens een regel, zoals semver of de nieuwste build, en schrijft terug naar GitWeinig pipeline-code; handig voor staging en omgevingen die automatisch mogen volgenMinder controle per release; vanaf v1.0 gaat configuratie via een ImageUpdater-resource in plaats van annotaties
Direct kubectl of helm upgrade vanuit CIPipeline praat rechtstreeks met de API van het clusterSnel op te zettenClustersleutels 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.

Zo bouwen we je Kubernetes CI/CD

Zes stappen, met het vaste team dat de pipeline daarna ook onderhoudt.

  1. 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. 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. 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. 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. 5

    Progressive delivery

    Argo Rollouts met canary of blue-green waar het past, AnalysisTemplates op je eigen metrics en een geteste rollback.

  6. 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.

Hyvä Silver PartnerHypernode Silver Partner

Veelgestelde vragen

Het is de keten die van een commit een draaiende versie in je cluster maakt. CI bouwt, test en scant de code en levert een container-image op in een registry. CD zet dat image in een omgeving, bij voorkeur via Git en Argo CD in plaats van rechtstreeks vanuit de pipeline.

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.