Inhoud als code beheren met Microsoft Sentinel opslagplaatsen

met Microsoft Sentinel opslagplaatsen kunt u aangepaste Sentinel inhoud implementeren en beheren vanuit een externe opslagplaats voor broncodebeheer voor continue integratie/continue levering (CI/CD). Deze automatisering zorgt ervoor dat er geen handmatige processen meer nodig zijn om uw aangepaste inhoud in werkruimten bij te werken en te implementeren. Een subset van inhoud als code is detecties als code (DaC). Microsoft Sentinel Opslagplaatsen implementeert ook DaC.

Zie Over Microsoft Sentinel inhoud en oplossingen voor meer informatie over Sentinel inhoud.

Hoe Microsoft Sentinel-opslagplaatsen werken

U kunt deze aangepaste inhoudstypen in Microsoft Sentinel implementeren vanuit een externe opslagplaats voor versiebeheer die u met Microsoft Sentinel verbindt:

• Analyseregels
• Automatiseringsregels
• Aangepaste detectieregels (Preview)
• Zoekquery's
• Parsers
• Draaiboeken
• Werkmappen

Updates die u aanbrengt in de inhoud van uw Microsoft Sentinel-opslagplaatsen, worden gesynchroniseerd naar uw Microsoft Sentinel-werkruimte en overschrijven alle wijzigingen die u via de Microsoft Sentinel-portal in die inhoud aanbrengt. Uw Microsoft Sentinel opslagplaatsen worden uw enige waarheidsbron voor aangepaste inhoud in de verbonden werkruimten.

De verbinding met de opslagplaats plannen

Microsoft Sentinel-repository's vereisen zorgvuldige planning om ervoor te zorgen dat u vanuit uw werkruimte over de juiste machtigingen beschikt voor de repository (repo) die u wilt koppelen.

• Alleen verbindingen met GitHub- en Azure DevOps-opslagplaatsen worden ondersteund.
• Samenwerkende toegang tot uw GitHub-opslagplaats of projectbeheerdertoegang tot uw Azure DevOps-opslagplaats is vereist.
• De Microsoft Sentinel toepassing moet worden geautoriseerd voor uw opslagplaats.
• Acties moeten zijn ingeschakeld voor GitHub.
• Pijplijnen moeten zijn ingeschakeld voor Azure DevOps.
• Een Azure DevOps-verbinding moet zich in dezelfde tenant bevinden als uw Microsoft Sentinel werkruimte.

Voor het maken van een verbinding met een opslagplaats is de rol Eigenaar vereist in de resourcegroep die uw Microsoft Sentinel werkruimte bevat.

Als u inhoud vindt in een openbare opslagplaats waar u geen inzender bent, importeert, verdeelt of kloont u de inhoud eerst naar een opslagplaats waar u een bijdrager bent. Verbind vervolgens uw opslagplaats met uw Microsoft Sentinel werkruimte. Zie Aangepaste inhoud implementeren vanuit uw opslagplaats voor meer informatie.

Maximum aantal verbindingen en implementaties

• Elke Microsoft Sentinel werkruimte is momenteel beperkt tot vijf opslagplaatsverbindingen.
• Elke Azure resourcegroep is beperkt tot 800 implementaties in de implementatiegeschiedenis. Als u een groot aantal implementaties van sjablonen in een of meer van uw resourcegroepen hebt, krijgt u mogelijk de fout Deployment QuotaExceeded te zien. Zie DeploymentQuotaExceeded in de documentatie over Azure Resource Manager sjablonen voor meer informatie.

Inhoud van uw opslagplaats plannen

Microsoft Sentinel-opslagplaatsen ondersteunen het implementeren van inhoud die u opslaat als Bicep-bestanden of Azure Resource Manager (ARM)-sjablonen. U wordt aangeraden Bicep te gebruiken. Dit is intuïtiever en maakt het eenvoudiger om Azure resources en Microsoft Sentinel inhoud te beschrijven.

De sjabloon voor elk inhoudstype heeft een specifieke structuur en parameternaam, zoals beschreven in de sjabloonreferentie voor Sentinel resources. Zie OpslagplaatsenSampleContent-opslagplaats voor voorbeelden van elk inhoudstype.

