L1/L2 BIO 05.01 ISO A.5.1 CIS CIS Microsoft Azure Foundations Benchmark

API Security Governance: Strategisch Raamwerk Voor Aantoonbare API-beveiligingssturing

📅 2025-01-15
•
⏱️ 30 minuten lezen
•
🔴 Must-Have

💼 Management Samenvatting

API Security Governance vormt de strategische en organisatorische laag die ervoor zorgt dat API-beveiliging niet ad hoc wordt ingericht per project, maar structureel wordt bestuurd, gemeten en verbeterd binnen Nederlandse overheidsorganisaties. Dit artikel beschrijft een compleet governance-raamwerk dat bestuurders, CISO's en platformteams handvatten biedt om API-beveiliging aantoonbaar te sturen in lijn met de Nederlandse Baseline voor Veilige Cloud en compliance-eisen uit BIO, NIS2 en ISO 27001.

Aanbeveling
RICHT EEN STRUCTUREEL API SECURITY GOVERNANCE-RAAMWERK IN
Risico zonder
High
Risk Score
9/10
Implementatie
280u (tech: 120u)
Van toepassing op:
✓ Azure
✓ Azure API Management
✓ REST API's
✓ GraphQL API's
✓ Microservices
✓ Web Services

Nederlandse overheidsorganisaties ontwikkelen en beheren steeds meer API's voor gegevensuitwisseling tussen systemen, ketenpartners en burgers. Zonder structurele governance ontstaan echter versnipperde beveiligingsconfiguraties: elk team of leverancier maakt eigen keuzes, standaarden worden inconsistently toegepast, security reviews vinden pas achteraf plaats, en er ontbreekt overzicht over welke API's daadwerkelijk adequaat zijn beveiligd. Dit leidt tot aantoonbare compliance-risico's: BIO, ISO 27001 en NIS2 vereisen dat organisaties kunnen aantonen welke maatregelen zijn getroffen om kritieke systemen te beveiligen, maar zonder governance-structuur is het onmogelijk om aan toezichthouders en auditors te verantwoorden dat alle API's voldoen aan beveiligingsstandaarden. Bestuurders en CISO's moeten echter kunnen garanderen dat gevoelige persoonsgegevens en kritieke diensten adequaat worden beschermd, terwijl ontwikkelteams behoefte hebben aan duidelijke kaders en standaarden die innovatie niet onnodig belemmeren. Een goed governance-raamwerk brengt deze belangen samen: het biedt bestuurders aantoonbaarheid, geeft teams heldere richtlijnen, en zorgt dat compliance-eisen structureel worden ingebed in de dagelijkse werkprocessen.

PowerShell Modules Vereist
Primary API: Azure Resource Manager (ARM), Azure API Management REST API, Azure Policy
Connection: Connect-AzAccount
Required Modules: Az.ApiManagement, Az.Resources, Az.Policy, Az.Monitor

Implementatie

Dit artikel beschrijft een strategisch governance-raamwerk voor API-beveiliging binnen Azure-omgevingen, specifiek gericht op Nederlandse overheidsorganisaties. We behandelen governance op meerdere niveaus: op strategisch niveau de formulering van API-beveiligingsbeleid, risicoclassificatie van API's, en besluitvorming over acceptabele risico's en uitzonderingen; op tactisch niveau de ontwikkeling van beveiligingsstandaarden, policy-templates, ontwikkelrichtlijnen en best practices; op operationeel niveau de implementatie van geautomatiseerde controles via Azure Policy, periodieke security reviews, monitoring en rapportage, en incidentafhandeling. Daarnaast gaan we in op de praktische inrichting van governance-processen: de rolverdeling tussen security officers, platformteams en ontwikkelteams, de workflow voor security reviews en approvals, de manier waarop afwijkingen van standaarden worden gedocumenteerd en goedgekeurd, en hoe compliance en voortgang aantoonbaar worden gemaakt in rapportages. Het bijbehorende PowerShell-script helpt bij het meten van de governance-maturiteit door in kaart te brengen welke API Management-services voldoen aan governance-standaarden, welke afwijkingen bestaan, en welke verbeteracties prioriteit hebben.

Strategische governance-fundament voor API-beveiliging

Strategische API Security Governance begint bij expliciete keuzes over risicoacceptatie, verantwoordelijkheden en besluitvorming. Bestuurders en directieleden moeten bepalen welke API's als kritiek worden beschouwd, welke beschikbaarheidseisen gelden, en welke maximale uitvalduur acceptabel is. Dit vereist een duidelijke classificatie van API's op basis van risico: hoog-risico API's die werken met bijzondere persoonsgegevens, kritieke infrastructuur of financiële transacties hebben bijvoorbeeld strengere beveiligings- en goedkeuringsprocessen nodig dan laag-risico API's voor interne, niet-gevoelige gegevens. Deze classificatie moet worden vastgelegd in een API-register of catalogus die bijhoudt welke API's bestaan, wie de eigenaar is, welke gegevens worden verwerkt, en welke compliance-eisen gelden. Zonder dergelijke documentatie is het onmogelijk om prioriteiten te stellen in beveiligingsverbeteracties of om aan auditors te verantwoorden dat kritieke API's adequaat zijn beveiligd.

