Tutorial: Angepasste Berichte im Azure-Daten-Explorer mit Daten aus Microsoft Entra

Artikel
02/06/2025

In diesem Tutorial erfahren Sie, wie Sie in Azure Data Explorer (ADX) mithilfe von Daten aus Microsoft Entra ID- und Microsoft Entra ID Governance-Diensten angepasste Berichte erstellen. Dieses Tutorial ergänzt weitere Berichtsoptionen wie die Methode Archivieren und Berichterstellung mit Azure Monitor und der Berechtigungsverwaltung, die sich auf das Exportieren des Überwachungsprotokolls in Azure Monitor zur Aufbewahrung und Analyse konzentriert. Im Vergleich dazu bietet das Exportieren von Microsoft Entra ID-Daten in Azure Data Explorer Flexibilität beim Erstellen benutzerdefinierter Berichte zu Microsoft Entra-Objekten, einschließlich historischer und gelöschter Objekte. Darüber hinaus ermöglicht die Verwendung von Azure Data Explorer die Datenaggregation aus zusätzlichen Quellen mit großer Skalierbarkeit, einem flexiblen Schema und Aufbewahrungsrichtlinien. Azure Data Explorer ist besonders hilfreich, wenn Sie jahrelang Zugriffsdaten aufbewahren, Ad-hoc-Untersuchungen durchführen oder benutzerdefinierte Abfragen für Benutzerzugriffsdaten ausführen müssen.

In diesem Artikel wird veranschaulicht, wie aus Microsoft Entra exportierte Konfiguration, Benutzer und Zugriffsrechte zusammen mit aus weiteren Quellen exportierten Daten wie Anwendungen mit Zugriffsrechten in ihren eigenen SQL-Datenbanken angezeigt werden. Anschließend können Sie in Azure Data Explorer die Kusto-Abfragesprache (KQL) verwenden, um benutzerdefinierte Berichte basierend auf den Anforderungen Ihrer Organisation zu erstellen.

Führen Sie die folgenden Schritte aus, um diese Berichte zu erstellen:

Einrichten von Azure Data Explorer in einem Azure-Abonnement oder Erstellen eines kostenlosen Clusters
Extrahieren von Daten aus Microsoft Entra ID mithilfe von PowerShell-Skripten und Microsoft Graph.
Erstellen Sie Tabellen und importieren Sie die Daten aus Microsoft Entra ID in Azure Data Explorer.
Daten aus Microsoft Entra ID Governance extrahieren.
Erstellen von Tabellen und Importieren der Daten aus Microsoft Entra ID Governance in Azure Data Explorer.
Erstellen Sie eine benutzerdefinierte Abfrage mithilfe von Kusto Query Language.

Am Ende dieses Tutorials können Sie angepasste Sichten der Zugriffsrechte und Benutzerberechtigungen entwickeln. Diese Sichten umfassen verschiedene Anwendungen mithilfe von Tools, die von Microsoft unterstützt werden. Sie können für die Berichterstellung ebenfalls Daten aus Datenbanken oder Anwendungen von Drittanbietern einbinden.

Voraussetzungen

Wenn Sie neu bei Azure Data Explorer sind und die in diesem Artikel gezeigten Szenarien kennenlernen möchten, können Sie einen kostenlosen Azure Data Explorer-Cluster herunterladen. Für die in der Produktion unterstützte Verwendung mit einer Vereinbarung zum Servicelevel für Azure Data Explorer benötigen Sie ein Azure-Abonnement, um einen vollständigen Azure Data Explorer-Cluster zu hosten.

Bestimmen Sie, welche Daten in Ihre Berichte aufgenommen werden sollen. Die Skripts in diesem Artikel enthalten Beispiele mit spezifischen Benutzer-, Gruppen- und Anwendungsdaten aus Microsoft Entra. Diese Beispiele sollen die Berichtstypen veranschaulichen, die Sie mit dieser Methode generieren können. Ihre spezifischen Berichtsanforderungen können jedoch variieren und andere oder zusätzliche Daten erfordern. Sie können mit diesen Objekten beginnen und mit der Zeit weitere Arten von Microsoft Entra-Objekten hinzufügen.

In diesem Artikel wird das Abrufen von Daten aus Microsoft Entra als angemeldeter Benutzer veranschaulicht. Stellen Sie hierfür sicher, dass Sie über die erforderlichen Rollenzuweisungen verfügen, um Daten aus Microsoft Entra abzurufen. Sie benötigen die Rollen mit den richtigen Berechtigungen zum Exportieren des Microsoft Entra-Datentyps, mit dem Sie arbeiten möchten.
- Benutzerdaten: globaler Administrator, Administrator für privilegierte Rolle, Benutzeradministrator
- Gruppendaten: globaler Administrator, Administrator für privilegierte Rolle, Gruppenadministrator
- Anwendungen/App-Rollenzuweisungen: globaler Administrator, Administrator für privilegierte Rollen, Anwendungsadministrator, Cloudanwendungsadministrator
Microsoft Graph PowerShell muss die Erlaubnis erteilt werden, dass Microsoft Entra-Objekte über Microsoft Graph abgerufen werden können. Die Beispiele in diesem Tutorial erfordern die delegierten Berechtigungen „User.Read.All“, „Group.Read.All“, „Application.Read.All“ und „Directory.Read.All“. Wenn Sie planen, Daten mithilfe von Automatisierung ohne einen angemeldeten Benutzer abzurufen, stimmen Sie stattdessen den entsprechenden Anwendungsberechtigungen zu. Weitere Informationen finden Sie in der Referenz zu den Microsoft Graph-Berechtigungen. Wenn Sie Microsoft Graph PowerShell noch nicht die Zustimmung zu diesen Berechtigungen erteilt haben, müssen Sie ein Globaler Administrator sein, um diesen Zustimmungsvorgang vorzunehmen.
In diesem Lernprogramm werden keine benutzerdefinierten Sicherheitsattribute veranschaulicht. Standardmäßig enthalten globale Administratorrollen und weitere Administratorrollen keine Berechtigungen zum Lesen benutzerdefinierter Sicherheitsattribute von Microsoft Entra-Benutzern. Wenn Sie planen, benutzerdefinierte Sicherheitsattribute abzurufen, sind möglicherweise weitere Rollen und Berechtigungen erforderlich.
Stellen Sie sicher, dass Sie auf dem Computer über Schreibzugriff auf das Dateisystemverzeichnis verfügen, auf dem Microsoft Graph PowerShell installiert ist. Hier installieren Sie die erforderlichen Microsoft Graph PowerShell-Module, und die exportierten Microsoft Entra-Daten werden gespeichert.
Stellen Sie sicher, dass Sie über Berechtigungen zum Abrufen von Daten aus weiteren Datenquellen neben Microsoft Entra verfügen, wenn Sie diese Daten ebenfalls in Azure Data Explorer integrieren möchten.

1: Einrichten von Azure Data Explorer

Wenn Sie Azure Data Explorer noch nicht verwendet haben, müssen Sie den Dienst zunächst einrichten. Sie können einen kostenlosen Cluster ohne Azure-Abonnement oder Kreditkarte erstellen oder einen vollständigen Cluster, der ein Azure-Abonnement erfordert. Anleitungen zu den ersten Schritten finden Sie unter Schnellstart: Erstellen eines Azure Data Explorer-Clusters und einer Datenbank.

2: Microsoft Entra-ID-Daten mit PowerShell extrahieren

In diesem Abschnitt führen Sie die Installation der Microsoft Graph PowerShell-Module durch. Außerdem stellen Sie in PowerShell eine Verbindung mit Microsoft Graph her, um Microsoft Entra ID-Daten zu extrahieren.

Wenn Ihre Organisation diese Module für dieses Szenario zum ersten Mal verwendet, müssen Sie über eine globale Administratorrolle verfügen, damit Microsoft Graph PowerShell die Einwilligung zur Verwendung in Ihrem Mandanten erteilen kann. Für nachfolgende Interaktionen können Rollen mit geringerem Berechtigungsumfang verwendet werden.

