Je hebt een testomgeving nodig in Azure. Niets bijzonders. Gewoon een virtueel netwerk, een paar virtuele machines en een storage account. Dus je logt in op de portal, zoekt de knop voor resource groepen en begint te klikken. Eén klik om de groep aan te maken, nog een paar om het virtuele netwerk in te stellen. Dan doorloop je de wizard voor het maken van de VM, kies je de regio, de grootte, de image, configureer je de schijf en stel je het netwerk in. Dat zijn misschien wel 50 klikken. Dan doe je het opnieuw voor de tweede VM, dan configureer je het storage account en vervolgens stel je de firewall regels in. En het punt is, elke klik is een kans om een fout te maken. Kies je de verkeerde regio, dan draait je app trager dan zou moeten. Kies je de verkeerde VM grootte, dan betaal je vanaf dag 1 te veel. Vergeet je een poort te sluiten, dan heb je je omgeving onbedoeld blootgesteld aan het internet. Vermenigvuldig dat nu met drie omgevingen, def, test en productie, plotseling doe je geen 50 klikken meer, maar 150. En ergens in dat proces gaat de productieomgeving er totaal anders uitzien dan de ontwikkelomgeving. Een instelling hier, een vinkje daar, kleine verschillen die later voor grote hoofdpijn zorgen. Maar wat als je je volledige Azure setup in een bestand zou kunnen beschrijven in plaats van door al die schermen te klikken? Wat als je dat bestand één keer zou kunnen uitvoeren en elke keer hetzelfde resultaat zou krijgen? Dat is waar we het vandaag over gaan hebben. Aan het einde van deze aflevering begrijp je wat infrastructure als code precies is, waarom Azure Teams erop vertrouwen en hoe je ermee kunt beginnen zonder developer te zijn. Wat handmatige provisioning je werkelijk kost. Laten we een typische Azure setup doorlopen. Je hebt een resource groep nodig, daarin een virtueel netwerk met een paar subnets, dan een paar virtuele machines, één voor je webserver, één voor je database en een storage account voor je applicatiedata. In de portal ben je daar een hele middag mee aan het klikken. En dit is het probleem, elke klik is een kans op een fout. Misschien kies je de verkeerde regio omdat het opdouwmenu standaard op East US staat en je West Europe bedoelde. Misschien kies je een VM grote die veel te duur is voor wat je eigenlijk nodig hebt. Misschien laat je per ongeluk een beheerpoort openstaan naar het internet. Deze fouten gebeuren nu eenmaal. Ze gebeuren omdat de portal het makkelijk maakt om snel te klikken, maar lastig om rustig aan te doen en je werk te controleren. En de echte kosten zijn niet alleen de tijd die je verspilt aan het herstellen van die fouten. Het is de tijd die je kwijt bent aan het herhalen van dezelfde klikken voor dev, test, staging en productie. Want dit is wat er gebeurt. Je bouwt dev op maandag, het kost je drie uur en het werkt perfect. Op dinsdag bouw je de testomgeving. Je bent deze keer iets sneller, 2,5 uur, maar je vergeet één instelling. Een firewall-regel die open stond in dev, is gesloten in test. Je applicatie gedraagt zich anders en je bent een uur kwijt aan debuggen. Tegen de tijd dat je op vrijdag bij productie aankomt, lijkt je omgeving totaal niet meer op dev. Andere VM-groottes, andere opslagconfiguraties, een paar instellingen die je wijzigt omdat iemand zei, probeer dit even snel. Dat is configuratiedrift en het is het logische gevolg van het handmatig bouwen van omgevingen. Het echte probleem is dat je een muisklik niet kunt controleren. Odden. Je kunt een muisklik niet ongedaan maken. Als er over zes weken iets kapot gaat in productie, weet je niet meer welk vak je je hebt aan of uitgevinkt. Je hebt geen verslag van wat er tussen dev en productie is veranderd. Dus, wat als je je volledige Azure setup in een bestand kon beschrijven in plaats van door schermen te klikken? Eén bestand dat precies aangeeft hoe je omgeving eruit moet zien. Voer het één keer uit en krijg elke keer hetzelfde resultaat. Voer het opnieuw uit en krijg weer hetzelfde resultaat. Geen drift, geen vergeten instellingen, geen productieomgevingen die totaal anders zijn dan dev. Infrastructure als code, de definitie in één zin. Infrastructure als code betekent dat je je infrastructuur beschrijft in een bestand dat Azure kan lezen en voor je kan bouwen. Dat is alles. Eén zin. Je schrijft een bestand, Azure leest het en je omgeving verschijnt. Zie het als een kantoorpand. Als je een nieuw kantoor wilde inrichten, zou je rond kunnen lopen en elke werknemer kunnen vertellen waar elk bureau en elke stoel moet staan. Dat is de handmatige aanpak. Het werkt, maar het is traag en iedereen eindigt met een net iets andere indeling. Of je geeft ze een blauwdruk. Een fel papier waarop precies staat waar alles moet komen. Elke ruimte is identiek omdat iedereen hetzelfde plan heeft gevolgd. Je IAC-bestand is die blauwdruk. Het is de enige bron van waarheid voor je volledige Azure-omgeving. Alles wat je omgeving nodig heeft, de resource-groepen, de virtuele netwerken, de VM's, de opslagaccounts, de firewall-regels, het staat allemaal in dat ene bestand. Nu is er hier een belangrijk onderscheid. IAC gebruikt wat men een declaratieve aanpak noemt. Dat is een chique manier om te zeggen dat je Azure vertelt wat je wilt en niet hoe het stap voor stap gebouwd moet worden. Je zegt niet, maak een resource-groep, maak dan een virtueel netwerk daarbinnen en maak dan een subnet daarbinnen. Je zegt, ik wil een resource-groep met een virtueel netwerk dat een subnet bevat. Azure bepaalt zelf de volgorde. Dit is anders dan de scripts die systeembeheerders jarenlang hebben gebruikt. Scripts zijn imperatief. Ze vertellen het systeem precies wat het stap voor stap moet doen. Doe dit, doe dan dat, doe daarna dit andere ding. En als één stap faalt, loopt alles in de zoek. IAC is het tegenovergestelde. Je beschrijft de eindtoestand en het systeem bepaalt zelf hoe het daar komt. Hier is een concreet voorbeeld. In plaats van 50 losse CLI-commando's te typen om een virtuele machine te maken, schrijf je zoiets als Ik heb een virtuele machine nodig met 8 GB RAM, draaiend op Ubuntu 4 over 10 s'avonds, verbonden met dit virtuele netwerk en met een opslagaccount eraan gekoppeld. Dat is alles. Eén beschrijving in plaats van 100 commando's. En dit is specifiek belangrijk voor Azure omdat de portal het zo makkelijk maakt om te beginnen. Je kunt met een paar klikken binnen 10 minuten een virtuele machine laten draaien. Maar de portal schaalt niet. Wanneer je 10 omgevingen nodig hebt in plaats van 1, wordt de portal een blok aan je been. IAC is hoe je uit die valstrik ontsnapt. Dus, dat klinkt nuttig, toch? Maar welke tools geeft Microsoft je eigenlijk om deze blauwdruk bestanden te schrijven? De Azure IAC Toolkit, ARM, Bicep en de olifant in de kamer. Dus, welke tools geeft Microsoft je eigenlijk om deze blauwdruk bestanden te schrijven? De originele tool heet ARM Templates. ARM staat voor Azure Resource Manager en deze templates bestaan al sinds het begin. Ze zijn geschreven in JSON, een dataformaat dat er uitziet als een configuratiebestand uit 2015. Veel accolades, veel haakjes, veel inspringingen. Als je wel eens naar een JSON-bestand hebt gekeken, weet je wat ik bedoel? Het is functioneel, maar het leest niet prettig. ARM Templates worden nog steeds veel gebruikt, vooral in bedrijfsomgevingen. Grote bedrijven hebben jarenlang geïnvesteerd in het opbouwen van hun templatebibliotheken en die gaan dat werk niet zomaar weggooien. Maar als je een beginner bent, kan het bekijken van een ARM Template voor de eerste keer intimiderend zijn. Het is onslachtig. Het is makkelijk om het kapot te maken. Een ontbrekende komma en de hele boel faalt. Het met de hand schrijven ervan is pijnlijk. Microsoft erkende dit probleem, dus bouwde ze Bicep. Bicep is Microsoft's antwoord op het feit dat ARM Templates te ingewikkeld zijn. Het is een nieuwere taal die op de achtergrond compileert naar ARM Templates, maar de syntaxis is veel schoner. Het ziet eruit als echte code. Je schrijft iets als Resource MyV en Microsoft. Compute virtual machines in plaats van pagina's volgeneste JSON. Het is in de eerste plaats voor mensen ontworpen. Nu is er nog een optie waar je van zult horen. Terraform. Terraform is een tool van een bedrijf genaamd HashiCorp en het werkt met Azure en andere clouds. Als je infrastructuur moet beheren over AWS, Google Cloud en Azure tegelijk, is Terraform je beste keuze. Het is beter overdraagbaar, maar die overdraagbaarheid heeft een prijs. Terraform voegt een abstractielaag toe tussen jou en Azure. Je moet de eigen taal van Terraform, HCL, leren naast het begrijpen van Azure zelf. Het is krachtig, maar het introduceert zijn eigen complexiteit. Dus, welke moet een beginner kiezen als je alleen Azure gebruikt? Begin dan met Bicep. De reden is simpel, native integratie. Bicep is door Microsoft specifiek voor Azure gebouwd. Het heeft minder bewegende onderdelen. Het krijgt volledige ondersteuning van Microsoft. En omdat het compileert naar ARM templates, zit je nergens aan vast. Je kunt altijd later overstappen naar ruwe ARM templates als dat nodig is. Bicep is de weg van de minste weerstand voor iemand die net wil beginnen. Dit is hoe deze tools in de praktijk werken. Je schrijft een bestand, een Bicep bestand, een ARM template, wat je maar kiest. Vervolgens voer je een commando uit. Voor Bicep is dat commando as deployment group create. Azure leest je bestand, vergelijkt het met wat er al bestaat en bouwt wat ontbreekt of wijzigt wat anders is. Je hoeft Azure niet te vertellen in welke volgorde dingen moeten gebeuren. Dat zoekt het zelf uit. En hier wordt het pas echt interessant. Je kunt dit koppelen aan een CI-CD pipeline, continuous integration, continuous deployment. Dat betekent dat elke keer als je een wijziging naar je code repository bust, Azure automatisch je IAC bestand uitvoert en je infrastructuur bijwerkt. Geen handmatige stappen, niemand die inlogt op de portal, alleen code wijzigingen die automatisch naar productie stromen. Je hebt dus een bestand dat je infrastructuur beschrijft. Je kunt het uitvoeren en krijgt een consistent resultaat. Je kunt het hele proces zelfs automatiseren met een pipeline. Maar wat ontgrendelt dat nu eigenlijk? Dat is waar de dingen pas echt krachtig worden. Wat versiebeheer doet voor je Azure-omgeving? Dit is iets waar mensen niet vaak genoeg over praten. De echte superkracht van IAC is niet het template-formaat zelf. Het is niet Bicep versus ARM versus Terraform. De echte superkracht is versiebeheer. Wanneer je je IAC bestanden opslaat in een repository zoals GitHub of Azure Repos, wordt elke wijziging traceerbaar. Wie heeft wat veranderd, wanneer en waarom? Je krijgt een volledige historie van elke wijziging aan je infrastructuur vanaf dag 1. En dat betekent dat je terug kunt rollen. Als een implementatie iets kapot maakt, hoef je niet te raden wat er misging. Je hoeft niet in auditlogboeken van de portal te spitten in de hoop het antwoord te vinden. Je keert gewoon terug naar de laatst werkende versie van je IAC bestand en implementeert opnieuw. Het probleem verdwijnt. Dat is iets wat je simpelweg niet kunt doen met muisklikken. Het betekent ook dat je omgevingen consistent blijven. Dev, test en productie komen allemaal voort uit dezelfde bestanden. Geen vergelijkbare bestanden, geen bestanden die hetzelfde begonnen maar gaandeweg uit elkaar liepen. Dezelfde bestanden. Je implementeert dev vanuit je hoofdbranche. Wanneer je klaar bent voor test, implementeer je dezelfde bestanden naar het testabonnement. Wanneer je klaar bent voor productie, implementeer je diezelfde bestanden opnieuw. Elke omgeving is identiek omdat elke omgeving is gebouwd met hetzelfde blauwdrukontwerp. En omdat deze bestanden in een repository staan, kun je code reviews doen voor infrastructuur. Voordat iemand een wijziging implementeert, moet een ander teamlid ernaar kijken en deze goedkeuren. Dat vangt fouten op voordat ze ooit je omgeving bereiken. Het is hetzelfde proces dat softwareontwikkelaars voor applicatiecode gebruiken, toegepast op je Azure setup. Hier is een praktijkvoorbeeld. Iemand in je team stelt per ongeluk een storage account open voor het publiek. Zonder IAC merk je dat misschien pas als de rekening komt of als iemand je vertelt dat je data open ligt. Met IAC is die wijziging zichtbaar in de repository. Het gaat door een code review. Iemand ziet het en zegt, hé, dat storage account hoort niet openbaar te zijn. De wijziging wordt geblokkeerd voordat deze ooit de productieomgeving bereikt. En mocht het er toch doorheen glippen, dan kun je het in seconden terugdraaien. Je kunt zelfs branchestrategieën gebruiken. Wil je experimenteren met een nieuwe configuratie? Maak een aparte branche, breng je wijzigingen aan, implementeer naar een testomgeving en kijk of het werkt. Als het werkt, merge je terug naar de hoofdbranche. Als dat niet zo is, verwijder je de branche en probeer je iets anders. Je productieomgeving wordt niet aangeraakt totdat je zeker weet dat de wijziging veilig is. Consistentie is geweldig, maar IAC maakt je Azure setup ook veiliger. En dat is belangrijk of je nu in je eentje alles beheert of met een heel team. Beveiliging door ontwerp, niet bij toeval. Dit is iets wat veel mensen verrast. Wanneer je IAC gebruikt, is beveiliging niet iets wat je later toevoegt. Het zit vanaf het begin ingebakken in de schabloon. In plaats van te onthouden om encryptie in te schakelen voor elk nieuw opslagaccount, staat het al in je bestand. In plaats van te hopen dat iemand de firewall regels correct heeft geconfigureerd, zijn de regels vastgelegd en worden ze telkens afgedwongen. Dit idee heeft een naam, policy als code. Je codeert je beveiligingsregels direct in je implementatiepipeline. Dus, telkens wanneer iemand een opslagaccount probeert te implementeren, controleert de pipeline of HTTPS is ingeschakeld, encryptie aanstaat en openbare toegang is geblokkeerd. Als het schabloon niet aan die regels voldoet, mislukt de implementatie. De onveilige configuratie bereikt je omgeving nooit. Denk eens na over wat dat vervangt. Tientallen handmatige controles, iemand die eraan moet denken het juiste vakje aan te vinken, iemand anders die die vakjes later controleert. Dat verdwijnt allemaal. Eén veilig schabloon, één set beleidsregels en elke implementatie voldoet automatisch aan je beveiligingsbasislijn. Maar hier wordt het pas echt interessant, de zesde recovery. Het bestand dat je infrastructuur beschrijft, kan deze overal opnieuw opbouwen. Als een aanvaller je omgeving compromitteert, hoef je geen dagen te besteden aan uitzoeken wat ze hebben veranderd en hoe je het herstelt. Je breekt het af, je implementeert het opnieuw vanuit je IAC-bestand. Je schone omgeving is binnen minuten terug. Dat is niet mogelijk wanneer je infrastructuur handmatig is gebouwd. En omdat alles in versiebeheer staat, heb je een audit trail. Elke wijziging aan je infrastructuur wordt vastgelegd. Wie het deed, wanneer en waarom. Dat is compliance bewijs zonder dat iemand een spreadsheet hoeft in te vullen. Voor kleine teams zonder toegewijd beveiligingspersoneel is dit een enorme versterking. Je krijgt beveiligingspraktijken van bedrijfsniveau zonder een beveiligingsteam van bedrijfsniveau in te huren. Dit klinkt allemaal geweldig op papier, maar beginnen kan overweldigend voelen. Laat me je een realistisch pad vooruitgeven. Hoe te beginnen zonder iets kapot te maken? Regel 1, begin niet met productie. Ik kan dit niet genoeg benadrukken. IAC is krachtig, maar het is ook nieuw. Je zult fouten maken. Maak ze ergens waar het niet uitmaakt. Kies een klein onderdeel van je Azure-omgeving, een resource-groep met een enkele virtuele machine of een opslagaccount. Iets simpels dat al draait, iets waarvan je weet dat het werkt. Dit is de truc. De Azure-portal kan daadwerkelijk arm-schablonen genereren van je bestaande resources. Je gaat naar je resource-groep, klikt op schabloon exporteren en Azure geeft je het JSON-bestand dat alles in die groep beschrijft. Het is niet perfect. Het geëxporteerde schabloon bevat vaak dingen die je niet nodig hebt, maar het is een startpunt. Je neemt iets dat je handmatig hebt gebouwd en zet het om naar code. Dat is de reverse-engineering-benadering en het is de snelste manier om te leren. Begin met Bicep en de gratis Azure-tools. Microsoft heeft een VS-code-extensie voor Bicep die syntax-highlighting automatisch aanvullen en een visueel voorbeeld van je ontwerp biedt. Je kunt je virtuele netwerk en subnetten als een diagram bekijken voordat je iets implementeert. Dat maakt het veel makkelijker om te begrijpen wat je code daadwerkelijk doet. Gebruik een apart abonnement voor het testen. De meeste Azure-abonnementen hebben bestedingslimieten en gratis te goeden. Maak een testabonnement aan. Implementeer je IAC daar, maak dingen kapot, repareer ze en leer. Wanneer je er vertrouwen in hebt, ga je over naar een niet-productie-abonnement. Productie komt als laatste. Dit is het deel dat je misschien zal verrassen. Je hoeft geen software-engineer te zijn om dit te doen. De rol van citizen-developer is heel reëel. Bicep is ontworpen voor mensen die Azure-infrastructuur beheren, niet voor professionele programmeurs. Het is leesbaar. Het heeft minder poespas dan traditionele programmeertalen. Het is volledig gericht op Azure en niets anders. Als je begrijpt wat een virtuele machine is, kun je leren hoe je er een beschrijft in Bicep. Je eerste praktische project, automatiseer het afbreken en opnieuw opbouwen van je ontwikkelomgeving. Schrijf een Bicep bestand dat je ontwikkelomgeving opzet, implementeer het, gebruik het, breek het af en implementeer het opnieuw. Doe dat een paar keer totdat het proces routine voelt. Alleen die oefening al leert je meer over IAC dan welke handleiding dan ook. Een paar algemene adviezen voor beginners. Commit vroeg en commit vaak. Elke keer dat je een deel van je template werkend hebt, sla je het op in je repository. Dat geeft je checkpoints waar je naar terug kunt keren. En voer altijd het preview-commando uit voordat je implementeert. In Bicep is dat what-if. Het laat je precies zien wat er zal veranderen voordat er daadwerkelijk iets wijzigt. Geen verrassingen. Zelfs met de beste bedoelingen zijn er een paar valkuilen waar beginners in trappen. Laat me je wat nachtelijke deba-sessies besparen. Drie fouten die je zullen achtervolgen en hoe je ze kunt vermijden. Fout nummer 1 is de klassieker, het hardcoderen van secrets. Je hebt haast. Je moet een template werkend krijgen, dus zet je het database-wachtwoord rechtstreeks in het bestand. Het werkt. Je gaat verder. En nu staat je wachtwoord in je IAC-repository, zichtbaar voor iedereen met toegang. Achteraf gezien overduidelijk, toch? Maar het is ongelooflijk makkelijk om te doen als je gefocust bent op het werkend krijgen van iets. De oplossing is Azure Key Vault. Zowel Bicep als ARM templates kunnen secrets rechtstreeks uit Key Vault halen tijdens de implementatie. Je bestand zegt, haal het wachtwoord uit deze kluis in plaats van het daadwerkelijke wachtwoord te bevatten. Het secret raakt nooit je repository aan. Zet nooit wachtwoorden, connection strings of API-sleutels in je IAC-bestanden. Gebruik elke keer Key Vault. Fout nummer 2 is IAC behandelen als een eenmalig script. Je schrijft een template, implementeert het, het werkt en je kijkt er nooit meer naar om. Zes maanden later gaat er iets stuk. Je opent het bestand en hebt geen idee wat de helft ervan doet. Die parameter genaamd param1, geen idee. Die resource met die cryptische naam, geen flauw benul. Schrijf je IAC alsof iemand anders het over zes maanden moet onderhouden, want die iemand anders bent waarschijnlijk jijzelf. En dan ben je alles vergeten. Voeg commentaar toe. Gebruik beschrijvende namen in plaats van afkortingen. Hou bestanden klein en gefocust op één ding. Een bicep-bestand dat een virtueel netwerk maakt, moet over virtuele netwerken gaan, niet over het hele datacenter. Fout nummer 3 is de pipeline omzeilen voor snelle oplossingen. De portal is altijd verleidelijk. Je moet één instelling wijzigen. Het zou vijf minuten kosten om de template aan te passen, te committen en te implementeren via de pipeline. Of je logt gewoon in op de portal, klikt drie keer en bent in 30 seconden klaar. Die snelle wijziging creëert, drift. Je code zegt het ene, de realiteit zegt het andere. De volgende keer dat je vanuit je template implementeert, probeert Azure je handmatige wijziging ongedaan te maken? Of erger nog, het merkt de drift niet op en je omgevingen lopen langzaam uiteen totdat productie zich totaal anders gedraagt dan def. De discipline is simpel. Breng de wijziging aan in de code. Implementeer via de pipeline, zelfs als het vijf minuten extra kost. Die vijf minuten besparen je later uren aan debuggen. Eén bonustip, voer altijd het previewcommando uit voordat je wijzigingen doorvoert. In Bicep is dat what-if. Het laat je precies zien wat er wordt gemaakt, gewijzigd of verwijderd. Geen verrassingen, je ziet de impact voordat het gebeurt. Dat is IAC in begrijpelijke taal. Geen jargon, geen marketingpraatjes. Gewoon een praktisch hulpmiddel dat je Azure leven makkelijker maakt. Het enige om deze week te proberen. Dus, dit hebben we behandeld. IAC verandert je Azure-infrastructuur in een versiebeheerd, herhaalbaar en veilig blauwdruk. Eén bestand dat alles beschrijft, elke keer op dezelfde manier geïmplementeerd. Je uitdaging voor deze week? Exporteer één bestaande Azure resource als ARM-template. Open het in VS-code. Kijk of je begrijpt wat het doet. Die ene oefening leert je meer dan welke uitleg ik ook zou kunnen geven. De volgende keer in deze serie lopen we stap voor stap door het schrijven van je eerste Bicep-bestand. Abonneer je op je favoriete podcast-platform en deel dit met een teamgenoot die nog steeds alles in de portal klikt. Bedankt voor het kijken.