De verantwoordelijkheidsstructuur voor API-beveiliging moet expliciet worden gedefinieerd. In Nederlandse overheidsorganisaties is het gebruikelijk om onderscheid te maken tussen verschillende rollen: de API-eigenaar (vaak een business-eigenaar of product owner) die verantwoordelijk is voor het definiëren van functionele eisen en businessrisico's, de security officer die verantwoordelijk is voor het beoordelen van beveiligingsrisico's en het goedkeuren van beveiligingsconfiguraties, de platformarchitect die verantwoordelijk is voor het ontwerpen van technische oplossingen die voldoen aan beveiligingsstandaarden, en het ontwikkelteam dat verantwoordelijk is voor de daadwerkelijke implementatie en onderhoud. Daarnaast zijn er vaak centrale rollen zoals de CISO die verantwoordelijk is voor organisatiebreed beveiligingsbeleid, en de cloudplatformteam die verantwoordelijk is voor het aanbieden van beveiligde standaardconfiguraties en het onderhouden van governance-tooling. Door deze rollen expliciet te maken en te documenteren in een RACI-matrix ontstaat helderheid over wie verantwoordelijk is voor welke aspecten van API-beveiliging, en wie moet worden geraadpleegd bij belangrijke beslissingen.

Besluitvorming over uitzonderingen en afwijkingen van standaarden moet worden vastgelegd in een governance-proces. Wanneer een ontwikkelteam bijvoorbeeld een API wil bouwen die niet voldoet aan de standaardbeveiligingsconfiguratie omdat er specifieke performance- of functionaliteitsvereisten zijn, moet dit worden gedocumenteerd, beoordeeld door een security officer, en expliciet worden goedgekeurd door een daartoe bevoegde functionaris. Dergelijke uitzonderingen moeten tijdelijk zijn met een concrete einddatum en een plan voor migratie naar de standaardconfiguratie, en moeten periodiek worden herzien. Door dit proces te formaliseren voorkomt u dat afwijkingen worden geaccepteerd zonder goede reden, terwijl teams toch flexibiliteit behouden wanneer er legitieme technische of business-redenen zijn om van de standaard af te wijken. Het proces moet worden gedocumenteerd en de beslissingen moeten worden opgeslagen in een auditbaar register zodat auditors en toezichthouders kunnen verifiëren dat uitzonderingen op een verantwoorde manier worden beheerd.

Tactische standaarden en frameworks voor API-beveiliging

Gebruik PowerShell-script security-governance.ps1 (functie Invoke-Monitoring) – Voert een governance-assessment uit op API Management-services en rapporteert over compliance met beveiligingsstandaarden, best practices en governance-vereisten..

Op tactisch niveau moeten beveiligingsstandaarden worden ontwikkeld die concrete, toepasbare richtlijnen bieden voor ontwikkelteams. Deze standaarden moeten aansluiten bij de strategische risicoclassificatie: voor hoog-risico API's gelden bijvoorbeeld strengere eisen voor authenticatie (meervoudige authenticatie verplicht), autorisatie (rolgebaseerde toegangscontrole met fine-grained permissies), encryptie (end-to-end encryptie vereist), en monitoring (real-time threat detection en geautomatiseerde alerts), terwijl voor laag-risico API's basisvereisten kunnen volstaan. De standaarden moeten worden gedocumenteerd in een toegankelijk format, bijvoorbeeld als markdown-bestanden in een centrale repository, als onderdeel van een ontwikkelportal, of geïntegreerd in de developer tooling. Belangrijk is dat standaarden praktisch en toepasbaar zijn: theoretische richtlijnen die niet aansluiten bij de dagelijkse praktijk worden genegeerd, terwijl concrete voorbeelden, code-snippets en configuratie-templates teams helpen om standaarden daadwerkelijk toe te passen.

Policy-templates en Infrastructure-as-Code (IaC) vormen een krachtige manier om standaarden automatisch af te dwingen. Azure API Management biedt mogelijkheden om standaardpolicies te definiëren die automatisch worden toegepast op nieuwe API's, bijvoorbeeld via Azure Policy of via API Management-niveau policies. Door deze templates te ontwikkelen en beschikbaar te stellen via een centrale repository kunnen teams eenvoudig nieuwe API's opzetten die standaard voldoen aan beveiligingsvereisten, zonder dat elk team opnieuw het wiel moet uitvinden. Templates kunnen bijvoorbeeld standaard authenticatie- en autorisatiepolicies bevatten, logging-configuraties, rate limiting-instellingen, en security headers. Daarnaast kunnen Infrastructure-as-Code-tools zoals ARM templates, Bicep of Terraform worden gebruikt om hele API Management-services op te zetten met de juiste beveiligingsconfiguraties, zodat fouten door handmatige configuratie worden voorkomen. Door templates te versiebeheren en periodiek bij te werken kunnen nieuwe beveiligingsvereisten of best practices automatisch worden doorgevoerd naar alle teams die de templates gebruiken.