Öffnen Sie PowerShell.
Wenn Sie nicht bereits alle Microsoft Graph PowerShell-Module installiert haben, installieren Sie die erforderlichen Microsoft Graph-Module. Für diesen Abschnitt des Tutorial sind die folgenden Module erforderlich: Microsoft.Graph.Authentication, Microsoft.Graph.Users, Microsoft.Graph.Groups, Microsoft.Graph.Applications, Microsoft.Graph.DirectoryObjects. Wenn Sie diese Module bereits installiert haben, fahren Sie mit dem nächsten Schritt fort.

   $modules = @('Microsoft.Graph.Users', 'Microsoft.Graph.Groups', 'Microsoft.Graph.Applications', 'Microsoft.Graph.DirectoryObjects') 
   foreach ($module in $modules) { 
   Install-Module -Name $module -Scope CurrentUser -AllowClobber -Force
   }

Importieren Sie die Module in die aktuelle PowerShell-Sitzung.

  $modules = @('Microsoft.Graph.Users', 'Microsoft.Graph.Groups', 'Microsoft.Graph.Applications', 'Microsoft.Graph.DirectoryObjects') 
  foreach ($module in $modules) { 
  Import-Module -Name $module 
  }

Stellen Sie eine Verbindung mit Microsoft Graph her. Dieser Abschnitt des Tutorials veranschaulicht das Lesen von Benutzern, Gruppen und Anwendungen und erfordert daher die Berechtigungsbereiche User.Read.All, Group.Read.All, Application.Read.Allund Directory.Read.All. Weitere Informationen zu Berechtigungen finden Sie in der Microsoft Graph-Berechtigungsübersicht.

  Connect-MgGraph -Scopes "User.Read.All", "Group.Read.All", "Application.Read.All", "Directory.Read.All" -ContextScope Process -NoWelcome

Dieser Befehl fordert Sie dazu auf, sich mit Ihren Microsoft Entra-Anmeldeinformationen anzumelden. Nach der Anmeldung müssen Sie möglicherweise den erforderlichen Berechtigungen zustimmen, wenn Sie zum ersten Mal eine Verbindung herstellen oder neue Berechtigungen erforderlich sind.

PowerShell-Abfragen zum Extrahieren von Microsoft Entra ID-Daten, die zum Erstellen benutzerdefinierter Berichte in Azure Data Explorer erforderlich sind

Die folgenden Abfragen extrahieren mithilfe von PowerShell Microsoft Entra ID-Daten aus Microsoft Graph. Außerdem exportieren sie die Daten in JSON-Dateien, die im folgenden Abschnitt 3 in Azure Data Explorer importiert werden. Es können mehrere Szenarios zum Generieren von Berichten mit diesem Datentyp bestehen, einschließlich der folgenden Szenarios:

Ein Auditor möchte einen Bericht anzeigen, in dem die Gruppenmitglieder für 10 Gruppen aufgelistet sind, organisiert nach der Abteilung der Mitglieder.
Ein Auditor möchte einen Bericht zu allen Benutzern anzeigen, die zwischen zwei bestimmten Tagen Zugriff auf eine Anwendung hatten.

Sie können Daten ebenfalls aus weiteren Quellen neben Microsoft Entra in Azure Data Explorer übertragen. Das ermöglicht die folgenden Szenarios:

Ein Administrator möchte alle Benutzer anzeigen, die über Microsoft Entra ID zu einer Anwendung hinzugefügt wurden und deren Zugriffsrechte im eigenen Anwendungs-Repository, wie z. B. SQL-Datenbanken.

Diese Arten von Berichten sind nicht in Microsoft Entra ID integriert. Sie können diese Berichte jedoch selbst erstellen, indem Sie Daten aus Entra extrahieren und die Daten in Azure Data Explorer mithilfe benutzerdefinierter Abfragen kombinieren. Dies wird später im Lernprogramm im Abschnitt Einfügen von Daten aus anderen Quellen behandelt.

In diesem Tutorial extrahieren wir Microsoft Entra ID-Daten aus mehreren Bereichen:

Benutzerinformationen wie Anzeigename, UPN und Auftragsdetails
Gruppeninformationen einschließlich der Gruppenmitgliedschaften
Zuweisungen von Anwendungen und Anwendungsrollen

Mit diesem Datensatz können wir eine breite Palette von Abfragen darüber durchführen, wer Zugriff auf eine Anwendung erhalten hat, einschließlich ihrer Anwendungsrolleninformationen sowie des zugehörigen Zeitrahmens. Beachten Sie, dass es sich hierbei um Beispielabfragen handelt. Ihre Daten und spezifischen Anforderungen können von den hier gezeigten Angaben abweichen.

Hinweis

Bei größeren Mandanten können Bandbreiteneinschränkungen oder 429-Fehler auftreten, die vom Microsoft Graph-Modul behandelt werden. Azure Data Explorer kann außerdem die Größe des Dateiuploads beschränken.

In diesen PowerShell-Skripts werden ausgewählte Eigenschaften aus den Microsoft Entra-Objekten in JSON-Dateien exportiert. Die Daten aus diesen exportierten Eigenschaften werden verwendet, um in Azure Data Explorer benutzerdefinierte Berichte zu generieren. Die folgenden spezifischen Eigenschaften sind in diesen Beispielen enthalten, da diese Daten zur Veranschaulichung der Arten von Berichten verwendet werden, die Sie in Azure Data Explorer erstellen können. Da Ihre spezifischen Berichterstattungsbedürfnisse wahrscheinlich von den gezeigten abweichen, sollten Sie dafür sorgen, dass die für Sie interessanten spezifischen Eigenschaften in diese Skripts aufgenommen werden, die Sie in Ihren Berichten sehen möchten. Sie können zur Erstellung Ihrer Skripts jedoch dem gezeigten Muster folgen.

Auswählen des Datums der Momentaufnahme

Wir haben ein hartcodiertes Momentaufnahmedatum eingefügt, das die Daten in der JSON-Datei mit einem bestimmten Datum identifiziert und es uns ermöglicht, ähnliche Datensätze im Laufe der Zeit im Azure Data Explorer nachzuverfolgen. Mithilfe des Momentaufnahmedatums können auch Änderungen der Daten zwischen zwei Momentaufnahmen mit jeweils unterschiedlichem Datum verglichen werden.

$SnapshotDate = Get-Date -AsUTC -Format "yyyy-MM-dd"

Abrufen von Entra-Benutzerdaten

Mit diesem Skript werden ausgewählte Eigenschaften aus dem Entra-Benutzerobjekt in eine JSON-Datei exportiert. Wir importieren diese und zusätzliche Daten aus anderen JSON-Dateien in Azure Data Explorer in einem späteren Abschnitt dieses Tutorials.

  function Export-EntraUsersToJson { 

  # Define a hash table for property mappings 
   $propertyMappings = @{ 
    "Id" = "ObjectID" 
    "DisplayName" = "DisplayName" 
    "UserPrincipalName" = "UserPrincipalName" 
    "EmployeeId" = "EmployeeId" 
    "UserType" = "UserType" 
    "CreatedDateTime" = "CreatedDateTime" 
    "JobTitle" = "JobTitle" 
    "Department" = "Department" 
    "AccountEnabled" = "AccountEnabled" 

   # Add custom properties as needed 
    "custom_extension" = "CustomExtension" 
   } 
  # Retrieve users with specified properties and create custom objects directly 
   $users = Get-MgUser -Select ($propertyMappings.Keys) -All | ForEach-Object { 
      $userObject = @{} 
      foreach ($key in $propertyMappings.Keys) { 
        if ($key -eq "CreatedDateTime") { 
          # Convert date string directly to DateTime and format it 
          $date = [datetime]::Parse($_.$key) 
          $userObject[$propertyMappings[$key]] = $date.ToString("yyyy-MM-dd") 
        } else { 
          $userObject[$propertyMappings[$key]] = $_.$key 
        } 
      } 
      # Additional properties or transformations 
      $userObject["SnapshotDate"] = $SnapshotDate
      [pscustomobject]$userObject 
    } 
    # Convert the user data to JSON and save it to a file 
    $users | ConvertTo-Json -Depth 2 | Set-Content ".\EntraUsers.json" 
  } 
  # Execute the function 
  Export-EntraUsersToJson

