Tutorial: Benutzerdefinierte Berichte in Azure Data Explorer (ADX) mithilfe von Daten aus Microsoft Entra ID

Artikel
05/29/2024

In diesem Tutorial wird beschrieben, wie Sie benutzerdefinierte Berichte in Azure Data Explorer (ADX) mithilfe von Daten aus Microsoft Entra ID erstellen. Dieses Tutorial ergänzt weitere Berichtsoptionen wie die Methode Archivieren und Berichterstellung mit Azure Monitor und Berechtigungsverwaltung, die sich auf das Exportieren von Überwachungsprotokolldaten für längere Aufbewahrung und Analyse konzentriert. Im Vergleich dazu bietet das Exportieren von Microsoft Entra ID-Daten nach Azure Data Explorer eine größere Flexibilität beim Erstellen benutzerdefinierter Berichte, indem die Datenaggregation aus mehreren Quellen mit massiver Skalierbarkeit ermöglicht wird. Außerdem werden flexible Schema- und Aufbewahrungsrichtlinien unterstützt.

In diesem Bericht wird veranschaulicht, wie Konfigurationen, Benutzer und Zugriffsrechte angezeigt werden, die aus Microsoft Entra exportiert wurden, zusammen mit Daten, die aus anderen Quellen exportiert wurden, z. B. Anwendungen mit SQL-Datenbanken. Anschließend können Sie Kusto Query Language (KQL) verwenden, um benutzerdefinierte Berichte basierend auf den Anforderungen Ihrer Organisation zu erstellen. Das Generieren dieser Berichtstypen in Azure Data Explorer kann besonders hilfreich sein, wenn Sie Zugriffsdaten für längere Zeiträume aufbewahren, Ad-hoc-Untersuchungen durchführen oder benutzerdefinierte Abfragen für Benutzerzugriffsdaten ausführen müssen.

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

Richten Sie Azure Data Explorer in einem Azure-Abonnement ein.
Extrahieren Sie Daten aus Microsoft Entra und Datenbanken und Anwendungen von Drittanbietern mithilfe von PowerShell-Skripts und MS Graph.
Importieren Sie die Daten in Azure Data Explorer, einen schnellen und skalierbaren Datenanalysedienst.
Erstellen Sie eine benutzerdefinierte Abfrage mithilfe von Kusto Query Language.

Am Ende dieses Tutorials werden Sie in der Lage sein, mit von Microsoft unterstützten Tools benutzerdefinierte Ansichten der Zugriffsrechte und Berechtigungen von Benutzern in verschiedenen Anwendungen zu entwickeln.

Voraussetzungen

Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen verfügen. Sie benötigen die richtigen Berechtigungen zum Exportieren der Entra-Datentypen, mit denen Sie arbeiten möchten, und Berechtigungen zum Speichern exportierter JSON-Dateien.
- 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
PowerShell muss folgende Berechtigungen zulassen: User.Read.All, Group.Read.All, Application.Read.All, Directory.Read.All. Weitere Informationen finden Sie in der Referenz zu den Microsoft Graph-Berechtigungen.
Stellen Sie sicher, dass Sie Schreibzugriff auf das Verzeichnis haben, in dem Sie die erforderlichen MS Graph PowerShell-Module installieren und in dem die exportierten Entra-Daten gespeichert werden.
Bestimmen Sie, welche Daten in Ihre Berichte aufgenommen werden sollen. Die Skripts in diesem Artikel enthalten Beispiele mit spezifischen Daten von Benutzern, Gruppen und Anwendungen aus 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.

Schritt 1: Einrichten von Azure Data Explorer

Wenn Sie Azure Data Explorer noch nicht verwendet haben, müssen Sie ihn 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.

Schritt 2: Herstellen einer Verbindung mit MS Graph und Extrahieren von Entra-Daten mit PowerShell

Installieren Sie MS Graph PowerShell-Module, und stellen Sie eine Verbindung mit MS Graph her.

Installieren Sie die erforderlichen MS Graph-Module. Für dieses Tutorial sind die folgenden Module erforderlich: Microsoft.Graph.Users, Microsoft.Graph.Groups, Microsoft.Graph.Applications, Microsoft.Graph.DirectoryObjects

   $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:

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

Herstellen einer Verbindung mit Microsoft Graph

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

Mit diesem Befehl werden Sie aufgefordert, sich mit Ihren MS Graph-Anmeldeinformationen anzumelden. Wählen Sie die erforderlichen Berechtigungen aus: Nach der Anmeldung müssen Sie möglicherweise den erforderlichen Berechtigungen zustimmen, wenn Sie zum ersten Mal eine Verbindung herstellen oder wenn neue Berechtigungen erforderlich sind.

PowerShell-Abfragen zum Extrahieren von Daten, die zum Erstellen benutzerdefinierter Berichte in ADX erforderlich sind

Mit den folgenden Abfragen werden Entra-Daten mithilfe von PowerShell aus MS Graph extrahiert und in JSON-Dateien exportiert, die in Schritt 3 in Azure Data Explorer importiert werden. Es kann mehrere Szenarien zum Generieren von Berichten mit dieser Art von Daten geben:

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.
Ein Administrator möchte alle Benutzer anzeigen, die einer Anwendung von Microsoft Entra ID und SQL-Datenbanken hinzugefügt wurden.

Diese Berichtstypen sind nicht in Microsoft Entra ID integriert, aber Sie können diese Berichte selbst erstellen, indem Sie Daten aus Entra extrahieren und mit benutzerdefinierten Abfragen in Azure Data Explorer kombinieren.

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

Benutzerinformationen wie Anzeigename, UPN und Auftragsdetails
Gruppeninformationen
Anwendungs- und Rollenzuweisungen

