Aan de slag met aangepaste grafieken in Microsoft Sentinel (preview)

Met aangepaste grafieken in Microsoft Sentinel kunnen beveiligingsonderzoekers en analisten op maat gemaakte grafiekweergaven maken van hun beveiligingsgegevens. Door aangepaste grafieken te bouwen, kunt u specifieke aanvalspatronen modelleren, bedreigingen onderzoeken en geavanceerde grafiekalgoritmen uitvoeren om verborgen relaties binnen uw digitale omgeving te ontdekken. Deze handleiding begeleidt u bij de stappen voor het maken en beheren van aangepaste grafieken met behulp van Jupyter-notebooks in de Microsoft Sentinel Visual Studio Code-extensie.

Dit artikel is gericht op het handmatig ontwerpen van aangepaste grafieken met behulp van code. Zie AI-ondersteunde aangepaste grafieken ontwerpen in Microsoft Sentinel voor een ai-gestuurde ervaring.

Vereisten

Het volgende is vereist om aangepaste grafieken te maken in Microsoft Sentinel:

Schakel de Microsoft Entra ID-connector in om de Microsoft Entra assettabellen op te nemen die worden gebruikt in de voorbeeldcode van dit artikel. Zie Opname van assetgegevens in de Microsoft Sentinel data lake voor meer informatie.

Machtigingen

Als u wilt werken met aangepaste grafieken, hebt u de volgende XDR-machtigingen nodig in Sentinel Data Lake. De volgende tabel bevat de machtigingsvereisten voor algemene grafiekbewerkingen:

Grafiekbewerking Vereiste machtigingen
Een notebookgrafiek modelleren en bouwen Gebruik een aangepaste Microsoft Defender XDR geïntegreerde RBAC-rol met gegevensmachtigingen (beheren) voor de Microsoft Sentinel gegevensverzameling.
Een grafiek in tenant behouden Gebruik een van de volgende Microsoft Entra ID rollen:
Beveiligingsoperator
Beveiligingsbeheerder
Globale beheerder
Een query uitvoeren op een persistente grafiek Gebruik een aangepaste Microsoft Defender XDR geïntegreerde RBAC-rol met basismachtigingen voor beveiligingsgegevens (lezen) voor de Microsoft Sentinel gegevensverzameling.

Belangrijk

U moet gemachtigd zijn om de gegevens te lezen die in de grafiek worden gebruikt. Als u geen toegang hebt tot een specifieke gegevensset, worden deze gegevens niet opgenomen in de grafiek. Als u een grafiek wilt maken, mag u niet worden beperkt door een Sentinel bereik. Een gebruiker met een bereik kan geen aangepaste grafiek maken.

Microsoft Entra ID rollen bieden brede toegang tot alle werkruimten in de Data Lake. Zie Rollen en machtigingen in Microsoft Sentinel voor meer informatie.

Visual Studio Code en de Microsoft Sentinel-extensie installeren

Maak aangepaste grafieken met behulp van Jupyter-notebooks in de Microsoft Sentinel Visual Studio Code-extensie. Zie Visual Studio Code en de Microsoft Sentinel-extensie installeren voor meer informatie

Een aangepaste grafiek maken

Voer de volgende stappen uit om aangepaste grafieken te maken en ermee te werken:

  1. Een aangepaste grafiek modelleren
  2. De aangepaste grafiek behouden door een grafiektaak te plannen
  3. Aangepaste grafieken weergeven en beheren

Een aangepaste grafiek modelleren

Maak een aangepaste grafiek met behulp van een Jupyter-notebook in de Microsoft Sentinel Visual Studio Code-extensie.

De volgende stappen begeleiden u bij het maken van uw eerste aangepaste grafiek met behulp van een voorbeeldnotitieblok.

