BIO 09.01 ISO A.5.15

Azure API Management Als Hoeksteen Voor Veilige En Beheersbare API-platfoms

📅 2025-11-26
•
⏱️ 25 minuten lezen
•
🔴 Must-Have

💼 Management Samenvatting

Azure API Management (APIM) is voor veel Nederlandse overheidsorganisaties het centrale toegangspunt voor API-verkeer tussen interne systemen, ketenpartners en publieke diensten. Het platform fungeert als beveiligde voordeur naar achterliggende applicaties en data, en bundelt cruciale functionaliteit voor authenticatie, autorisatie, throttling, logging en integratie met bestaande beveiligings- en governanceprocessen.

Aanbeveling
POSITIONEER AZURE API MANAGEMENT ALS CENTRAAL EN AANTOONBAAR BEVEILIGD API-PLATFORM
Risico zonder
High
Risk Score
8/10
Implementatie
100u (tech: 60u)
Van toepassing op:
✓ Azure
✓ Azure API Management
✓ API Gateway
✓ Microservices
✓ Integratieplatformen

Zonder een doordachte inzet van Azure API Management ontstaat al snel een versnipperd landschap van ad-hoc API-gateways, rechtstreeks ontsloten backendservices en uiteenlopende beveiligingsniveaus per team of leverancier. Dit leidt tot ondoorzichtig beheer, verhoogde kans op datalekken en verstoringen, en grote uitdagingen bij het aantonen van compliance met BIO, ISO 27001, NIS2 en de AVG. Onbeschermde of onvoldoende bewaakte API-endpoints kunnen fungeren als toegangspoort voor aanvallers, bijvoorbeeld via brute-force authenticatiepogingen, misbruik van ontbrekende rate limiting, of het uitnutten van foutafhandeling die te veel technische details prijsgeeft. Ook vanuit bedrijfsvoering levert versnippering problemen op: bestuurders en CISO’s hebben moeite om inzicht te krijgen in welke API’s er zijn, welke afhankelijkheden bestaan tussen diensten, en welke maatregelen daadwerkelijk zijn getroffen om kritieke processen te beschermen. Tot slot bemoeilijkt het ontbreken van een centraal API-platform de samenwerking met ketenpartners; iedere integratie wordt dan een eenmalig project in plaats van een herhaalbaar patroon dat past binnen de Nederlandse Baseline voor Veilige Cloud.

PowerShell Modules Vereist
Primary API: Azure Portal, Azure Resource Manager (ARM)
Connection: Connect-AzAccount (voor geavanceerde controles)
Required Modules: Az.Accounts, Az.Resources, Az.ApiManagement

Implementatie

Dit indexartikel schetst de rol van Azure API Management binnen de "Nederlandse Baseline voor Veilige Cloud" en biedt een kapstok voor de detailartikelen over specifieke configuraties en policies. We beschrijven hoe u API Management positioneert in uw cloudarchitectuur, hoe u het platform inricht als centrale gateway in lijn met Zero Trust-principes, en hoe u governance, lifecycle management en monitoring structureert. Daarbij ligt de nadruk op de context van Nederlandse overheidsorganisaties: meerdere ontwikkelteams, een mix van SaaS-, PaaS- en on-premises systemen, en strenge eisen aan transparantie, logging en auditability. Het bijbehorende PowerShell-script helpt om binnen deze repository snel te controleren of voor API Management-artikelen de verwachte JSON- en PS1-bestanden aanwezig zijn en of de koppeling met de website-HTML-structuur klopt. Daarmee vormt dit artikel zowel een inhoudelijke als een praktische startpunt voor iedereen die API Management binnen de organisatie veilig, beheersbaar en aantoonbaar compliant wil inzetten.

Rol en positionering van Azure API Management in de overheidsarchitectuur