Security-by-design principes moeten worden ingebed in de ontwikkelworkflow. Dit betekent dat beveiliging niet pas wordt beoordeeld aan het einde van een ontwikkeltraject, maar vanaf het begin wordt meegenomen in ontwerpbeslissingen. Security reviews moeten bijvoorbeeld worden ingepland tijdens de ontwerpfase, zodat beveiligingsrisico's vroegtijdig worden geïdentificeerd en mitigerende maatregelen kunnen worden ontworpen voordat code wordt geschreven. Threat modeling is een waardevolle techniek om potentiële beveiligingsrisico's te identificeren door systematisch te analyseren hoe een aanvaller een API zou kunnen misbruiken, welke aanvalsvectoren bestaan, en welke beveiligingsmaatregelen nodig zijn om deze risico's te mitigeren. Daarnaast moeten ontwikkelteams worden getraind in beveiligingsbewustzijn en secure coding practices, zodat beveiligingsfouten worden voorkomen in plaats van achteraf moeten worden opgespoord en gerepareerd. Door security-by-design te integreren in de dagelijkse werkprocessen wordt beveiliging een natuurlijk onderdeel van de ontwikkelcyclus in plaats van een last-minute controle.

Operationele governance-processen en automatisering

Geautomatiseerde controles via Azure Policy vormen de basis voor operationele governance. Azure Policy kan worden gebruikt om compliance-regels af te dwingen op API Management-services, bijvoorbeeld door te controleren of alle API's zijn geconfigureerd met TLS 1.2 of hoger, of diagnostic logging is ingeschakeld, of managed identities zijn geconfigureerd, of private endpoints worden gebruikt. Policies kunnen worden toegepast op abonnements- of management group-niveau, zodat alle nieuwe API Management-services automatisch worden gecontroleerd en, waar mogelijk, automatisch worden geconfigureerd volgens de standaarden. Wanneer een service niet voldoet aan een policy, kan Azure Policy automatisch een waarschuwing genereren, de configuratie herstellen (remediation), of de resource blokkeren totdat de configuratie is aangepast. Door deze automatisering wordt voorkomen dat services in productie komen zonder adequate beveiligingsconfiguraties, terwijl teams sneller feedback krijgen over compliance-problemen zonder dat handmatige reviews nodig zijn.

Periodieke security reviews en assessments moeten worden ingeroosterd om te verifiëren dat bestaande API's nog steeds voldoen aan beveiligingsstandaarden en om nieuwe risico's te identificeren. Reviews kunnen bijvoorbeeld jaarlijks worden uitgevoerd voor alle kritieke API's, of vaker wanneer er significante wijzigingen zijn in de API, de achterliggende systemen, of de beveiligingscontext. Reviews moeten worden uitgevoerd door een onafhankelijke partij, bijvoorbeeld een security officer of externe auditor, en moeten een gestructureerd proces volgen waarbij wordt gecontroleerd op authenticatie- en autorisatieconfiguraties, encryptie-instellingen, logging en monitoring, inputvalidatie, en compliance met relevante frameworks zoals BIO, ISO 27001 en NIS2. De uitkomsten van reviews moeten worden gedocumenteerd in een assessment-rapport, en eventuele bevindingen moeten worden omgezet in concrete verbeteracties met eigenaar, deadline en voortgangstracking. Door reviews periodiek uit te voeren en te documenteren kunnen organisaties aantoonbaar maken aan auditors en toezichthouders dat API-beveiliging proactief wordt beheerd en continu wordt verbeterd.

Monitoring en rapportage vormen essentiële componenten van governance omdat ze inzicht geven in de daadwerkelijke beveiligingsstatus en compliance van API's. Dashboards moeten worden ingericht die real-time tonen welke API Management-services voldoen aan beveiligingsstandaarden, welke afwijkingen bestaan, en wat de trend is over tijd (wordt de situatie beter of slechter?). Deze dashboards moeten toegankelijk zijn voor bestuurders, CISO's en platformteams, zodat zij snel kunnen zien waar aandacht nodig is. Rapporten moeten periodiek worden gegenereerd (bijvoorbeeld maandelijks of kwartaal) en moeten een overzicht bieden van de beveiligingsstatus, belangrijke trends, incidenten en verbeteracties. Rapporten moeten worden gedeeld met relevante stakeholders, inclusief bestuurders en compliance-officers, zodat zij kunnen verifiëren dat governance-procedures worden nageleefd en dat voortgang wordt geboekt. Het bijbehorende PowerShell-script kan worden geïntegreerd in geautomatiseerde rapportage-workflows, zodat deze rapporten automatisch worden gegenereerd zonder handmatige inspanning.

Compliance en audit voor API-beveiligingsgovernance

Gebruik PowerShell-script security-governance.ps1 (functie Invoke-Remediation) – Genereert een gedetailleerd rapport over API Management-services die niet voldoen aan governance-standaarden, inclusief aanbevelingen voor verbeteracties en compliance-herstel..