Abrufen von Gruppendaten

Generieren Sie eine JSON-Datei mit Gruppennamen und IDs, die in Azure Data Explorer zum Erstellen benutzerdefinierter Sichten verwendet werden. Das Beispiel enthält alle Gruppen, bei Bedarf können jedoch zusätzliche Filter einbezogen werden. Wenn Sie die Daten so filtern, dass nur bestimmte Gruppen eingeschlossen werden, sollten Sie Logik in Ihr Skript aufnehmen, um nach verschachtelten Gruppen zu suchen.

    # Get all groups and select Id and DisplayName 
    $groups = Get-MgGroup -All | Select-Object Id,DisplayName 
    # Export the groups to a JSON file 
    $groups | ConvertTo-Json | Set-Content ".\EntraGroups.json"

Abrufen von Daten zur Gruppenmitgliedschaft

Generieren Sie eine JSON-Datei mit der Gruppenmitgliedschaft, die in Azure Data Explorer zum Erstellen benutzerdefinierter Sichten verwendet wird. Das Beispiel enthält alle Gruppen, bei Bedarf können jedoch zusätzliche Filter einbezogen werden.

    # Retrieve all groups from Microsoft Entra (Azure AD) 
    $groups = Get-MgGroup -All 
    # Initialize an array to store results 
    $results = @() 
    # Iterate over each group 
    foreach ($group in $groups) { 
      # Extract the group ID 
      $groupId = $group.Id 
      # Get members of the current group and select their IDs 
      $members = Get-MgGroupMember -GroupId $groupId | Select-Object -ExpandProperty Id 
      # Add a custom object with group ID and member IDs to the results array 
      $results += [PSCustomObject]@{ 
        GroupId = $groupId 
        Members = $members 
        SnapshotDate = $SnapshotDate
      } 
      # Pause for a short time to avoid rate limits 
      Start-Sleep -Milliseconds 200 
    } 
    # Convert the results array to JSON format and save it to a file 
    $results | ConvertTo-Json | Set-Content "EntraGroupMembership.json"

Abrufen von Daten zu Anwendungen und Dienstprinzipalen

Generieren Sie eine JSON-Datei mit allen Anwendungen und den entsprechenden Dienstprinzipalen im Mandanten. Wir werden diese Daten in einem späteren Abschnitt dieses Tutorials in Azure Data Explorer importieren, was es uns ermöglicht, benutzerdefinierte Berichte im Zusammenhang mit Anwendungen basierend auf diesen Daten zu erstellen.

    # Fetch applications and their corresponding service principals, then export to JSON 
    Get-MgApplication -All | ForEach-Object { 
      $app = $_ 
      $sp = Get-MgServicePrincipal -Filter "appId eq '$($app.AppId)'" 
      [pscustomobject]@{ 
        Name        = $app.DisplayName 
        ApplicationId   = $app.AppId 
        ServicePrincipalId = $sp.Id 
        SnapshotDate = $SnapshotDate
      } 
    } | ConvertTo-Json -Depth 10 | Set-Content "Applications.json"

Abrufen von AppRole-Daten

Generieren Sie eine JSON-Datei aller appRoles für Unternehmens-Apps in Microsoft Entra. Nachdem die Daten in Azure Data Explorer importiert wurden, verwenden wir sie, um Berichte zu generieren, die App-Rollenzuweisungen für Benutzer umfassen.

    # Get a list of all applications, handle pagination manually if necessary 
    $apps = Get-MgApplication -All 
    # Loop through each application to gather the desired information 
    $results = foreach ($app in $apps) { 
      # Get the service principal for the application using its appId 
      $spFilter = "appId eq '$($app.AppId)'" 
      $sp = Get-MgServicePrincipal -Filter $spFilter | Select-Object -First 1 
      # Process AppRoles, if any, for the application 
      $appRoles = if ($app.AppRoles) { 
        $app.AppRoles | Where-Object { $_.AllowedMemberTypes -contains "User" } | 
        Select-Object Id, Value, DisplayName 
      } 
      # Construct a custom object with application and service principal details 
      [PSCustomObject]@{ 
        ApplicationId    = $app.AppId 
        DisplayName     = $app.DisplayName 
        ServicePrincipalId = $sp.Id 
        AppRoles      = $appRoles 
        SnapshotDate = $SnapshotDate
      } 
    } 
    # Export the results to a JSON file 
    $results | ConvertTo-Json -Depth 4 | Out-File 'AppRoles.json'

Abrufen von AppRole-Zuweisungsdaten

Generieren Sie eine JSON-Datei mit allen App-Rollenzuweisungen von Benutzern im Mandanten.

    $users = Get-MgUser -All 
    $result = @() 
    foreach ($user in $users) { 
      Get-MgUserAppRoleAssignment -UserId $user.Id | ForEach-Object { 
        # Use the same date formatting approach 
        $createdDateTime = $_.CreatedDateTime -replace "\\/Date\((\d+)\)\\/", '$1' 
        # Convert the milliseconds timestamp to a readable date format if needed 
        $result += [PSCustomObject]@{ 
          AppRoleId      = $_.AppRoleId 
          CreatedDateTime   = $createdDateTime 
          PrincipalDisplayName = $_.PrincipalDisplayName 
          PrincipalId     = $_.PrincipalId 
          ResourceDisplayName = $_.ResourceDisplayName 
          ResourceId      = $_.ResourceId 
          SnapshotDate     = $SnapshotDate
        } 
      } 
    } 
    $result | ConvertTo-Json -Depth 10 | Out-File "AppRoleAssignments.json"

3: Erstellen von Tabellen und Importieren von JSON-Dateien mit Daten aus Microsoft Entra ID in Azure Data Explorer

In diesem Abschnitt werden die neu erstellten JSON-Dateien für die Microsoft Entra ID-Dienste als Tabellen zur weiteren Analyse in Azure Data Explorer importiert. Beim ersten Import mithilfe der Azure Data Explorer-Web-UI erstellen Sie die Tabellen basierend auf dem Schema, das die Web-UI aus jeder JSON-Datei vorschlägt.

Nachdem Sie in Ihrem Azure Data Explorer-Cluster oder in einem kostenlosen Cluster eine Datenbank eingerichtet haben, wie im ersten Abschnitt dieses Artikels beschrieben, navigieren Sie zu dieser Datenbank.

Melden Sie sich bei der Azure Data Explorer-Webbenutzeroberfläche an.
Wählen Sie im Menü auf der linken Seite Abfrage aus.

Führen Sie als Nächstes für jede exportierte JSON-Datei die folgenden Schritte aus, um Ihre exportierten Daten in diese Azure Data Explorer-Datenbank als neue Tabelle zu importieren.

Wählen Sie mit der rechten Maustaste den Datenbanknamen der Datenbank aus, in der Sie die Daten erfassen möchten. Wählen Sie Daten abrufen aus.
Wählen Sie die Datenquelle aus der verfügbaren Liste aus. In diesem Tutorial werden Daten aus einer lokalen Datei erfasst.
Wählen Sie + Neue Tabelle aus, und geben Sie basierend auf dem Namen der zu importierenden JSON-Datei einen Tabellennamen ein. Beispiel: Benennen Sie die Tabelle EntraUsers, wenn Sie die Datei „EntraUsers.json“ importieren. Nach dem ersten Import ist die Tabelle bereits vorhanden, und Sie können diese als Zieltabelle für einen nachfolgenden Import auswählen.
Wählen Sie Nach Dateien durchsuchen aus. Wählen Sie die JSON-Datei aus, und wählen Sie Weiter aus.
Azure Data Explorer erkennt das Schema automatisch und stellt auf der Registerkarte Überprüfen eine Vorschau bereit. Wählen Sie Fertig stellen aus, um die Tabelle zu erstellen und die Daten aus dieser Datei zu importieren. Nach der Erfassung der Daten klicken Sie auf Schließen.
Wiederholen Sie jeden der vorherigen Schritte für jede JSON-Datei, die Sie im vorherigen Abschnitt generiert haben.