Azure API Management vervult in moderne overheidsarchitecturen een dubbelrol: enerzijds is het een technisch product dat concrete functionaliteit levert zoals request routing, protocoltransformatie en caching; anderzijds is het een governance-instrument waarmee u afdwingt dat alle API-verkeer langs een gecontroleerd en aantoonbaar beveiligd pad loopt. In plaats van dat iedere applicatie zijn eigen beveiligings- en loggingmechanismen implementeert, wordt deze functionaliteit geconcentreerd in een centraal API-platform. Dat maakt het mogelijk om uniforme beveiligingsmaatregelen op te leggen – bijvoorbeeld verplichte authenticatie via Microsoft Entra ID, standaard rate limiting en centrale diagnostische logging – ongeacht welk team of welke leverancier de achterliggende dienst beheert. Voor Nederlandse overheidsorganisaties, waar meerdere directies, ketenpartners en externe leveranciers tegelijk actief zijn, is zo’n centraal ankerpunt essentieel om de complexiteit beheersbaar te houden en tegelijkertijd de eisen uit de BIO en NIS2 te kunnen operationaliseren.

Het platform is bovendien een belangrijke schakel in de overgang naar Zero Trust. Waar in traditionele omgevingen vaak werd vertrouwd op netwerksegmentatie en firewalls aan de buitenrand, vraagt de Zero Trust-benadering om continue verificatie van identiteit en context voor elke request. Azure API Management sluit hier naadloos op aan door authenticatie, autorisatie en aanvullende contextcontroles dicht bij de API-endpoints zelf te plaatsen. Denk aan het valideren van OAuth2- of OpenID Connect-tokens, het toepassen van claims-gebaseerde autorisatie en het combineren van informatie over client-type, abonnement en bron-IP in policies die bepalen of een request wordt geaccepteerd. Belangrijk is dat deze principes niet alleen in technische documentatie worden beschreven, maar dat ze daadwerkelijk worden verankerd in standaardconfiguraties en policy-templates. Vanuit het perspectief van de Nederlandse Baseline voor Veilige Cloud is Azure API Management daarmee geen optionele toevoeging, maar een fundamenteel bouwblok in de architectuur voor veilige cloudomgevingen.

Daarnaast speelt API Management een sleutelrol in ketensamenwerking en gegevensuitwisseling tussen overheidsorganisaties, semi-publieke instellingen en private partijen. Door API’s via een gecontroleerde gateway te ontsluiten, kunnen afspraken over beschikbaarheid, beveiliging en gebruiksvoorwaarden veel preciezer worden vastgelegd én gemonitord. Abonnementen, products en developer portals maken het mogelijk om verschillende doelgroepen – interne ontwikkelteams, andere overheidsinstellingen, leveranciers – elk hun eigen toegangsprofiel te geven, met bijbehorende SLA’s en beveiligingsniveaus. Dit voorkomt dat integraties onzichtbaar via directe databasekoppelingen of niet-geregistreerde endpoints worden opgezet. Wanneer API Management op deze manier wordt gepositioneerd, ontstaat een consistent beeld van welke API’s in omloop zijn, welke contracten en versies gelden, en hoe de beveiligingsmaatregelen in de praktijk zijn ingericht. Dat is onmisbaar voor CISO’s, CIO’s en architecten die verantwoordelijk zijn voor de integrale digitale weerbaarheid van hun organisatie.

Architectuurpatronen voor een veilig en schaalbaar API Management-platform

Een robuuste inzet van Azure API Management vraagt om bewuste architectuurkeuzes op meerdere lagen. Allereerst is er de vraag naar de topologie van het platform: één centraal API Management-cluster voor de hele organisatie, gescheiden clusters per omgeving (ontwikkel, test, acceptatie, productie) of zelfs dedicated clusters per domein of keten. In de praktijk kiezen veel overheidsorganisaties voor een hybride model waarin een beperkt aantal centrale API Management-instanties wordt gebruikt, aangevuld met strikte afspraken over tenant- en abonnementsstructuur. Productie-API’s worden dan bijvoorbeeld alleen ontsloten via een Premium- of Developer SKU met private endpoints en geïntegreerde netwerkbeveiliging, terwijl niet-productieomgevingen gebruikmaken van aparte API Management-instanties die wél internettoegang hebben maar met beperkte rechten en datasets. Deze scheiding ondersteunt zowel beveiligingsdoelen (geen kruisbesmetting tussen omgevingen) als organisatorische eisen rond scheiding van verantwoordelijkheden en change management.

