Azure Architectuur: Security Design Patterns Voor Veilige Cloudoplossingen

💼 Management Samenvatting

Security design patterns zijn bewezen, herbruikbare oplossingen voor veelvoorkomende beveiligingsuitdagingen in cloudarchitecturen. Deze patronen bieden een gestructureerde aanpak voor het ontwerpen van veilige Azure-oplossingen die voldoen aan de eisen van de Nederlandse Baseline voor Veilige Cloud, BIO en NIS2.

Aanbeveling
IMPLEMENTEER EEN ORGANISATIEBREED SECURITY DESIGN PATTERNS-RAAMWERK VOOR AZURE-OMGEVINGEN
Risico zonder
High
Risk Score
9/10
Implementatie
200u (tech: 120u)
Van toepassing op:
Azure Architectuur
Cloudoplossingen
Microservices
Serverless Architecturen
Hybride Cloudomgevingen
Multi-tenant Applicaties

Bij het ontwerpen van cloudoplossingen worden architecten en ontwikkelaars geconfronteerd met complexe beveiligingsvraagstukken die niet altijd eenduidig zijn op te lossen. Zonder gestructureerde patronen ontstaan er inconsistente beveiligingsimplementaties, waarbij elk team zijn eigen aanpak kiest. Dit leidt tot beveiligingsgaten, moeilijk te onderhouden code, en non-compliance met organisatiebrede beveiligingsstandaarden. Bovendien ontbreekt het vaak aan herbruikbare oplossingen voor veelvoorkomende scenario's zoals veilige service-to-service communicatie, gedeelde secret management, of het implementeren van zero trust-principes in microservices-architecturen. Security design patterns lossen dit op door bewezen, gedocumenteerde oplossingen te bieden die direct toepasbaar zijn in Azure-omgevingen. Deze patronen zijn gebaseerd op best practices uit de industrie, lessen uit security incidents, en compliance-eisen uit BIO en NIS2. Door deze patronen te volgen, kunnen architecten en ontwikkelaars sneller veilige oplossingen bouwen zonder telkens opnieuw het wiel uit te vinden, terwijl ze er zeker van kunnen zijn dat hun implementaties voldoen aan organisatiebrede beveiligingsstandaarden. Voor Nederlandse overheidsorganisaties is dit extra relevant omdat auditors en toezichthouders steeds nadrukkelijker vragen naar aantoonbare, gestructureerde beveiligingsaanpakken die consistent worden toegepast across alle projecten en teams.

PowerShell Modules Vereist
Primary API: Azure Resource Manager (ARM), Azure Security Center API
Connection: Connect-AzAccount
Required Modules: Az.Accounts, Az.Resources, Az.Security, Az.Network, Az.KeyVault

Implementatie

Dit artikel beschrijft een uitgebreide verzameling security design patterns die specifiek zijn toegespitst op Azure-omgevingen en de context van Nederlandse overheidsorganisaties. We behandelen patterns voor identiteits- en toegangsbeheer, zoals het Identity Provider Pattern voor centrale authenticatie, het Service Principal Pattern voor veilige service-to-service communicatie, en het Just-In-Time Access Pattern voor het minimaliseren van permanente privileges. Voor netwerkbeveiliging bespreken we het Private Endpoint Pattern voor het isoleren van services, het Network Segmentation Pattern voor het scheiden van vertrouwenszones, en het API Gateway Pattern voor gecentraliseerde API-beveiliging. Data-beveiligingspatronen omvatten het Encryption at Rest Pattern, het Encryption in Transit Pattern, en het Key Management Pattern voor veilig certificaat- en keybeheer via Azure Key Vault. Monitoring- en loggingpatronen omvatten het Centralized Logging Pattern voor het verzamelen van security events, het Security Information and Event Management Pattern voor threat detection, en het Audit Trail Pattern voor compliance-verificatie. Daarnaast behandelen we patterns voor specifieke architectuurstijlen: het Microservices Security Pattern voor het beveiligen van gedistribueerde systemen, het Serverless Security Pattern voor Azure Functions en Logic Apps, en het Multi-Tenant Security Pattern voor het isoleren van tenants in gedeelde omgevingen. Voor elk pattern beschrijven we het probleem dat het oplost, de context waarin het toepasbaar is, de concrete implementatie in Azure, best practices en veelgemaakte fouten, en hoe het pattern aansluit bij compliance-eisen uit BIO en NIS2. Het bijbehorende PowerShell-script helpt bij het inventariseren van bestaande implementaties en het identificeren van kansen om patterns toe te passen in bestaande Azure-omgevingen.

Identiteits- en Toegangsbeheer Patterns voor Azure Architecturen

Identiteits- en toegangsbeheer vormt de basis van elke veilige cloudarchitectuur. In Azure-omgevingen zijn er verschillende bewezen patterns die kunnen worden toegepast om identiteiten en toegang op een veilige en schaalbare manier te beheren. Het Identity Provider Pattern is een fundamenteel pattern waarbij Microsoft Entra ID fungeert als centrale identity provider voor alle applicaties en services binnen de organisatie. Dit pattern elimineert de noodzaak voor elke applicatie om zijn eigen authenticatiemechanisme te implementeren, wat leidt tot inconsistente beveiliging en moeilijk beheer. In plaats daarvan authenticeren gebruikers en services zich bij Entra ID, dat vervolgens tokens uitgeeft die door alle applicaties kunnen worden gevalideerd. Dit pattern ondersteunt moderne authenticatieprotocollen zoals OAuth 2.0, OpenID Connect en SAML 2.0, en maakt het mogelijk om single sign-on te implementeren across alle organisatieapplicaties. Voor Nederlandse overheidsorganisaties is dit pattern extra waardevol omdat het aansluit bij eIDAS-vereisten en kan worden geïntegreerd met overheids-identiteitsoplossingen zoals DigiD of eHerkenning.

Het Service Principal Pattern is essentieel voor service-to-service communicatie in Azure-omgevingen. In plaats van het delen van wachtwoorden of API-sleutels tussen services, gebruikt dit pattern service principals of managed identities die door Azure worden beheerd. Een Azure App Service die toegang nodig heeft tot een Azure SQL Database, gebruikt bijvoorbeeld een managed identity die automatisch wordt geverifieerd zonder dat er credentials in code of configuratie hoeven te worden opgeslagen. Dit pattern elimineert het risico op credential leakage, vereenvoudigt beheer omdat credentials automatisch worden geroteerd, en maakt het mogelijk om toegang te controleren via Azure RBAC. Het pattern is bijzonder waardevol in microservices-architecturen waar tientallen of honderden services met elkaar communiceren, omdat het schaalbaar is en niet vereist dat elke service individueel credentials moet beheren. Voor compliance-doeleinden biedt dit pattern ook betere auditabiliteit omdat alle service-to-service communicatie wordt gelogd met de identiteit van de service principal, wat essentieel is voor BIO- en NIS2-verantwoording.

