Naar de inhoud
maarten.
Een medewerker houdt toezicht op een lopende band die materialen vervoert.
Alle stories

CI/CD-pipeline: build, test en deployment

Maarten Soetens 15 min lezen

Een CI/CD-pipeline automatiseert de controles en stappen waarmee codewijzigingen van een repository naar een draaiende applicatie gaan. Je leest hoe builds, tests, artefacten, configuratie en deploymentstrategieën samenhangen, en waar pipelines in de praktijk vaak vastlopen.

Wat CI/CD betekent voor het softwareontwikkelproces

Je leest en hoort veel over CI (Continuous Integration), maar wat bedoelen teams daar nou echt mee? Het komt neer op: je voegt regelmatig updates toe aan een centrale repo en meteen daarna controleren tools de code automatisch, zodat je problemen snel in beeld krijgt. CD (Continuous Delivery) plakt daar het bouwen en klaarzetten van releasepakketten achteraan, zodat je veranderingen eenvoudig naar een demo- of acceptatieomgeving brengt. Continuous Deployment gaat nog een stap verder; als alles klopt, rolt het proces software direct in productie uit. Sommige teams gebruiken 'CD' standaard voor beide laatste stappen, dus vraag altijd even wat zij precies uitvoeren als er verwarring mogelijk is.

De pipeline zelf is de stroom aan taken die je code doorloopt: broncode ophalen, dependencies binnenhalen, dingen compileren, tests draaien, een pakket maken en uitrollen. Maar: niet elke wijziging hoeft die hele route door te lopen. Bijvoorbeeld, een pull request krijgt extra controle, terwijl een releasebranch misschien nog een handmatige review vereist voordat deze software oplevert. Automation is handig, maar die zichtbaarheid in stappen en checks geeft je ook extra grip: je weet en kunt laten zien welk proces geldt en welke versie uiteindelijk draait.

Pipeline als onderdeel van het ontwikkelproces

Ontwerpbeslissingen of code review blijven mensenwerk. Maar een pipeline maakt het herhalen van controles consistent. Dus minder risico dat iemand een stap vergeet of alleen lokaal uitvoert. Handmatige uitzonderingen vertragen het debuggen en geven onduidelijkheid over wat nu echt is getest of uitgerold. Je pipeline moet dus aansluiten op jullie branchmanagement, releasetactiek en de manier waarop je na storingen wilt terugkijken wat er is gebeurd. Een freelance developer kan helpen de pipeline op jullie werkwijze af te stemmen.

Van codewijziging naar geautomatiseerde build

Zo'n pipeline komt pas op gang na een trigger. Dat kan van alles zijn: een commit, een pull request, het maken van een release-tag of een handmatige opdracht. Welke check wanneer draait, hangt af van die trigger. Denk aan: alleen snelle checks bij een gewone commit, uitgebreide tests en bouwen van een versie bij een release. Te weinig triggers en soms blijft slechte code ongezien; te veel en je pipeline staat eindeloos in de rij. Dus is het afwegen: wat moet snel na elke wijziging, wat kan later?

De buildfase neemt vervolgens de broncode en dependencies en zet dat vast om naar een pakket, een image of executable. Het is belangrijk dat die omgeving klopt met wat je project vraagt, instellingen moeten niet alleen op de laptop van een specifieke ontwikkelaar bestaan. Werk daarom met een lockfile (zoals package-lock.json of poetry.lock). Zo krijg je een build die reproduceerbaar is: als je dezelfde input hebt, krijg je telkens hetzelfde resultaat of in elk geval inzicht in waarom het anders is.

Buildfouten onderscheiden

Waarom kan een build mislukken? Soms is het pijnlijk duidelijk: een dependency mist, de buildtool is net anders, environment variables staan lokaal wél maar op de runner niet, of zo'n externe packagebron ligt flink te slapen. Een cryptische 'build failed' helpt je weinig. Leg gewoon vast welke stap stuk ging, welke versies en log foutmeldingen zonder gevoelige info. Daarmee kun je terugvinden of het aan je code lag, of aan de omgeving waarin wordt gebouwd. Voor PHP-projecten kan een PHP developer build- en teststappen inrichten.

Tests in een CI/CD-pipeline logisch opbouwen