Uw notebook instellen en verbinding maken met de data lake

  1. Selecteer in Visual Studio Code met de Microsoft Sentinel-extensie het pictogram Microsoft Sentinel in het linkermenu.

  2. Selecteer Aanmelden om grafieken weer te geven

  3. Er wordt een dialoogvenster weergegeven met de tekst De extensie 'Microsoft Sentinel' wil zich aanmelden met Microsoft. Selecteer Toestaan om u aan te melden.

  4. Meld u aan met uw referenties.

  5. Nadat u zich hebt aangemeld, selecteert + u vervolgens Nieuw notitieblok maken.

  6. Geef het notitieblok een naam en sla het op een geschikte locatie in uw werkruimte op.

    Een schermopname van de aanmeldingspagina voor grafieken in Visual Studio Code.

  7. Selecteer Kernel selecteren in de rechterbovenhoek van het notebookvenster om een Spark-rekengroep te selecteren.

  8. Selecteer Microsoft Sentinel en selecteer vervolgens een van de beschikbare Spark-pools.

    Een schermopname van de geselecteerde kernelpagina in Visual Studio Code.

    Tip

    U kunt AI-prompts gebruiken om een aangepast grafieknotitieblok te maken. Zie aangepaste grafieken ontwerpen met AI in Microsoft Sentinel voor meer informatie.

  9. Voer een cel uit naar door het pictogram celdriehoek uitvoeren links van de cel te selecteren. De eerste keer dat u een cel uitvoert, wordt u mogelijk gevraagd een kernel te selecteren als u er nog geen hebt geselecteerd.

    De eerste keer dat u een cel uitvoert, duurt het ongeveer vijf minuten om de Spark-sessie te starten.

    Een schermopname van het uitvoeren van de eerste cel in Visual Studio Code.

Een grafiek maken

In het volgende voorbeeld wordt een grafiek gemaakt om Microsoft Entra groepslidmaatschappen te doorlopen en geneste groepsrelaties te begrijpen. De voorbeeldcode helpt u aan de slag te gaan met een eenvoudige use-case om de aangepaste grafiekfunctionaliteit te leren en de kracht van graph traversal te gebruiken voor uw onderzoeken. U kunt een grafiek maken op basis van elke tabel die beschikbaar is in de Sentinel Data Lake.

  1. Maak verbinding met uw werkruimte en lees Entra activatabellen om te beginnen met het bouwen van de grafiek.

    from pyspark.sql import functions as F
from sentinel_lake.providers import MicrosoftSentinelProvider

lake_provider = MicrosoftSentinelProvider(spark=spark)

# Use the "System tables" workspace which contains the Entra* Assets tables
# If you are data is in a different workspace, update this variable accordingly and ensure the tables are present
LOG_ANALYTICS_WORKSPACE = "System tables"

# Dynamically get the latest snapshot time from EntraUsers
snapshot_time = (
    lake_provider.read_table("EntraUsers", LOG_ANALYTICS_WORKSPACE)
    .df.agg(F.max("_SnapshotTime").alias("max_snapshot"))
    .collect()[0]["max_snapshot"]
    .strftime("%Y-%m-%dT%H:%M:%SZ")
)
print(f"Using snapshot_time: {snapshot_time}")

snapshot_filter = (F.col("_SnapshotTime") == F.lit(snapshot_time).cast("timestamp"))

# Load EntraMembers - edges: group contains user/group/servicePrincipal
df_members = (
    lake_provider.read_table("EntraMembers", LOG_ANALYTICS_WORKSPACE)
    .filter(
        snapshot_filter
        & (F.col("sourceType") == "group")
        & (F.col("targetType").isin("user", "group", "servicePrincipal"))
    )
)

# Load EntraGroups - nodes
df_groups = (
    lake_provider.read_table("EntraGroups", LOG_ANALYTICS_WORKSPACE)
    .filter(snapshot_filter)
    .select("id", "displayName", "mailEnabled")
)

# Load EntraUsers - nodes
df_users = (
    lake_provider.read_table("EntraUsers", LOG_ANALYTICS_WORKSPACE)
    .filter(snapshot_filter)
    .select("id", "accountEnabled", "displayName", "department",
            "lastPasswordChangeDateTime", "userPrincipalName", "usageLocation")
)