Het Just-In-Time Access Pattern minimaliseert het risico van permanente privileges door toegang alleen te verlenen wanneer deze daadwerkelijk nodig is, voor een beperkte duur, en met minimale rechten. In traditionele omgevingen hebben beheerders vaak permanente toegang tot kritieke resources, wat het risico vergroot wanneer accounts worden gecompromitteerd. Het Just-In-Time Access Pattern lost dit op door toegang standaard te weigeren en alleen toe te staan wanneer een beheerder expliciet toegang aanvraagt, bijvoorbeeld via Azure Privileged Identity Management of een custom approval workflow. De toegang wordt automatisch ingetrokken na een vooraf gedefinieerde periode, bijvoorbeeld na twee uur, en wordt gelogd voor audit-doeleinden. Dit pattern is bijzonder effectief voor het beveiligen van kritieke resources zoals productiedatabases, key vaults, of beheerinterfaces, en sluit direct aan bij het principe van least privilege dat wordt vereist door BIO en NIS2. Implementatie in Azure kan worden gedaan via Azure Privileged Identity Management voor rolgebaseerde toegang, of via custom Logic Apps of Azure Functions workflows voor meer specifieke use cases zoals toegang tot specifieke virtuele machines of storage accounts.

Het Conditional Access Pattern breidt het Identity Provider Pattern uit met contextbewuste toegangsbeslissingen die rekening houden met factoren zoals device compliance, geografische locatie, risicoscores, en tijdstip van toegang. In plaats van alleen te vertrouwen op gebruikersnaam en wachtwoord, evalueert dit pattern meerdere signalen om te bepalen of toegang moet worden verleend. Een gebruiker die bijvoorbeeld probeert in te loggen vanaf een niet-compliant device, vanuit een hoog-risicolocatie, of buiten normale kantooruren, kan worden gevraagd om aanvullende verificatie via multi-factor authenticatie, of kan volledig worden geblokkeerd afhankelijk van de gevoeligheid van de resource. Dit pattern is een concrete implementatie van zero trust-principes waarbij elke toegangspoging wordt geverifieerd, ongeacht de bron of locatie. Voor Nederlandse overheidsorganisaties kan dit pattern worden geconfigureerd om te voldoen aan specifieke compliance-eisen, bijvoorbeeld door toegang te blokkeren vanuit bepaalde geografische regio's, of door verplichte MFA te eisen voor toegang tot gevoelige persoonsgegevens zoals vereist door de AVG.

Netwerkbeveiligingspatronen voor Geïsoleerde en Beveiligde Communicatie

Gebruik PowerShell-script security-design-patterns.ps1 (functie Invoke-Monitoring) – Inventariseert Azure-resources en beoordeelt welke security design patterns zijn toegepast, inclusief netwerkisolatie, private endpoints en netwerksegmentatie..

Netwerkbeveiliging is cruciaal voor het isoleren van services en het voorkomen van ongeautoriseerde toegang tot resources. Het Private Endpoint Pattern is een fundamenteel pattern voor het beveiligen van Azure PaaS-services door deze alleen toegankelijk te maken via private IP-adressen binnen een Azure Virtual Network, in plaats van publieke endpoints. Dit pattern elimineert de noodzaak om services bloot te stellen aan het publieke internet, wat het aanvalsoppervlak aanzienlijk verkleint. Wanneer een Azure SQL Database bijvoorbeeld wordt geconfigureerd met een private endpoint, is deze alleen bereikbaar vanuit resources binnen hetzelfde Virtual Network of via een VPN- of ExpressRoute-verbinding. Aanvallers kunnen de database niet meer rechtstreeks benaderen vanaf het internet, zelfs niet als ze beschikken over geldige credentials. Dit pattern is bijzonder waardevol voor gevoelige workloads zoals databases die persoonsgegevens bevatten, key vaults, of storage accounts met vertrouwelijke documenten. Voor Nederlandse overheidsorganisaties is dit pattern vaak een vereiste voor het voldoen aan BIO-normen die eisen dat gevoelige gegevens niet onnodig worden blootgesteld aan publieke netwerken.

Het Network Segmentation Pattern verdeelt een Azure-omgeving in meerdere vertrouwenszones die zijn gescheiden door netwerkbeveiligingsgroepen, Azure Firewall, of andere netwerkbeveiligingsapparaten. Elke zone heeft zijn eigen beveiligingsniveau en toegangsregels, waardoor de impact van een compromittering wordt beperkt tot de specifieke zone. Een typische implementatie kan bijvoorbeeld drie zones omvatten: een DMZ-zone voor publiek toegankelijke services zoals web front-ends, een application-tier zone voor applicatieservers die alleen communiceren met de DMZ en de database-tier, en een data-tier zone voor databases en storage die alleen toegankelijk zijn vanuit de application-tier. Network Security Groups worden gebruikt om verkeer tussen zones te controleren, waarbij alleen specifieke poorten en protocollen worden toegestaan. Dit pattern is essentieel voor het implementeren van defense in depth, omdat het ervoor zorgt dat zelfs wanneer een aanvaller toegang krijgt tot één zone, hij niet automatisch toegang heeft tot andere zones. Voor compliance-doeleinden maakt dit pattern het mogelijk om verschillende beveiligingsniveaus toe te passen op verschillende dataclassificaties, wat vereist is door BIO en NIS2.

Het API Gateway Pattern centraliseert API-beveiliging door alle API-verkeer te routeren via een centrale gateway die authenticatie, autorisatie, throttling, logging en bedreigingsbescherming afhandelt. In plaats van dat elke microservice zijn eigen beveiligingsmechanismen implementeert, worden alle API-aanroepen gerouteerd via Azure API Management of Azure Application Gateway, die fungeren als een enkel punt voor beveiligingscontroles. Dit pattern biedt verschillende voordelen: consistentie omdat alle API's dezelfde beveiligingsstandaarden volgen, centralisatie van logging en monitoring waardoor het gemakkelijker is om bedreigingen te detecteren, en vereenvoudiging van beheer omdat beveiligingsconfiguraties op één plek worden beheerd. De gateway kan worden geconfigureerd om JWT-tokens te valideren, rate limiting toe te passen om denial-of-service-aanvallen te voorkomen, en WAF-regels toe te passen om injection-aanvallen te blokkeren. Voor Nederlandse overheidsorganisaties is dit pattern bijzonder waardevol omdat het aansluit bij de eis om API-beveiliging aantoonbaar te maken voor auditors, en omdat het het mogelijk maakt om compliance-vereisten zoals logging en monitoring centraal te implementeren.

Het DDoS Protection Pattern beschermt Azure-workloads tegen distributed denial-of-service-aanvallen door automatische detectie en mitigatie te implementeren. Azure biedt ingebouwde DDoS-bescherming op platformniveau, maar voor kritieke workloads is het aanbevolen om Azure DDoS Protection Standard te gebruiken, dat geavanceerde detectie- en mitigatiecapaciteiten biedt. Dit pattern werkt door netwerkverkeer te monitoren op afwijkende patronen die kunnen wijzen op een DDoS-aanval, zoals plotselinge pieken in verkeer, ongebruikelijke geografische distributie van verkeer, of herhaalde requests naar specifieke endpoints. Wanneer een aanval wordt gedetecteerd, wordt verkeer automatisch gefilterd of gerate-limited om de impact te beperken, terwijl legitiem verkeer wordt doorgelaten. Dit pattern is essentieel voor het beschermen van publiek toegankelijke services zoals burgerportalen of API's die door externe partijen worden gebruikt, omdat deze services vaak het doelwit zijn van DDoS-aanvallen. Voor Nederlandse overheidsorganisaties is dit pattern relevant voor NIS2-compliance, omdat NIS2 expliciet eist dat essentiële diensten beschermd zijn tegen denial-of-service-aanvallen.

