💼 Management Samenvatting
Een doordachte Azure-architectuur vormt de fundamentele basis voor veilige, schaalbare en beheersbare cloudomgevingen binnen de Nederlandse publieke sector. Dit index-artikel schetst de overkoepelende principes, design patterns en best practices die organisaties helpen om een robuuste, compliance-gerichte Azure-infrastructuur op te bouwen die voldoet aan de eisen van de Baseline Informatiebeveiliging Overheid (BIO), NIS2 richtlijn en andere relevante wet- en regelgeving.
Aanbeveling
IMPLEMENT
Risico zonder
High
Risk Score
8/10
Implementatie
200u (tech: 120u)
Van toepassing op:
✓ Azure
✓ M365
✓ M365
Nederlandse overheidsorganisaties die migreren naar Azure of hun bestaande cloudomgevingen willen professionaliseren, staan voor complexe uitdagingen. Zonder een gestructureerde architectuuraanpak ontstaan versnipperde oplossingen waarin beveiligingsmaatregelen inconsistent worden toegepast, netwerksegmentatie ontbreekt, logging en monitoring onvolledig zijn en compliance-vereisten moeilijk aantoonbaar zijn. Dit leidt tot verhoogde risico's op datalekken, niet-naleving van wet- en regelgeving zoals de AVG en NIS2, en bestuurlijke aansprakelijkheid bij incidenten. Een doordachte architectuur zorgt ervoor dat beveiliging, beschikbaarheid, schaalbaarheid en beheerbaarheid vanaf het begin zijn ingebouwd in plaats van achteraf te worden toegevoegd, wat zowel kosten als risico's aanzienlijk verlaagt.
PowerShell Modules Vereist
Primary API: Azure Portal, Azure Resource Manager
Connection:
Required Modules: Az.Accounts, Az.Resources
Connection:
Connect-AzAccountRequired Modules: Az.Accounts, Az.Resources
Implementatie
Dit index-artikel positioneert Azure-architectuur binnen de "Nederlandse Baseline voor Veilige Cloud" en beschrijft hoe organisaties een samenhangend architectuurlandschap kunnen opbouwen. We behandelen fundamentele principes zoals Zero Trust, defense in depth, least privilege en security by design, en laten zien hoe deze worden vertaald naar concrete Azure-services en configuraties. Het artikel fungeert als kapstok voor meer specifieke artikelen over security design patterns, zero trust implementatie, defense in depth strategieën en secure application design, en beschrijft hoe deze onderdelen samenkomen in een volwassen, aantoonbaar beveiligde cloudomgeving. Daarnaast biedt het artikel handvatten voor governance, architectuurbeheer en periodieke evaluatie van de architectuurvolwassenheid.
Rol en scope van Azure-architectuur binnen de overheid
Azure-architectuur in een overheidscontext moet worden gezien als een strategisch kader dat technische keuzes, beveiligingsmaatregelen en operationele processen met elkaar verbindt tot een samenhangend geheel. In tegenstelling tot ad-hoc implementaties waarbij services en configuraties los van elkaar worden opgezet, vormt een doordachte architectuur de ruggengraat die ervoor zorgt dat alle componenten – van netwerken tot identiteiten, van opslag tot applicaties – op een consistente, beveiligde en beheersbare manier samenwerken. Deze architectuur moet expliciet rekening houden met de specifieke eisen die gelden voor Nederlandse overheidsorganisaties, waaronder de Baseline Informatiebeveiliging Overheid (BIO), de NIS2 richtlijn, de Algemene Verordening Gegevensbescherming (AVG) en sectorale wetgeving zoals de Archiefwet.
De primaire rol van Azure-architectuur is het waarborgen van een veilige, betrouwbare en compliance-gerichte cloudomgeving waarin organisaties hun digitale dienstverlening kunnen uitvoeren zonder onnodige risico's. Dit betekent dat architectuurkeuzes niet alleen technisch correct moeten zijn, maar ook aantoonbaar moeten voldoen aan wettelijke en bestuurlijke vereisten. Een goed ontworpen architectuur maakt het mogelijk om te bewijzen dat passende maatregelen zijn genomen om gegevens te beveiligen, dat toegang tot systemen en gegevens wordt gecontroleerd en gelogd, en dat de organisatie in staat is om snel te reageren op beveiligingsincidenten. Voor auditors, toezichthouders en bestuurders biedt een gedocumenteerde architectuur transparantie over hoe beveiliging is ingericht en hoe deze wordt onderhouden.
De scope van Azure-architectuur binnen de Nederlandse Baseline voor Veilige Cloud omvat alle lagen van de cloudstack: van de fysieke en netwerkinfrastructuur tot applicaties en data, van identiteits- en toegangsbeheer tot monitoring en incident response. Het architectuurlandschap moet rekening houden met verschillende workload-typen – van Infrastructure as a Service (IaaS) virtuele machines tot Platform as a Service (PaaS) applicaties en Software as a Service (SaaS) integraties – en moet schaalbaar zijn van kleine pilots tot enterprise-omgevingen die duizenden gebruikers en honderden applicaties ondersteunen. Daarnaast moet de architectuur flexibel genoeg zijn om te kunnen evolueren met nieuwe Azure-services en veranderende businessvereisten, terwijl de fundamentele beveiligingsprincipes consistent blijven.
Implementatieroadmap: van basis naar volwassen architectuur
De implementatie van een volwassen Azure-architectuur verloopt zelden in één grote stap, maar groeit geleidelijk van een solide basis naar een geavanceerd, geoptimaliseerd landschap. In de eerste fase wordt de fundamentele basis gelegd: een goed gestructureerde resource group-organisatie, netwerksegmentatie via virtuele netwerken en Network Security Groups, basisidentiteitsbeheer via Azure Active Directory, en essentiële beveiligingsservices zoals Microsoft Defender voor Cloud. Deze basislaag zorgt ervoor dat alle resources vanaf het begin worden beschermd en dat er een duidelijke scheiding is tussen verschillende omgevingen (development, test, productie) en verschillende vertrouwelijkheidsniveaus. In deze fase worden ook de eerste governance-mechanismen ingericht, zoals Azure Policy voor het afdwingen van standaarden en Azure Blueprints voor het snel opzetten van nieuwe omgevingen die voldoen aan compliance-vereisten.
In de volgende fase wordt de architectuur uitgebreid met geavanceerde beveiligingsmaatregelen en operationele processen. Zero Trust-principes worden geïmplementeerd door Conditional Access policies, Just-In-Time toegang, en microsegmentatie van netwerken. Defense in depth wordt versterkt door meerdere beveiligingslagen: netwerkfirewalls, applicatiefirewalls, endpoint protection, data encryption en identity protection werken samen om aanvallen op meerdere niveaus te detecteren en te blokkeren. Monitoring en logging worden uitgebreid met Azure Monitor, Log Analytics en Microsoft Sentinel voor centrale security monitoring en incident response. In deze fase worden ook disaster recovery en business continuity processen ingericht, inclusief geautomatiseerde back-ups, replicatie naar secundaire regio's en geteste herstelprocedures.
In de volwassenheidsfase wordt de architectuur geoptimaliseerd en geautomatiseerd. Infrastructure as Code (IaC) met Azure Resource Manager templates, Bicep of Terraform zorgt voor reproduceerbare, versiebeheerde omgevingen. Geautomatiseerde compliance-controles en security assessments worden regelmatig uitgevoerd om te verifiëren dat de architectuur nog steeds voldoet aan alle vereisten. Advanced threat protection, behavioral analytics en machine learning-gebaseerde detectie helpen om zero-day aanvallen en geavanceerde persistent threats (APT's) vroegtijdig te identificeren. Governance wordt volwassen met geautomatiseerde rapportages, dashboards voor bestuurders en geïntegreerde change management processen. Door deze fasering expliciet te maken in een roadmap – met duidelijke mijlpalen, beslismomenten en success criteria – ontstaat voorspelbaarheid voor bestuurders en wordt het eenvoudiger om investeringen, risico's en baten te verantwoorden.
Governance, compliance en relatie met andere architectuurartikelen
Governance rond Azure-architectuur raakt meerdere disciplines: enterprise architectuur, informatiebeveiliging, cloud governance, compliance en risk management. Zonder een helder governance-model ontstaat het risico dat architectuurkeuzes versnipperd worden gemaakt, dat verschillende teams verschillende standaarden hanteren, en dat niemand zich eigenaar voelt van de integrale architectuur. Een effectief governance-model benoemt daarom ten minste een enterprise architect die verantwoordelijk is voor de overkoepelende architectuurvisie, een cloud architect die de technische Azure-architectuur beheert, een security architect die beveiligingsaspecten waarborgt, en expliciete rollen voor CISO, privacy officer en compliance officer. Deze rollen worden vertaald naar concrete taken: wie keurt nieuwe architectuurpatronen goed, wie beoordeelt afwijkingen van standaarden, wie beheert de architectuurdocumentatie, en wie beslist over het uitfaseren van verouderde componenten. Deze afspraken worden vastgelegd in governance-documenten, architectuurprincipes en changeprocedures zodat zij organisatiebreed herkenbaar zijn.
Op compliancegebied vormt Azure-architectuur een kruispunt van verschillende wettelijke kaders. De AVG vereist dat persoonsgegevens adequaat worden beveiligd en dat organisaties kunnen aantonen welke technische en organisatorische maatregelen zijn genomen. De BIO en NIS2 leggen eisen op rond informatiebeveiliging, incident response en continuïteit. ISO 27001 biedt een internationaal erkend framework voor informatiebeveiligingsmanagement. Deze compliance-vereisten moeten expliciet worden vertaald naar architectuurkeuzes: welke encryptie-standaarden worden gebruikt, hoe wordt toegang gecontroleerd, hoe worden logs bewaard, en hoe wordt incident response georganiseerd. Dit index-artikel moet daarom expliciet worden gelezen in samenhang met andere artikelen binnen de "Nederlandse Baseline voor Veilige Cloud", zoals de artikelen over Zero Trust-architectuur, defense in depth implementatie, security design patterns en secure application design. Samen vormen zij een consistent raamwerk: dit artikel schetst de overkoepelende lijnen, terwijl de deelartikelen verdieping bieden op specifieke architectuurpatronen en technische implementaties.
Voor auditors en toezichthouders is vooral van belang dat de samenhang tussen beleid, architectuur, implementatie en operationele controles aantoonbaar is. Dat betekent dat u niet alleen architectuurdiagrammen en procesbeschrijvingen beschikbaar heeft, maar ook concreet kunt laten zien welke Azure-resources er zijn, hoe deze zijn geconfigureerd, hoe vaak security assessments worden uitgevoerd en welke verbeteracties zijn ondernomen na incidenten of bevindingen. De in dit domein beschreven PowerShell-scripts – waaronder het index-script bij dit artikel en de scripts voor specifieke architectuurcomponenten – helpen om deze informatie snel en reproduceerbaar te verzamelen. Door hun output te koppelen aan dashboards en rapportages wordt governance niet beperkt tot papieren documenten, maar ondersteund door actuele operationele data die aantoonbaar maakt dat de architectuur daadwerkelijk wordt nageleefd en onderhouden.
Monitoring van het Azure-architectuurlandschap
Gebruik PowerShell-script index.ps1 (functie Invoke-Monitoring) – Geeft een overzicht van de belangrijkste Azure-architectuurcomponenten en controleert of basiselementen aanwezig en correct geconfigureerd zijn..
Monitoring van het Azure-architectuurlandschap gaat verder dan het bewaken van individuele resources. Bestuurders, enterprise architects en security teams hebben behoefte aan een samenvattend beeld: welke resource groups en subscriptions zijn actief, hoe is de netwerksegmentatie ingericht, welke beveiligingsservices zijn geactiveerd, en zijn er signalen dat de architectuur niet meer voldoet aan compliance-vereisten. Het index-script bij dit artikel inventariseert de belangrijkste architectuurcomponenten en vertaalt die naar een compacte managementsamenvatting: hoeveel resource groups voldoen aan naming conventions, hoeveel netwerken zijn correct gesegmenteerd, welke Defender-services zijn actief, en voor welke onderdelen aanvullende acties nodig zijn. Dit vormt een startpunt voor diepgaandere analyses met gespecialiseerde scripts voor specifieke architectuurcomponenten, en helpt om het gesprek met bestuur en auditcommissies te structureren rond feitelijke cijfers en meetbare architectuurvolwassenheid.
Effectieve architectuurmonitoring omvat zowel technische als governance-aspecten. Technisch gezien moet worden gemonitord of resources correct zijn geconfigureerd volgens de architectuurstandaarden, of beveiligingsservices actief zijn en correct functioneren, en of er afwijkingen zijn die kunnen wijzen op security risico's of compliance-problemen. Governance-monitoring richt zich op de vraag of architectuurprincipes worden nageleefd, of documentatie actueel is, of change management processen correct worden gevolgd, en of er regelmatige reviews plaatsvinden om de architectuur te evalueren en te verbeteren. Door beide aspecten te combineren ontstaat een compleet beeld van de architectuurvolwassenheid en kunnen gerichte verbeteracties worden ondernomen om de architectuur verder te professionaliseren.
Remediatie en volwassenwording van Azure-architectuur
Gebruik PowerShell-script index.ps1 (functie Invoke-Remediation) – Genereert overzichten van architectuurhiaten en biedt handvatten voor gerichte verbeteracties om de architectuurvolwassenheid te verhogen..
Remediatie binnen het Azure-architectuurdomein betekent in de praktijk dat u gaten dicht tussen de gewenste architectuur en de werkelijkheid. In veel organisaties bestaan al wel beleidsdocumenten over cloudgebruik, informatiebeveiliging en architectuurprincipes, maar ontbreekt concrete vastlegging van hoe deze worden vertaald naar Azure-configuraties, welke resources daadwerkelijk zijn ingericht, en hoe de architectuur wordt onderhouden en geëvalueerd. Het index-script ondersteunt remediatie door automatisch te inventariseren waar architectuurstandaarden niet worden nageleefd, waar beveiligingsservices ontbreken, en waar documentatie verouderd of incompleet is. Op basis van deze inventarisatie kunnen gerichte verbeteracties worden gepland en uitgevoerd, waarbij prioriteit wordt gegeven aan de meest kritieke hiaten die de grootste impact hebben op beveiliging en compliance.
Een volwassen Azure-architectuur groeit stap voor stap door continue verbetering. Na elke monitoringsronde worden de belangrijkste verbeterpunten vastgelegd, van een eigenaar voorzien en ingepland in het reguliere change- of verbeterportfolio. Denk aan het standaardiseren van resource group-structuren, het implementeren van ontbrekende beveiligingsservices, het verbeteren van netwerksegmentatie, het actualiseren van architectuurdocumentatie of het invoeren van geautomatiseerde compliance-controles. Door de resultaten van het index-script te combineren met de uitkomsten van gespecialiseerde scripts voor specifieke architectuurcomponenten ontstaat een integraal beeld van de voortgang. Uiteindelijk wordt Azure-architectuur zo niet alleen een technisch ontwerp, maar een aantoonbaar beheerst en verantwoord ingericht fundament voor de digitale dienstverlening van de organisatie, dat continu wordt geëvalueerd en verbeterd om te blijven voldoen aan veranderende eisen en dreigingen.
Compliance & Frameworks
- BIO: 12.01, 12.02, 12.05, 17.01 - Borging van veilige, gedocumenteerde en controleerbare cloudarchitectuur binnen informatiebeveiligingsmanagement voor overheidsorganisaties.
- ISO 27001:2022: A.8.1.1, A.12.6.1, A.14.1.1, A.18.1.3 - Architectuurdocumentatie, risicobeheer en beheersmaatregelen voor cloudgebaseerde systemen en ondersteunende services.
- NIS2: Artikel - Versterking van digitale weerbaarheid door gecontroleerde inzet van cloudarchitectuur, inclusief governance, monitoring en incident response.
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
Overzichtsmonitoring en remediatie voor Azure-architectuurlandschap
.DESCRIPTION
Geeft een samenvattend beeld van de belangrijkste Azure-architectuurcomponenten
(resource groups, netwerken, beveiligingsservices en documentatie) binnen de
repository en ondersteunt het gericht dichten van hiaten in architectuurstandaarden
en configuratieregisters.
.NOTES
Filename: index.ps1
Author: Nederlandse Baseline voor Veilige Cloud
Created: 2025-01-27
Last Modified: 2025-01-27
Version: 1.0
Related JSON: content/azure/architecture/index.json
.LINK
https://github.com/[org]/m365-tenant-best-practise
.EXAMPLE
.\index.ps1 -Monitoring
Toont een samenvattend overzicht van Azure-architectuurcomponenten en configuratiestatus.
.EXAMPLE
.\index.ps1 -Remediation
Genereert een basisoverzicht en, indien gewenst, templates voor ontbrekende architectuurdocumentatie.
#>
#Requires -Version 5.1
#Requires -Modules Az.Accounts, Az.Resources
[CmdletBinding()]
param(
[Parameter(HelpMessage = "Voer een samenvattende monitoring uit van het Azure-architectuurlandschap.")]
[switch]$Monitoring,
[Parameter(HelpMessage = "Genereer remediatie-overzichten en optioneel documentatietemplates.")]
[switch]$Remediation,
[Parameter(HelpMessage = "Toon welke acties zouden worden uitgevoerd zonder daadwerkelijk te wijzigen.")]
[switch]$WhatIf
)
$ErrorActionPreference = 'Stop'
$VerbosePreference = 'Continue'
function Get-RepositoryRoot {
<#
.SYNOPSIS
Bepaalt de rootmap van de repository op basis van de locatie van dit script.
.OUTPUTS
String met pad naar repository-root.
#>
[CmdletBinding()]
param()
$root = Resolve-Path (Join-Path $PSScriptRoot "..\..\..") -ErrorAction SilentlyContinue
if (-not $root) {
throw "Kon de repository-root niet bepalen op basis van PSScriptRoot: $PSScriptRoot"
}
return $root.Path
}
function Get-AzureArchitectureInventory {
<#
.SYNOPSIS
Stelt een overzicht op van Azure-architectuur-gerelateerde JSON- en PS1-bestanden.
.OUTPUTS
PSCustomObject met aantallen en details.
#>
[CmdletBinding()]
param()
$repoRoot = Get-RepositoryRoot
$contentRoot = Join-Path $repoRoot "content\azure\architecture"
$codeRoot = Join-Path $repoRoot "code\azure\architecture"
$jsonFiles = @()
if (Test-Path -Path $contentRoot) {
$jsonFiles = Get-ChildItem -Path $contentRoot -Filter "*.json" -File -ErrorAction SilentlyContinue
}
$ps1Files = @()
if (Test-Path -Path $codeRoot) {
$ps1Files = Get-ChildItem -Path $codeRoot -Filter "*.ps1" -File -ErrorAction SilentlyContinue
}
$byName = @{}
foreach ($json in $jsonFiles) {
$base = [System.IO.Path]::GetFileNameWithoutExtension($json.Name)
if (-not $byName.ContainsKey($base)) {
$byName[$base] = [pscustomobject]@{
Name = $base
JsonPath = $null
JsonUpdated = $null
ScriptPath = $null
ScriptUpdated= $null
}
}
$entry = $byName[$base]
$entry.JsonPath = $json.FullName
$entry.JsonUpdated = $json.LastWriteTime
$byName[$base] = $entry
}
foreach ($ps1 in $ps1Files) {
$base = [System.IO.Path]::GetFileNameWithoutExtension($ps1.Name)
if (-not $byName.ContainsKey($base)) {
$byName[$base] = [pscustomobject]@{
Name = $base
JsonPath = $null
JsonUpdated = $null
ScriptPath = $null
ScriptUpdated= $null
}
}
$entry = $byName[$base]
$entry.ScriptPath = $ps1.FullName
$entry.ScriptUpdated = $ps1.LastWriteTime
$byName[$base] = $entry
}
$items = $byName.Values | Sort-Object Name
$missingJson = $items | Where-Object { -not $_.JsonPath }
$missingScript = $items | Where-Object { -not $_.ScriptPath }
return [pscustomobject]@{
RepositoryRoot = $repoRoot
Items = $items
MissingJson = $missingJson
MissingScripts = $missingScript
TotalControls = $items.Count
WithJsonAndPs1 = ($items | Where-Object { $_.JsonPath -and $_.ScriptPath }).Count
}
}
function Test-AzureConnection {
<#
.SYNOPSIS
Controleert of er een actieve Azure-verbinding bestaat.
.OUTPUTS
Boolean: $true als verbonden, anders $false
#>
[CmdletBinding()]
param()
try {
$context = Get-AzContext -ErrorAction Stop
if ($context) {
Write-Verbose "Azure-verbinding actief: $($context.Account.Id) in tenant $($context.Tenant.Id)"
return $true
}
return $false
}
catch {
Write-Verbose "Geen actieve Azure-verbinding: $_"
return $false
}
}
function Get-AzureArchitectureStatus {
<#
.SYNOPSIS
Inventariseert de status van belangrijke Azure-architectuurcomponenten.
.OUTPUTS
PSCustomObject met architectuurstatus.
#>
[CmdletBinding()]
param()
$isConnected = Test-AzureConnection
if (-not $isConnected) {
Write-Warning "Geen actieve Azure-verbinding. Alleen repository-inventarisatie wordt uitgevoerd."
return [pscustomobject]@{
AzureConnected = $false
ResourceGroups = 0
VirtualNetworks = 0
DefenderEnabled = $false
LogAnalyticsWorkspaces = 0
}
}
try {
Write-Verbose "Inventariseren van Azure-architectuurcomponenten..."
$resourceGroups = @()
try {
$resourceGroups = Get-AzResourceGroup -ErrorAction SilentlyContinue
}
catch {
Write-Verbose "Kon resource groups niet ophalen: $_"
}
$virtualNetworks = @()
try {
$virtualNetworks = Get-AzVirtualNetwork -ErrorAction SilentlyContinue
}
catch {
Write-Verbose "Kon virtual networks niet ophalen: $_"
}
$logAnalyticsWorkspaces = @()
try {
$logAnalyticsWorkspaces = Get-AzOperationalInsightsWorkspace -ErrorAction SilentlyContinue
}
catch {
Write-Verbose "Kon Log Analytics workspaces niet ophalen: $_"
}
return [pscustomobject]@{
AzureConnected = $true
ResourceGroups = $resourceGroups.Count
VirtualNetworks = $virtualNetworks.Count
DefenderEnabled = $false # Vereist specifieke Defender-module
LogAnalyticsWorkspaces = $logAnalyticsWorkspaces.Count
}
}
catch {
Write-Warning "Fout bij inventariseren van Azure-componenten: $_"
return [pscustomobject]@{
AzureConnected = $false
ResourceGroups = 0
VirtualNetworks = 0
DefenderEnabled = $false
LogAnalyticsWorkspaces = 0
}
}
}
function New-ArchitectureDocumentationTemplate {
<#
.SYNOPSIS
Maakt een eenvoudige Markdown-template aan voor aanvullende Azure-architectuurdocumentatie.
#>
[CmdletBinding()]
param(
[Parameter(Mandatory = $true)]
[string]$Name,
[Parameter(Mandatory = $true)]
[string]$OutputPath
)
$template = @"
# Azure Architectuur component: $Name
**Laatst bijgewerkt:** $(Get-Date -Format "yyyy-MM-dd")
**Documentatie-eigenaar:** [Naam / functie]
**Status:** Concept
## 1. Rol in het Azure-architectuurlandschap
[Beschrijf hoe deze component (artikel, script of control) past in de totale Azure-architectuur.]
## 2. Architectuurprincipes en design patterns
[Beschrijf welke architectuurprincipes en design patterns worden toegepast.]
## 3. Technische implementatie
[Beschrijf de concrete Azure-services, configuraties en koppelingen.]
## 4. Beveiligingsmaatregelen
[Beschrijf beveiligingslagen, encryptie, toegangscontrole en monitoring.]
## 5. Compliance en governance
[Beschrijf hoe wordt voldaan aan BIO, NIS2, AVG en andere relevante kaders.]
## 6. Verbeterpunten en vervolgstappen
[Beschrijf bekende verbeterpunten, gepland onderhoud en evaluatiemomenten.]
"@
$folder = Split-Path -Path $OutputPath -Parent
if (-not (Test-Path -Path $folder)) {
New-Item -Path $folder -ItemType Directory -Force | Out-Null
}
$template | Out-File -FilePath $OutputPath -Encoding UTF8
Write-Host " Template gegenereerd: $OutputPath" -ForegroundColor Green
}
function Invoke-Monitoring {
<#
.SYNOPSIS
Voert een samenvattende monitoring uit van Azure-architectuurcomponenten.
.OUTPUTS
PSCustomObject met overzichtsresultaten.
#>
[CmdletBinding()]
param()
Write-Host "`nMonitoring: Azure Architectuur overzicht" -ForegroundColor Yellow
Write-Host "=========================================" -ForegroundColor Yellow
$inventory = Get-AzureArchitectureInventory
$azureStatus = Get-AzureArchitectureStatus
Write-Host "`nRepository-root: $($inventory.RepositoryRoot)" -ForegroundColor Cyan
Write-Host "Totaal Azure-architectuurcontrols (JSON/PS1-combinaties): $($inventory.TotalControls)" -ForegroundColor Cyan
Write-Host "Volledig gekoppeld (JSON + PS1): $($inventory.WithJsonAndPs1)" -ForegroundColor Cyan
if ($azureStatus.AzureConnected) {
Write-Host "`nAzure-omgeving status:" -ForegroundColor Cyan
Write-Host " Resource Groups: $($azureStatus.ResourceGroups)" -ForegroundColor Gray
Write-Host " Virtual Networks: $($azureStatus.VirtualNetworks)" -ForegroundColor Gray
Write-Host " Log Analytics Workspaces: $($azureStatus.LogAnalyticsWorkspaces)" -ForegroundColor Gray
}
else {
Write-Host "`n⚠️ Geen actieve Azure-verbinding. Verbind met Connect-AzAccount voor volledige monitoring." -ForegroundColor Yellow
}
if ($inventory.MissingJson.Count -gt 0) {
Write-Host "`n❌ Ontbrekende JSON voor de volgende scripts:" -ForegroundColor Red
foreach ($item in $inventory.MissingJson) {
Write-Host " - $($item.Name) (script: $($item.ScriptPath))" -ForegroundColor Red
}
}
if ($inventory.MissingScripts.Count -gt 0) {
Write-Host "`n❌ Ontbrekende PS1-scripts voor de volgende JSON-bestanden:" -ForegroundColor Red
foreach ($item in $inventory.MissingScripts) {
Write-Host " - $($item.Name) (json: $($item.JsonPath))" -ForegroundColor Red
}
}
if (($inventory.MissingJson.Count -eq 0) -and ($inventory.MissingScripts.Count -eq 0)) {
Write-Host "`n✅ Alle Azure-architectuurartikelen hebben zowel JSON als PS1." -ForegroundColor Green
}
else {
Write-Host "`n⚠️ Er zijn nog hiaten in de JSON/PS1-koppeling voor Azure-architectuur." -ForegroundColor Yellow
Write-Host " Gebruik -Remediation om gericht met deze hiaten aan de slag te gaan." -ForegroundColor Yellow
}
return [pscustomobject]@{
Inventory = $inventory
AzureStatus = $azureStatus
}
}
function Invoke-Remediation {
<#
.SYNOPSIS
Ondersteunt remediatie door ontbrekende componenten inzichtelijk te maken en optioneel documentatietemplates te genereren.
.OUTPUTS
PSCustomObject met remediatieadvies.
#>
[CmdletBinding()]
param()
Write-Host "`nRemediatie: Azure Architectuur overzicht" -ForegroundColor Yellow
Write-Host "========================================" -ForegroundColor Yellow
$inventory = Get-AzureArchitectureInventory
$repoRoot = $inventory.RepositoryRoot
$docRoot = Join-Path $repoRoot "documentatie\azure-architecture"
if (-not (Test-Path -Path $docRoot)) {
New-Item -Path $docRoot -ItemType Directory -Force | Out-Null
}
$actions = @()
foreach ($item in $inventory.Items) {
$action = [pscustomobject]@{
Name = $item.Name
HasJson = [bool]$item.JsonPath
HasScript = [bool]$item.ScriptPath
DocumentationPath = $null
DocumentationExists = $false
}
$docFile = Join-Path $docRoot ("arch-" + $item.Name + ".md")
$action.DocumentationPath = $docFile
$action.DocumentationExists = Test-Path -Path $docFile
if (-not $action.DocumentationExists -and -not $WhatIf) {
New-ArchitectureDocumentationTemplate -Name $item.Name -OutputPath $docFile
}
elseif (-not $action.DocumentationExists -and $WhatIf) {
Write-Host " [WhatIf] Zou documentatietemplate aanmaken: $docFile" -ForegroundColor Yellow
}
$actions += $action
}
Write-Host "`nSamenvatting remediatie-status:" -ForegroundColor Cyan
Write-Host (" Items zonder JSON: {0}" -f ($actions | Where-Object { -not $_.HasJson }).Count) -ForegroundColor Cyan
Write-Host (" Items zonder script: {0}" -f ($actions | Where-Object { -not $_.HasScript }).Count) -ForegroundColor Cyan
Write-Host (" Items zonder documentatie: {0}" -f ($actions | Where-Object { -not $_.DocumentationExists }).Count) -ForegroundColor Cyan
return $actions
}
try {
Write-Host "`n========================================" -ForegroundColor Cyan
Write-Host "Azure Architectuur Overzichtsmonitor" -ForegroundColor Cyan
Write-Host "Nederlandse Baseline voor Veilige Cloud" -ForegroundColor Cyan
Write-Host "========================================`n" -ForegroundColor Cyan
if ($Monitoring) {
Invoke-Monitoring | Out-Null
}
elseif ($Remediation) {
Invoke-Remediation | Out-Null
}
else {
# Standaard: compacte compliance check via monitoring
$result = Invoke-Monitoring
if (($result.Inventory.MissingJson.Count -eq 0) -and ($result.Inventory.MissingScripts.Count -eq 0)) {
Write-Host "`n✅ COMPLIANT" -ForegroundColor Green
}
else {
Write-Host "`n❌ NON-COMPLIANT" -ForegroundColor Red
Write-Host "Run met -Remediation voor een gericht overzicht van hiaten en documentatietemplates." -ForegroundColor Yellow
}
}
}
catch {
Write-Error "Er is een fout opgetreden in index.ps1: $_"
throw
}
finally {
Write-Host "`n========================================`n" -ForegroundColor Cyan
}
Risico zonder implementatie
Risico zonder implementatie
High: Zonder een doordachte Azure-architectuur ontstaan versnipperde, inconsistente cloudomgevingen waarin beveiligingsmaatregelen niet samenhangend worden toegepast, compliance-vereisten moeilijk aantoonbaar zijn en het risico op datalekken en beveiligingsincidenten aanzienlijk toeneemt. Dit kan leiden tot niet-naleving van AVG, BIO en NIS2, bestuurlijke aansprakelijkheid en verlies van vertrouwen bij burgers en bestuurders.
Management Samenvatting
Een doordachte Azure-architectuur vormt de fundamentele basis voor veilige, schaalbare en beheersbare cloudomgevingen binnen de Nederlandse publieke sector. Dit index-artikel schetst de overkoepelende principes, design patterns en best practices, en fungeert als kapstok voor meer specifieke artikelen over security design patterns, zero trust implementatie en defense in depth strategieën.
- Implementatietijd: 200 uur
- FTE required: 1 FTE