Am Ende dieser Schritte haben Sie die Tabellen EntraUsers, EntraGroups, EntraGroupMembership, Applications, AppRolesund AppRoleAssignments in der Datenbank.

4: Extrahieren von Microsoft Entra ID Governance-Daten mit PowerShell

In diesem Abschnitt verwenden Sie PowerShell, um Daten aus Microsoft Entra ID Governance-Diensten zu extrahieren. Wenn Sie nicht über Microsoft Entra ID Governance, Microsoft Entra ID P2 oder Microsoft Entra Suite verfügen, fahren Sie mit dem Abschnitt fort und verwenden Sie Azure Data Explorer, um benutzerdefinierte Berichtezu erstellen.

Sie müssen möglicherweise Microsoft Graph PowerShell-Module installieren, um Microsoft Entra ID Governance-Daten zu extrahieren. Wenn Ihre Organisation diese Module für dieses Szenario zum ersten Mal verwendet, müssen Sie über eine globale Administratorrolle verfügen, damit Microsoft Graph PowerShell die Einwilligung zur Verwendung in Ihrem Mandanten erteilen kann. Für nachfolgende Interaktionen können Rollen mit geringerem Berechtigungsumfang verwendet werden.

Öffnen Sie PowerShell.
Wenn Sie nicht bereits alle Microsoft Graph PowerShell-Module installiert haben, installieren Sie die erforderlichen Microsoft Graph-Module. Für diesen Abschnitt des Tutorials sind die folgenden Module erforderlich: Microsoft.Graph.Identity.Governance. Wenn Sie diese Module bereits installiert haben, fahren Sie mit dem nächsten Schritt fort.

   $modules = @('Microsoft.Graph.Identity.Governance')
   foreach ($module in $modules) {
   Install-Module -Name $module -Scope CurrentUser -AllowClobber -Force
   }

Importieren Sie die Module in die aktuelle PowerShell-Sitzung.

  $modules = @('Microsoft.Graph.Identity.Governance')
  foreach ($module in $modules) {
  Import-Module -Name $module
  }

Stellen Sie eine Verbindung mit Microsoft Graph her. In diesem Abschnitt des Lernprogramms wird veranschaulicht, wie Daten aus der Berechtigungsverwaltung und aus Zugriffsüberprüfungen abgerufen werden. Daher sind die Berechtigungsbereiche AccessReview.Read.All und EntitlementManagement.Read.All erforderlich. Aktualisieren Sie für weitere Berichtsanwendungsfälle wie PIM- oder Lebenszyklus-Workflows den Scopes-Parameter mit den erforderlichen Berechtigungen. Weitere Informationen zu Berechtigungen finden Sie in der Microsoft Graph-Berechtigungsübersicht.

  Connect-MgGraph -Scopes "AccessReview.Read.All, EntitlementManagement.Read.All" -ContextScope Process -NoWelcome

PowerShell-Abfragen zum Extrahieren von Microsoft Entra ID Governance-Daten, die zum Erstellen benutzerdefinierter Berichte in Azure Data Explorer erforderlich sind

Sie können Abfragen verwenden, um mithilfe von PowerShell Microsoft Entra ID Governance-Daten aus Microsoft Graph zu extrahieren und die Daten in JSON-Dateien zu exportieren, die im folgenden Abschnitt in Azure Data Explorer importiert werden. Es können mehrere Szenarios zum Generieren von Berichten mit diesem Datentyp bestehen, einschließlich der folgenden Szenarios:

Berichterstellung zu historischen Zugriffsüberprüfungen
Berichterstellung zu Aufgaben über die Berechtigungsverwaltung

Abrufen von Definitionsdaten für den Zeitplan der Zugriffsüberprüfungen

Generieren Sie eine JSON-Datei mit Zugriffsüberprüfungsdefinitionsnamen und IDs, die zum Erstellen benutzerdefinierter Ansichten in Azure Data Explorer verwendet werden. Das Beispiel enthält alle Zugriffsüberprüfungen, bei Bedarf können jedoch zusätzliche Filter einbezogen werden. Weitere Informationen finden Sie unter Verwenden des Filterabfrageparameters.

   $allsched = Get-MgIdentityGovernanceAccessReviewDefinition -All
   $definitions = @()
   # Iterate over each definition
   foreach ($definition in $allsched) {
      $definitions += [PSCustomObject]@{
         Id = $definition.Id
         DisplayName = $definition.DisplayName
         SnapshotDate = $SnapshotDate
      }
   }
   $definitions | ConvertTo-Json -Depth 10 | Set-Content "EntraAccessReviewDefinitions.json"

Abrufen von Instanzdaten für die Zugriffsüberprüfung

Um alle Access Review-Definitionen, Instanzen und Entscheidungen mithilfe von PowerShell in ein strukturiertes Ordnerformat zu exportieren, können Sie die Microsoft Graph-API verwenden. Mit diesem Ansatz wird sichergestellt, dass Ihre Daten hierarchisch organisiert und an der angegebenen Ordnerstruktur ausgerichtet sind.

Bevor Sie beginnen, beachten Sie bitte Folgendes:

Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen für den Zugriff auf Access Reviews-Daten in Microsoft Graph verfügen.
Je nach Datenvolumen kann die Ausführungszeit des Skripts variieren. Überwachen Sie den Prozess, und passen Sie die Parameter nach Bedarf an.

Laden Sie das Export_Access_Reviews.ps1 Skript herunter, und speichern Sie es lokal.
Heben Sie im Datei-Explorer die Blockierung des Skripts auf, damit es in PowerShell ausgeführt werden kann.
Führen Sie den folgenden Befehl aus, der alle Daten in drei Unterordnern ReviewInstances, ReviewInstanceDecisionItems und ReviewInstanceContactedReviewersausgibt.

 .\ExportAccessReviews.ps1 -InstanceStartDate "11/15/2024" -InstanceEndDate "12/15/2024" -ExportFolder "C:\AccessReviewsExport\11_15_to_12_15"

Zugriffspaketdaten für die Berechtigungsverwaltung abrufen

Generieren Sie eine JSON-Datei mit Zugriffspaketnamen und IDs, die in Azure Data Explorer zum Erstellen benutzerdefinierter Sichten verwendet werden. Das Beispiel enthält alle Zugriffspakete, bei Bedarf können jedoch zusätzliche Filter einbezogen werden.

   $accesspackages1 = Get-MgEntitlementManagementAccessPackage -All
   $accesspackages2 = @()
   # Iterate over each access package
   foreach ($accesspackage in $accesspackages1) {
      $accesspackages2 += [PSCustomObject]@{
         Id = $accesspackage.Id
         DisplayName = $accesspackage.DisplayName
         SnapshotDate = $SnapshotDate
      }
   }
   $accesspackages2 | ConvertTo-Json -Depth 10 | Set-Content "EntraAccessPackages.json"

Abrufen der Zuweisungsdaten von Zugriffspaketen für die Berechtigungsverwaltung