Mit diesem Dataset können wir zahlreiche Abfragen ausführen, um festzustellen, wer Zugriff auf eine Anwendung erhalten hat. Außerdem können Rolleninformationen und der jeweilige Zeitrahmen abgerufen werden. 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 MS Graph-Modul behandelt werden.

In diesen PowerShell-Skripts exportieren wir ausgewählte Eigenschaften aus den Entra-Objekten in JSON-Dateien. Die Daten aus diesen exportierten Eigenschaften werden dann verwendet, um benutzerdefinierte Berichte in Azure Data Explorer zu generieren. Die unten aufgeführten spezifischen Eigenschaften waren in diesen Beispielen enthalten, da wir diese Daten verwenden, um die Berichtstypen zu veranschaulichen, die Sie in Azure Data Explorer erstellen können. Ihre spezifischen Berichterstellungsanforderungen weichen wahrscheinlich von den unten gezeigten Angaben ab. Deshalb sollten Sie die Eigenschaften in diese Skripts einschließen, die Sie in Ihren Berichten anzeigen möchten. Sie können jedoch dem unten gezeigten Muster folgen, um Ihre Skripts zu erstellen.

Darüber hinaus haben wir unten ein hartcodiertes Momentaufnahmedatum eingeschlossen, das die Daten in der JSON-Datei mit einem bestimmten Datum identifiziert. Damit können wir ähnliche Datasets im Laufe der Zeit in Azure Data Explorer nachverfolgen. Mithilfe des Momentaufnahmedatums können auch Änderungen der Daten zwischen zwei Momentaufnahmen mit jeweils unterschiedlichem Datum verglichen werden.

Abrufen von Entra-Benutzerdaten

Dieses Skript exportiert ausgewählte Eigenschaften aus dem Entra-Benutzerobjekt in eine JSON-Datei. Wir importieren diese Daten in Schritt 3 in Azure Data Explorer.

  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"] = "2024-01-11" 
      [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 zum Erstellen benutzerdefinierter Ansichten in ADX verwendet werden. Das Beispiel enthält alle Gruppen, aber bei Bedarf können 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 Daten zur Gruppenmitgliedschaft, die zum Erstellen benutzerdefinierter Ansichten in ADX verwendet 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 
      } 
      # 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 importieren diese Daten in Schritt 3 in ADX, wodurch wir benutzerdefinierte Berichte für Anwendungen basierend auf diesen Daten generieren können.

    # 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 
      } 
    } | ConvertTo-Json -Depth 10 | Set-Content "Applications.json"

Abrufen von AppRole-Daten

Generieren Sie eine JSON-Datei aller App-Rollen (AppRoles) für Unternehmens-Apps in Entra. Nach dem Import in ADX verwenden wir diese Daten, 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 
      } 
    } 
    # 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 aller App-Rollenzuweisungen 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     = "2024-03-13" # Hard-coded date 
        } 
      } 
    } 
    $result | ConvertTo-Json -Depth 10 | Out-File "AppRoleAssignments.json"

Schritt 3: Importieren der JSON-Dateidaten in Azure Data Explorer

In Schritt 3 importieren wir die neu erstellten JSON-Dateien zur weiteren Analyse. Wenn Sie Azure Data Explorer noch nicht eingerichtet haben, lesen Sie die Informationen in Schritt 1 weiter oben.

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

Nachdem Sie eine Datenbank eingerichtet haben, führen Sie die folgenden Schritte aus, um Ihre exportierten Daten in ADX abzurufen.

Klicken Sie mit der rechten Maustaste auf den Datenbanknamen, und wählen Sie Daten abrufen aus.
Wählen Sie Neue Tabelle aus, und geben Sie den Namen der zu importierenden JSON-Datei ein. Wenn Sie z. B. „EntraUsers.json“ importieren, nennen Sie die Tabelle EntraUsers. Nach dem ersten Import ist die Tabelle bereits vorhanden, und Sie können sie als Zieltabelle für den Import auswählen.
Wählen Sie die JSON-Datei aus.
ADX erkennt das Schema automatisch und stellt eine Vorschau bereit. Klicken Sie auf Fertigstellen, um die Tabelle zu erstellen und die Daten zu importieren.
Führen Sie die Schritte 1 bis 4 für jede der JSON-Dateien aus, die Sie in Schritt 1 generiert haben.

Schritt 4: Verwenden von ADX zum Erstellen benutzerdefinierter Berichte

Nachdem die Daten jetzt in ADX verfügbar sind, können Sie mit dem Erstellen benutzerdefinierter Berichte basierend auf Ihren Geschäftsanforderungen beginnen. Die folgenden Abfragen enthalten Beispiele für allgemeine Berichte. Sie können diese Berichte aber an Ihre Anforderungen anpassen und zusätzliche Berichte erstellen.

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 innerhalb von Entra ID ab und analysiert die Rollenzuweisungen ab einem bestimmten Datum. Die Abfrage ruft sowohl direkte als auch gruppenbasierte Rollenzuweisungen ab. Diese Daten werden mit Benutzerdetails aus der Tabelle „EntraUsers“ und Rolleninformationen aus der Tabelle „AppRoles“ zusammengeführt.

/// 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. Diese Daten werden mit Benutzerdetails aus der Tabelle „EntraUsers“ und Rolleninformationen aus der Tabelle „AppRoles“ zusammengeführt.

// 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: Kombinieren von App-Zuweisungen aus einer Entra- und einer zweiten Quelle (z. B. SQL-Export), um einen Bericht aller Benutzer (Entra-Zuweisungen und lokale Zuweisungen) zu erstellen, die zwischen zwei Datumsangaben Zugriff auf Salesforce hatten

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

// 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() 
)

Nächste Schritte

Was ist Microsoft Entra-Berechtigungsverwaltung?

Freigeben über