Niet alle tests zijn gelijk. Unit tests? Die test je razendsnel en los van elkaar, ideaal bij elke commit. Integratietests combineren meerdere onderdelen, zoals een app die echt met een database praat. End-to-endtests benaderen een echte gebruikersactie en krijgen zo het complete traject te zien, inclusief routering en misschien zelfs de browser. Zulke tests zijn gevoeliger voor timing en infrastructuur en duren meestal langer. Daarom draaien snelle checks als eerste, pas als die goedgaan volgen lange of complexe testsuites.

Met de juiste volgorde krijg je sneller feedback en kun je fouten bij de simpele checks meteen zien. Failt een build bij linting of unit tests? Dan hoef je geen zware setup te starten. Parallel testen versnelt het proces, maar vraagt wel om gescheiden testdata en voldoende infra. Heb je tests die dezelfde database of bestanden aanraken zonder isolatie, dan krijg je snel rare, niet-herhaalbare fouten. Gebruik vaste fixtures en hou resources gescheiden waar dat kan.

Testdekking is geen kwaliteitsmaat op zichzelf

Test je veel regels code, dan zegt dat weinig over of je de juiste risico's test. Focus liever op gedrag en mogelijk pijnlijke delen: denk aan autorisatie, foutafhandeling, conversies en ingewikkelde business logica. Laat in de pipeline zien wat voor test faalde en bewaar bruikbare feedback. Worden tests vaak handmatig opnieuw gestart tot ze wél slagen, dan klopt er iets niet en moet je de oorzaak zoeken, niet 'gewoon doorgaan'.

Buildartefacten en versies betrouwbaar beheren

Als de build gelukt is, krijg je meestal een artefact: een image, pakket of app in kant-en-klare vorm. Daarmee weet je dat alles consistent bij elkaar hoort. Het beste werkt het om steeds hetzelfde artefact van test via acceptatie naar productie door te schuiven. Als je in iedere omgeving opnieuw bouwt, kunnen kleine verschillen (libraryversies, tools) ertoe leiden dat het ineens anders werkt in productie dan je getest had.

Gebruik voor elk artefact een duidelijke, unieke versie. Bijvoorbeeld: een vaste tag op een image, een exacte commit hash of een versie uit een releasebeheer-tool. Documenteer ook uit welke commit deze build kwam en welke inputs zijn gebruikt. Metadata en manifesten maken het later makkelijk terugzoeken. Voor opslag geldt: versies voor productie moeten lang beschikbaar blijven voor rollback, tijdelijke builds kunnen vaak sneller weg.

Herkomst en integriteit

Een pipeline die zonder fout klaar is meldt niet alles: het artefact moet ook betrouwbaar aankomen. Denk daarbij aan wie toegang heeft tot je storage, het onderschrijven (signen) van images en checks op gebruikte dependencies. Publicatiefouten zijn iets anders dan buildfouten. Soms is het ding wél gebouwd, maar kon het niet neergezet worden (netwerk, expired credentials, etc.). Koppel dus build en publicatie los in de registratie, zo zie je wat je echt moet herstellen zonder onnodig opnieuw te bouwen.

Configuratiebeheer tussen ontwikkel-, test- en productieomgevingen

Je applicatie werkt niet overal hetzelfde; databaseadressen, featureflags, endpoints en logging verschillen per omgeving. Voeg zulke instellingen niet zomaar toe aan je broncode of buildrunner. Beter is: beschrijf niet-geheime configuratie in een bestand (of als declaratie) en lever geheimen aan met een secret manager of pulled via versleutelde environment variables bij deployment. Zo voorkom je dat gevoelige gegevens in images terechtkomen.

Met configuratie komen ook risico's. Een variabele die in test gevuld is maar in productie niet bestaat, kan pas na deployen een fout opleveren. Een fout of oude credential? Dan maakt je app mogelijk verbinding met de verkeerde service, of wijst authenticatie af. Valideer daarom bij het opstarten wat echt nodig is en rapporteer missende config, maar log nooit geheimen zelf. Hou namen gelijk per omgeving en noteer wat het verwacht: een bool die je als tekst verwerkt kan voor subtiele bugs zorgen.

Omgevingsverschillen expliciet houden

Het hoeft niet exact gelijk te zijn in test en productie, maar afwijkingen moeten helder zijn. Heb je een andere databaseversie of minder rechten in test, dan worden sommige productiebugs onzichtbaar. Zorg voor infrastructuur en settings-as-code als het kan, zodat alles te reviewen en te reproduceren is. Scheid wijzigingen in code en omgeving; als beide tegelijk veranderen, is het lastiger te traceren wat de storing veroorzaakt. Geheimen dus nooit in commits, zelfs niet als je ze later wist.