We hebben een voorbeeldopslagplaats geleverd met sjablonen voor elk van de vermelde inhoudstypen. De opslagplaats laat ook zien hoe u geavanceerde functies van opslagplaatsverbindingen gebruikt. Zie Microsoft Sentinel voorbeeld van CI/CD-opslagplaatsen voor meer informatie.

Hoewel u helemaal zelf sjablonen kunt bouwen, is het vaak eenvoudiger om te beginnen met de YAML-bestanden van Sentinel openbare GitHub-opslagplaats of vanuit out-of-the-box Microsoft Sentinel inhoud. In deze tabel wordt beschreven hoe u een ARM-sjabloon converteert voor gebruik met Microsoft Sentinel-opslagplaatsen.

Zie de relevante Microsoft Sentinel GitHub-wiki voor elk inhoudstype voor meer informatie over het maken van aangepaste inhoud.

Aangepaste detectieregels implementeren als code (Preview)

U kunt aangepaste detectieregels beheren als code in uw opslagplaats met behulp van de Microsoft Beveiliging BICEP-extensie. Aangepaste detectieregels gebruiken een andere BICEP-extensie en resourceprovider dan andere Microsoft Sentinel inhoudstypen.

Vereisten voor aangepaste detectieregels

Naast de vereisten voor standaardopslagplaatsverbindingen zijn aangepaste detectieregels vereist:

• Een Microsoft 365 E5 licentie (of gelijkwaardige licentie die Microsoft Defender XDR bevat).
• Microsoft Sentinel-werkruimtes geïntegreerd in de Microsoft Defender-portal.

De Microsoft Beveiliging BICEP-extensie configureren

Voor aangepaste detectieregels is de Microsoft Beveiliging BICEP-extensie vereist. Maak een bicepconfig.json bestand in de hoofdmap van uw opslagplaats:

{
  "extensions": {
    "MicrosoftSecurity": "br:mcr.microsoft.com/bicep/extensions/microsoftsecurity:v1.0.1"
  }
}

Deze configuratie is vereist voor zowel synchronisatie op basis van opslagplaatsen als directe BICEP-implementatie.

Een BICEP-bestand met aangepaste detectieregels maken

Definieer een aangepaste detectieregel met behulp van het Microsoft.Security/detectionRules resourcetype. Maak een .bicep bestand (bijvoorbeeld detectionRule.bicep) met de volgende structuur:

extension MicrosoftSecurity

resource detectionRule 'Microsoft.Security/detectionRules@2026-06-01-preview' = {
  id: 'custom-rule-id'
  displayName: 'Custom Rule Display Name'
  status: 'enabled'
  queryCondition: {
    queryText: 'DeviceProcessEvents | take 10 | project DeviceId, Timestamp, FileName'
  }
  schedule: {
    frequency: 'PT1H'
  }
  detectionAction: {
    alertTemplate: {
      title: '<ruleTitle>'
      description: 'Custom detection rule'
      severity: 'medium'
      tactics: [
        {
          tactic: 'Execution'
          techniques: [
            {
              technique: 'T1059'
            }
          ]
        }
      ]
      entityMappings: {
        hosts: [
          {
            id: 'h'
            deviceIdColumn: 'DeviceId'
          }
        ]
      }
    }
  }
}

Regels worden uniek geïdentificeerd door hun id, die moeten worden opgegeven in de sjabloon.

Aangepaste detectieregels implementeren

U kunt aangepaste detectieregels implementeren met behulp van een van de volgende methoden.

Optie 1: Implementeren met behulp van Microsoft Sentinel Opslagplaatsen

1. Dien het BICEP-bestand en bicepconfig.json in in uw GitHub- of Azure DevOps-opslagplaats.
2. Navigeer in de Microsoft Defender-portal naar Microsoft Sentinel>Content-beheeropslagplaatsen>.
3. Maak een nieuwe opslagplaatsverbinding of bewerk een bestaande opslagplaats.
4. Selecteer in de verbindingsinstellingen aangepaste detectieregels onder Inhoudstypen.
5. Sla de verbinding op.

Zodra deze optie is ingeschakeld, synchroniseert Microsoft Sentinel aangepaste detectieregels automatisch vanuit de opslagplaats.