Vervolgens is er de logische architectuur van API’s, producten en backends. Een gezond ontwerp vermijdt een wildgroei aan individuele API’s zonder duidelijke structuur. In plaats daarvan wordt een hiërarchie gehanteerd waarin functioneel samenhangende API’s worden gegroepeerd in producten, bijvoorbeeld per domein (zaken, vergunningen, handhaving), per keten (jeugdzorg, belastingen, omgevingswet) of per afnemersgroep (interne diensten, ketenpartners, publiek). Binnen elk product kunnen vervolgens specifieke policies worden toegepast die passen bij het risicoprofiel van die groep: strengere rate limiting en uitgebreidere logging voor publieke API’s, zwaardere authenticatie voor administratieve API’s, en beperkte toegankelijkheid voor interne API’s die enkel binnen een specifiek netwerksegment beschikbaar mogen zijn. Belangrijk is dat deze logische structuur wordt vastgelegd in architectuurdocumentatie én in de technische configuratie, zodat nieuwe API’s automatisch in het juiste kader worden opgenomen in plaats van als losse entiteiten te ontstaan.

Ten slotte moet de architectuur rekening houden met integratie in het bredere security- en operationslandschap. Azure API Management staat niet op zichzelf, maar werkt samen met onder andere Azure Application Gateway of andere reverse proxies, Web Application Firewalls, identity-providers, SIEM-oplossingen en CI/CD-pijplijnen. Voor een volwassen inrichting betekent dit dat API Management enerzijds wordt afgeschermd door netwerk- en WAF-componenten, en anderzijds intensief samenwerkt met logging- en monitoringplatformen zoals Azure Monitor, Log Analytics en Microsoft Sentinel. Ook de ontwikkelstraat speelt een belangrijke rol: wijzigingen in API’s en policies horen zoveel mogelijk via geautomatiseerde pipelines te verlopen, waarbij kwaliteitscontroles en security scans zijn ingebouwd. Binnen de Nederlandse Baseline voor Veilige Cloud zijn dit geen optionele optimalisaties, maar noodzakelijke voorwaarden om te kunnen aantonen dat de inrichting van API Management reproduceerbaar, controleerbaar en goed gedocumenteerd is.

Governance, lifecyclebeheer en documentatie van API’s

Gebruik PowerShell-script index.ps1 (functie Invoke-Monitoring) – Voert een lichte controle uit op de aanwezigheid en consistentie van API Management-artikelen en scripts in deze repository, inclusief koppeling met de website-HTML-structuur..

Een effectief API Management-platform staat of valt met goed ingerichte governance en lifecyclebeheer. In veel organisaties ontstaan API’s vanuit individuele projecten, waarbij de focus ligt op het zo snel mogelijk realiseren van functionaliteit voor een specifieke applicatie of keten. Zonder aanvullende afspraken blijven vragen onbeantwoord als: wie is eigenaar van een API, hoe lang mag een versie in productie blijven, wat is de strategie voor backwards compatibility, en hoe wordt vastgesteld dat een API veilig en compliant blijft tijdens de hele levenscyclus. Binnen de Nederlandse Baseline voor Veilige Cloud wordt daarom aanbevolen om expliciete rollen en processen rondom API’s vast te leggen. Denk aan een product owner of API-owner die verantwoordelijk is voor de functionele scope en afnemers, een technische eigenaar of platformteam dat verantwoordelijk is voor de technische kwaliteit en beveiliging van de API, en governancefora waarin besluiten worden genomen over introductie, wijziging en uitfasering van API’s. Deze afspraken moeten worden vertaald naar concrete procedures voor versiebeheer, deprecatie en communicatie met afnemers, zodat niemand onaangenaam wordt verrast door breaking changes of het plotseling wegvallen van functionaliteit.