Deploymentstrategieën en veilig terugdraaien

Uitrollen is meer dan een paar bestanden kopiëren. Je wilt dat een nieuwe versie beschikbaar komt zonder dat actieve processen of data ineens raar doen. Rolling deployment? Je vervangt de instances stukje bij beetje, oude en nieuwe draaien tijdelijk naast elkaar. Daardoor blijft het systeem beschikbaar en kun je sneller terug. De blue-green tactiek houdt twee aparte omgevingen in de lucht, pas als de nieuwe is goedgekeurd stuur je daar het verkeer heen. Simpel terugdraaien, maar je hebt wel dubbele infrastructuur nodig en databeheer wordt lastiger.

Met canary deployment test je de nieuwe versie op maar een deel van het verkeer. Zie je dat de metrics oké blijven, dan ga je verder. Dat werkt vooral als je veel verkeer krijgt. Kleine samples kunnen fouten missen. Welke deploymentstrategie werkt, hangt af van jullie applicatie, data en infra. Feature flags gebruiken? Zo kun je nieuwe functionaliteit aanzetten voor aparte gebruikersgroepen, maar je krijgt er wel een extra laag configuratie bij die je moet beheren en weer netjes moet weghalen.

Databasewijzigingen vragen extra aandacht

Applicatie terugzetten is niet altijd voldoende. Een databaseaanpassing kan data definitief wijzigen of een oud schema onbruikbaar maken. Werk daarom in fases: voeg eerst nieuwe velden toe, ondersteun beide structuren tijdelijk en haal oude pas weg als alle code erop voorbereid is. Een pipeline kan migratie coördineren en controleren, maar automatische data-rollback blijft riskant. Een herstelplan moet altijd rekening houden met wat er met je data gebeurt, niet alleen met de code. Voor WordPress-deployments kan WP-CLI terugkerende taken automatiseren.

Veelvoorkomende oorzaken van mislukte deployments

Een deployment kan in je pipeline slagen en alsnog stuk lopen zodra de applicatie opstart of verkeer ontvangt. Vaak is het een omgevingsprobleem: missende rechten, een dependency die niet bereikbaar is, fout endpoint of een andere runtime. Capacitiet en verkeer spelen ook mee. Een applicatie werkt lokaal, maar in productie kan geheugen te krap zijn, data te groot of starten meerdere replicas tegelijk waardoor er ineens bottlenecks ontstaan.

Ook fouten tijdens deployment zelf komen vaak voor. Health checks kunnen te snel of te oppervlakkig zijn, waardoor ze een kapotte service niet of juist te snel afkeuren. Readiness bepaalt of een instance verkeer aankan, liveness checkt of het proces nog gezond is. Time-outs en shutdown-instellingen zijn belangrijk: staan ze verkeerd, krijg je herhaalde restarts of verlies je verzoeken. Rolling deployments? Dan wil je tijdig genoeg capaciteit beschikbaar houden als je vervangt.

Diagnose op basis van fase en signalen

Leg in logs en deployment-events vast welke versie, omgeving en stap plaatsvond. Een image die niet gevonden wordt, vraagt een andere actie dan een crash door een missende variable. Vergelijk settings en runtime-omstandigheden met een eerdere, stabiele versie; verander niet alles tegelijk, zo blijf je traceerbaar. Ook externe dependencies kunnen falen. Check netwerkregels en afhankelijkheden. Een bruikbare rollback lost niet alles vanzelf op, maar beperkt hoe lang je in storing zit en houdt details vast voor analyse.

CI/CD-beveiliging voor secrets, dependencies en rechten

Je CI/CD-omgeving heeft meestal toegang tot veel gevoelige onderdelen: broncode, artefacten, soms tot productie zelf. Het is dus een interessant doel voor aanvallen. Beperk rechten strikt per pipelinejob en per omgeving. Een test hoeft echt geen toegang tot productiesleutels. Werk waar mogelijk met tijdelijke credentials, en geef een deploymentjob alleen de minimale extra rechten die strikt nodig zijn. Secret keys horen niet in repo-bestanden, container images of uitvoerlogs. Ook verwijderde geheimen blijven soms terug te halen uit commitgeschiedenis.