Generieren Sie eine JSON-Datei mit Zuweisungen für Zugriffspakete, die in Azure Data Explorer zum Erstellen benutzerdefinierter Sichten verwendet werden. Die Stichprobe enthält alle Aufgaben, die bereitgestellt werden. Bei Bedarf können allerdings zusätzliche Filter einbezogen werden.

   $apassignments1 = Get-MgEntitlementManagementAssignment -ExpandProperty target,accessPackage -filter "state eq 'Delivered'" -all
   $apassignments2 = @()
   # Iterate over each access package assignment
   foreach ($assignment in $apassignments1) {
      $apassignments2 += [PSCustomObject]@{
         Id = $assignment.Id
         ScheduleStartDateTime = $assignment.Schedule.StartDateTime -replace "\\/Date\((\d+)\)\\/", '$1' 
         AccessPackageId = $assignment.AccessPackage.Id
         AccessPackageDisplayName = $assignment.AccessPackage.DisplayName
         TargetId = $assignment.Target.Id
         TargetDisplayName = $assignment.Target.DisplayName
         TargetEmail = $assignment.Target.Email
         TargetObjectId = $assignment.Target.ObjectId
         TargetPrincipalName = $assignment.Target.PrincipalName
         TargetSubjectType = $assignment.Target.SubjectType
         SnapshotDate = $SnapshotDate
      }
   }
   $apassignments2 | ConvertTo-Json -Depth 10 | Set-Content "EntraAccessPackageAssignments.json"

5: Erstellen von Tabellen und Importieren von JSON-Dateien mit Daten aus Microsoft Entra ID Governance in Azure Data Explorer

In diesem Abschnitt werden die neu erstellten JSON-Dateien für die Microsoft Entra ID Governance-Dienste zusammen mit den bereits für die Microsoft Entra ID-Dienste importierten Daten zur weiteren Analyse in Azure Data Explorer importiert. Beim ersten Import mithilfe der Azure Data Explorer-Web-UI erstellen Sie Tabellen basierend auf dem Schema, das die Web-UI aus jeder JSON-Datei vorschlägt.

Navigieren Sie in Ihrem Azure Data Explorer-Cluster oder in Ihrem kostenlosen Cluster zu der Datenbank, die Ihre Microsoft Entra ID-Daten enthält.

Melden Sie sich bei der Azure Data Explorer-Webbenutzeroberfläche an.
Wählen Sie im Menü auf der linken Seite Abfrage aus.

Führen Sie als Nächstes für jede exportierte JSON-Datei aus dem vorherigen Abschnitt die folgenden Schritte aus, um Ihre exportierten Daten in diese Azure Data Explorer-Datenbank als neue Tabelle zu importieren.

Wählen Sie mit der rechten Maustaste den Datenbanknamen der Datenbank aus, in der Sie die Daten erfassen möchten. Wählen Sie Daten abrufen aus.
Wählen Sie die Datenquelle aus der verfügbaren Liste aus. In diesem Tutorial werden Daten aus einer lokalen Datei erfasst.
Wählen Sie + Neue Tabelle aus, und geben Sie basierend auf dem Namen der zu importierenden JSON-Datei einen Tabellennamen ein. Nach dem ersten Import ist die Tabelle bereits vorhanden, und Sie können diese als Zieltabelle für einen nachfolgenden Import auswählen.
Wählen Sie Nach Dateien durchsuchen aus. Wählen Sie die JSON-Datei aus, und wählen Sie Weiter aus.
Azure Data Explorer erkennt das Schema automatisch und stellt auf der Registerkarte Überprüfen eine Vorschau bereit. Wählen Sie Fertig stellen aus, um die Tabelle zu erstellen und die Daten aus dieser Datei zu importieren. Nach der Erfassung der Daten klicken Sie auf Schließen.
Wiederholen Sie alle vorherigen Schritte für jede der JSON-Dateien, die Sie im vorherigen Abschnitt generiert haben, für jeden der Ordner.
Wenn es viele Dateien in einem Ordner gibt, können Sie lightingest verwenden, um den Rest zu importieren, nachdem die Tabelle erstellt wurde.

Am Ende dieser Schritte befinden sich die Tabellen EntraAccessReviewDefinitions, EntraAccessPackagesund EntraAccessPackageAssignments, ReviewInstances, ReviewInstanceDecisionItems, ReviewInstanceContactedReviewers in der Datenbank sowie die tabellen, die in Abschnitt 3 erstellt wurden.

6: Verwenden von Azure Data Explorer zum Erstellen benutzerdefinierter Berichte

Da die Daten nun in Azure Data Explorer verfügbar sind, können Sie angepasste Berichte basierend auf Ihren Geschäftsanforderungen erstellen.

Azure Data Explorer ist ein leistungsstarkes Datenanalysetool, das hochgradig skalierbar und flexibel ist und eine ideale Umgebung zum Generieren benutzerdefinierter Berichte zum Benutzerzugriff bietet. Azure Data Explorer verwendet die Kusto-Abfragesprache (KQL).

Melden Sie sich bei der Azure Data Explorer-Webbenutzeroberfläche an.
Wählen Sie im Menü auf der linken Seite Abfrage aus.

Die folgenden Abfragen enthalten Beispiele für allgemeine Berichte. Sie können diese Berichte aber an Ihre Anforderungen anpassen und zusätzliche Berichte erstellen.

Sie können Ihre Berichte auch in Excel anzeigen, indem Sie die Registerkarte Exportieren und dann In Excelöffnen auswählen.

Beispiel 1: Generieren von App-Rollenzuweisungen für direkte und Gruppenzuweisungen für ein bestimmtes Momentaufnahmedatum

Dieser Bericht bietet eine Übersicht darüber, wer wann über welchen Zugriff auf die Ziel-App verfügte. Der Bericht kann für Sicherheitsprüfungen, Complianceüberprüfungen und das Verständnis von Zugriffsmustern innerhalb der Organisation verwendet werden.

Diese Abfrage zielt auf eine bestimmte Anwendung in Microsoft Entra ID ab und analysiert die Rollenzuweisungen ab einem bestimmten Datum. Die Abfrage ruft direkte und gruppenbasierte Rollenzuweisungen ab und führt diese Daten mit Benutzerdetails aus der Tabelle EntraUsers und Rolleninformationen aus der Tabelle AppRoles zusammen. Legen Sie in der folgenden Abfrage targetSnapshotDate auf den Wert snapshotDate fest, der beim Laden der Daten verwendet wurde.

/// Define constants 
let targetServicePrincipalId = "<your service principal-id>"; // Target Service Principal ID 
let targetSnapshotDate = datetime("2024-01-13"); // Target Snapshot Date for the data 

// Extract role assignments for the target Service Principal and Snapshot Date 
let roleAssignments = AppRoleAssignments 
    | where ResourceId == targetServicePrincipalId and startofday(SnapshotDate) == targetSnapshotDate 
    | extend AppRoleIdStr = tostring(AppRoleId); // Convert AppRoleId to string for easier comparison 

// Prepare user data from EntraUsers table 
let users = EntraUsers 
    | project ObjectID, UserPrincipalName, DisplayName, ObjectIDStr = tostring(ObjectID); // Include ObjectID as string for joining 

// Prepare role data from AppRoles table 
let roles = AppRoles 
    | mvexpand AppRoles // Expand AppRoles to handle multiple roles 
    | extend RoleName = AppRoles.DisplayName, RoleId = tostring(AppRoles.Id) // Extract Role Name and ID 
    | project RoleId, RoleName; 
// Process direct assignments 
let directAssignments = roleAssignments 
    | join kind=inner users on $left.PrincipalId == $right.ObjectID // Join with EntraUsers on PrincipalId 
    | join kind=inner roles on $left.AppRoleIdStr == $right.RoleId // Join with roles to get Role Names 
    | project UserPrincipalName, DisplayName, CreatedDateTime, RoleName, AssignmentType = "Direct", SnapshotDate; 

// Process group-based assignments 

let groupAssignments = roleAssignments 
    | join kind=inner EntraGroupMembership on $left.PrincipalId == $right.GroupId // Join with Group Membership 
    | mvexpand Members // Expand group members 
    | extend MembersStr = tostring(Members) // Convert member ID to string 
    | distinct MembersStr, CreatedDateTime, AppRoleIdStr, SnapshotDate // Get distinct values 
    | join kind=inner users on $left.MembersStr == $right.ObjectIDStr // Join with EntraUsers for user details 
    | join kind=inner roles on $left.AppRoleIdStr == $right.RoleId // Join with roles for role names 
    | project UserPrincipalName, DisplayName, CreatedDateTime, RoleName, AssignmentType = "Group", SnapshotDate; 