# Load EntraServicePrincipals - nodes
df_service_principals = (
    lake_provider.read_table("EntraServicePrincipals", LOG_ANALYTICS_WORKSPACE)
    .filter(snapshot_filter)
    .select("accountEnabled", "id", "displayName", "servicePrincipalType",
            "tenantId", "organizationId")
)

# Fix for Spark 3.x Parquet datetime rebase issue. Required when reading Parquet files
# written by Spark 2.x which used the Julian calendar, whereas Spark 3.x uses Proleptic
# Gregorian. Without these settings, timestamp columns (e.g. lastPasswordChangeDateTime)
# may throw errors or return incorrect values. Safe to remove if all data was written by
# Spark 3.x (typical for current Fabric/Sentinel environments).
spark.conf.set("spark.sql.parquet.datetimeRebaseModeInRead", "CORRECTED")
spark.conf.set("spark.sql.parquet.datetimeRebaseModeInWrite", "CORRECTED")
spark.conf.set("spark.sql.parquet.int96RebaseModeInRead", "CORRECTED")
spark.conf.set("spark.sql.parquet.int96RebaseModeInWrite", "CORRECTED")

  2. De knooppunt- en edge-dataframes voorbereiden die vereist zijn voor het bouwen van de grafiek

    # ============================================================
# NODE PREPARATION
# ============================================================

# EntraUser nodes - keyed by user id
user_nodes = (
    df_users.df
    .select(
        F.col("id"),
        F.col("displayName"),
        F.col("accountEnabled"),
        F.col("department"),
        F.col("lastPasswordChangeDateTime"),
        F.col("userPrincipalName"),
        F.col("usageLocation")
    )
)

# EntraGroup nodes - keyed by group id
group_nodes = (
    df_groups.df
    .select(
        F.col("id"),
        F.col("displayName"),
        F.col("mailEnabled")
    )
)

# EntraServicePrincipal nodes - keyed by SP id
sp_nodes = (
    df_service_principals.df
    .select(
        F.col("id"),
        F.col("displayName"),
        F.col("accountEnabled"),
        F.col("servicePrincipalType"),
        F.col("tenantId"),
        F.col("organizationId")
    )
)

# ============================================================
# EDGE PREPARATION
# ============================================================

# Edge: EntraGroup --Contains--> EntraUser
edge_group_contains_user = (
    df_members.df
    .filter(F.col("targetType") == "user")
    .select(
        F.col("sourceId").alias("SourceGroupId"),
        F.col("targetId").alias("TargetUserId")
    )
    .distinct()
    .withColumn("EdgeKey", F.concat_ws("_", F.col("SourceGroupId"), F.col("TargetUserId")))
)

# Edge: EntraGroup --Contains--> EntraGroup (nested groups)
edge_group_contains_group = (
    df_members.df
    .filter(F.col("targetType") == "group")
    .select(
        F.col("sourceId").alias("SourceGroupId"),
        F.col("targetId").alias("TargetGroupId")
    )
    .distinct()
    .withColumn("EdgeKey", F.concat_ws("_", F.col("SourceGroupId"), F.col("TargetGroupId")))
)

# Edge: EntraGroup --Contains--> EntraServicePrincipal
edge_group_contains_sp = (
    df_members.df
    .filter(F.col("targetType") == "servicePrincipal")
    .select(
        F.col("sourceId").alias("SourceGroupId"),
        F.col("targetId").alias("TargetSPId")
    )
    .distinct()
    .withColumn("EdgeKey", F.concat_ws("_", F.col("SourceGroupId"), F.col("TargetSPId")))
)

  3. Uw grafiekschema definiëren en verbinden met de DataFrames die u in de vorige stap hebt gemaakt

    from sentinel_graph import GraphSpecBuilder, Graph

# Define the graph schema 