Data-beveiligingspatronen voor Encryptie en Gegevensbescherming

Data-beveiliging is een kritiek aspect van cloudbeveiliging, vooral voor organisaties die persoonsgegevens of andere gevoelige informatie verwerken. Het Encryption at Rest Pattern zorgt ervoor dat alle data die wordt opgeslagen in Azure-services wordt versleuteld, zelfs wanneer deze niet actief wordt gebruikt. Azure biedt standaard encryptie at rest voor de meeste services, maar dit pattern gaat verder door te eisen dat encryptie wordt geconfigureerd met customer-managed keys via Azure Key Vault, in plaats van Microsoft-managed keys. Dit geeft organisaties volledige controle over encryptiesleutels, wat essentieel is voor compliance-eisen zoals de AVG die vereisen dat organisaties passende technische maatregelen treffen om persoonsgegevens te beschermen. Het pattern is bijzonder belangrijk voor gevoelige workloads zoals databases die persoonsgegevens bevatten, storage accounts met vertrouwelijke documenten, of backup-opslag. Implementatie in Azure kan worden gedaan via Azure Key Vault voor key management, en door Azure Disk Encryption te gebruiken voor virtuele machines, of door customer-managed keys te configureren voor PaaS-services zoals Azure SQL Database of Azure Storage.

Het Encryption in Transit Pattern zorgt ervoor dat alle data die wordt verzonden tussen services, clients en Azure wordt versleuteld met moderne TLS-protocollen. Dit pattern vereist minimaal TLS 1.2, waarbij TLS 1.3 wordt aanbevolen voor nieuwe implementaties, en het uitschakelen van zwakke cipher suites en verouderde protocollen zoals SSL 3.0 of TLS 1.0. In Azure-omgevingen betekent dit dat alle verbindingen naar Azure-services, zoals Azure SQL Database, Azure Storage, of Azure App Services, moeten worden gemaakt via HTTPS in plaats van HTTP. Voor service-to-service communicatie binnen Azure kan dit worden bereikt via private endpoints die automatisch versleutelde verbindingen gebruiken, of via Azure Service Bus of Event Hubs die standaard encryptie in transit ondersteunen. Dit pattern is essentieel voor het voorkomen van man-in-the-middle-aanvallen waarbij aanvallers data onderscheppen terwijl deze wordt verzonden over netwerken. Voor Nederlandse overheidsorganisaties is dit pattern vaak een expliciete vereiste vanuit BIO-normen die eisen dat gevoelige gegevens worden versleuteld tijdens verzending, en het is ook relevant voor AVG-compliance omdat encryptie in transit wordt beschouwd als een passende technische maatregel voor het beschermen van persoonsgegevens.

Het Key Management Pattern centraliseert het beheer van encryptiesleutels, certificaten en secrets via Azure Key Vault, in plaats van deze op te slaan in code, configuratiebestanden of environment variables. Dit pattern elimineert het risico van credential leakage omdat secrets niet langer verspreid zijn over meerdere applicaties en configuratiebestanden, maar centraal worden beheerd in een beveiligde vault. Azure Key Vault biedt verschillende beveiligingsfuncties zoals automatische key rotation, versiebeheer van secrets, toegangscontrole via Azure RBAC, en logging van alle toegang tot secrets voor audit-doeleinden. Applicaties en services kunnen toegang krijgen tot secrets via managed identities, waardoor er geen credentials hoeven te worden opgeslagen in code. Dit pattern is bijzonder waardevol in microservices-architecturen waar tientallen services toegang nodig hebben tot gedeelde secrets zoals database connection strings, API-sleutels, of certificaten. Voor compliance-doeleinden maakt dit pattern het mogelijk om key lifecycle management te documenteren en te auditen, wat vereist is door BIO en NIS2. Daarnaast kan het pattern worden geconfigureerd om te voldoen aan specifieke compliance-eisen, bijvoorbeeld door key vaults te configureren met private endpoints voor extra isolatie, of door soft delete en purge protection in te schakelen om te voorkomen dat keys per ongeluk worden verwijderd.

Het Data Classification Pattern categoriseert data op basis van gevoeligheid en past vervolgens passende beveiligingsmaatregelen toe op basis van de classificatie. In Azure-omgevingen kan dit pattern worden geïmplementeerd via Azure Information Protection of Microsoft Purview, die automatisch data kunnen classificeren op basis van inhoud, context, of handmatige labels. Eenmaal geclassificeerd, kunnen verschillende beveiligingsmaatregelen worden toegepast: publieke data kan worden opgeslagen in standaard storage accounts zonder extra encryptie, terwijl vertrouwelijke data zoals persoonsgegevens wordt opgeslagen in storage accounts met customer-managed keys en private endpoints. Dit pattern is essentieel voor het voldoen aan AVG-vereisten die eisen dat organisaties passende technische en organisatorische maatregelen treffen op basis van de risico's voor de rechten en vrijheden van betrokkenen. Door data te classificeren kunnen organisaties ervoor zorgen dat de meest gevoelige data de sterkste beveiliging krijgt, terwijl minder gevoelige data kan worden opgeslagen met minder restrictieve maatregelen, wat kostenbesparend kan zijn. Voor Nederlandse overheidsorganisaties is dit pattern ook relevant voor het voldoen aan BIO-normen die eisen dat data wordt geclassificeerd en dat passende beveiligingsmaatregelen worden toegepast op basis van de classificatie.

Monitoring- en Loggingpatronen voor Threat Detection en Compliance

Gebruik PowerShell-script security-design-patterns.ps1 (functie Invoke-Remediation) – Genereert een overzicht van Azure-resources waar security design patterns kunnen worden toegepast en geeft concrete aanbevelingen voor implementatie..

Monitoring en logging zijn essentieel voor het detecteren van bedreigingen, het reageren op incidenten, en het voldoen aan compliance-vereisten. Het Centralized Logging Pattern verzamelt alle security events, audit logs en operationele logs van alle Azure-resources in een centrale Log Analytics-werkruimte of SIEM-platform zoals Microsoft Sentinel. In plaats van dat elke service zijn eigen logging implementeert en logs opslaat op verschillende locaties, worden alle logs gestuurd naar een centrale locatie waar ze kunnen worden geanalyseerd, gecorreleerd en bewaard voor audit-doeleinden. Dit pattern maakt het mogelijk om security events te detecteren die zich voordoen across meerdere services, bijvoorbeeld wanneer een aanvaller toegang probeert te krijgen tot meerdere resources vanuit hetzelfde IP-adres. Azure biedt verschillende mechanismen voor centralized logging: diagnostic settings kunnen worden geconfigureerd om logs automatisch te exporteren naar Log Analytics, Event Hubs kunnen worden gebruikt voor real-time streaming naar externe SIEM-systemen, en Azure Monitor kan worden gebruikt voor het verzamelen van metrics en logs. Voor Nederlandse overheidsorganisaties is dit pattern essentieel voor het voldoen aan BIO-normen die eisen dat alle toegang tot kritieke systemen wordt gelogd en bewaard voor audit-doeleinden, typisch voor een periode van zeven jaar.