Documentatie speelt hierin een cruciale rol. Een API die weliswaar technisch functioneert maar onvoldoende is gedocumenteerd, vormt in de praktijk een risico: ontwikkelaars gaan zelf interpreteren hoe de API gebruikt moet worden, foutafhandeling wordt misbegrepen en beveiligingsvoorwaarden worden niet goed nageleefd. Voor overheidsorganisaties, waar transparantie en uitlegbaarheid zwaar wegen, is dat extra problematisch. Daarom hoort bij iedere in API Management gepubliceerde API minimaal: een up-to-date OpenAPI-specificatie, duidelijke beschrijving van functioneel gedrag en scenario’s, uitleg van authenticatie- en autorisatievereisten, informatie over toegepaste rate limits en quota, en verwijzingen naar relevante juridische of beleidsmatige kaders (zoals welke persoonsgegevens via de API kunnen worden verwerkt). Deze documentatie moet niet verspreid zijn over losse bestanden, maar logisch samenkomen in API Management zelf, in centrale documentatiebronnen en – zoals in deze repository – in artikelen die de achterliggende rationale en best practices beschrijven. Het bijbehorende PowerShell-script helpt om de consistentie in deze repository te bewaken door na te gaan of voor API Management-onderwerpen zowel JSON-artikelen als gekoppelde scripts bestaan en of de bijbehorende websitepagina’s aanwezig zijn.

Governance en lifecyclebeheer krijgen pas echt waarde als ze zijn verbonden met besluitvorming en rapportage. In plaats van governance te beperken tot het vastleggen van beleidsstukken, is het belangrijk om periodiek te rapporteren over de feitelijke staat van het API-landschap: hoeveel API’s zijn er, welke classificatie en risicocategorie hebben ze, welke versies zijn actief, hoeveel afnemers gebruiken ze en welke beveiligingsmaatregelen zijn toegepast. Voor Nederlandse overheidsorganisaties sluiten deze rapportages aan op bestaande kaders zoals ENSIA, interne risicorapportages en dashboards voor digitale weerbaarheid. Door API Management expliciet in deze rapportagelijnen op te nemen, wordt zichtbaar dat API’s niet slechts technische artefacten zijn, maar kritieke bouwstenen van publieke dienstverlening die op bestuurlijk niveau aandacht verdienen. Dit indexartikel en het gekoppelde script fungeren als startpunt: ze helpen om binnen deze repository de basis op orde te brengen, zodat verdere automatisering en verdiepende controles gericht kunnen worden ontwikkeld.

Monitoring, auditability en continue verbetering

Gebruik PowerShell-script index.ps1 (functie Invoke-Remediation) – Genereert een rapport in de artifacts-map met bevindingen over ontbrekende of inconsistente API Management-artikelen en doet aanbevelingen voor vervolgstappen..

Monitoring in de context van Azure API Management gaat verder dan het in de gaten houden van performancecijfers of foutpercentages. Vanuit de Nederlandse Baseline voor Veilige Cloud is monitoring ook een middel om aan te tonen dat beveiligings- en governanceafspraken daadwerkelijk worden nageleefd. Dit betekent dat u niet alleen wilt weten hoeveel requests er per API worden verwerkt, maar ook of alle productie-API’s de juiste authenticatiepolicies gebruiken, of diagnostische logging op de juiste manier is ingericht, en of policyconfiguraties corresponderen met de vastgelegde architectuur- en beveiligingsprincipes. In operationele zin wordt hiervoor gebruikgemaakt van een combinatie van Azure Monitor, Log Analytics, Application Insights en eventueel Microsoft Sentinel, aangevuld met periodieke configuratiescans en reviews. Het doel is een integraal beeld te creëren waarin zowel technische als governance-aspecten zichtbaar zijn: welke API’s voldoen aan de afgesproken baseline, welke lopen achter en welke uitzonderingen zijn bewust geaccepteerd door de organisatie.