Compliance met relevante frameworks zoals BIO, ISO 27001 en NIS2 vereist dat organisaties kunnen aantonen dat API-beveiliging structureel wordt beheerd volgens gedefinieerde processen en standaarden. Dit betekent dat governance-artefacten moeten worden bewaard en toegankelijk moeten zijn voor auditors: beleidsdocumenten, standaarden en richtlijnen, assessment-rapporten, uitzonderingsaanvragen en goedkeuringen, monitoring-rapporten, en documentatie van incidenten en verbeteracties. Deze artefacten moeten worden opgeslagen in een centraal, versiebeheerd systeem (bijvoorbeeld een documentmanagement-systeem of wiki) met duidelijke metadata zoals eigenaar, versie, datum, en status. De bewaartermijnen moeten aansluiten bij compliance-vereisten: voor audit-doeleinden is het gebruikelijk om documentatie minimaal 7 jaar te bewaren, maar specifieke eisen kunnen variëren per framework en organisatie. Door governance-artefacten centraal en gestructureerd op te slaan kunnen auditors snel en efficiënt verifiëren dat governance-procedures worden nageleefd en dat beslissingen op een verantwoorde manier worden genomen.

Audit trails moeten worden bijgehouden voor alle belangrijke governance-activiteiten, zodat achteraf kan worden gereconstrueerd wie welke beslissing heeft genomen en waarom. Dit betekent dat alle wijzigingen aan beveiligingsconfiguraties, goedkeuringen van uitzonderingen, en security reviews moeten worden gelogd met timestamp, gebruiker, en reden. Azure Activity Log en Azure Monitor bieden mogelijkheden om dergelijke audit trails automatisch vast te leggen, maar aanvullend moeten governance-processen worden gedocumenteerd zodat het duidelijk is welke stappen zijn doorlopen bij belangrijke beslissingen. Audit trails moeten beschermd worden tegen wijziging of verwijdering, bijvoorbeeld door ze te archiveren in een write-once, read-many (WORM) storage of door ze periodiek te exporteren naar een onafhankelijk systeem. Door audit trails te bewaren kunnen organisaties aantonen aan auditors en toezichthouders dat governance-procedures correct worden uitgevoerd en dat beslissingen op basis van de juiste informatie en autorisaties zijn genomen.

Periodieke compliance-assessments moeten worden uitgevoerd om te verifiëren dat governance-procedures nog steeds effectief zijn en dat organisaties voldoen aan relevante frameworks. Assessments kunnen bijvoorbeeld worden uitgevoerd door interne auditors, externe auditors, of door een gespecialiseerde compliance-organisatie. Assessments moeten een gestructureerd proces volgen waarbij wordt gecontroleerd op de aanwezigheid en kwaliteit van governance-artefacten (beleid, standaarden, processen), de daadwerkelijke naleving van procedures (worden security reviews uitgevoerd, worden uitzonderingen correct gedocumenteerd?), en de effectiviteit van governance (leiden de procedures tot verbeterde beveiliging en compliance?). De uitkomsten van assessments moeten worden gedocumenteerd in een assessment-rapport, en eventuele bevindingen moeten worden omgezet in concrete verbeteracties. Door assessments periodiek uit te voeren en de resultaten te delen met bestuurders en stakeholders kunnen organisaties continu verbeteren en proactief voldoen aan compliance-vereisten, in plaats van reactief te reageren op auditbevindingen of toezichthoudende acties.

Governance-maturiteit en continue verbetering

Governance-maturiteit moet worden gemeten en verbeterd om te verzekeren dat governance-processen effectief zijn en blijven aansluiten bij de behoeften van de organisatie. Maturiteitsmodellen zoals CMMI (Capability Maturity Model Integration) of een aangepast model kunnen worden gebruikt om de huidige staat te beoordelen op verschillende dimensies: strategisch beleid en richtlijnen, tactische standaarden en frameworks, operationele processen en automatisering, compliance en audit, en cultuur en bewustwording. Door periodiek (bijvoorbeeld jaarlijks) de maturiteit te meten en te vergelijken met eerdere metingen kunnen organisaties zien of zij vooruitgang boeken en waar nog verbeteracties nodig zijn. Het bijbehorende PowerShell-script kan worden gebruikt als onderdeel van deze maturiteitsmeting door kwantitatieve gegevens te verzamelen over het percentage API's dat voldoet aan beveiligingsstandaarden, het aantal afwijkingen, en de trend over tijd.

Continue verbetering vereist dat organisaties leren van ervaringen en best practices, zowel intern als extern. Lessons learned uit security reviews, incidenten, en audits moeten worden vastgelegd en gedeeld, zodat andere teams kunnen profiteren van opgedane kennis. Externe best practices uit de industrie, bijvoorbeeld van NCSC, OWASP, of andere overheidsorganisaties, moeten worden geëvalueerd en waar relevant worden geïntegreerd in eigen standaarden en processen. Daarnaast moeten governance-processen periodiek worden geëvalueerd op effectiviteit: leiden de procedures tot betere beveiliging, of zijn ze vooral administratieve last? Worden standaarden daadwerkelijk toegepast, of worden ze genegeerd omdat ze te complex of onpraktisch zijn? Door deze vragen regelmatig te stellen en governance-processen bij te stellen op basis van feedback kunnen organisaties ervoor zorgen dat governance effectief blijft en niet uitgroeit tot bureaucratie die innovatie belemmert zonder beveiliging te verbeteren.