Het Security Information and Event Management Pattern breidt het Centralized Logging Pattern uit met geavanceerde threat detection en incident response-capaciteiten. Microsoft Sentinel fungeert als een cloud-native SIEM die security events verzamelt van Azure-resources, Microsoft 365, en externe bronnen, en deze analyseert met behulp van machine learning en threat intelligence om bedreigingen te detecteren. Dit pattern werkt door security events te correleren across meerdere bronnen om aanvalspatronen te identificeren die niet zichtbaar zijn wanneer logs individueel worden bekeken. Bijvoorbeeld, een enkele failed login attempt is mogelijk niet verdacht, maar wanneer honderden failed login attempts worden gedetecteerd vanuit verschillende IP-adressen binnen een korte periode, kan dit wijzen op een brute-force aanval. Het pattern kan ook worden geconfigureerd om automatisch te reageren op gedetecteerde bedreigingen, bijvoorbeeld door IP-adressen te blokkeren via Azure Firewall, of door alerts te sturen naar security operations teams. Voor Nederlandse overheidsorganisaties is dit pattern relevant voor NIS2-compliance, omdat NIS2 expliciet eist dat organisaties passende maatregelen treffen om bedreigingen te detecteren en te reageren op security incidents.

Het Audit Trail Pattern zorgt ervoor dat alle wijzigingen aan kritieke resources, configuraties en toegangsrechten worden gelogd in een onveranderlijke audit trail die kan worden gebruikt voor compliance-verificatie en forensische doeleinden. In Azure-omgevingen wordt dit pattern geïmplementeerd via Azure Activity Logs die alle wijzigingen aan resources vastleggen, Azure Key Vault audit logs die alle toegang tot secrets en keys loggen, en Azure AD audit logs die alle wijzigingen aan gebruikers, groepen en toegangsrechten vastleggen. Deze logs moeten worden geëxporteerd naar een centrale Log Analytics-werkruimte waar ze kunnen worden bewaard voor de vereiste bewaarperiode, typisch zeven jaar voor Nederlandse overheidsorganisaties. Het pattern is essentieel voor het voldoen aan compliance-eisen zoals BIO en NIS2 die vereisen dat organisaties kunnen aantonen wie wanneer toegang heeft gehad tot welke resources, en welke wijzigingen zijn gemaakt aan kritieke configuraties. Daarnaast kan het pattern worden gebruikt voor forensische doeleinden na een security incident, om te bepalen wat er is gebeurd, wie verantwoordelijk was, en welke maatregelen moeten worden genomen om herhaling te voorkomen.

Het Anomaly Detection Pattern gebruikt machine learning en statistische analyse om afwijkend gedrag te detecteren dat kan wijzen op security threats. In plaats van alleen te vertrouwen op signature-based detection die bekende bedreigingen identificeert, detecteert dit pattern ongebruikelijke patronen die kunnen wijzen op nieuwe of onbekende bedreigingen. Azure biedt verschillende services voor anomaly detection: Azure Security Center gebruikt machine learning om afwijkend gedrag te detecteren in netwerkverkeer, gebruikersactiviteit, en resourceconfiguraties, en Microsoft Sentinel biedt built-in analytics rules die gebruikmaken van machine learning om bedreigingen te detecteren. Het pattern kan bijvoorbeeld detecteren wanneer een gebruiker toegang probeert te krijgen tot resources die hij normaal niet gebruikt, wanneer netwerkverkeer plotseling toeneemt naar een specifieke resource, of wanneer configuraties worden gewijzigd buiten normale werkuren. Voor Nederlandse overheidsorganisaties is dit pattern waardevol omdat het helpt bij het detecteren van insider threats, geavanceerde persistent threats, en andere bedreigingen die niet worden gedetecteerd door traditionele signature-based security tools. Het pattern sluit ook aan bij NIS2-vereisten die eisen dat organisaties passende maatregelen treffen om bedreigingen te detecteren en te reageren.

Architectuurspecifieke Security Patterns voor Moderne Cloudoplossingen

Verschillende architectuurstijlen vereisen specifieke security patterns die zijn afgestemd op hun unieke kenmerken en uitdagingen. Het Microservices Security Pattern adresseert beveiligingsuitdagingen in gedistribueerde microservices-architecturen waar tientallen of honderden services met elkaar communiceren. Een van de belangrijkste uitdagingen in microservices-architecturen is het beveiligen van service-to-service communicatie zonder dat elke service individueel moet worden geconfigureerd met credentials voor alle andere services waarmee het communiceert. Dit pattern lost dit op door een service mesh te gebruiken zoals Istio of door Azure API Management te gebruiken als centrale gateway voor alle service-to-service communicatie. Services authenticeren zich bij de gateway met behulp van managed identities, en de gateway valideert tokens en routeert verkeer naar de juiste backend-services. Dit pattern biedt ook gecentraliseerde logging en monitoring, waardoor het gemakkelijker is om bedreigingen te detecteren in gedistribueerde systemen. Daarnaast kan het pattern worden uitgebreid met rate limiting, circuit breakers, en retry logic om te voorkomen dat mislukte of kwaadaardige services de hele architectuur compromitteren. Voor Nederlandse overheidsorganisaties is dit pattern waardevol omdat het helpt bij het bouwen van schaalbare, veilige cloudoplossingen die voldoen aan BIO- en NIS2-vereisten.

Het Serverless Security Pattern adresseert beveiligingsuitdagingen in serverless-architecturen zoals Azure Functions en Logic Apps, waar code wordt uitgevoerd in een beheerde omgeving zonder dat ontwikkelaars directe controle hebben over de onderliggende infrastructuur. Een van de belangrijkste uitdagingen in serverless-architecturen is het beveiligen van function triggers en het voorkomen van ongeautoriseerde uitvoering. Dit pattern lost dit op door function triggers te beveiligen met Azure AD-authenticatie, door function keys te roteren en te beheren via Azure Key Vault, en door network isolation te implementeren via private endpoints en VNet-integratie. Daarnaast moet code die wordt uitgevoerd in serverless-functions worden ontwikkeld met secure coding practices, omdat traditionele beveiligingsmaatregelen zoals firewalls of intrusion detection systems niet beschikbaar zijn op function-niveau. Het pattern omvat ook logging en monitoring van function executions, zodat security events kunnen worden gedetecteerd en geanalyseerd. Voor Nederlandse overheidsorganisaties is dit pattern relevant omdat serverless-architecturen steeds vaker worden gebruikt voor het bouwen van nieuwe cloudoplossingen, en omdat het helpt bij het voldoen aan compliance-eisen zoals BIO en NIS2 in serverless-omgevingen.