// Combine results from direct and group-based assignments 
directAssignments 
| union groupAssignments

Beispiel 2: Erstellen eines grundlegenden Prüferberichts mit Entra-Daten, die zeigen, wer zwischen diesen beiden Datumsangaben Zugriff auf eine App hatte

Dieser Bericht bietet eine Übersicht darüber, wer zwischen zwei Datumsangaben über welchen Zugriff auf die Ziel-App verfügte. Der Bericht kann für Sicherheitsprüfungen, Complianceüberprüfungen und das Verständnis von Zugriffsmustern innerhalb der Organisation verwendet werden.

Diese Abfrage zielt auf eine bestimmte Anwendung innerhalb von Microsoft Entra ID ab und analysiert die Rollenzuweisungen zwischen zwei Datumsangaben. Die Abfrage ruft direkte Rollenzuweisungen aus der Tabelle AppRoleAssignments ab und führt diese Daten mit Benutzerdetails aus der Tabelle EntraUsers und Rolleninformationen aus der Tabelle AppRoles zusammen.

// Set the date range and service principal ID for the query 
let startDate = datetime('2024-01-01'); 
let endDate = datetime('2024-03-14'); 
let servicePrincipalId = "<your service principal-id>"; 

// Query AppRoleAssignments for the specified service principal within the date range 
AppRoleAssignments 
| where ResourceId == servicePrincipalId and 
    todatetime(CreatedDateTime) between (startDate .. endDate) 

// Extend AppRoleId to a string for joining 
| extend AppRoleIdStr = tostring(AppRoleId) 

// Project the necessary fields for the join with EntraUsers and AppRoles 
| project PrincipalId, AppRoleIdStr, CreatedDateTime 

// Join with EntraUsers to get user details 
| join kind=inner (EntraUsers | project UserPrincipalName, DisplayName, ObjectID) on $left.PrincipalId == $right.ObjectID 

// Join with AppRoles to get the role display names 
| join kind=inner ( 
  AppRoles | mvexpand AppRoles | project RoleIdStr = tostring(AppRoles.Id), RoleDisplayName = tostring(AppRoles.DisplayName) 
) on $left.AppRoleIdStr == $right.RoleIdStr 

// Final projection of the report with the current date and time 
| project UserPrincipalName, DisplayName, RoleDisplayName, CreatedDateTime, ReportDate = now()

Beispiel 3: Abrufen der Benutzer, die einer App zwischen den Datenmomentaufnahmen an zwei bestimmten Tagen hinzugefügt wurden

Diese Berichte bieten eine Ansicht darüber, welche Benutzer zwischen zwei Datumsangaben eine App-Rollenzuweisung für die Zielanwendung erhalten haben. Diese Berichte können verwendet werden, um Änderungen beim App-Zugriff im Laufe der Zeit nachzuverfolgen.

Diese Abfrage zielt auf eine bestimmte Anwendung innerhalb von Microsoft Entra ID ab und analysiert die Änderungen bei Rollenzuweisungen zwischen einem Start- und einem Enddatum.

// Define the date range and service principal ID for the query 

let startDate = datetime("2024-03-01"); 
let endDate = datetime("2024-03-14"); 
let servicePrincipalId = "<your service principal-id>"; 
let earlierDate = startDate; // Update this to your specific earlier date 

AppRoleAssignments 
| where SnapshotDate < endDate and ResourceId == servicePrincipalId
| project PrincipalId, AppRoleId2 = tostring(AppRoleId), CreatedDateTime 
| join kind=anti ( 
    AppRoleAssignments 
    | where SnapshotDate < earlierDate and ResourceId == servicePrincipalId 
    | project PrincipalId, AppRoleId1 = tostring(AppRoleId) 
) on PrincipalId 
| join kind=inner (EntraUsers) on $left.PrincipalId == $right.ObjectID 
| join kind=inner (AppRoles 
                   | mvexpand AppRoles 
                   | project AppRoleId=tostring(AppRoles.Id), RoleDisplayName=tostring(AppRoles.DisplayName) 
                  ) on $left.AppRoleId2 == $right.AppRoleId 
| project UserPrincipalName, DisplayName, RoleDisplayName, CreatedDateTime, PrincipalId, Change = "Added"

Beispiel 4: Zugriffsüberprüfungen

Überprüfen der Informationen zu Abschluss und Zeitachse

Nachdem die Daten hochgeladen wurden, verwenden Sie die folgenden Kusto-Abfragen, um sie zu überprüfen.

Wann wurde der letzte Zugriffsüberprüfungszyklus abgeschlossen? Wie lange dauerte es?

ReviewInstances 
| summarize LastCompletedDate = max(ReviewInstanceEndDateTime),  
            ReviewDuration = datetime_diff('minute', max(ReviewInstanceEndDateTime), min(ReviewInstanceStartDateTime))

Wird der Prozess der Zugriffsüberprüfung rechtzeitig durchgeführt (z. B. vierteljährlich, jährlich)?

ReviewInstances 
| extend ExpectedFrequency = "Quarterly" // Replace with organization's frequency 
| summarize ReviewsCompleted = count(), LastReviewEndDate = max(ReviewInstanceEndDateTime) 
| extend CurrentDate = now(),  
         TimeSinceLastReview = datetime_diff('day', now(), LastReviewEndDate) 
| extend IsOnSchedule = iff(TimeSinceLastReview <= 90, "Yes", "No") // Assuming quarterly = 90 days

Überprüfen von Teilnahme und Beteiligung

Wem wurden die Prüfer zugewiesen?

ReviewInstanceContactedReviewers 
| project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerName = DisplayName, ReviewerUserPrincipalName = UserPrincipalName, CreatedDateTime

Welche Prüfer nahmen aktiv teil und lieferten Antworten?

ReviewInstanceDecisionItems 
| where ReviewedBy_DisplayName != "AAD Access Reviews" 
| where Decision in ("Approve", "Deny") 
| project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerName = ReviewedBy_DisplayName, 
ReviewerUserPrincipalName = ReviewedBy_UserPrincipalName, Decision, ReviewedDateTime 
| distinct AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerName, ReviewerUserPrincipalName, Decision

Prozentsatz der Prüfer, die auf die Zugriffsüberprüfungsanforderung geantwortet haben.

let TotalReviewers = ReviewInstanceContactedReviewers 
    | summarize Total = dcount(Id) by AccessReviewDefinitionId, AccessReviewInstanceId;  

let RespondedReviewers = ReviewInstanceDecisionItems 
    | where ReviewedBy_DisplayName != "AAD Access Reviews" 
    | where ReviewedBy_Id != "00000000-0000-0000-0000-000000000000" 
    | where Decision in ("Approve", "Deny") 
    | summarize Responded = dcount(ReviewedBy_Id) by AccessReviewDefinitionId, AccessReviewInstanceId;  

TotalReviewers 
| join kind=leftouter RespondedReviewers on AccessReviewDefinitionId, AccessReviewInstanceId 
| extend Responded = coalesce(Responded, 0)  // Replace null with 0 for Responded 
| extend NotResponded = Total - Responded   // Calculate the number of non-responders 
| extend ResponsePercentage = (Responded * 100.0) / Total  // Percentage of those who responded 
| extend NonResponsePercentage = (NotResponded * 100.0) / Total  // Percentage of those who didn’t respond 
| project AccessReviewDefinitionId, AccessReviewInstanceId, Total, Responded, ResponsePercentage, NotResponded, NonResponsePercentage

Wann hat jeder Prüfer seine Aufgaben abgeschlossen?

ReviewInstanceDecisionItems 
| where Decision in ("Approve", "Deny") 
| project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerName = ReviewedBy_DisplayName, ReviewerUserPrincipalName = ReviewedBy_UserPrincipalName, ReviewedDateTime