entra_group_graph_spec = (
    GraphSpecBuilder.start()

    # === NODES ===

    .add_node("EntraUser")
    .from_dataframe(user_nodes)  # Native Spark DataFrame (from .df + .select + .distinct)
    .with_columns(
        "id", "displayName", "accountEnabled",
        "department", "lastPasswordChangeDateTime", "userPrincipalName", "usageLocation",
        key="id", display="displayName"
    )

    .add_node("EntraGroup")
    .from_dataframe(group_nodes)  # Native Spark DataFrame
    .with_columns(
        "id", "displayName", "mailEnabled",
        key="id", display="displayName"
    )

    .add_node("EntraServicePrincipal")
    .from_dataframe(sp_nodes)  # Native Spark DataFrame
    .with_columns(
        "id", "displayName", "accountEnabled",
        "servicePrincipalType", "tenantId", "organizationId",
        key="id", display="displayName"
    )

    # === EDGES ===

    # EntraGroup --ContainsUser--> EntraUser
    .add_edge("ContainsUser")
    .from_dataframe(edge_group_contains_user)  # Native Spark DataFrame
    .source(id_column="SourceGroupId", node_type="EntraGroup")
    .target(id_column="TargetUserId", node_type="EntraUser")
    .with_columns("SourceGroupId", "TargetUserId", "EdgeKey",
                  key="EdgeKey", display="EdgeKey")

    # EntraGroup --ContainsGroup--> EntraGroup (nested groups)
    .add_edge("ContainsGroup")
    .from_dataframe(edge_group_contains_group)  # Native Spark DataFrame
    .source(id_column="SourceGroupId", node_type="EntraGroup")
    .target(id_column="TargetGroupId", node_type="EntraGroup")
    .with_columns("SourceGroupId", "TargetGroupId", "EdgeKey",
                  key="EdgeKey", display="EdgeKey")

    # EntraGroup --ContainsServicePrincipal--> EntraServicePrincipal
    .add_edge("ContainsServicePrincipal")
    .from_dataframe(edge_group_contains_sp)  # Native Spark DataFrame
    .source(id_column="SourceGroupId", node_type="EntraGroup")
    .target(id_column="TargetSPId", node_type="EntraServicePrincipal")
    .with_columns("SourceGroupId", "TargetSPId", "EdgeKey",
                  key="EdgeKey", display="EdgeKey")

).done()

  4. Het grafiekschema valideren

    # Check the schema of the graph spec to ensure it's correct
entra_group_graph_spec.show_schema()

  5. De grafiek bouwen, inclusief het voorbereiden van de gegevens en het publiceren van de grafiek

    # Build the graph from the spec - this will validate the spec and prepare it for querying
# Alter options is to use Graph.prepare() to prepare the graph nodes and edges in the lake
# and then use Graph.publish() to create the graph. You would typically call prepare() and publish()
# seperately to understand the cost of Graph API calls that are triggeterd by Graph.publish()
# see https://learn.microsoft.com/azure/sentinel/billing?tabs=simplified%2Ccommitment-tiers
intra_group_graph = Graph.build(entra_group_graph_spec)

    Opmerking

    Grafieken die zijn gemaakt tijdens interactieve notebooksessies, worden verwijderd wanneer de notebooksessie wordt gesloten. Als u de grafiek wilt behouden voor hergebruik en delen, raadpleegt u Uw aangepaste grafiek behouden

U hebt nu een grafiek gemaakt in het notitieblok.

Als u een visuele weergave van de grafiek wilt weergeven, plakt u de volgende code in een nieuwe cel:

# Query 1: Find nested group relationships nexting up to 8 levels deep
# Update the Entra Group name that you want to traverse from
query_nested_groups = """
MATCH p=(g1:EntraGroup)-[cg]->{1,8}(g2)
WHERE g1.displayName = 'tmplevel3'
RETURN *
"""
intra_group_graph.query(query_nested_groups).show()

Met deze code wordt een GQL-voorbeeldquery (Graph Query Language) uitgevoerd om alle geneste groepslidmaatschappen op te halen tot 8 niveaus diep De resulterende grafiek wordt gevisualiseerd in de uitvoer

Een schermopname van de visualisatie van een grafiek in Visual Studio Code.

Uw aangepaste grafiek behouden