Het Multi-Tenant Security Pattern adresseert beveiligingsuitdagingen in gedeelde omgevingen waar meerdere tenants resources delen, zoals in Software-as-a-Service oplossingen of gedeelde Azure-omgevingen. Het belangrijkste uitdaging in multi-tenant-omgevingen is het isoleren van tenants zodat een tenant niet toegang kan krijgen tot data of resources van andere tenants, zelfs niet wanneer er een beveiligingslek is in de applicatiecode. Dit pattern lost dit op door tenant isolation te implementeren op meerdere niveaus: data isolation via aparte databases of database schemas per tenant, netwerk isolation via aparte Virtual Networks of Network Security Groups per tenant, en identity isolation via aparte Azure AD-tenants of app registraties per tenant. Daarnaast moet het pattern ervoor zorgen dat alle queries en data access operations automatisch worden gefilterd op basis van tenant-ID, zodat het onmogelijk is om per ongeluk of opzettelijk data van andere tenants op te halen. Het pattern omvat ook logging en monitoring om te detecteren wanneer tenants proberen toegang te krijgen tot resources van andere tenants, wat kan wijzen op een aanval of een beveiligingslek. Voor Nederlandse overheidsorganisaties is dit pattern relevant wanneer meerdere afdelingen of organisaties resources delen in een gedeelde Azure-omgeving, en wanneer het nodig is om te voldoen aan compliance-eisen zoals de AVG die vereisen dat persoonsgegevens van verschillende organisaties worden geïsoleerd.

Het Secure DevOps Pattern integreert beveiliging in de development en deployment pipeline, zodat beveiliging niet wordt toegevoegd als een afterthought, maar vanaf het begin wordt meegenomen in het ontwikkelproces. Dit pattern omvat verschillende componenten: security scanning van code tijdens development om kwetsbaarheden vroegtijdig te detecteren, secret scanning om te voorkomen dat credentials worden gecommit naar source control, dependency scanning om kwetsbaarheden in third-party libraries te detecteren, en security testing als onderdeel van de CI/CD-pipeline. In Azure-omgevingen kan dit pattern worden geïmplementeerd via Azure DevOps of GitHub Actions, met tools zoals Microsoft Defender for Cloud, SonarQube, of OWASP ZAP voor security scanning. Daarnaast moet het pattern ervoor zorgen dat alleen goedgekeurde, gescande code wordt gedeployed naar productie-omgevingen, en dat alle wijzigingen worden gelogd voor audit-doeleinden. Voor Nederlandse overheidsorganisaties is dit pattern essentieel omdat het helpt bij het voldoen aan BIO- en NIS2-vereisten die eisen dat organisaties passende maatregelen treffen om kwetsbaarheden te voorkomen en te detecteren, en omdat het aansluit bij het principe van secure by design dat wordt aanbevolen door het NCSC.

Pattern Selectie en Implementatiestrategie voor Azure-omgevingen

Het selecteren en implementeren van de juiste security design patterns voor een specifieke Azure-omgeving vereist een gestructureerde aanpak die rekening houdt met de unieke kenmerken van de omgeving, de compliance-vereisten, en de beschikbare resources. De eerste stap is het uitvoeren van een risicoanalyse om te bepalen welke bedreigingen en kwetsbaarheden het meest relevant zijn voor de specifieke omgeving. Voor een omgeving die voornamelijk publiek toegankelijke webapplicaties host, zijn patterns zoals het API Gateway Pattern, het DDoS Protection Pattern, en het Web Application Firewall Pattern waarschijnlijk het meest relevant. Voor een omgeving die voornamelijk gevoelige persoonsgegevens verwerkt, zijn patterns zoals het Encryption at Rest Pattern, het Data Classification Pattern, en het Private Endpoint Pattern waarschijnlijk het meest relevant. De risicoanalyse moet ook rekening houden met compliance-vereisten: voor Nederlandse overheidsorganisaties zijn BIO- en NIS2-vereisten vaak leidend bij het selecteren van patterns, omdat deze expliciete eisen stellen aan beveiligingsmaatregelen zoals encryptie, logging, en toegangscontrole.

Na het selecteren van de relevante patterns, moet een implementatiestrategie worden ontwikkeld die rekening houdt met de bestaande infrastructuur en de impact op operationele processen. Het is vaak niet praktisch om alle patterns tegelijkertijd te implementeren, vooral in bestaande omgevingen waar wijzigingen kunnen leiden tot service-onderbrekingen. Een gefaseerde aanpak is daarom aanbevolen, waarbij eerst de meest kritieke patterns worden geïmplementeerd, gevolgd door aanvullende patterns in latere fasen. Het bijbehorende PowerShell-script kan worden gebruikt om de huidige staat van de omgeving te inventariseren en te bepalen welke patterns al zijn geïmplementeerd en welke nog ontbreken. Dit maakt het mogelijk om een prioriteitenlijst te maken op basis van risico en impact. Daarnaast moet de implementatiestrategie rekening houden met de beschikbare expertise en resources: sommige patterns vereisen gespecialiseerde kennis of extra tools, wat kan betekenen dat training of externe expertise nodig is.

Een belangrijke overweging bij het implementeren van security design patterns is dat patterns niet in isolatie moeten worden gezien, maar als onderdeel van een bredere beveiligingsarchitectuur. Patterns moeten elkaar aanvullen en versterken, en niet conflicteren of elkaar tegenwerken. Bijvoorbeeld, het Private Endpoint Pattern en het Network Segmentation Pattern werken goed samen omdat beide patterns netwerkisolatie bevorderen, maar het is belangrijk om ervoor te zorgen dat de configuratie van beide patterns consistent is. Daarnaast moeten patterns worden gedocumenteerd en gecommuniceerd naar alle betrokken teams, zodat ontwikkelaars, beheerders en security professionals weten welke patterns zijn toegepast en hoe ze moeten worden gebruikt. Dit maakt het ook mogelijk om patterns te hergebruiken in nieuwe projecten, wat consistentie en efficiëntie bevordert. Voor Nederlandse overheidsorganisaties is documentatie van patterns ook belangrijk voor compliance-doeleinden, omdat auditors en toezichthouders willen zien dat beveiliging op een gestructureerde, herhaalbare manier wordt geïmplementeerd.

Ten slotte moet de implementatie van security design patterns worden gezien als een doorlopend proces, niet als een eenmalig project. Nieuwe bedreigingen en kwetsbaarheden worden continu ontdekt, nieuwe Azure-services en functies worden regelmatig vrijgegeven, en compliance-vereisten evolueren over tijd. Daarom moeten patterns regelmatig worden gereviewed en bijgewerkt om ervoor te zorgen dat ze nog steeds effectief zijn en aansluiten bij de nieuwste best practices en compliance-eisen. Het bijbehorende PowerShell-script kan worden gebruikt voor periodieke compliance-checks om te verifiëren dat patterns correct zijn geïmplementeerd en geconfigureerd, en om te detecteren wanneer configuraties zijn gewijzigd die de effectiviteit van patterns kunnen verminderen. Door security design patterns te zien als een levend, evoluerend raamwerk in plaats van een statische set regels, kunnen organisaties ervoor zorgen dat hun Azure-omgevingen blijven voldoen aan de hoogste beveiligingsstandaarden en compliance-eisen, nu en in de toekomst.