Welche Prüfer haben keine Entscheidungen getroffen?

let AllReviewers = ReviewInstanceContactedReviewers 
    | project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerId = Id, ReviewerUserPrincipalName = UserPrincipalName, ReviewerName = DisplayName; 
  
let ActiveReviewers = ReviewInstanceDecisionItems 
    | where Decision in ("Approve", "Deny") 
    | where ReviewedBy_DisplayName != "AAD Access Reviews" 
    | where ReviewedBy_Id != "00000000-0000-0000-0000-000000000000" 
    | summarize ActiveReviewers = make_set(ReviewedBy_Id) by AccessReviewDefinitionId, AccessReviewInstanceId; 

AllReviewers 
| extend ReviewerId = tostring(ReviewerId)  // Ensure ReviewerId is a string 
| join kind=leftanti ( 
    ActiveReviewers 
    | mv-expand ActiveReviewers 
    | extend ActiveReviewers = tostring(ActiveReviewers)  // Cast ActiveReviewers to a string 
) on $left.ReviewerId == $right.ActiveReviewers 
| project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerUserPrincipalName, ReviewerName

Prozentsatz der Prüfer, die nicht interagiert haben.

let TotalReviewers = ReviewInstanceContactedReviewers 
    | summarize Total = dcount(Id) by AccessReviewDefinitionId, AccessReviewInstanceId; 

let RespondedReviewers = ReviewInstanceDecisionItems 
    | where ReviewedBy_DisplayName != "AAD Access Reviews" 
    | where ReviewedBy_Id != "00000000-0000-0000-0000-000000000000" 
    | where Decision in ("Approve", "Deny") 
    | summarize Responded = dcount(ReviewedBy_Id) by AccessReviewDefinitionId, AccessReviewInstanceId; 
  
TotalReviewers 
| join kind=leftouter RespondedReviewers on AccessReviewDefinitionId, AccessReviewInstanceId 
| extend Responded = coalesce(Responded, 0)  // Replace null with 0 for Responded 
| extend NotResponded = Total - Responded   // Calculate the number of non-responders 
| extend ResponsePercentage = (Responded * 100.0) / Total  // Percentage of those who responded 
| extend NonResponsePercentage = (NotResponded * 100.0) / Total  // Percentage of those who didn’t respond 
| project AccessReviewDefinitionId, AccessReviewInstanceId, Total, Responded, ResponsePercentage, NotResponded, NonResponsePercentage

Wurden Erinnerungen an nicht antwortende Bewerter gesendet? Ausstehende Entscheidungen?

// Step 1: Get the list of all reviewers 
let TotalReviewers = ReviewInstanceContactedReviewers 
    | project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerId = Id, ReviewerUserPrincipalName = UserPrincipalName, ReviewerName = DisplayName; 
 
// Step 2: Get the list of reviewers who have responded 
let RespondedReviewers = ReviewInstanceDecisionItems 
    | where ReviewedBy_DisplayName != "AAD Access Reviews" 
    | where ReviewedBy_Id != "00000000-0000-0000-0000-000000000000" 
    | where Decision in ("Approve", "Deny") 
    | project AccessReviewDefinitionId, AccessReviewInstanceId, RespondedReviewerId = ReviewedBy_Id; 

// Step 3: Get the list of review instances 
let ReviewInstancesWithDetails = ReviewInstances 
    | project AccessReviewDefinitionId = ReviewDefinitionId,  
              AccessReviewInstanceId = ReviewInstanceId,  
              RemindersSent = ReviewDefinitionSettings_ReminderNotificationsEnabled,  
              StartDate = todatetime(ReviewInstanceStartDateTime),  
              EndDate = todatetime(ReviewInstanceEndDateTime) 
    | extend 
              ReminderSentDate = iif(RemindersSent, StartDate + (EndDate - StartDate) / 2, datetime(null)); 

// Step 4: Identify non-responsive reviewers and join with review instance details 
TotalReviewers 
| join kind=leftouter (ReviewInstancesWithDetails) on AccessReviewDefinitionId, AccessReviewInstanceId 
| join kind=leftanti RespondedReviewers on $left.ReviewerId == $right.RespondedReviewerId 
| project AccessReviewDefinitionId, AccessReviewInstanceId, ReviewerUserPrincipalName, ReviewerName, RemindersSent, ReminderSentDate

Änderungen des Zugriffs für Benutzer &

Wer hat während der Zugriffsüberprüfung zugriff auf bestimmte Ressourcen verloren?

ReviewInstanceDecisionItems 
| where Decision == "Deny" 
| project User = Principal_DisplayName, Resource = Resource_DisplayName, Decision, Justification

Wurden Benutzer aufgrund von Inaktivität gekennzeichnet?

ReviewInstanceDecisionItems 
| where Insights contains "inactive" 
| project User = Principal_DisplayName, Resource = Resource_DisplayName, Insights, Decision

Zugriffsentfernungsdatum und Gründe für den Verlust des Zugriffs.

ReviewInstanceDecisionItems 
| where Decision == "Deny" 
| project User = Principal_DisplayName, Resource=Resource_DisplayName, AccessRemovalDate = AppliedDateTime, Reason = Justification

Benutzer ohne getroffene Entscheidungen.

ReviewInstanceDecisionItems 
| where Decision == "NotReviewed" 
| project User = Principal_DisplayName, Resource=Resource_DisplayName

Rezensionen ohne Bearbeiter.

ReviewInstances 
| join kind=leftanti ( 
    ReviewInstanceContactedReviewers 
    | summarize by AccessReviewInstanceId 
) on $left.ReviewInstanceId == $right.AccessReviewInstanceId

Bewertungen ohne Benutzer.

ReviewInstances 
| join kind=leftanti ( 
    ReviewInstanceDecisionItems 
    | summarize by AccessReviewInstanceId 
) on $left.ReviewInstanceId == $right.AccessReviewInstanceId

Überprüfen von Entscheidungsdaten

Getroffene Entscheidungen: Genehmigt, abgelehnt oder unverändert.

ReviewInstanceDecisionItems 
| summarize count() by Decision

Die Anzahl der Benutzer, denen der Zugriff genehmigt oder verweigert wurde.

ReviewInstanceDecisionItems 
| summarize ApprovedCount = countif(Decision == "Approve"), DeniedCount = countif(Decision == "Deny")

Wurden Genehmigungsgründe dokumentiert?

ReviewInstanceDecisionItems 
| where Decision == "Approve" and isnotempty(Justification) 
| summarize count() by ReviewedBy_DisplayName

Qualität der Zugriffsüberprüfung und Complianceprüfungen

Wurden Zugriffssperren für ruhende Benutzer in Betracht gezogen?

ReviewInstanceDecisionItems 
| where Insights contains "inactive" and Decision == "Deny" 
| project User = Principal_DisplayName, Decision

Wurde ein Zugriff nicht ordnungsgemäß entfernt?

ReviewInstanceDecisionItems 
| where ApplyResult != "New" and ApplyResult != "AppliedSuccessfully"

Haben Prüfer ihre Entscheidungen dokumentiert?

ReviewInstanceDecisionItems 
| where isnotempty(Justification) 
| summarize count() by ReviewedBy_DisplayName

Wurden Kommentare für jeden Benutzer erfasst?

ReviewInstanceDecisionItems 
| where isnotempty(Justification) 
| project User = Principal_DisplayName, Resource = Resource_DisplayName, Comments = Justification

Einrichten laufender Importe

In diesem Tutorial wird ein einmaliger Prozess zur Datenextraktion, -transformation und -ladung (ETL) veranschaulicht, um Azure Data Explorer mit einer einzelnen Momentaufnahme für Berichtszwecke zu befüllen. Für laufende Berichte oder Vergleiche der Änderungen im Laufe der Zeit können Sie den Prozess der Auffüllung von Azure Data Explorer aus Microsoft Entra automatisieren, damit Ihre Datenbank weiterhin aktuelle Daten enthält.