Optie 2: Rechtstreeks implementeren met BICEP

Voer de volgende Azure CLI opdracht uit:

az deployment group create \
  --resource-group <RESOURCE_GROUP> \
  --template-file detectionRule.bicep \
  --name mtp-deployment

Controleer of de implementatie is voltooid in de resourcegroep.

De implementatie valideren

Na de implementatie met een van beide opties:

1. Controleer of de detectieregel wordt weergegeven in uw lijst met aangepaste detectieregels in de Microsoft Defender-portal.
2. Controleer of de regel is ingeschakeld en of de verwachte resultaten worden geproduceerd.
3. Als u synchronisatie van opslagplaatsen (optie 1) hebt gebruikt, moet u wijzigingen aanbrengen in de opslagplaats om het synchronisatiegedrag te valideren.

Preview-beperkingen

Tijdens de preview:

• Aangepaste frequentie voor Microsoft Sentinel gegevens wordt niet ondersteund.
• Aangepaste details worden niet ondersteund.

Prestaties verbeteren met slimme implementaties

De functie voor slimme implementaties is een back-endfunctie die de prestaties verbetert door wijzigingen in de inhoudsbestanden van een verbonden opslagplaats actief bij te houden. Er wordt een CSV-bestand in de .sentinel map in uw opslagplaats gebruikt om elke doorvoer te controleren. De werkstroom voorkomt opnieuw implementeren van inhoud die niet is gewijzigd sinds de laatste implementatie. Dit proces verbetert de prestaties van uw implementatie en voorkomt manipulatie met ongewijzigde inhoud in uw werkruimte, zoals het opnieuw instellen van dynamische planningen van uw analyseregels.

Slimme implementaties zijn standaard ingeschakeld voor zojuist gemaakte verbindingen. Als u de voorkeur geeft aan alle inhoud voor broncodebeheer die wordt geïmplementeerd telkens wanneer een implementatie wordt geactiveerd, ongeacht of die inhoud is gewijzigd of niet, wijzigt u uw werkstroom om slimme implementaties uit te schakelen. Zie De werkstroom of pijplijn aanpassen voor meer informatie.

Aanpassingsopties voor implementatie overwegen

Houd rekening met de volgende aanpassingsopties bij het implementeren van inhoud met Microsoft Sentinel opslagplaatsen.

De werkstroom of pijplijn aanpassen

Pas de werkstroom of pijplijn op een van de volgende manieren aan:

• verschillende implementatietriggers configureren
• alleen inhoud implementeren vanuit een specifieke hoofdmap voor een bepaalde werkruimte
• plannen om de werkstroom periodiek uit te voeren
• verschillende werkstroomevenementen combineren
• slimme implementaties uitschakelen

Deze aanpassingen worden gedefinieerd in een .yml bestand dat specifiek is voor uw werkstroom of pijplijn. Zie Implementaties van opslagplaatsen aanpassen voor meer informatie over het implementeren

De implementatie aanpassen

Zodra de werkstroom of pijplijn is geactiveerd, ondersteunt de implementatie de volgende scenario's:

• prioriteit geven aan inhoud die moet worden geïmplementeerd vóór de rest van de opslagplaatsinhoud
• inhoud uitsluiten van implementatie
• ARM-sjabloonparameterbestanden opgeven

Deze opties zijn beschikbaar via een functie van het PowerShell-implementatiescript dat wordt aangeroepen vanuit de werkstroom of pijplijn. Zie Implementaties van repositories aanpassen voor meer informatie over hoe u deze aanpassingen kunt implementeren.

Microsoft Sentinel-opslagplaatsen beheren met behulp van de API

Zie de acties broncodebeheer en broncodebeheer in de Microsoft Sentinel REST API voor meer informatie over het beheren van Microsoft Sentinel opslagplaatsen met behulp van de API.

Volgende stappen

Meer voorbeelden en stapsgewijze instructies voor het implementeren van Microsoft Sentinel opslagplaatsen.

• Aangepaste inhoud implementeren vanuit uw opslagplaats
• Microsoft Sentinel CI/CD-voorbeeldopslagplaats
• Integratie van Sentinel met DevOps automatiseren