Auditability – het vermogen om achteraf te reconstrueren wat er is gebeurd en waarom – is in de publieke sector minstens zo belangrijk als operationele monitoring. Auditors en toezichthouders zullen willen weten welke API’s wanneer zijn geïntroduceerd, hoe de besluitvorming rond risicovolle integraties is verlopen, welke incidenten zijn opgetreden en welke verbetermaatregelen vervolgens zijn getroffen. Dit vraagt om zorgvuldig beheer van loggegevens, configuratiehistorie en besluitdocumenten. Voor API Management betekent dit onder meer: bewaartermijnen voor logging die passen bij wettelijke vereisten, het vastleggen van changes in policies en configuraties (bij voorkeur via Infrastructure as Code en versiebeheer), en het onderhouden van een actueel overzicht van API’s, hun classificatie, gebruikte policies en eigenaarschap. Het ondersteunende PowerShell-script in deze repository levert hiervoor geen volledige auditoplossing, maar fungeert als een praktische check om te voorkomen dat basisdocumentatie ontbreekt of uit de pas loopt met de website- en code-structuur. Door dergelijke lichte controles te automatiseren en regelmatig te draaien, wordt de kans kleiner dat hiaten pas aan het licht komen tijdens een externe audit of na een incident.

Continue verbetering tenslotte vraagt om een cyclische aanpak: meten, analyseren, verbeteren en opnieuw meten. Binnen de context van Azure API Management vertaalt dit zich naar een ritme van periodieke policyscans, prestatie- en incidentanalyses, en reviews van architectuur- en governanceafspraken. Bevindingen uit monitoring en audits worden vertaald naar backlog-items voor platform- en ontwikkelteams, waarbij prioriteit wordt gegeven aan maatregelen met de grootste impact op risicoverlaging en compliance. Denk aan het aanscherpen van standaardpolicies, het uitfaseren van legacy-authenticatiemechanismen, het verbeteren van foutafhandeling of het uitbreiden van logging- en rapportagefunctionaliteit. Het is raadzaam om deze verbetercyclus expliciet te koppelen aan de bredere roadmap voor digitale weerbaarheid en cloudtransformatie binnen de organisatie. Zo wordt Azure API Management niet alleen een technisch hulpmiddel, maar een actief stuurinstrument waarmee de organisatie haar beveiligings- en compliance-ambities stap voor stap realiseert in de praktijk.

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 Basis monitoring- en rapportagescript voor Azure API Management-content in deze repository. .DESCRIPTION Dit script ondersteunt het artikel "Azure API Management als hoeksteen voor veilige en beheersbare API-platfoms" door een lichte, lokaal uitvoerbare controle uit te voeren op: - de aanwezigheid van JSON-artikelen over Azure API Management; - de aanwezigheid van corresponderende PowerShell-scripts; - de koppeling met de HTML-artikelen onder website\artikelen\azure\api-management. Het script voert GEEN wijzigingen uit in Azure-resources en heeft geen externe modules nodig. Alle controles vinden plaats op de lokale repositorystructuur. .NOTES Filename: index.ps1 Author: Nederlandse Baseline voor Veilige Cloud Created: 2025-11-26 Last Modified: 2025-11-26 Version: 1.0 Related JSON: content/azure/api-management/index.json .EXAMPLE .\index.ps1 -Monitoring Voert een controle uit en toont een samenvatting van API Management-artikelen, scripts en website-HTML-pagina's. .EXAMPLE .\index.ps1 -Remediation Genereert een tekstueel rapportbestand met bevindingen en aanbevelingen. #> #Requires -Version 5.1 [CmdletBinding()] param( [Parameter()] [switch]$WhatIf, [Parameter()] [switch]$Monitoring, [Parameter()] [switch]$Remediation ) $ErrorActionPreference = 'Stop' $VerbosePreference = 'Continue' $PolicyName = "Azure API Management - Content en scriptkoppelingen gecontroleerd" $RepoRoot = Split-Path -Parent (Split-Path -Parent (Split-Path -Parent $PSScriptRoot)) $ContentPath = Join-Path -Path $RepoRoot -ChildPath "content\azure\api-management" $CodePath = Join-Path -Path $RepoRoot -ChildPath "code\azure\api-management" $WebsitePath = Join-Path -Path $RepoRoot -ChildPath "website\artikelen\azure\api-management" $ReportFolder = Join-Path -Path $RepoRoot -ChildPath "artifacts---\reviews" $ReportFile = Join-Path -Path $ReportFolder -ChildPath "api-management-index-report.txt" $IndexJsonPath = Join-Path -Path $ContentPath -ChildPath "index.json" $IndexScriptPath = Join-Path -Path $CodePath -ChildPath "index.ps1" $IndexHtmlPath = Join-Path -Path $WebsitePath -ChildPath "index.html" function Connect-RequiredServices { <# .SYNOPSIS Plaatshouder voor externe verbindingen (niet vereist voor dit script). .DESCRIPTION Dit script werkt volledig lokaal op de repositorystructuur en maakt geen verbinding met Azure of andere externe diensten. De functie is aanwezig om aan het standaardschema te voldoen en kan in de toekomst worden uitgebreid voor geavanceerdere controles. #> [CmdletBinding()] param() Write-Verbose "Geen externe services nodig; alleen lokale bestandsanalyse wordt uitgevoerd." } function Get-ApiManagementInventory { <# .SYNOPSIS Bouwt een overzicht van API Management-gerelateerde JSON- en PS1-bestanden. .OUTPUTS PSCustomObject[] met basisinformatie per artikel. #> [CmdletBinding()] param() $results = @() if (-not (Test-Path -Path $ContentPath)) { Write-Verbose "Contentpad niet gevonden: $ContentPath" return @() } if (-not (Test-Path -Path $CodePath)) { Write-Verbose "Codepad niet gevonden: $CodePath" return @() } $jsonFiles = Get-ChildItem -Path $ContentPath -Filter *.json -Recurse -ErrorAction SilentlyContinue foreach ($json in $jsonFiles) { $relativeFromContent = ($json.FullName.Substring($ContentPath.Length)).TrimStart('\') $expectedScript = Join-Path -Path $CodePath -ChildPath $relativeFromContent $expectedScript = [System.IO.Path]::ChangeExtension($expectedScript, ".ps1") $hasScript = Test-Path -Path $expectedScript $results += [PSCustomObject]@{ ArticleId = [System.IO.Path]::GetFileNameWithoutExtension($json.Name) JsonPath = $json.FullName ScriptPath = if ($hasScript) { $expectedScript } else { $null } ScriptExists = $hasScript JsonLastWrite = $json.LastWriteTime } } return $results } function Get-WebsiteApiManagementPages { <# .SYNOPSIS Bepaalt welke HTML-artikelen voor Azure API Management aanwezig zijn. .OUTPUTS PSCustomObject[] met bestandsnaam en volledig pad. #> [CmdletBinding()] param() if (-not (Test-Path -Path $WebsitePath)) { Write-Verbose "Websitepad niet gevonden: $WebsitePath" return @() } $htmlFiles = Get-ChildItem -Path $WebsitePath -Filter *.html -Recurse -ErrorAction SilentlyContinue $results = foreach ($file in $htmlFiles) { [PSCustomObject]@{ Name = $file.Name Path = $file.FullName } } return $results } function Test-Compliance { <# .SYNOPSIS Voert een basale compliancecontrole uit op API Management-content en scripts. .OUTPUTS PSCustomObject met samenvattende resultaten. #> [CmdletBinding()] param() Write-Verbose "Start API Management contentcontrole in: $RepoRoot" $inventory = Get-ApiManagementInventory $webPages = Get-WebsiteApiManagementPages $indexJsonExists = Test-Path -Path $IndexJsonPath $indexScriptExists = Test-Path -Path $IndexScriptPath $indexHtmlExists = Test-Path -Path $IndexHtmlPath $totalArticles = $inventory.Count $withScript = ($inventory | Where-Object { $_.ScriptExists }).Count $missingScripts = $inventory | Where-Object { -not $_.ScriptExists } $issues = @() if (-not $indexJsonExists) { $issues += "Index-JSON voor Azure API Management ontbreekt op verwacht pad: $IndexJsonPath" } if (-not $indexScriptExists) { $issues += "Index-PS1-script voor Azure API Management ontbreekt op verwacht pad: $IndexScriptPath" } if (-not $indexHtmlExists) { $issues += "Website-HTML voor Azure API Management index ontbreekt op verwacht pad: $IndexHtmlPath" } if ($missingScripts.Count -gt 0) { $issues += "Er zijn API Management JSON-bestanden zonder corresponderend PS1-script." } $isCompliant = ($issues.Count -eq 0) $recommendations = if ($isCompliant) { @( "Blijf bij nieuwe API Management-artikelen consequent een gekoppeld PS1-script aanmaken.", "Controleer periodiek of de website-HTML-structuur overeenkomt met de content- en codepaden." ) } else { $baseRec = @() if (-not $indexJsonExists -or -not $indexScriptExists -or -not $indexHtmlExists) { $baseRec += "Zorg dat het indexartikel voor Azure API Management consistent aanwezig is als JSON, PS1 en HTML." } if ($missingScripts.Count -gt 0) { $baseRec += "Maak voor alle API Management JSON-bestanden een corresponderend PowerShell-script aan in dezelfde padstructuur." } if ($webPages.Count -eq 0) { $baseRec += "Controleer of de HTML-artikelen voor Azure API Management correct zijn gegenereerd onder website\artikelen\azure\api-management." } if (-not $baseRec) { $baseRec = @("Werk inconsistenties in API Management-artikelen en scripts weg volgens de Nederlandse Baseline voor Veilige Cloud.") } $baseRec } return [PSCustomObject]@{ ScriptName = "code/azure/api-management/index.ps1" IsCompliant = $isCompliant Timestamp = Get-Date TotalArticles = $totalArticles ArticlesWithScript = $withScript MissingScripts = $missingScripts IndexJsonExists = $indexJsonExists IndexScriptExists = $indexScriptExists IndexHtmlExists = $indexHtmlExists WebsitePageCount = $webPages.Count Issues = $issues Recommendations = $recommendations } } function Invoke-Remediation { <# .SYNOPSIS Genereert een tekstueel rapport met bevindingen en aanbevelingen. .DESCRIPTION Past geen configuraties aan, maar schrijft – indien WhatIf niet is gezet – een rapportbestand in de artifacts-map. #> [CmdletBinding()] param() Write-Verbose "Genereren van API Management index-rapport in: $ReportFile" $result = Test-Compliance $inventory = Get-ApiManagementInventory if ($WhatIf) { Write-Host "[WhatIf] Zou rapport genereren op: $ReportFile" -ForegroundColor Yellow return } if (-not (Test-Path -Path $ReportFolder)) { New-Item -Path $ReportFolder -ItemType Directory -Force | Out-Null } $lines = @() $lines += "Azure API Management - Index Rapport" $lines += "====================================" $lines += "Beleid: $PolicyName" $lines += "Datum: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')" $lines += "" $lines += "Repository root : $RepoRoot" $lines += "Content pad : $ContentPath" $lines += "Code pad : $CodePath" $lines += "Website pad : $WebsitePath" $lines += "" $lines += "Samenvatting" $lines += "-----------" $lines += "Totaal API Management-artikelen : $($result.TotalArticles)" $lines += "Met gekoppeld script : $($result.ArticlesWithScript)" $lines += "Index JSON aanwezig : $($result.IndexJsonExists)" $lines += "Index script aanwezig : $($result.IndexScriptExists)" $lines += "Index HTML aanwezig : $($result.IndexHtmlExists)" $lines += "Aantal website-HTML pagina's : $($result.WebsitePageCount)" $lines += "Compliant : $($result.IsCompliant)" $lines += "" if ($result.Issues -and $result.Issues.Count -gt 0) { $lines += "Geconstateerde issues" $lines += "---------------------" foreach ($issue in $result.Issues) { $lines += "- $issue" } $lines += "" } if ($result.MissingScripts -and $result.MissingScripts.Count -gt 0) { $lines += "Artikelen zonder gekoppeld script" $lines += "---------------------------------" foreach ($item in $result.MissingScripts) { $lines += "Artikel : $($item.ArticleId)" $lines += "JSON : $($item.JsonPath)" $lines += "" } } if ($result.Recommendations) { $lines += "Aanbevelingen" $lines += "-------------" foreach ($rec in $result.Recommendations) { $lines += "- $rec" } } $lines | Out-File -FilePath $ReportFile -Encoding UTF8 Write-Host "Rapport gegenereerd: $ReportFile" -ForegroundColor Green } function Invoke-Monitoring { <# .SYNOPSIS Start een korte monitoring-run en toont een samenvatting in de console. .OUTPUTS PSCustomObject met resultaten. #> [CmdletBinding()] param() $result = Test-Compliance Write-Host "`n========================================" -ForegroundColor Cyan Write-Host $PolicyName -ForegroundColor Cyan Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan Write-Host "========================================" -ForegroundColor Cyan Write-Host "`nTotaal API Management-artikelen : $($result.TotalArticles)" -ForegroundColor White Write-Host "Met gekoppeld script : $($result.ArticlesWithScript)" -ForegroundColor White Write-Host "Index JSON aanwezig : $($result.IndexJsonExists)" -ForegroundColor White Write-Host "Index script aanwezig : $($result.IndexScriptExists)" -ForegroundColor White Write-Host "Index HTML aanwezig : $($result.IndexHtmlExists)" -ForegroundColor White Write-Host "Aantal website-HTML pagina's : $($result.WebsitePageCount)" -ForegroundColor White if ($result.IsCompliant) { Write-Host "`n✅ API Management-content is consistent en compleet." -ForegroundColor Green } else { Write-Host "`n❌ Er zijn hiaten in API Management-content of scripts. Zie aanbevelingen voor acties." -ForegroundColor Red if ($result.Recommendations) { Write-Host "Aanbevolen vervolgstappen:" -ForegroundColor Yellow foreach ($rec in $result.Recommendations) { Write-Host (" - {0}" -f $rec) -ForegroundColor Yellow } } } return $result } try { Write-Host "`n========================================" -ForegroundColor Cyan Write-Host "Script: Azure API Management - Index" -ForegroundColor Cyan Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan Write-Host "========================================`n" -ForegroundColor Cyan Connect-RequiredServices if ($Monitoring) { Invoke-Monitoring | Out-Null } elseif ($Remediation) { Invoke-Remediation } else { $result = Test-Compliance if ($result.IsCompliant) { Write-Host "`n✅ COMPLIANT - API Management-content lijkt op orde." -ForegroundColor Green } else { Write-Host "`n❌ NON-COMPLIANT - Zie details en aanbevelingen uit de controle." -ForegroundColor Red Write-Host "Voer het script uit met -Remediation om een rapport te genereren." -ForegroundColor Yellow } return $result } } catch { Write-Error "Er is een fout opgetreden in index.ps1 voor Azure API Management: $_" throw } finally { Write-Host "`n========================================`n" -ForegroundColor Cyan }

Risico zonder implementatie

Risico zonder implementatie
High: Wanneer Azure API Management niet als centrale, goed beheerde gateway wordt ingezet, ontstaat een versnipperd en onvoldoende beschermd API-landschap. Onvoldoende authenticatie, ontbrekende rate limiting en beperkte logging vergroten dan de kans op datalekken, verstoringen en negatieve auditbevindingen, met directe gevolgen voor burgervertrouwen en bestuurlijke verantwoording.

Management Samenvatting

Azure API Management is een kerncomponent van veilige cloudarchitecturen in de publieke sector. Door het platform bewust te positioneren, architectuur- en governanceprincipes vast te leggen, lifecyclebeheer en documentatie te organiseren en monitoring en verbetercycli in te richten, kunnen overheidsorganisaties API’s veilig, schaalbaar en aantoonbaar compliant aanbieden binnen de Nederlandse Baseline voor Veilige Cloud.