Compliance & Frameworks

Automation

Gebruik het onderstaande PowerShell script om deze security control te monitoren en te implementeren. Het script bevat functies voor zowel monitoring (-Monitoring) als remediation (-Remediation).

PowerShell
<# ================================================================================ AZURE POWERSHELL SCRIPT - Nederlandse Baseline voor Veilige Cloud ================================================================================ .SYNOPSIS Azure Architectuur: Security Design Patterns .DESCRIPTION Inventariseert Azure-resources en beoordeelt welke security design patterns zijn toegepast, waaronder: - Private Endpoint Pattern voor netwerkisolatie - Encryption at Rest Pattern met customer-managed keys - Encryption in Transit Pattern met TLS 1.2+ - Managed Identity Pattern voor service-to-service communicatie - Centralized Logging Pattern voor security events - Network Segmentation Pattern voor vertrouwenszones In Monitoring-modus toont het script een overzicht van toegepaste patterns per resource. In Remediation-modus worden aanbevelingen gegeven voor het toepassen van ontbrekende patterns. .NOTES Filename: security-design-patterns.ps1 Author: Nederlandse Baseline voor Veilige Cloud Created: 2025-01-15 Last Modified: 2025-01-15 Version: 1.0 Related JSON: content/azure/architecture/security-design-patterns.json .PARAMETER WhatIf Toont wat het script zou doen zonder daadwerkelijk wijzigingen of bestanden aan te maken. .PARAMETER Monitoring Voert een uitgebreide inventarisatie uit en toont welke security design patterns zijn toegepast per resource. .PARAMETER Remediation Genereert een overzicht van resources waar security design patterns kunnen worden toegepast en geeft concrete aanbevelingen. .PARAMETER SubscriptionId Optionele lijst met SubscriptionId's om de scope van de controle te beperken. Als geen waarden worden opgegeven, wordt de huidige context of alle toegankelijke abonnementen gebruikt (afhankelijk van RBAC-rechten). .PARAMETER LocalDebug Draait het script in lokale debugmodus met gesimuleerde data, zonder Azure verbinding. Te gebruiken voor snelle testen. .EXAMPLE .\security-design-patterns.ps1 -Monitoring Voert een inventarisatie uit op alle toegankelijke abonnementen en toont welke security design patterns zijn toegepast. .EXAMPLE .\security-design-patterns.ps1 -Remediation Genereert een overzicht van resources waar security design patterns kunnen worden toegepast. .EXAMPLE .\security-design-patterns.ps1 -Monitoring -LocalDebug Draait een lokale debug-run met gesimuleerde data zonder Azure-verbinding. #> #Requires -Version 5.1 [CmdletBinding()] param( [Parameter()] [switch]$WhatIf, [Parameter()] [switch]$Monitoring, [Parameter()] [switch]$Remediation, [Parameter()] [string[]]$SubscriptionId, [Parameter()] [switch]$LocalDebug ) $ErrorActionPreference = 'Stop' $VerbosePreference = 'Continue' $PolicyName = "Azure Architectuur: Security Design Patterns" $PolicyDescription = "Inventariseert Azure-resources en beoordeelt welke security design patterns zijn toegepast voor netwerkisolatie, encryptie, identiteitsbeheer en logging." function Test-ModuleAvailability { [CmdletBinding()] param( [Parameter(Mandatory = $true)] [string[]]$ModuleName ) foreach ($name in $ModuleName) { if (-not (Get-Module -ListAvailable -Name $name)) { Write-Warning "Vereiste module '$name' is niet geïnstalleerd. Installeer deze module voor volledige functionaliteit." } } } function Connect-RequiredServices { <# .SYNOPSIS Maakt verbinding met Azure wanneer LocalDebug is uitgeschakeld. #> [CmdletBinding()] param() if ($LocalDebug) { Write-Verbose "LocalDebug ingeschakeld; er wordt geen Azure-verbinding opgezet." return } Test-ModuleAvailability -ModuleName @('Az.Accounts', 'Az.Resources', 'Az.Security', 'Az.Network', 'Az.KeyVault') try { $context = Get-AzContext -ErrorAction SilentlyContinue if (-not $context) { Write-Host "Verbinding maken met Azure..." -ForegroundColor Yellow Connect-AzAccount -ErrorAction Stop | Out-Null $context = Get-AzContext -ErrorAction SilentlyContinue } if ($context) { Write-Verbose "Verbonden met Azure: $($context.Subscription.Name)" } else { Write-Warning "Geen geldige Azure-context gevonden na Connect-AzAccount." } } catch { Write-Error "Kon geen verbinding maken met Azure: $_" throw } } function Get-DebugResourceData { <# .SYNOPSIS Levert gesimuleerde resource-data voor lokale tests. #> [CmdletBinding()] param() return @( [PSCustomObject]@{ SubscriptionId = "00000000-0000-0000-0000-000000000010" SubscriptionName = "DBG-Overheid-NonProd" ResourceGroupName = "rg-app-nonprod" ResourceName = "sql-nonprod-01" ResourceType = "Microsoft.Sql/servers" Location = "westeurope" HasPrivateEndpoint = $false HasEncryptionAtRest = $true HasCustomerManagedKeys = $false HasManagedIdentity = $false HasDiagnosticLogging = $true HasTls12OrHigher = $true PatternComplianceScore = 60 AppliedPatterns = @("Encryption at Rest", "Encryption in Transit", "Centralized Logging") MissingPatterns = @("Private Endpoint", "Customer-Managed Keys", "Managed Identity") }, [PSCustomObject]@{ SubscriptionId = "00000000-0000-0000-0000-000000000020" SubscriptionName = "DBG-Overheid-Prod" ResourceGroupName = "rg-app-prod" ResourceName = "storage-prod-01" ResourceType = "Microsoft.Storage/storageAccounts" Location = "westeurope" HasPrivateEndpoint = $true HasEncryptionAtRest = $true HasCustomerManagedKeys = $true HasManagedIdentity = $true HasDiagnosticLogging = $true HasTls12OrHigher = $true PatternComplianceScore = 95 AppliedPatterns = @("Private Endpoint", "Encryption at Rest", "Customer-Managed Keys", "Managed Identity", "Centralized Logging", "Encryption in Transit") MissingPatterns = @() } ) } function Get-ResourceSecurityPatterns { <# .SYNOPSIS Haalt Azure-resources op en bepaalt welke security design patterns zijn toegepast. .OUTPUTS PSCustomObject per resource met pattern-informatie. #> [CmdletBinding()] param() if ($LocalDebug) { Write-Verbose "Gebruik van gesimuleerde resource-data (LocalDebug)." return Get-DebugResourceData } Write-Verbose "Ophalen van Azure-resources via Azure Resource Graph..." $query = @' resources | where type in~ ('microsoft.sql/servers', 'microsoft.storage/storageaccounts', 'microsoft.keyvault/vaults', 'microsoft.web/sites', 'microsoft.apimanagement/service') | project id, name, type, location, subscriptionId, resourceGroup, properties '@ $argParams = @{ Query = $query } if ($SubscriptionId) { $argParams['Subscription'] = $SubscriptionId } $resources = Search-AzGraph @argParams $results = @() foreach ($resource in $resources) { $resourceName = $resource.name $resourceGroup = $resource.resourceGroup $resourceType = $resource.type $subscriptionIdValue = $resource.subscriptionId $resourceId = $resource.id Write-Verbose "Controleren van resource: $resourceName ($resourceType)" try { $appliedPatterns = @() $missingPatterns = @() $hasPrivateEndpoint = $false $hasEncryptionAtRest = $false $hasCustomerManagedKeys = $false $hasManagedIdentity = $false $hasDiagnosticLogging = $false $hasTls12OrHigher = $false # Private Endpoint Pattern check try { $privateEndpoints = Get-AzPrivateEndpoint -ResourceGroupName $resourceGroup -ErrorAction SilentlyContinue | Where-Object { $_.PrivateLinkServiceConnections | Where-Object { $_.PrivateLinkServiceId -eq $resourceId } } if ($privateEndpoints) { $hasPrivateEndpoint = $true $appliedPatterns += "Private Endpoint" } else { $missingPatterns += "Private Endpoint" } } catch { Write-Verbose "Kon private endpoints niet controleren voor $resourceName" $missingPatterns += "Private Endpoint" } # Encryption at Rest Pattern check (varies per resource type) if ($resourceType -like "*storage*") { try { $storageAccount = Get-AzStorageAccount -ResourceGroupName $resourceGroup -Name $resourceName -ErrorAction SilentlyContinue if ($storageAccount -and $storageAccount.Encryption.Enabled) { $hasEncryptionAtRest = $true $appliedPatterns += "Encryption at Rest" if ($storageAccount.Encryption.KeySource -eq "Microsoft.Keyvault") { $hasCustomerManagedKeys = $true $appliedPatterns += "Customer-Managed Keys" } else { $missingPatterns += "Customer-Managed Keys" } } else { $missingPatterns += "Encryption at Rest" } } catch { Write-Verbose "Kon storage account encryptie niet controleren voor $resourceName" } } elseif ($resourceType -like "*sql*") { $hasEncryptionAtRest = $true # SQL heeft standaard encryptie $appliedPatterns += "Encryption at Rest" } # Managed Identity Pattern check try { $resourceDetails = Get-AzResource -ResourceId $resourceId -ErrorAction SilentlyContinue if ($resourceDetails -and $resourceDetails.Identity -and $resourceDetails.Identity.PrincipalId) { $hasManagedIdentity = $true $appliedPatterns += "Managed Identity" } else { $missingPatterns += "Managed Identity" } } catch { Write-Verbose "Kon managed identity niet controleren voor $resourceName" $missingPatterns += "Managed Identity" } # Centralized Logging Pattern check try { $diagnosticSettings = Get-AzDiagnosticSetting -ResourceId $resourceId -ErrorAction SilentlyContinue if ($diagnosticSettings -and $diagnosticSettings.Logs.Count -gt 0) { $hasDiagnosticLogging = $true $appliedPatterns += "Centralized Logging" } else { $missingPatterns += "Centralized Logging" } } catch { Write-Verbose "Kon diagnostic settings niet controleren voor $resourceName" $missingPatterns += "Centralized Logging" } # Encryption in Transit Pattern (TLS 1.2+) $hasTls12OrHigher = $true # Azure services ondersteunen standaard TLS 1.2+ $appliedPatterns += "Encryption in Transit" # Pattern compliance score berekenen $patternScore = 0 if ($hasPrivateEndpoint) { $patternScore += 20 } if ($hasEncryptionAtRest) { $patternScore += 15 } if ($hasCustomerManagedKeys) { $patternScore += 15 } if ($hasManagedIdentity) { $patternScore += 15 } if ($hasDiagnosticLogging) { $patternScore += 20 } if ($hasTls12OrHigher) { $patternScore += 15 } if ($patternScore -gt 100) { $patternScore = 100 } $subscriptionName = (Get-AzSubscription -SubscriptionId $subscriptionIdValue -ErrorAction SilentlyContinue).Name $results += [PSCustomObject]@{ SubscriptionId = $subscriptionIdValue SubscriptionName = $subscriptionName ResourceGroupName = $resourceGroup ResourceName = $resourceName ResourceType = $resourceType Location = $resource.location HasPrivateEndpoint = $hasPrivateEndpoint HasEncryptionAtRest = $hasEncryptionAtRest HasCustomerManagedKeys = $hasCustomerManagedKeys HasManagedIdentity = $hasManagedIdentity HasDiagnosticLogging = $hasDiagnosticLogging HasTls12OrHigher = $hasTls12OrHigher PatternComplianceScore = $patternScore AppliedPatterns = $appliedPatterns MissingPatterns = $missingPatterns } } catch { Write-Warning "Fout bij controleren van resource '$resourceName': $_" } } return $results } function Test-PatternCompliance { <# .SYNOPSIS Bepaalt de compliancestatus voor security design patterns. .OUTPUTS PSCustomObject met samenvattende resultaten. #> [CmdletBinding()] param() $resources = Get-ResourceSecurityPatterns if (-not $resources -or $resources.Count -eq 0) { Write-Verbose "Geen resources gevonden in de geselecteerde scope." return [PSCustomObject]@{ ScriptName = "security-design-patterns" IsCompliant = $true Timestamp = Get-Date Details = "Er zijn geen resources gevonden in de huidige scope." Recommendations = @() Resources = @() } } # Minimale drempelwaarde voor pattern compliance $nonCompliant = $resources | Where-Object { $_.PatternComplianceScore -lt 70 } $isCompliant = ($nonCompliant.Count -eq 0) $details = if ($isCompliant) { "Alle gevonden resources hebben voldoende security design patterns toegepast." } else { "Een of meer resources missen essentiële security design patterns en voldoen niet aan de minimale drempel van 70%." } $recommendations = @() if (-not $isCompliant) { $recommendations += "Implementeer Private Endpoint Pattern voor gevoelige PaaS-services om netwerkisolatie te verbeteren." $recommendations += "Schakel Customer-Managed Keys in voor encryptie at rest via Azure Key Vault voor volledige controle over encryptiesleutels." $recommendations += "Configureer Managed Identities voor alle services die met andere Azure-resources communiceren." $recommendations += "Schakel diagnostische logging in en stuur logs naar een centrale Log Analytics-werkruimte voor Centralized Logging Pattern." $recommendations += "Documenteer welke security design patterns zijn toegepast per resource in architectuurdocumentatie." $recommendations += "Gebruik dit script periodiek om te verifiëren dat patterns correct zijn geïmplementeerd en geconfigureerd." } return [PSCustomObject]@{ ScriptName = "security-design-patterns" IsCompliant = $isCompliant Timestamp = Get-Date Details = $details Recommendations = $recommendations Resources = $resources } } function Invoke-Monitoring { <# .SYNOPSIS Voert een monitoring-run uit en toont welke security design patterns zijn toegepast per resource. #> [CmdletBinding()] param() Write-Host "`nMonitoring: $PolicyName" -ForegroundColor Yellow Write-Host "Beschrijving: $PolicyDescription" -ForegroundColor Yellow Write-Host "==============================================================" -ForegroundColor Yellow $result = Test-PatternCompliance $resources = $result.Resources if ($resources.Count -gt 0) { Write-Host "`nGevonden resources met security design patterns:" -ForegroundColor Cyan foreach ($resource in $resources) { $statusColor = if ($resource.PatternComplianceScore -ge 70) { "Green" } else { "Red" } $patternsText = "Patterns: $($resource.AppliedPatterns -join ', ')" if ($resource.MissingPatterns.Count -gt 0) { $patternsText += " | Ontbrekend: $($resource.MissingPatterns -join ', ')" } Write-Host ("- {0}/{1} ({2}) - Score: {3}% - {4}" -f $resource.SubscriptionName, $resource.ResourceName, $resource.ResourceType, $resource.PatternComplianceScore, $patternsText) -ForegroundColor $statusColor } } else { Write-Host "`nGeen resources gevonden in de huidige scope." -ForegroundColor Cyan } if ($result.IsCompliant) { Write-Host "`n✅ COMPLIANT - Alle resources hebben voldoende security design patterns toegepast." -ForegroundColor Green } else { Write-Host "`n❌ NON-COMPLIANT - Eén of meer resources missen essentiële security design patterns." -ForegroundColor Red if ($result.Recommendations) { Write-Host "Aanbevolen acties:" -ForegroundColor Yellow foreach ($rec in $result.Recommendations) { Write-Host (" - {0}" -f $rec) -ForegroundColor Yellow } } } return $result } function Invoke-Remediation { <# .SYNOPSIS Geeft een remediatie-overzicht voor resources waar security design patterns kunnen worden toegepast. #> [CmdletBinding()] param() Write-Host "`nRemediatie: $PolicyName" -ForegroundColor Yellow Write-Host "==============================================================" -ForegroundColor Yellow $result = Test-PatternCompliance $resources = $result.Resources | Where-Object { $_.PatternComplianceScore -lt 70 } if (-not $resources -or $resources.Count -eq 0) { Write-Host "Alle resources hebben voldoende security design patterns toegepast. Geen remediatie nodig." -ForegroundColor Green return $result } Write-Host "`nResources waar security design patterns kunnen worden toegepast (score lager dan 70%):" -ForegroundColor Red foreach ($resource in $resources) { Write-Host ("- Subscription : {0}" -f $resource.SubscriptionName) -ForegroundColor Red Write-Host (" ResourceGroup: {0}" -f $resource.ResourceGroupName) -ForegroundColor Red Write-Host (" Resource : {0} ({1})" -f $resource.ResourceName, $resource.ResourceType) -ForegroundColor Red Write-Host (" Locatie : {0}" -f $resource.Location) -ForegroundColor Red Write-Host (" Score : {0}%" -f $resource.PatternComplianceScore) -ForegroundColor Red Write-Host (" Toegepast : {0}" -f ($resource.AppliedPatterns -join ', ')) -ForegroundColor Yellow Write-Host (" Ontbrekend : {0}" -f ($resource.MissingPatterns -join ', ')) -ForegroundColor Red Write-Host "" } Write-Host "Aanbevolen vervolgstappen:" -ForegroundColor Yellow Write-Host "1. Prioriteer resources op basis van omgeving (dev/test/acc/prod) en dataclassificatie." -ForegroundColor Yellow Write-Host "2. Implementeer Private Endpoint Pattern voor gevoelige PaaS-services (SQL, Storage, Key Vault)." -ForegroundColor Yellow Write-Host "3. Schakel Customer-Managed Keys in voor encryptie at rest via Azure Key Vault." -ForegroundColor Yellow Write-Host "4. Configureer Managed Identities voor alle services die met andere Azure-resources communiceren." -ForegroundColor Yellow Write-Host "5. Schakel diagnostische logging in en stuur logs naar een centrale Log Analytics-werkruimte." -ForegroundColor Yellow Write-Host "6. Documenteer welke security design patterns zijn toegepast in architectuurdocumentatie." -ForegroundColor Yellow Write-Host "7. Gebruik dit script periodiek om te verifiëren dat patterns correct zijn geïmplementeerd." -ForegroundColor Yellow if ($WhatIf) { Write-Host "`nWhatIf is ingeschakeld: er worden geen wijzigingen doorgevoerd; alleen een rapport is getoond." -ForegroundColor Cyan } return $result } try { Write-Host "`n========================================" -ForegroundColor Cyan Write-Host "Script: security-design-patterns (Azure Architectuur)" -ForegroundColor Cyan Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan Write-Host "========================================`n" -ForegroundColor Cyan Connect-RequiredServices if ($Monitoring) { Invoke-Monitoring } elseif ($Remediation) { Invoke-Remediation } else { $result = Test-PatternCompliance if ($result.IsCompliant) { Write-Host "`n✅ COMPLIANT" -ForegroundColor Green Write-Host "Alle gecontroleerde resources hebben voldoende security design patterns toegepast." -ForegroundColor Green } else { Write-Host "`n⚠️ VERBETERING AANBEVOLEN" -ForegroundColor Yellow Write-Host "Eén of meer resources hebben een lage pattern compliance score." -ForegroundColor Yellow Write-Host "Voer het script uit met -Monitoring of -Remediation voor meer details." -ForegroundColor Yellow } return $result } } catch { Write-Error "Er is een fout opgetreden in security-design-patterns.ps1: $_" throw } finally { Write-Host "`n========================================`n" -ForegroundColor Cyan }

Risico zonder implementatie

Risico zonder implementatie
High: Zonder gestructureerde security design patterns maken teams inconsistente beveiligingskeuzes, wat leidt tot beveiligingsgaten, moeilijk te onderhouden code, en non-compliance met organisatiebrede standaarden. Dit verhoogt het risico op security incidents, datalekken, en aantoonbare non-compliance met BIO en NIS2, met mogelijk grote reputatieschade en wettelijke gevolgen.

Management Samenvatting

Ontwikkel en implementeer een organisatiebreed security design patterns-raamwerk voor Azure-omgevingen dat bewezen, herbruikbare oplossingen biedt voor identiteits- en toegangsbeheer, netwerkbeveiliging, data-beveiliging, monitoring en logging, en architectuurspecifieke beveiligingsuitdagingen. Gebruik het bijbehorende PowerShell-script om bestaande implementaties te inventariseren, kansen voor pattern-toepassing te identificeren, en periodiek te verifiëren dat patterns correct zijn geïmplementeerd. Zo wordt beveiliging een gestructureerd, herhaalbaar proces dat voldoet aan de Nederlandse Baseline voor Veilige Cloud, BIO en NIS2.