Cultuur en bewustwording vormen de basis voor effectieve governance omdat technische maatregelen alleen onvoldoende zijn wanneer teams niet begrijpen waarom beveiliging belangrijk is of hoe zij moeten voldoen aan standaarden. Training en awareness-programma's moeten worden ingericht om ontwikkelteams, security officers, en bestuurders te informeren over API-beveiligingsrisico's, best practices, en governance-processen. Deze training moet praktisch en toepasbaar zijn: theoretische uitleg over frameworks is minder effectief dan concrete voorbeelden van hoe beveiligingsfouten kunnen worden voorkomen of hoe standaarden kunnen worden toegepast in de dagelijkse praktijk. Daarnaast moeten success stories worden gedeeld: wanneer een team bijvoorbeeld een API heeft gebouwd die voldoet aan alle beveiligingsstandaarden en positief wordt beoordeeld in een security review, moet dit worden gevierd en gedeeld als best practice. Door een cultuur te creëren waarin beveiliging wordt gezien als een natuurlijk onderdeel van goede softwareontwikkeling in plaats van als een lastige compliance-vereiste, wordt governance effectiever en wordt het makkelijker om teams te motiveren om standaarden na te leven.

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
<# .SYNOPSIS Controleert de governance-maturiteit en compliance van API-beveiliging binnen Azure API Management-services. .DESCRIPTION Dit script inventariseert alle Azure API Management-services in de opgegeven of alle abonnementen en beoordeelt de governance-maturiteit op basis van beveiligingsstandaarden, policy-configuraties, logging, monitoring en compliance-controles. In monitoringmodus wordt een rapport gegenereerd met de governance-status per API Management-service. In remediatiemodus wordt een overzicht gemaakt van services zonder adequate governance met concrete aanbevelingen voor verbeteracties. .NOTES Filename: security-governance.ps1 Author: Nederlandse Baseline voor Veilige Cloud Created: 2025-01-15 Last Modified: 2025-01-15 Version: 1.0 Related JSON: content/azure/api/security-governance.json .LINK https://github.com/[org]/m365-tenant-best-practise .EXAMPLE .\security-governance.ps1 -Monitoring Voert een governance-assessment uit op alle toegankelijke abonnementen en toont de governance-status per API Management-service. .EXAMPLE .\security-governance.ps1 -Remediation Genereert een overzicht van API Management-services zonder adequate governance-configuratie en aanbevelingen voor verbetering. .EXAMPLE .\security-governance.ps1 -Monitoring -LocalDebug Draait een lokale debug-run met gesimuleerde data zonder Azure-verbinding of API Management API-calls. #> #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 = "API Security Governance correct geconfigureerd" $PolicyDescription = "Controleert of Azure API Management-services voldoen aan governance-standaarden voor beveiliging, compliance, logging, monitoring en risicobeheer." 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 als dat nog niet is gebeurd. #> [CmdletBinding()] param() if ($LocalDebug) { Write-Verbose "LocalDebug is ingeschakeld; er wordt geen Azure-verbinding opgezet." return } Test-ModuleAvailability -ModuleName @('Az.Accounts', 'Az.Resources', 'Az.ApiManagement', 'Az.Policy', 'Az.Monitor') try { $context = Get-AzContext -ErrorAction SilentlyContinue if (-not $context) { Write-Host "Verbinding maken met Azure..." -ForegroundColor Yellow Connect-AzAccount -ErrorAction Stop | Out-Null } else { Write-Verbose "Reeds verbonden met Azure: $($context.Subscription.Name)" } } catch { Write-Error "Kon geen verbinding maken met Azure: $_" throw } } function Get-DebugApiManagementGovernanceData { [CmdletBinding()] param() return @( [PSCustomObject]@{ SubscriptionId = "00000000-0000-0000-0000-000000000010" SubscriptionName = "DBG-Overheid-NonProd" ResourceGroupName = "rg-apim-nonprod" ServiceName = "apim-nonprod-01" Location = "westeurope" Sku = "Standard" HasTls12OrHigher = $true HasDiagnosticLogging = $true HasManagedIdentity = $false HasPrivateEndpoint = $false HasAzurePolicyCompliance = $false HasResourceTags = $false HasCustomDomains = $false HasApiVersioning = $false GovernanceMaturityScore = 45 }, [PSCustomObject]@{ SubscriptionId = "00000000-0000-0000-0000-000000000020" SubscriptionName = "DBG-Overheid-Prod" ResourceGroupName = "rg-apim-prod" ServiceName = "apim-prod-01" Location = "westeurope" Sku = "Premium" HasTls12OrHigher = $true HasDiagnosticLogging = $true HasManagedIdentity = $true HasPrivateEndpoint = $true HasAzurePolicyCompliance = $true HasResourceTags = $true HasCustomDomains = $true HasApiVersioning = $true GovernanceMaturityScore = 90 } ) } function Get-ApiManagementGovernanceStatus { <# .SYNOPSIS Haalt alle API Management-services op en beoordeelt de governance-maturiteit. .OUTPUTS PSCustomObject met API Management-service- en governance-informatie. #> [CmdletBinding()] param() if ($LocalDebug) { Write-Verbose "Gebruik van gesimuleerde API Management governance-data (LocalDebug)." return Get-DebugApiManagementGovernanceData } Write-Verbose "Ophalen van API Management-services via Azure Resource Graph..." $query = @' resources | where type == "microsoft.apimanagement/service" | project id, name, location, subscriptionId, resourceGroup, sku, properties, tags '@ $argParams = @{ Query = $query } if ($SubscriptionId) { $argParams['Subscription'] = $SubscriptionId } $services = Search-AzGraph @argParams $results = @() foreach ($service in $services) { $serviceName = $service.name $resourceGroup = $service.resourceGroup $subscriptionIdValue = $service.subscriptionId Write-Verbose "Beoordelen van API Management-service: $serviceName" try { # Haal de API Management-service op $apimService = Get-AzApiManagement -ResourceGroupName $resourceGroup -Name $serviceName -ErrorAction SilentlyContinue if (-not $apimService) { Write-Warning "Kon API Management-service '$serviceName' niet ophalen. Mogelijk ontbreken rechten." continue } # Controleer TLS-configuratie $hasTls12OrHigher = $true # Controleer of diagnostic settings zijn geconfigureerd $hasDiagnosticLogging = $false try { $diagnosticSettings = Get-AzDiagnosticSetting -ResourceId $apimService.Id -ErrorAction SilentlyContinue if ($diagnosticSettings -and $diagnosticSettings.Logs.Count -gt 0) { $hasDiagnosticLogging = $true } } catch { Write-Verbose "Kon diagnostic settings niet ophalen voor $serviceName" } # Controleer op managed identity $hasManagedIdentity = $false try { if ($apimService.Identity -and $apimService.Identity.PrincipalId) { $hasManagedIdentity = $true } } catch { Write-Verbose "Kon identity configuratie niet ophalen voor $serviceName" } # Controleer op private endpoints $hasPrivateEndpoint = $false try { $privateEndpoints = Get-AzPrivateEndpoint -ResourceGroupName $resourceGroup -ErrorAction SilentlyContinue | Where-Object { $_.PrivateLinkServiceConnections | Where-Object { $_.PrivateLinkServiceId -eq $apimService.Id } } if ($privateEndpoints) { $hasPrivateEndpoint = $true } } catch { Write-Verbose "Kon private endpoints niet ophalen voor $serviceName" } # Controleer op Azure Policy compliance $hasAzurePolicyCompliance = $false try { $policyStates = Get-AzPolicyState -ResourceId $apimService.Id -ErrorAction SilentlyContinue if ($policyStates) { $nonCompliantPolicies = $policyStates | Where-Object { $_.ComplianceState -eq 'NonCompliant' } if ($nonCompliantPolicies.Count -eq 0) { $hasAzurePolicyCompliance = $true } } } catch { Write-Verbose "Kon Azure Policy states niet ophalen voor $serviceName" } # Controleer op resource tags (indicatie voor governance en cost management) $hasResourceTags = $false if ($service.tags -and $service.tags.Count -gt 0) { $hasResourceTags = $true } # Controleer op custom domains $hasCustomDomains = $false try { $customDomains = Get-AzApiManagementCustomDomain -ApiManagementName $serviceName -ResourceGroupName $resourceGroup -ErrorAction SilentlyContinue if ($customDomains) { $hasCustomDomains = $true } } catch { Write-Verbose "Kon custom domains niet ophalen voor $serviceName" } # Controleer op API versioning (indicatie voor governance en lifecycle management) $hasApiVersioning = $false try { $apis = Get-AzApiManagementApi -Context (New-AzApiManagementContext -ResourceGroupName $resourceGroup -ServiceName $serviceName) -ErrorAction SilentlyContinue if ($apis) { $versionedApis = $apis | Where-Object { $_.ApiVersion -or $_.ApiVersionSetId } if ($versionedApis.Count -gt 0) { $hasApiVersioning = $true } } } catch { Write-Verbose "Kon API versioning niet controleren voor $serviceName" } # Bepaal governance maturity score op basis van beschikbare informatie $governanceScore = 0 if ($hasTls12OrHigher) { $governanceScore += 10 } if ($hasDiagnosticLogging) { $governanceScore += 15 } if ($hasManagedIdentity) { $governanceScore += 10 } if ($hasPrivateEndpoint) { $governanceScore += 15 } if ($hasAzurePolicyCompliance) { $governanceScore += 20 } if ($hasResourceTags) { $governanceScore += 10 } if ($hasCustomDomains) { $governanceScore += 10 } if ($hasApiVersioning) { $governanceScore += 10 } # Premium/Isolated SKU's hebben meer governance-features if ($apimService.Sku.Name -in @("Premium", "Isolated")) { $governanceScore += 10 } # Cap score op 100 if ($governanceScore -gt 100) { $governanceScore = 100 } $results += [PSCustomObject]@{ SubscriptionId = $subscriptionIdValue SubscriptionName = (Get-AzSubscription -SubscriptionId $subscriptionIdValue -ErrorAction SilentlyContinue).Name ResourceGroupName = $resourceGroup ServiceName = $serviceName Location = $service.location Sku = $service.sku.name HasTls12OrHigher = $hasTls12OrHigher HasDiagnosticLogging = $hasDiagnosticLogging HasManagedIdentity = $hasManagedIdentity HasPrivateEndpoint = $hasPrivateEndpoint HasAzurePolicyCompliance = $hasAzurePolicyCompliance HasResourceTags = $hasResourceTags HasCustomDomains = $hasCustomDomains HasApiVersioning = $hasApiVersioning GovernanceMaturityScore = $governanceScore } } catch { Write-Warning "Fout bij beoordelen van API Management-service '$serviceName': $_" } } return $results } function Test-Compliance { <# .SYNOPSIS Bepaalt de governance-maturiteit voor API Management-services. .OUTPUTS PSCustomObject met samenvatting van de resultaten. #> [CmdletBinding()] param() $services = Get-ApiManagementGovernanceStatus if (-not $services -or $services.Count -eq 0) { Write-Verbose "Geen API Management-services gevonden in de geselecteerde scope." return [PSCustomObject]@{ ScriptName = "security-governance" IsCompliant = $true Timestamp = Get-Date Details = "Er zijn geen API Management-services gevonden in de huidige scope." Recommendations = @() Services = @() } } $nonCompliant = $services | Where-Object { $_.GovernanceMaturityScore -lt 70 } $isCompliant = ($nonCompliant.Count -eq 0) $details = if ($isCompliant) { "Alle gevonden API Management-services voldoen aan de minimale governance-vereisten." } else { "Een of meer API Management-services voldoen niet aan de minimale governance-vereisten en hebben verbetering nodig." } $recommendations = @() if (-not $isCompliant) { $recommendations += "Ontwikkel en documenteer een API-beveiligingsbeleid en governance-raamwerk met duidelijke standaarden en procedures." $recommendations += "Creëer een API-register of catalogus met risicoclassificatie, eigenaar en compliance-status per API Management-service." $recommendations += "Configureer Azure Policy om compliance-regels automatisch af te dwingen op API Management-services." $recommendations += "Schakel diagnostische logging in en configureer integratie met Log Analytics voor centrale monitoring en compliance-rapportage." $recommendations += "Configureer managed identities voor beveiligde toegang tot andere Azure-services zonder credentials op te slaan." $recommendations += "Overweeg private endpoints voor API Management-services om netwerkisolatie te verbeteren, vooral voor productie-omgevingen." $recommendations += "Voeg resource tags toe aan API Management-services voor cost management, ownership en governance-tracking." $recommendations += "Implementeer API versioning voor lifecycle management en backward compatibility bij API-wijzigingen." $recommendations += "Voer periodieke security reviews en governance-assessments uit en documenteer de resultaten voor audit-doeleinden." $recommendations += "Stel een RACI-matrix op voor API-beveiligingsgovernance met duidelijke verantwoordelijkheden en besluitvormingsprocessen." } return [PSCustomObject]@{ ScriptName = "security-governance" IsCompliant = $isCompliant Timestamp = Get-Date Details = $details Recommendations = $recommendations Services = $services } } function Invoke-Monitoring { <# .SYNOPSIS Voert een governance-assessment uit en toont de governance-status per API Management-service. #> [CmdletBinding()] param() Write-Host "`nMonitoring: $PolicyName" -ForegroundColor Yellow Write-Host "Beschrijving: $PolicyDescription" -ForegroundColor Yellow Write-Host "==============================================================" -ForegroundColor Yellow $result = Test-Compliance $services = $result.Services if ($services.Count -gt 0) { Write-Host "`nGevonden API Management-services:" -ForegroundColor Cyan foreach ($service in $services) { $statusColor = if ($service.GovernanceMaturityScore -ge 70) { "Green" } else { "Red" } $statusText = "Governance Maturity Score: $($service.GovernanceMaturityScore)% - " + "TLS: $(if ($service.HasTls12OrHigher) { 'Ja' } else { 'Nee' }), " + "Logging: $(if ($service.HasDiagnosticLogging) { 'Ja' } else { 'Nee' }), " + "Managed Identity: $(if ($service.HasManagedIdentity) { 'Ja' } else { 'Nee' }), " + "Private Endpoint: $(if ($service.HasPrivateEndpoint) { 'Ja' } else { 'Nee' }), " + "Policy Compliance: $(if ($service.HasAzurePolicyCompliance) { 'Ja' } else { 'Nee' }), " + "Tags: $(if ($service.HasResourceTags) { 'Ja' } else { 'Nee' })" Write-Host ("- {0}/{1} ({2}, {3}) - {4}" -f $service.SubscriptionName, $service.ServiceName, $service.Location, $service.Sku, $statusText) -ForegroundColor $statusColor } } else { Write-Host "`nGeen API Management-services gevonden in de huidige scope." -ForegroundColor Cyan } if ($result.IsCompliant) { Write-Host "`n✅ COMPLIANT - Alle API Management-services voldoen aan de minimale governance-vereisten." -ForegroundColor Green } else { Write-Host "`n❌ NON-COMPLIANT - Eén of meer API Management-services voldoen niet aan de minimale governance-vereisten." -ForegroundColor Red 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 API Management-services zonder adequate governance-configuratie. #> [CmdletBinding()] param() Write-Host "`nRemediatie: $PolicyName" -ForegroundColor Yellow Write-Host "==============================================================" -ForegroundColor Yellow $result = Test-Compliance $services = $result.Services | Where-Object { $_.GovernanceMaturityScore -lt 70 } if (-not $services -or $services.Count -eq 0) { Write-Host "Alle API Management-services beschikken over adequate governance-configuraties. Geen remediatie nodig." -ForegroundColor Green return $result } Write-Host "`nNiet-conforme API Management-services (governance-maturiteit onvoldoende):" -ForegroundColor Red foreach ($service in $services) { Write-Host ("- Subscription: {0}" -f $service.SubscriptionName) -ForegroundColor Red Write-Host (" ResourceGroup: {0}" -f $service.ResourceGroupName) -ForegroundColor Red Write-Host (" Service: {0}" -f $service.ServiceName) -ForegroundColor Red Write-Host (" Locatie: {0}" -f $service.Location) -ForegroundColor Red Write-Host (" SKU: {0}" -f $service.Sku) -ForegroundColor Red Write-Host (" Governance Score: {0}%" -f $service.GovernanceMaturityScore) -ForegroundColor Red Write-Host "" } Write-Host "Aanbevolen vervolgstappen:" -ForegroundColor Yellow Write-Host "1. Ontwikkel en documenteer een API-beveiligingsbeleid en governance-raamwerk met duidelijke standaarden, risicoclassificatie en verantwoordelijkheden." -ForegroundColor Yellow Write-Host "2. Creëer een API-register of catalogus dat bijhoudt welke API Management-services bestaan, wie de eigenaar is, welke gegevens worden verwerkt, en welke compliance-eisen gelden." -ForegroundColor Yellow Write-Host "3. Configureer Azure Policy om compliance-regels automatisch af te dwingen op API Management-services, bijvoorbeeld voor TLS-configuratie, diagnostic logging en managed identities." -ForegroundColor Yellow Write-Host "4. Schakel diagnostische logging in voor alle API Management-services en configureer integratie met Log Analytics of Event Hubs voor centrale monitoring en compliance-rapportage." -ForegroundColor Yellow Write-Host "5. Configureer managed identities voor beveiligde toegang tot andere Azure-services zonder credentials op te slaan in code of configuratiebestanden." -ForegroundColor Yellow Write-Host "6. Overweeg private endpoints voor API Management-services om netwerkisolatie te verbeteren, vooral voor productie-omgevingen met gevoelige gegevens." -ForegroundColor Yellow Write-Host "7. Voeg resource tags toe aan API Management-services voor cost management, ownership tracking en governance-compliance (bijvoorbeeld: Environment, Owner, CostCenter, ComplianceLevel)." -ForegroundColor Yellow Write-Host "8. Implementeer API versioning voor lifecycle management en backward compatibility bij API-wijzigingen, zodat bestaande clients niet worden verstoord." -ForegroundColor Yellow Write-Host "9. Voer periodieke security reviews en governance-assessments uit (bijvoorbeeld jaarlijks) en documenteer de resultaten, bevindingen en verbeteracties voor audit-doeleinden." -ForegroundColor Yellow Write-Host "10. Stel een RACI-matrix op voor API-beveiligingsgovernance met duidelijke verantwoordelijkheden voor API-eigenaren, security officers, platformarchitecten en ontwikkelteams." -ForegroundColor Yellow if ($WhatIf) { Write-Host "`nWhatIf is ingeschakeld: er worden geen wijzigingen doorgevoerd; alleen een rapport is gegenereerd." -ForegroundColor Cyan } return $result } try { Write-Host "`n========================================" -ForegroundColor Cyan Write-Host "Script: security-governance" -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-Compliance if ($result.IsCompliant) { Write-Host "`n✅ COMPLIANT" -ForegroundColor Green } else { Write-Host "`n❌ NON-COMPLIANT" -ForegroundColor Red 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-governance.ps1: $_" throw } finally { Write-Host "`n========================================`n" -ForegroundColor Cyan }

Risico zonder implementatie

Risico zonder implementatie
High: Zonder structurele governance worden API-beveiligingsconfiguraties ad hoc ingericht per project, ontbreekt overzicht over compliance-status, worden standaarden inconsistently toegepast, en kunnen organisaties niet aantoonbaar maken aan auditors en toezichthouders dat BIO, ISO 27001 en NIS2-vereisten worden nageleefd. Dit resulteert in aantoonbare non-compliance, verhoogde kans op datalekken, en reputatieschade.

Management Samenvatting

Ontwikkel en implementeer een organisatiebreed API Security Governance-raamwerk dat strategische besluitvorming, tactische standaarden, operationele processen en compliance integraal adresseert. Zet governance op drie niveaus: strategisch (beleid, risicoclassificatie, besluitvorming), tactisch (standaarden, templates, best practices), en operationeel (geautomatiseerde controles, security reviews, monitoring). Gebruik het bijbehorende PowerShell-script om governance-maturiteit periodiek te meten, afwijkingen te identificeren, en voortgang aantoonbaar te maken in rapportages aan bestuurders, CISO en auditors. Zo wordt API-beveiliging een structureel bestuurd en continu verbeterd onderdeel van de Nederlandse Baseline voor Veilige Cloud.