Zodra u de grafiekcode in het notitieblok hebt gemaakt, kunt u het notitieblok uitvoeren in een interactieve sessie of een grafiektaak plannen. Grafieken die tijdens de interactieve notebooksessie zijn gemaakt, zijn tijdelijk en zijn alleen beschikbaar in de context van de notebooksessie. Als u uw grafiek wilt opslaan en met uw team wilt delen, plant u een grafiektaak om uw grafiek regelmatig opnieuw te bouwen. Zodra de grafiek is opgeslagen, is deze toegankelijk vanuit: de grafiekervaring in Microsoft Defender portal onder Sentinel, Visual Studio Code Notebooks en Graph-query-API's.

  1. Selecteer in uw grafieknotitieblok Geplande taak maken en selecteer vervolgens Een grafiektaak maken.

    Een schermopname van de knop Geplande taak maken in een grafieknotitieblok.

  2. Voer in het formulier Grafiektaak maken de Grafieknaam en Beschrijving in en controleer of het juiste grafieknotitieblok is opgenomen in Pad.

  3. Als u de grafiek wilt bouwen zonder een vernieuwingsschema te configureren, selecteert u Op aanvraag in de sectie Planning en selecteert u vervolgens Verzenden om de grafiek te maken.

    Opmerking

    Grafieken die zijn gemaakt met een planning op aanvraag, hebben een standaardretentie van 30 dagen en worden verwijderd na verlooptijd.

  4. Als u de grafiek wilt bouwen waarin de grafiekgegevens regelmatig worden vernieuwd, selecteert u Gepland in de sectie Planning .

    1. Selecteer een herhalingsfrequentie voor de taak. U kunt kiezen uit Per minuut, Per uur, Wekelijks, Dagelijks of Maandelijks.

    2. Er worden meer opties weergegeven om de planning te configureren, afhankelijk van de frequentie die u selecteert. Bijvoorbeeld dag van de week, tijdstip van de dag of dag van de maand.

    3. Selecteer een Start op tijd om de planning uit te voeren.

    4. Selecteer een Einde op tijd om de planning niet meer uit te voeren. Als u geen eindtijd voor de planning wilt instellen, selecteert u Taak instellen om voor onbepaalde tijd uit te voeren. Datums en tijden bevinden zich in uw tijdzone.

    5. Selecteer Verzenden om de taakconfiguratie op te slaan en de taak te publiceren. Het grafiekbouwproces begint in uw tenant. Bekijk de zojuist gemaakte grafiek en de meest recente status in de Sentinel-extensie.

    Een schermopname van de pagina grafiektaak maken.

Aangepaste grafieken weergeven en beheren

Nadat u een grafiektaak hebt gemaakt, kunt u de grafiek in uw tenant bekijken en beheren vanuit de Microsoft Sentinel-extensie in Visual Studio Code.

  1. Selecteer in de lijst met grafieken de gerealiseerde grafiek om de details ervan weer te geven.

  2. Selecteer het tabblad Taakdetails om de status van de grafiektaak weer te geven, inclusief de laatste uitvoeringstijd, de volgende uitvoeringstijd en eventuele fouten die zijn opgetreden tijdens het buildproces.

  3. Selecteer Nu uitvoeren om handmatig een grafiekbuild buiten de geplande tijden te activeren. De status wordt gewijzigd in In wachtrij en vervolgens 'In uitvoering' terwijl de grafiek wordt gebouwd.

    Een schermopname van het tabblad Grafiektaakdetails in Visual Studio Code.

  4. Wanneer de grafiek is gemaakt, wordt de status bijgewerkt naar Gereed. Selecteer het tabblad Grafiekdetails om informatie over de grafiek weer te geven.

    Een schermopname van het tabblad Grafiekdetails.

  5. U kunt uw grafiek nu opvragen en visualiseren vanuit de grafiekvisualisatie in Microsoft Sentinel in de Defender-portal. Zie Grafieken visualiseren in Microsoft Sentinel grafiek (preview) voor meer informatie.

  • Last updated on