Het onderwerp van vandaag is iets waar bijna iedereen van gehoord heeft, maar wat weinigen echt kunnen uitleggen. GitOps. Je hebt het waarschijnlijk voorbij zien komen in vacatures, conferentiepraatjes of Azure documentatie. Maar wat is het precies? Is het weer de zoveelste DevOps-baswoord of is het iets fundamenteel anders? Hier is de korte versie. GitOps is een operationeel model waarbij Git de enige bron van waarheid wordt voor je gehele infrastructuur, niet alleen je applicatiecode, maar alles wat die draait. Aan het einde van deze aflevering begrijp je wat GitOps echt is, waarom het de standaard is geworden voor het beheren van Kubernetes op Azure en hoe het rollbacks zo simpel maakt als één enkel commando. De oude manier, handmatige deployments en configuratie drift. Laten we beginnen bij het probleem dat GitOps oplost. Stel je voor dat je een Kubernetes-cluster beheert op Azure. Ontwikkelaars pushen code, een CI-pipeline bouwt container-images en iemand voert Qbackt LApply uit om die images te deployen. Misschien jij, misschien een teamgenoot, of je klikt op een knop in Azure DevOps, hoe dan ook vindt de deployment plaats. Dat werkt prima, totdat het niet meer werkt. Dit is wat er daarna gebeurt. Iemand in je team moet snel een bak repareren, dus logt hij via SSH in op een node, gebruikt de Azure portal of voert Qbackt LEdit direct uit op een deployment. Ze maken een kleine wijziging, zoals een aanpassing in een config map of een andere omgevingsvariabele, en het lijkt onschuldig. Tenminste, dat denken ze. Het probleem is dat die wijziging nooit is teruggegaan naar Git, waardoor je cluster nu een configuratie heeft die niet overeenkomt met wat er in je repository staat. Dat noemen we configuratie drift. Drift is een stille doder, want het werkt prima tot de volgende deployment, wanneer iemand Qbackt LApply uitvoert met het oorspronkelijke manifest en die snelle fixe overschrijft. Of erger, de drift veroorzaakt onverwacht gedrag dat niemand kan verklaren. Je begint met debuggen, controleert de LAX, kijkt naar de Griekse YAML in Git en niets lijkt mis, maar het cluster doet iets anders. Je hebt geen idee wat er veranderd is, wanneer het veranderde of wie het veranderd heeft. Ik heb dit zien gebeuren. Een teamgenoot logt via SSH in op een node, past een configuratie aan om iets te testen, vergeet het terug te draaien en gaat naar huis. De volgende dag breekt er een deployment en niemand kan uitleggen waarom. De Git repo ziet er schoon uit, maar het cluster is een puinhoop en je bent uren kwijt om uit te zoeken wat er is gebeurd. Dus, hier is de vraag. Wat als er een manier was om het cluster te dwingen altijd overeen te stemmen met wat er in Git staat? Wat als je kon garanderen dat wat er in je repository staat precies is wat er in productie draait? Dat is het kernidee achter GitOps. Wat GitOps daadwerkelijk is. Dus, wat is GitOps nou eigenlijk? Hier is de simpelste definitie die ik je kan geven. Git wordt je enige bron van waarheid, niet alleen voor je code, maar voor alles wat je infrastructuur nodig heeft om te draaien. Elke configuratie, elk deployment manifest, elk omgevingsvariabele, het staat allemaal in Git. Niets draait op je cluster tenzij het daar gedefinieerd is. Nu is GitOps geen tool die je kunt kopen. Het is een bedrijfsmodel zoals DevOps of DevSecOps. Een set principes die bepalen hoe je je infrastructuur beheert. De open GitOps standaard bevat vier kernprincipes en ik wil ze stuk voor stuk langslopen. Ten eerste moet je systeem declaratief zijn. Dat betekent dat je de eindtoestand beschrijft, niet de stappen om daar te komen. Dus in plaats van een script te schrijven dat zegt, maak een deployment aan, schaal naar vijf replica's. Stel poort 8080 open, schrijf je een Griekse YAML bestand dat zegt, ik wil vijf replica's op poort 8080 en het systeem bedenkt te stappen. En dat is declaratief. Ten tweede moet het geversioneerd zijn. Elke wijziging die je aanbrengt in je cluster status is een committing Git. Zo krijg je een volledige geschiedenis van wie wat heeft gewijzigd, wanneer en waarom. Geen gegroep meer of spitten door logbestanden. Ten derde worden wijzigingen automatisch opgehaald. Het cluster neemt contact op met Git om te zien wat er nieuw is. Later leg ik uit waarom dit zo belangrijk is. En ten vierde wordt het systeem continu afgestemd. Er draait een software-agent binnen je cluster die constant vergelijkt wat in Git staat met wat er daadwerkelijk draait. Als ze niet overeen komen, corrigeert het de afwijking. Dat is de reconciliatieloop. Zie het op deze manier. Git is je bouwtekening van de architect. Het beschrijft precies hoe het gebouw eruit moet zien. Kubernetes is de bouwplaats. En de Gitops operator, dat is de opzichter. Hij loopt rond met de bouwtekening en controleert elke muur, elke balk, elk raam. Als iets niet overeenkomt, herstelt hij het. Stel dat iemand van het team een ongeoorloofde wijziging doorvoert, dan ziet hij dat en draait hij het terug. De bouwtekening is altijd de bron van waarheid. Maar hier vindt de echte verandering plaats. Hoe deployments daadwerkelijk werken. In traditionele CI-CD-push je wijzigingen naar het cluster. In Gitops haalt het cluster ze op. En dat verschil is belangrijker dan het klinkt. Pool-gebaseerde deployments versus push-gebaseerde. Laten we praten over hoe deployments echt werken, want hier verandert Gitops alles. In het traditionele push-model doet je CI-pipeline alles. Azure Pipelines, Jenkins, GitHub Actions. Het bouwt de container, voert tests uit en pust die image vervolgens direct naar je Kubernetes-cluster. De pipeline bevat inloggegevens die directe toegang geven tot de cluster-API. Deze zegt, hier is de nieuwe deployment. Pas deze nu toe. Aanhalingsteken. Dat werkt, maar het creëert een beveiligingsprobleem. Het punt is, als die pipeline gecompromitteerd wordt, iemand een schadelijke stap invoegt, een tokelekt of een dependency wordt gekaapt, dan heeft die pipeline een directe lijn naar je productie-cluster. Het kan deployments vernietigen, namens spaces verwijderen, configuraties wijzigen, allemaal met de rechten die je het hebt gegeven om zijn werk te doen. Kijk nu eens naar het Gitops-model. De flow begint hetzelfde. CI bouwt de container en pust deze naar een register zoals Azure Container Registry. Dat is waar CI stopt. Het raakt de cluster niet aan. In plaats daarvan werkt CI een Git repository bij met een nieuwe image-tag. Het wijzigt één regel in een Griekse YAML-bestand, de image-versie, en commit die wijziging. Dat is alles. Geen directe cluster-toegang. Vervolgens ziet de Gitops-operator die in je cluster draait die wijziging. Het haalt de laatste status uit Git en past deze toe. De cluster benadert Git niet andersom. Dit is het poolgebaseerde model. Je cluster stelt zijn API nooit bloot aan externe systemen. Het haalt alleen gegevens op uit Git. Als iemand je CI-pipeline comprometeert is het ergste wat ze kunnen doen aan manifest in een repository wijzigen. Ze kunnen de cluster niet direct aanraken. De operator bepaalt wat er wordt toegepast en wanneer. Er is ook nog een ander voordeel. Je ontkoppelt bouwen van deployen. CI doet waar het goed in is bouwen, testen, scannen. De Gitops-operator regelt de deployment. Elk systeem focust zich op één taak. Als de beeld faalt, verandert er niets in de cluster. Als de deployment faalt, probeert de operator het opnieuw of waarschuwt je. Een duidelijke scheiding. Dus in plaats van dat een pipeline wijzigingen in je cluster pust, haalt je cluster de gewenste status op uit Git. Die eenvoudige omdraaiing maakt je infrastructuur veiliger, beter controleerbaar en minder kwetsbaar voor fouten. De reconciliation loop. Dus hoe weet de operator wanneer hij moet updaten? Hij wacht niet op een melding. Hij draait een continuous, Git in de gaten houden, vergelijken met de cluster, wijzigingen toepassen indien nodig en dan alles steeds opnieuw doen. Dit wordt de reconciliation loop genoemd. Deze draait constant, elke paar seconden of minuten, afhankelijk van je configuratie. De operator stopt nooit met kijken. Denk erover zoals een thermostaat in je huis. Je stelt de gewenste temperatuur in, zeg 21 graden. De thermostaat controleert constant de werkelijke temperatuur. Als deze onder de 21 zakt, gaat de verwarming aan. Als deze erboven komt, gaat de verwarming uit. Hij blijft aanpassen om aan je instelling te voldoen. De GitOps operator werkt op dezelfde manier. Git bevat de gewenste status, het cluster heeft de werkelijke status, en de operator vergelijkt deze continu en voert aanpassingen uit. Dus, wat gebeurt er als iemand handmatig een deployment in het cluster bewerkt? Misschien voeren ze Q-backed L-edit uit om het aantal replica's te wijzigen. De operator detecteert dat verschil tijdens de volgende reconciliatiecyclus. Het cluster heeft nu drie replica's, maar in Git staan er vijf. Dus past de operator de in Git gedefinieerde status toe en gaat het cluster terug naar vijf replica's. De ongeautoriseerde wijziging is verdwenen. Wat gebeurt er als je een wijziging naar Git pust? Hetzelfde proces. De operator detecteert het verschil en voert het door. Een ontwikkelaar merget een PR die de imageversie bijwerkt van v1.2 naar v1.3. De operator ziet het nieuwe manifest, haalt de nieuwe image op en start de nieuwe pods op. Binnen enkele seconden komt het cluster weer overeen met Git. Nu is er hier een belangrijk onderscheid. Als een podcrash kan dat de operator niet schelen. Dat is de taak van Kubernetes, afgehandeld door de replica-set controller. De GitOps operator geeft alleen om de configuratie. Als het deployment manifest vijf replica's en image v1.3 aangeeft en het cluster heeft vijf replica's met v1.3, dan is de operator tevreden. Het maakt niet uit of een specifieke pad opnieuw is opgestart. Dat is normaal Kubernetes gedrag. Maar als iemand het manifesting-git wijzigt of als iemand direct wijzigingen aanbrengt in het cluster waardoor drift ontstaat, komt de operator in actie. Dat is wat GitOps zelf herstellend maakt. Het implementeert niet alleen wijzigingen, het voorkomt actief dat je infrastructuur afwijkt van wat is gedefinieerd. Je hebt dus een GitOps operator nodig die in je cluster draait. Dat is waar Argo CD en Flux in beeld komen. Argo CD versus Flux. Je hebt dus een GitOps operator nodig en je hebt twee uitstekende opties. Argo CD en Flux zijn beide CNCF-graduated, projecten, wat betekent dat ze voldoen aan de hoogste eisen voor stabiliteit, community en productierijpheid. Maar ze benaderen dezelfde taak vanuit verschillende invalshoeken. Argo CD is oorspronkelijk gebouwd door Intuit en wordt geleverd met een web UI. Wanneer je Argo CD installeert, krijg je een dashboard waar je elke applicatie, de synchronisatiestatus, gezondheid en deploymentgeschiedenis kunt zien. Je kunt rondklikken, verschillen tussen Git en het cluster bekijken, zaken handmatig triggeren en wijzigingen goedkeuren. Het is ontworpen voor teams die visuele dashboards en handmatige controlepunten willen. Flux komt van Weaveworks en is module raarder. Standaard is er geen UI aanwezig. Je werkt vanaf de commandline en definieert alles als Kubernetes custom resources. Je maakt een Git repository object aan dat zegt, monitor deze repo. En een customization object dat zegt, pas dit pad toe. Flux pikt het op en voert de reconciliatie uit. Het dwingt je om Git native workflows te omarmen, omdat er geen dashboard is om op de rug te vallen. Nu, dit is wat belangrijk is voor Azure gebruikers. Flux is de standaard GitOps optie op Azure Kubernetes Service. Microsoft heeft de native integratie rondom Flux V2 gebouwd. Wanneer je GitOps inschakelt op een Axe cluster via de Azure portal, gebruik je op de achtergrond Flux. Azure Arc gebruikt ook Flux voor multi-cluster beheer. Dus, als je een Azure engineer bent, is Flux het natuurlijke startpunt. Maar Argo CD heeft zijn eigen sterke punten. Het is populairder voor platform engineering scenario's waarbij je een centraal control plane wilt om meerdere clusters te beheren. De UI maakt het gemakkelijker voor teams die niet comfortabel zijn met de command line. En het integreert nauw met Argo rollouts voor progressive delivery, zoals canary deployments, blue, green deployments, dat soort dingen. Het belangrijkste architecturale verschil is dit Argo CD draait als een standalone applicatie met een eigen API server. Flux draait als een set Kubernetes controllers die dieper in het cluster zelf zijn ingebed. Flux voelt aan als onderdeel van je Kubernetes control plane, terwijl Argo CD aanvoelt als een apart platform dat er bovenop staat. Flux vertrouwt ook sterk op Customize, wat een Kubernetes native templating tool is. Argo CD kan Customize, helm of standaard Griekse YAML gebruiken. Beide ondersteunen helm, maar Flux heeft een dedicated helm controller die helm releases native afhandelt. Er is hier geen verkeerde keuze. Beide tools doen hetzelfde werk. Maar voor Azure engineers is Flux de weg van de minste weerstand. Je kunt GitOps met Flux in een paar klikken inschakelen via de Azure portal, het naar een Git repo wijzen en het begint met synchroniseren. Geen extra installatie, geen aparte server om te beheren. GitOps op Azure, Axe, Azure Arc en Azure DevOps. Dus, hoe ziet dit er in de praktijk uit als je het combineert met Azure? Laten we beginnen met Axe. Azure Kubernetes Service heeft ingebouwde GitOps ondersteuning met behulp van Flux V2. In de Azure portal ga je naar je cluster, zoek je de GitOps sectie en configureer je deze door het naar een Git repository te wijzen. Azure Repos, GitHub, waar dan ook. Flux begint te monitoren en alle manifests die je in die repo plaatst, worden automatisch op je cluster toegepast. Maar Axe is slechts één onderdeel. Azure Arc breidt GitOps uit naar clusters die niet in Azure staan, on-premises, in andere clouds of aan de Edge. Verbind ze met Azure Arc en je beheert ze allemaal met dezelfde GitOps configuratie. Eén repo, veel clusters, overal een consistente status. Dat is wat Arc doet. Laten we het nu over de pipeline hebben. Azure DevOps integreert op natuurlijke wijze met dit model en dit is het gangbare patroon. Uw broncode staat in Azure Repos of GitHub en Azure Pipelines verzorgt de CI. Het bouwt de container image, voert tests uit, scant op kwetsbaarheden en pust de image naar Azure Container Registry. Daarna werkt de pipeline de manifests in uw GitOps repo bij door de image tag van v1.2 naar v1.3 te wijzigen, die wijziging te committen en te pushen. Dat is alles. De pipeline komt nooit in aanraking met het cluster. Flux, dat binnen een axtraad, detecteert de wijziging in Git, haalt het nieuwe manifest op, ziet de bijgewerkte image tag en past de deployment toe. Nieuwe pads worden opgestart en het cluster synchroniseert. U kunt GitHub Actions gebruiken in plaats van Azure Pipelines als u dat liever heeft. Het patroon blijft hetzelfde. CI verzorgt de build, werkt de manifests bij en de GitOps operator verzorgt de deployment. De tool doet er niet toe, het model wel. Hier is een belangrijk detail. Sla nooit secrets direct op in Git. Geen API keys, geen connection strings, geen certificaten. Zelfs in een private repository zijn secrets in Git een risico. Gebruik in plaats daarvan Azure Key Vault of een externe secrets operator. Het manifest verwijst naar het secret bij naam en de operator haalt de werkelijke waarde uit de volt tijdens de deployment. U kunt ook een beleid bovenop leggen. Azure Policy met Gatekeeper kan regels afdwingen zoals geen geprivilegeerde containers of alleen goedgekeurde container registries gebruiken. Als iemand probeert een manifest te deployen dat in strijd is met het beleid, blokkeert Gatekeeper dit voordat het het cluster bereikt. Het echte voordeel hier is schaalbaarheid. Met 50-axe clusters beheert u ze niet elk afzonderlijk. Defineer de gewenste status in één Git repo en elk cluster synchroniseert naar die status. Voeg een nieuw cluster toe, wijs het naar de repo en het configureert zichzelf. Moet u een configuratie bijwerken voor alle clusters? Wijzig één bestand in Git en de operators regelen de rest. Dat is de belofte van GitOps op Azure. Eén bron van waarheid, vele clusters, geen afwijkingen. De belangrijkste voordelen. Dus, dit klinkt allemaal goed in theorie, maar wat betekent het echt voor uw team? Laten we beginnen met degene die ieders aandacht trekt. Rollbacks worden triviaal. Een foutieve deployment wordt uitgerold, uw applicatie geeft fouten, gebruikers klagen. In de oude wereld moest u haastig de laatst bekende goede configuratie zoeken, een reeks handmatige opdrachten uitvoeren en bidden dat u niets vergeten was. In GitOps maakt u de Git commit ongedaan. Dat is alles. Eén opdracht. De operator ziet de terugdraaiing, haalt de vorige status op en het cluster keert terug naar wat voorheen werkte. Geen SSH nodig, geen Q-backed L en zeker geen paniek. Een audit trail is automatisch ingebouwd. Elke wijziging aan je infrastructuur is een commit. Je weet wie het deed, wanneer ze het deden en wat ze precies veranderen. Geen gegroep meer of iemand om twee uur s'nacht zijn deployment heeft aangepast en dit vergat te melden. De geschiedenis is aanwezig, onveranderlijk en controleerbaar. Selfhealing is iets dat als magie klinkt totdat je het in actie ziet. Iemand past handmatig een deployment in het cluster aan. Misschien een junior engineer die snel iets probeert op te lossen. De operator detecteert de afwijking in de volgende reconciliatiecyclus en draait het terug. Het cluster herstelt zichzelf en je merkt het niet eens tenzij je de laks bekijkt. Consistentie tussen omgevingen wordt automatisch. Dev, test, staging, productie. Ze halen allemaal hun data uit dezelfde git repo. Verschillende branches of mappen, maar dezelfde bron van waarheid. Geen het werkt op mijn machine, meer omdat je staging cluster weken geleden afweek van productie. Beveiliging verbetert omdat het cluster vanuit git pult, in plaats van dat er naar gepust wordt. Je CI pipeline bevat nooit inloggegevens die direct toegang geven tot productie. Als iemand de pipeline overneemt, kunnen ze het cluster niet aanraken. De operator bepaalt wat er wordt toegepast en wanneer. Minste privileges als uitgangspunt. Er zijn ook gegevens die dit ondersteunen. Volgens Dora onderzoek zien teams die GitOps adopteren zo'n 25% minder deployment fouten... ...en de gemiddelde hersteltijd daalt tot onder de 2 minuten bij goede implementaties. Dat is geen theorie, dat is wat organisaties rapporteren. En er is een voordeel voor samenwerking dat makkelijk over het hoofd wordt gezien. Infrastructuurwijzigingen gaan via pull requests, code reviews en geautomatiseerde tests. Precies zoals bij applicatiecode. Je Ops team en je dev team spreken dezelfde taal. Git, geen overdrachten meer, niet meer dat. Deploy dit even voor mij. Iedereen werkt op dezelfde manier. Maar er zijn nog steeds wat veelvoorkomende misverstanden die opgehelderd moeten worden. Veelvoorkomende mythes en de eerste stappen. Laten we beginnen met het ophelderen van enkele veelvoorkomende mythes over GitOps. Ten eerste denken veel mensen dat GitOps alleen voor Kubernetes is. En zeker, het werkt het best op Kubernetes? Daar is geen twijfel over. Kubernetes is gebouwd rond declaratieve status en reconciliatie, dus het past van nature. Maar het punt is, diezelfde principes gelden overal waar je declaratieve configuraties hebt. Je kunt GitOps gebruiken met Terraform, Pulumi en zelfs Ansible. Sla die configuraties gewoon op in Git en laat een pipeline ze toepassen. Het self-healing aspect is lastiger buiten Kubernetes, maar het principe van de bron van waarheid werkt overal. Een andere mythe is dat je absoluut Argo CD of Flux nodig hebt om aan GitOps te doen. Als je het volledige model wilt, met poolgebaseerde implementatie, continu reconciliatie en driftdetectie, dan heb je inderdaad een GitOps operator nodig. Maar je kunt veel eenvoudiger beginnen. Zet al je manifests in Git en gebruikpool requests voor wijzigingen. Dat alleen al geeft je de meeste voordelen op het gebied van audit en samenwerking. Je kunt altijd later een operator toevoegen wanneer je de automatisering nodig hebt. En tot slot is er de mythe dat GitOps CI, CD volledig vervangt. Dat is niet zo. Het vervangt alleen het CD gedeelte. CI bouwt nog steeds je code, voert tests uit, scant op kwetsbaarheden en pust containerimages naar een registry. Dat blijft allemaal hetzelfde. Wat verandert, is hoe die images worden geïmplementeerd. In plaats van dat de CI-pipeline ze naar het cluster pust, haalt de GitOps operator de bijgewerkte manifest uit Git. De CI en GitOps werken samen, ze vervangen elkaar niet. Beginnen is eigenlijk heel eenvoudig. Kies een Kleinax-cluster en schakel Flux in via de Azure portal. Het kost slechts een paar klikken. Wijs het vervolgens naar een Git repository met een eenvoudige deployment Griekse Y-AML. Kijk hoe het synchroniseert en je bent vertrokken. Probeer een waarde in de Griekse Y-AML te veranderen. Commit deze en zie hoe het cluster bijwerkt. Dat is je eerste GitOps workflow. Van daaruit kun je omgevingen toevoegen, leren werken met Customize omdat Flux dit veel gebruikt... ...en geautomatiseerde image updates instellen met tools zoals Renovator of Dipenda Bot. Dus, dat is GitOps in een notendop. Het verandert je infrastructuur in een Git repository, waardoor alles traceerbaar, terugdraaibaar en zelfherstellend wordt. Als je Kubernetes op Azure beheert, probeer dan vandaag nog de GitOps integratie in Axe. Het opzetten duurt 10 minuten en zal je kijk op implementaties veranderen. Abonneer je voor meer duidelijke uitleg over de Cloud Tools van Microsoft.