Let extra op bij pull requests uit externe of onzekere bronnen: automatische workflows kunnen code uitvoeren die probeert alles te lezen wat bereikbaar is. Splits validatie van zulke code duidelijk van alles wat met echte secrets of rechten werkt. Pipelineconfiguratie is ook code: wie die mag wijzigen, bepaalt wat kan gebeuren. Bescherm kritieke branches en laat ten minste gewijzigde pipelinebestanden altijd reviewen.

Afhankelijkheden en herleidbaarheid

Gebruik je publieke packages of images, dan kun je te maken krijgen met kwetsbaarheden of overgenomen modules. Leg versies vast, scan dependencies en controleer bij afwijkingen of het gewenst is. Geen enkele scan is waterdicht: sommige kwetsbaarheden zijn niet publiek, andere dependencies hebben (nog) geen melding. Bewaar daarom wie bouwde, welke inputs zijn gebruikt en wat er in een release zit. Security vraagt een combinatie van toegangsbeheer, traceerbaarheid en grip op updates, niet alleen een scannerjobje in je pipeline.

Pipelineproblemen opsporen met logs, metrics en feedback

Een pipeline is zelf software, dus je kunt die monitoren en optimaliseren op basis van echte resultaten. Kijk niet alleen naar doorlooptijd, maar ook naar wachttijden, duren per stap, hoe vaak iets faalt en het percentage taken dat je onnodig herhaalt. Lange wachtrijen wijzen vaak op een tekort aan runners, een steeds tragere build is vaak een gevolg van groeiende tests, caching die niet werkt of te veel opgesplitste stappen die elkaar afremmen. Zonder cijfers is het makkelijk om verkeerde aannames te doen en aanpassingen te maken die niks oplossen.

Caching is handig voor snelle builds, maar een te grof gekozen cachekey kan verborgen fouten geven. Verouderde caches leveren soms verkeerde resultaten. Zet sleutels dus op relevante inputs, test ook builds zonder cache. Herhaal taken alleen automatisch als het waarschijnlijk een tijdelijk probleem is (denk aan een storing in een externe server). Herstart je deterministisch falende jobs zonder verder onderzoek, dan duurt het debuggen langer en loopt je feedback achter.

Foutmeldingen bruikbaar maken

Per stap wil je weten: welke toolversie en omgeving is gebruikt, wat was het resultaat en wat is het gelogde artefact. Vermijd enorme logs waarin cruciale foutmeldingen verloren raken. Sla testuitvoer en events op een vindbare plek op, met de juiste rechten en bewaartermijn. Als een taak faalt, wil je weten: ligt het aan code, settings, infrastructuur of een externe dienst? Dat maakt gerichte verbetering mogelijk, in plaats van structurele storingen steeds per geval te fixen.

CI/CD-configuratie onderhouden naarmate systemen groeien

Wat werkt voor één microservice, loopt op termijn uiteen als je met veel repositories bezig bent. Templatebestanden of gedeelde workflows beperken dubbele code, maar zorgen niet dat alle projecten identiek werken. Een verbeterde centrale template raakt snel veel projecten; versiebeheer, changelogs en gefaseerd doorvoeren zijn dan noodzakelijk. Elk team moet snel kunnen zien welke template draait en hoe afwijkingen worden getest of goedgekeurd.

Configuratie als code maakt wijzigingen inzichtelijk, toch kunnen YAML-bestanden met ingewikkelde logica onoverzichtelijk raken. Complexe matrix-combinaties en geneste templates vergroten de kans op fout geconfigureerde stappen. Houd pipeline-taken overzichtelijk en beschrijf ze op naam, maak bovendien vast wat naar productie kan. Falen soms controlechecks stilletjes? Dat mag nooit worden gezien als "geslaagd" als de check feitelijk nooit liep.

Beheer wijzigingen zonder operationele verrassingen

Runnerimages, tooling en plugins gaan een keer over de houdbaarheidsdatum en vereisen onderhoud. Plan updates, test een nieuwe runner eerst in een afzonderlijk project en let op verschillen in rechten, netwerk en aanwezige tools. Laat uitzonderingen alleen toe waar het echt nodig is; veel maatwerkroutes bemoeilijken centrale beveiliging of kwaliteitscheck. Goed pipelinebeheer legt de focus dus zowel op uniformiteit waar het kan als op inzicht in de feitelijke uitvoering.

Veelgestelde vragen

Wat is het verschil tussen CI/CD en DevOps?