Sie können den Azure-Clouddienst Azure Automation verwenden, um die PowerShell-Skripts zu hosten, die zum Extrahieren von Daten aus Microsoft Entra ID und Microsoft Entra ID Governance erforderlich sind. Weitere Informationen finden Sie unter Automatisieren von Microsoft Entra ID Governance-Aufgaben mit Azure Automation.

Sie können außerdem Azure-Features oder Befehlszeilentools wie lightingest verwenden, um Daten zu erfassen und eine bereits vorhandene Tabelle aufzufüllen. Weitere Informationen finden Sie unter Verwenden von LightIngest zum Erfassen von Daten in Azure Data Explorer.

So laden Sie beispielsweise eine Datei EntraAccessPackages.json im aktuellen Verzeichnis in der Tabelle EntraAccessPackages als aktuell angemeldete benutzende Person:

az login
LightIngest.exe "https://ingest-CLUSTERHOSTNAME;Fed=True" -database:"DATABASE" -table:EntraAccessPackages -sourcepath:"." -pattern:"EntraAccessPackages.json" -format:multijson -azcli:true

Abfragen von Daten in Azure Monitor

Wenn Sie Prüf-, Anmelde- oder andere Microsoft Entra-Protokolle an Azure Monitor senden, können Sie diese Protokolle aus dem Log Analytics-Arbeitsbereich von Azure Monitor in Ihre Abfragen integrieren. Weitere Informationen zur Beziehung von Azure Monitor und Azure Data Explorer finden Sie unter Abfragedaten in Azure Monitor mithilfe von Azure Data Explorer.

Melden Sie sich beim Microsoft Entra Admin Center an.
Wählen Sie Diagnoseeinstellungen aus.
Wählen Sie den Log Analytics-Arbeitsplatz aus, an dem Sie Ihre Protokolle senden.
Notieren Sie sich in der Übersicht über den Log Analytics-Arbeitsbereich die Abonnement-ID, den Ressourcengruppennamen und den Arbeitsbereichsnamen des Arbeitsbereichs.
Melden Sie sich beim Azure-Portal an.
Navigieren Sie zur Azure Data Explorer-Webbenutzeroberfläche.
Stellen Sie sicher, dass Ihr Azure Data Explorer-Cluster aufgelistet ist.
Wählen Sie + Hinzufügen und anschließend Verbindung aus.
Geben Sie im Fenster Verbindung hinzufügen die URL zum Log Analytics-Arbeitsbereich ein, die aus dem cloudspezifischen Hostnamen, der Abonnement-ID, dem Ressourcengruppennamen und dem Arbeitsbereichsnamen des Azure Monitor Log Analytics-Arbeitsbereichs gebildet wurde. Eine Beschreibung dieses Schritts finden Sie unter Hinzufügen eines Log Analytics-Arbeitsbereichs.
Nachdem die Verbindung hergestellt wurde, wird Ihr Log Analytics-Arbeitsbereich im linken Bereich mit Ihrem systemeigenen Azure Data Explorer-Cluster angezeigt.
Wählen Sie im linken Menü Abfrage aus, und wählen Sie Ihren Azure Data Explorer-Cluster aus.

Anschließend können Sie im Abfragebereich auf die Azure Monitor-Tabellen verweisen, die die Microsoft Entra-Protokolle in Ihren Azure Data Explorer-Abfragen enthalten. Beispiel:

let CL1 = 'https://ade.loganalytics.io/subscriptions/*subscriptionid*/resourcegroups/*resourcegroupname*/providers/microsoft.operationalinsights/workspaces/*workspacename*';
cluster(CL1).database('*workspacename*').AuditLogs | where Category == "EntitlementManagement"  and OperationName == "Fulfill access package assignment request"
| mv-expand TargetResources | where TargetResources.type == 'AccessPackage' | project ActivityDateTime,APID = toguid(TargetResources.id)
| join EntraAccessPackage on $left.APID == $right.Id
| limit 100

Einbinden von Daten aus weiteren Quellen

Sie können auch zusätzliche Tabellen in Azure Data Explorer erstellen, um Daten aus anderen Quellen zu importieren. Wenn sich die Daten ähnlich wie in den obigen Beispielen in einer JSON-Datei oder einer CSV-Datei befinden, können Sie die Tabelle zum Zeitpunkt des ersten Abrufens von Daten aus der Datei erstellen. Sobald eine Tabelle erstellt wurde, können Sie auch LightIngest verwenden, um Daten aus einer JSON- oder CSV-Datei in Azure Data Explorer aufzunehmen.

Weitere Informationen zur Datenerfassung finden Sie in der Übersicht über die Datenerfassung in Azure Data Explorer.

Beispiel 5: Kombinieren von App-Zuweisungen aus einer Entra-Quelle und einer zweiten Quelle zum Erstellen eines Berichts aller Benutzer, die Zugriff auf eine Anwendung zwischen zwei Datumsangaben hatten

In diesem Bericht wird veranschaulicht, wie Sie Daten aus zwei separaten Systemen kombinieren können, um in Azure Data Explorer benutzerdefinierte Berichte zu erstellen. Er aggregiert Daten zu Benutzern, ihren Rollen und anderen Attributen aus zwei Systemen in einem einheitlichen Format zur Analyse oder Berichterstellung.

In diesem Beispiel wird davon ausgegangen, dass es eine Tabelle mit dem Namen salesforceAssignments mit Spalten UserName, Name, EmployeeId, Department, JobTitle, AppName, Roleund CreatedDateTime gibt, die durch Das Einblenden von Daten aus einer anderen Anwendung aufgefüllt wurde.

// Define the date range and service principal ID for the query 

let startDate = datetime("2023-06-01"); 
let endDate = datetime("2024-03-13"); 
let servicePrincipalId = "<your service principal-id>"; 

// Pre-process AppRoleAssignments with specific filters and projections 
let processedAppRoleAssignments = AppRoleAssignments 
    | where ResourceId == servicePrincipalId and todatetime(CreatedDateTime) between (startDate .. endDate) 
    | extend AppRoleId = tostring(AppRoleId) 
    | project PrincipalId, AppRoleId, CreatedDateTime, ResourceDisplayName; // Exclude DeletedDateTime and keep ResourceDisplayName 

// Pre-process AppRoles to get RoleDisplayName for each role 
let processedAppRoles = AppRoles 
    | mvexpand AppRoles 
    | project AppRoleId = tostring(AppRoles.Id), RoleDisplayName = tostring(AppRoles.DisplayName); 

// Main query: Process EntraUsers by joining with processed role assignments and roles 
EntraUsers 
    | join kind=inner processedAppRoleAssignments on $left.ObjectID == $right.PrincipalId // Join with role assignments 
    | join kind=inner processedAppRoles on $left.AppRoleId == $right.AppRoleId // Join with roles to get display names 

    // Summarize to get the latest record for each unique combination of user and role attributes 
    | summarize arg_max(AccountEnabled, *) by UserPrincipalName, DisplayName, tostring(EmployeeId), Department, JobTitle, ResourceDisplayName, RoleDisplayName, CreatedDateTime 

    // Final projection of relevant fields including source indicator and report date 
    | project UserPrincipalName, DisplayName, EmployeeId=tostring(EmployeeId), Department, JobTitle, AccountEnabled=tostring(AccountEnabled), ResourceDisplayName, RoleDisplayName, CreatedDateTime, Source="EntraUsers", ReportDate = now() 

// Union with processed salesforceAssignments to create a combined report 
| union ( 
    salesforceAssignments 

    // Project fields from salesforceAssignments to align with the EntraUsers data structure 
    | project UserPrincipalName = UserName, DisplayName = Name, EmployeeId = tostring(EmployeeId), Department, JobTitle, AccountEnabled = "N/A", ResourceDisplayName = AppName, RoleDisplayName = Role, CreatedDateTime, Source = "salesforceAssignments", ReportDate = now() 
)

Teilen über