CI/CD draait om je code automatisch bouwen, testen, en klaarmaken voor uitrol. DevOps is ruimer dan dat: bij DevOps werken development en operations actief samen, delen teams verantwoordelijkheid voor productie, en horen feedback en samenwerking centraal te staan. CI/CD kan binnen DevOps worden gebruikt, maar DevOps betekent niet automatisch dat alles geautomatiseerd uitrolt.

Je ziet soms projecten met CI/CD, zonder dat ze DevOps-werkwijzes écht volgen. En andersom kan een organisatie DevOps-waarden aanhouden maar nog niet alle stappen van een pipeline automatisch geregeld hebben. De toolset bepaalt niet of je echt DevOps werkt.

Hoe kies je een CI/CD-tool voor je team?

Kies een CI/CD-tool op basis van aansluitingen bij je source control, infra, security-beleid en aanwezige kennis in het team. Populair is handig, maar niet doorslaggevend. Test eerst of de tool werkt met jullie repository, deploymentdoelen, toegangscontrole, logging, runnerondersteuning en configuratiebeheer.

  • Kijk naar beheerkosten, meer dan alleen aankoop of licentie.
  • Controleer of elke pipeline isoleerbaar blijft qua toegang tot geheimen.
  • Test een typische pipeline vóórdat je grootschalige migraties doet.

Een kleine pilot laat snel zien of de tool echt in de praktijk past bij je dagelijkse manier van werken en beheer.

Hoe meet je of CI/CD daadwerkelijk beter werkt?

Kijk of CI/CD daadwerkelijk voor snellere en betrouwbaardere uitrol zorgt, niet naar het aantal pipelinejobs op zich. Geschikte meetpunten zijn: tijd van commit tot release, hoeveel releases er worden gedaan, het percentage releases met issues en de tijd die nodig is voor herstel na fouten. Houd deze cijfers per dienst bij en vergelijk over periodes heen.

Koppel daarnaast signalen uit development, zoals pipelinewachttijd of instabiele testen. Gebruik de data om knelpunten te vinden, nooit om individuele mensen op af te rekenen. Te strakke sturing kan ertoe leiden dat teams alleen de cijfers verbeteren, zonder zichtbaar voordeel voor gebruikers of organisatie.

Kun je CI/CD toepassen op een legacy-applicatie?

Ja, CI/CD toevoegen aan een legacy-app kan zeker waardvol zijn. Maar begin voorzichtig: bouw en test automatiseer je als eerste stap en breng je afhankelijkheden in kaart (runtime, libraries, enz). Rol daarna checks uit die passen bij het risico en de architectuur van de applicatie.

Zijn er praktisch geen testen? Start dan met simpele rooktests of controles voor kernfunctionaliteit. Verwerk ook handmatige deploymentstappen en omgevingsafhankelijkheden in je documentatie. Zo ontdek je geleidelijk waar automatisering mogelijk is en waar technische vernieuwing nodig blijft.

Wanneer zijn handmatige goedkeuringen in een CI/CD-proces nodig?

Handmatige goedkeuringen zijn gewenst wanneer releases een duidelijk business- of compliancebesluit vragen of de impact van een fout groot is. Zet zo'n goedkeuring na geslaagde checks maar vóór productie. Weet wie mag goedkeuren en volgens welke criteria dit gebeurt.

Gebruik handmatige stappen niet als vaag vangnet voor alles wat niet geautomatiseerd is of als standaardvertraging. Beperk het tot gevoelige releases of specifieke targets. Leg ook de beslissing vast: wie gaf akkoord, op welke versie, opdat je later desgewenst terug kunt zien hoe het besluit tot stand kwam.

Foto: Galib Rahman Nadim

Portret van Maarten

Maarten

Freelance developer in Nijmegen

Even kennismaken?

Vertel kort wat er speelt. Dan hoor je wat er kan, wat ik anders zou doen en waar AI bij jou wél en niet iets toevoegt. Vrijblijvend.

Het kantoor in Nijmegen
© 2026 maarten.online Sitemap Privacy Algemene voorwaarden
Het kantoor in Nijmegen

Maarten.

Freelance developer in Nijmegen. Liever direct contact? Dat kan ook.

Kennismaken

Laat je gegevens achter, dan kijken we of het klikt. Vrijblijvend en zonder verkooppraat.

Maarten

Stuur een bericht via WhatsApp

Hoi! Waar kan ik je mee helpen?

nu