Esercitazione: Report personalizzati in Azure Data Explorer usando i dati di Microsoft Entra

Questa esercitazione illustra come creare report personalizzati in azure Data Explorer (ADX) usando i dati di Microsoft Entra ID e i servizi di governance di Microsoft Entra ID. Questa guida integra altre opzioni di creazione di rapporti, ad esempio il archivio & rapporti con Monitoraggio di Azure e la gestione dei diritti, che si concentra sull'esportazione del registro di controllo in Monitoraggio di Azure per la conservazione e l'analisi. Per confronto, l'esportazione dei dati di Microsoft Entra ID in Esplora dati di Azure offre flessibilità per la creazione di report personalizzati sugli oggetti Microsoft Entra, inclusi gli oggetti cronologici ed eliminati. Inoltre, l'uso di Esplora dati di Azure consente l'aggregazione dei dati da origini aggiuntive, con scalabilità elevata, schema flessibile e criteri di conservazione. Esplora dati di Azure è particolarmente utile quando è necessario conservare i dati di accesso per anni, eseguire indagini ad hoc o eseguire query personalizzate sui dati di accesso utente.

Questo articolo illustra come mostrare la configurazione, gli utenti e i diritti di accesso esportati da Microsoft Entra insieme ai dati esportati da altre origini, ad esempio le applicazioni con diritti di accesso nei propri database SQL. È quindi possibile usare il linguaggio di query Kusto (KQL) in Esplora dati di Azure per creare report personalizzati in base ai requisiti dell'organizzazione.

Per creare questi report, seguire questa procedura:

1. Configurare Azure Data Explorer in una sottoscrizione di Azure, oppure creare un cluster gratuito.
2. Estrarre dati da Microsoft Entra ID usando script di PowerShell e Microsoft Graph.
3. Creare tabelle e importare i dati da Microsoft Entra ID in Azure Data Explorer.
4. Estrarre dati da Microsoft Entra ID Governance.
5. Creare tabelle e importare tali dati da Microsoft Entra ID Governance in Azure Data Explorer.
6. Creare una query personalizzata usando Linguaggio di query Kusto.

Al termine di questa esercitazione, sarà possibile sviluppare visualizzazioni personalizzate dei diritti di accesso e delle autorizzazioni degli utenti. Queste visualizzazioni si estendono su applicazioni diverse usando gli strumenti supportati da Microsoft. È anche possibile inserire dati da database o applicazioni di terze parti per segnalare tali dati.

Prerequisiti

Se non si ha familiarità con Esplora dati di Azure e si vuole apprendere gli scenari illustrati in questo articolo, è possibile ottenere un cluster di Esplora dati di Azure gratuito . Per l'uso in produzione supportato con un contratto di servizio per Esplora dati di Azure, è necessario un abbonamento Azure per ospitare un cluster completo di Esplora dati di Azure.

Determinare i dati da includere nei report. Gli script di questo articolo forniscono esempi con dati specifici di utenti, gruppi e applicazioni di Microsoft Entra. Questi esempi sono destinati a illustrare i tipi di report che è possibile generare con questo approccio, ma le esigenze di creazione di report specifiche possono variare e richiedere dati diversi o aggiuntivi. È possibile iniziare con questi oggetti e inserire più tipi di oggetti Microsoft Entra nel tempo.

• Questo articolo illustra il recupero di dati da Microsoft Entra come utente connesso. A tale scopo, assicurarsi di disporre delle assegnazioni di ruolo necessarie per recuperare i dati da Microsoft Entra. Sono necessari i ruoli con le autorizzazioni appropriate per esportare il tipo di dati di Microsoft Entra con cui si vuole lavorare.
  • Dati utente: Amministratore globale, Amministratore ruolo con privilegi, Amministratore utenti
  • Dati dei gruppi: Amministratore globale, Amministratore ruolo con privilegi, Amministratore gruppo
  • Applicazioni/Assegnazioni di ruolo app: Amministratore globale, Amministratore ruolo con privilegi, Amministratore applicazioni, Amministratore applicazioni cloud
• Microsoft Graph PowerShell deve essere autorizzato a consentire il recupero di oggetti Microsoft Entra tramite Microsoft Graph. Gli esempi di questa esercitazione richiedono le autorizzazioni Delegated User.Read.All, Group.Read.All, Application.Read.All e Directory.Read.All. Se si prevede di recuperare dati usando l'automazione senza un utente connesso, fornire invece il consenso alle autorizzazioni dell'applicazione corrispondenti. Per altre informazioni, vedere Informazioni di riferimento sulle autorizzazioni di Microsoft Graph. Se Microsoft Graph PowerShell non è già stato acconsentito a tali autorizzazioni, è necessario essere un amministratore globale per eseguire questa operazione di consenso.
• Questa esercitazione non illustra gli attributi di sicurezza personalizzati. Per impostazione predefinita, l'amministratore globale e altri ruoli di amministratore non includono le autorizzazioni per leggere gli attributi di sicurezza personalizzati dagli utenti di Microsoft Entra. Se si prevede di recuperare attributi di sicurezza personalizzati, potrebbero essere necessari altri ruoli e autorizzazioni.
• Sul computer in cui è installato Microsoft Graph PowerShell, assicurati di avere accesso in scrittura alla directory del file system. In questo caso si installano i moduli di PowerShell di Microsoft Graph necessari e in cui vengono salvati i dati di Microsoft Entra esportati.
• Assicurarsi di disporre delle autorizzazioni necessarie per recuperare i dati da altre origini dati oltre a Microsoft Entra, se si desidera incorporare tali dati anche in Esplora dati di Azure.

1: Configurare Azure Data Explorer

Se non hai usato Esplora dati di Azure in precedenza, devi configurarlo prima. È possibile creare un cluster gratuito senza una sottoscrizione di Azure o una carta di credito o un cluster completo che richiede una sottoscrizione di Azure. Per iniziare, vedere Avvio rapido: Creare un cluster e un database di Azure Esplora dati.

2: Estrarre i dati di Microsoft Entra ID con PowerShell

In questa sezione è installare i moduli di PowerShell di Microsoft Graph e, in PowerShell, connettersi a Microsoft Graph per estrarre i dati di Microsoft Entra ID.

La prima volta che l'organizzazione usa questi moduli per questo scenario, è necessario trovarsi in un ruolo di amministratore globale per consentire a Microsoft Graph PowerShell di concedere il consenso per l'uso nel tenant. Le interazioni successive possono usare un ruolo con privilegi inferiori.

1. Aprire PowerShell.
2. Se non si dispone di tutti i moduli di PowerShell di Microsoft Graph già installati, installare i moduli di Microsoft Graph necessari. Per questa sezione dell'esercitazione sono necessari i moduli seguenti: Microsoft.Graph.Authentication, Microsoft.Graph.Users, Microsoft.Graph.Groups, Microsoft.Graph.Applications, Microsoft.Graph.DirectoryObjects. Se questi moduli sono già installati, continuare con il passaggio successivo.

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

2. Importare i moduli nella sessione di PowerShell corrente.

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

3. Connettersi a Microsoft Graph. Questa sezione dell'esercitazione illustra come leggere utenti, gruppi e applicazioni, e pertanto richiede gli ambiti di autorizzazione User.Read.All, Group.Read.All, Application.Read.Alle Directory.Read.All. Per ulteriori informazioni sui permessi, vedere riferimento ai permessi di Microsoft Graph.

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

Questo comando richiede di accedere con le credenziali di Microsoft Entra. Dopo l'accesso, potrebbe essere necessario fornire il consenso alle autorizzazioni necessarie se è la prima volta che ci si connette o se sono necessarie nuove autorizzazioni.

Query di PowerShell per estrarre i dati di Microsoft Entra ID necessari per creare report personalizzati in Azure Data Explorer

Le query seguenti estraggono i dati di Microsoft Entra ID da Microsoft Graph utilizzando PowerShell ed esportano i dati in file JSON, che vengono importati in Azure Data Explorer nella sezione successiva, la 3. Possono essere presenti più scenari per la generazione di report con questo tipo di dati, tra cui:

• Un revisore desidera visualizzare un report che elenca i membri del gruppo per 10 gruppi, organizzati dal reparto dei membri.
• Un revisore vuole visualizzare un report di tutti gli utenti che hanno accesso a un'applicazione tra due date.

Si possono anche inserire dati in Azure Data Explorer da altre origini oltre a Microsoft Entra. In questo modo si abilitano scenari come:

• Un amministratore vuole visualizzare tutti gli utenti aggiunti a un'applicazione da Microsoft Entra ID e i relativi diritti di accesso nel repository dell'applicazione, ad esempio i database SQL.

Questi tipi di report non sono incorporati in Microsoft Entra ID. È tuttavia possibile creare manualmente questi report estraendo i dati da Entra e combinandoli usando query personalizzate in Esplora dati di Azure. Questo verrà risolto più avanti nell'esercitazione nella sezione , inserimento dati da altre origini,.

Per questa esercitazione vengono estratti i dati di Microsoft Entra ID da diverse aree:

• Informazioni sull'utente, ad esempio nome visualizzato, UPN e dettagli del processo
• Informazioni sui gruppi, incluse le appartenenze
• Assegnazioni di applicazioni e ruoli applicativi

Questo set di dati consente di eseguire un ampio set di query su chi ha concesso l'accesso a un'applicazione, con le informazioni sul ruolo dell'applicazione e l'intervallo di tempo associato. Si noti che si tratta di query di esempio e i dati e requisiti specifici possono variare rispetto a quanto illustrato di seguito.

Nota

I tenant di dimensioni maggiori possono riscontrare errori di limitazione/429 gestiti dal modulo di Microsoft Graph. Esplora dati di Azure può anche limitare le dimensioni di caricamento dei file.

In questi script di PowerShell le proprietà selezionate vengono esportate dagli oggetti Microsoft Entra in file JSON. I dati di queste proprietà esportate vengono usati per generare report personalizzati in Esplora dati di Azure. Le proprietà specifiche seguenti sono state incluse in questi esempi, perché questi dati vengono usati per illustrare i tipi di report che è possibile creare in Esplora dati di Azure. Poiché è probabile che le tue esigenze specifiche di creazione di report varino rispetto a quanto mostrato qui, dovresti includere nei report le proprietà specifiche di cui desideri vedere nei tuoi script. Tuttavia, è possibile seguire lo stesso modello illustrato per compilare gli script.

Selezionare una data istantanea

È stata inclusa una data snapshot hardcoded che identifica i dati nel file JSON con una data specifica e consente di tenere traccia di set di dati simili nel tempo in Esplora dati di Azure. La data dello snapshot è utile anche per confrontare le modifiche apportate ai dati tra due date dello snapshot.

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

Ottenere i dati utente di Entra

Questo script esporta le proprietà selezionate dall'oggetto utente Entra in un file JSON. Questo e altri dati verranno importati da altri file JSON in Esplora dati di Azure in una sezione successiva di questa esercitazione.

  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 

Ottenere i dati del gruppo

Generare un file JSON con nomi di gruppo e ID usati per creare visualizzazioni personalizzate in Esplora dati di Azure. L'esempio include tutti i gruppi, ma è possibile includere filtri aggiuntivi, se necessario. Se si filtra in modo che includa solo determinati gruppi, è possibile includere la logica nello script per verificare la presenza di gruppi annidati.

    # 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" 

Ottenere i dati di appartenenza al gruppo

Generare un file JSON con appartenenza al gruppo usato per creare visualizzazioni personalizzate in Esplora dati di Azure. L'esempio include tutti i gruppi, ma è possibile includere filtri aggiuntivi, se necessario.

    # 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" 

Ottenere i dati dell'applicazione e dell'entità servizio

Genera un file JSON con tutte le applicazioni e le entità servizio corrispondenti nel tenant. Questi dati verranno importati in Azure Data Explorer in una sezione successiva di questa esercitazione che consente di generare report personalizzati correlati alle applicazioni basati su questi dati.

    # 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" 

Ottenere i dati di AppRole

Creare un file JSON di tutti i ruoli delle app per le applicazioni aziendali in Microsoft Entra. Dopo l'importazione in Azure Data Explorer, utilizziamo questi dati per generare report che coinvolgono le assegnazioni dei ruoli delle app agli utenti.

    # 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' 

Ottenere i dati dell'assegnazione di AppRole

Generare un file JSON di tutte le assegnazioni di ruolo delle app per gli utenti nel tenant.

    $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: Creare tabelle e importare file JSON con dati da Microsoft Entra ID in Esplora dati di Azure

In questa sezione vengono importati i file JSON appena creati per i servizi Microsoft Entra ID come tabelle in Esplora dati di Azure per ulteriori analisi. Nella prima importazione usando l'interfaccia utente Web di Esplora dati di Azure si creeranno le tabelle in base allo schema suggerito dall'interfaccia utente Web da ogni file JSON.

Dopo aver impostato un database nel tuo cluster o nel cluster gratuito di Esplora dati di Azure, come descritto nella prima sezione di questo articolo, vai a quel database.

1. Accedi all'interfaccia Web utente di Azure Data Explorer .
2. Nel menu a sinistra selezionare Query.

Seguire quindi questa procedura per ogni file JSON esportato per ottenere i dati esportati nel database di Esplora dati di Azure come nuova tabella.

1. Selezionare con il pulsante destro del computer il nome del database in cui si desidera inserire i dati. Selezionare Recupera i dati.

   

2. Selezionare l'origine dati dall'elenco disponibile. In questa esercitazione, stai inserendo dati da un file locale .

3. Selezionare + tabella Nuova e inserire un nome di tabella basato sul nome del file JSON che stai importando, ad esempio, se importa EntraUsers.json, dare alla tabella il nome EntraUsers. Dopo la prima importazione, la tabella esiste già ed è possibile selezionarla come tabella di destinazione per un'importazione successiva.

4. Seleziona Sfoglia file, seleziona il file JSON e fai clic su Avanti.

5. Azure Data Explorer rileva automaticamente lo schema e fornisce un'anteprima nella scheda ispeziona. Selezionare Fine per creare la tabella e importare i dati da quel file. Dopo aver inserito i dati, fare clic su Chiudi.

6. Ripetere ognuno dei passaggi precedenti per ognuno dei file JSON generati nella sezione precedente.

Al termine di questi passaggi si avranno le tabelle EntraUsers, EntraGroups, EntraGroupMembership, Applications, AppRolese AppRoleAssignments nel database.

4: Estrarre i dati di governance di Microsoft Entra ID con PowerShell

In questa sezione si userà PowerShell per estrarre i dati dai servizi di governance microsoft Entra ID. Se non si dispone di Microsoft Entra ID Governance, Microsoft Entra ID P2 o Microsoft Entra Suite, continuare nella sezione [] e utilizzare Esplora dati di Azure per creare report personalizzati [].

Per questo motivo, potrebbe essere necessario installare i moduli di PowerShell di Microsoft Graph per estrarre i dati di Microsoft Entra ID Governance. La prima volta che l'organizzazione usa questi moduli per questo scenario, è necessario trovarsi in un ruolo di amministratore globale per consentire a Microsoft Graph PowerShell di concedere il consenso per l'uso nel tenant. Le interazioni successive possono usare un ruolo con privilegi inferiori.

1. Aprire PowerShell.
2. Se non si dispone di tutti i moduli di PowerShell di Microsoft Graph già installati, installare i moduli di Microsoft Graph necessari. Per questa sezione dell'esercitazione sono necessari i moduli seguenti: Microsoft.Graph.Identity.Governance. Se questi moduli sono già installati, continuare con il passaggio successivo.

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

2. Importare i moduli nella sessione di PowerShell corrente.

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

3. Connettersi a Microsoft Graph. Questa sezione dell'esercitazione illustra il recupero dei dati dalla gestione delle assegnazioni e dalle verifiche di accesso, quindi richiede gli ambiti di autorizzazione AccessReview.Read.All e EntitlementManagement.Read.All. Per altri casi d'uso dei report, come per i flussi di lavoro PIM o del ciclo di vita, aggiornare il parametro Scopes con le autorizzazioni necessarie. Per ulteriori informazioni sui permessi, vedere riferimento ai permessi di Microsoft Graph.

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

Questo comando richiede di accedere con le credenziali di Microsoft Entra. Dopo l'accesso, potrebbe essere necessario fornire il consenso alle autorizzazioni necessarie se è la prima volta che ci si connette o se sono necessarie nuove autorizzazioni.

Query di PowerShell per estrarre i dati di Microsoft Entra ID Governance necessari per creare report personalizzati in Azure Data Explorer

È possibile usare le query per estrarre i dati di Governance ID di Microsoft Entra da Microsoft Graph usando PowerShell ed esportare i dati in formato file JSON, che vengono importati in Esplora dati di Azure nella sezione successiva. Possono essere presenti più scenari per la generazione di report con questo tipo di dati, tra cui:

• reportistica sulle verifiche di accesso storiche
• creazione di report sulle assegnazioni tramite la gestione entitlement

Ottenere i dati della definizione della pianificazione delle revisioni di accesso

Generare un file JSON con nomi e ID delle definizioni di verifica di accesso usati per creare visualizzazioni personalizzate in Esplora dati di Azure. L'esempio include tutte le verifiche di accesso, ma è possibile includere filtri aggiuntivi, se necessario. Per ulteriori informazioni, vedere e usare il parametro di query del filtro.

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

Accedere ai dati di istanza di revisione di Access

Per esportare tutte le definizioni, le istanze e le decisioni di Access Review in un formato di cartella strutturata tramite PowerShell, è possibile usare l'API Microsoft Graph. Questo approccio garantisce che i dati siano organizzati gerarchicamente, allineati alla struttura di cartelle specificata.

Prima di iniziare, tenere presente quanto segue:

• Assicurarsi di disporre delle autorizzazioni necessarie per accedere ai dati delle verifiche di accesso in Microsoft Graph.
• A seconda del volume di dati, il tempo di esecuzione dello script può variare. Monitorare il processo e regolare i parametri in base alle esigenze.

1. Scaricare lo script Export_Access_Reviews.ps1 e salvarlo in locale.
2. In Esplora file sbloccare lo script in modo che possa essere eseguito in PowerShell.
3. Eseguire il comando seguente, che restituirà tutti i dati in tre sottocartelle ReviewInstances, ReviewInstanceDecisionItems e ReviewInstanceContactedReviewers.

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

Ottenere i dati dei pacchetti di accesso alla gestione delle autorizzazioni

Generare un file JSON con nomi e ID dei pacchetti di accesso usati per creare visualizzazioni personalizzate in Esplora dati di Azure. L'esempio include tutti i pacchetti di accesso, ma è possibile includere filtri aggiuntivi, se necessario.

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

Ottenere i dati di assegnazione del pacchetto di accesso alla gestione dei diritti

Generare un file JSON con assegnazioni per accedere ai pacchetti usati per creare visualizzazioni personalizzate in Esplora dati di Azure. L'esempio include tutte le assegnazioni recapitate, ma è possibile includere filtri aggiuntivi, se necessario.

   $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: Creare tabelle e importare file JSON con dati provenienti da Microsoft Entra ID Governance in Azure Data Explorer

In questa sezione vengono importati i file JSON appena creati per i servizi di governance Microsoft Entra ID in Esplora dati di Azure, insieme ai dati già importati per i servizi Microsoft Entra ID, per ulteriori analisi. Nella prima importazione usando l'interfaccia utente Web di Esplora dati di Azure si creeranno tabelle basate sullo schema suggerito dall'interfaccia utente Web da ogni file JSON.

Nel cluster di Esplora dati di Azure o nel cluster gratuito passare al database che contiene i dati dell'ID Microsoft Entra.

1. Accedi all'interfaccia Web utente di Azure Data Explorer .
2. Nel menu a sinistra selezionare Query.

Seguire quindi questa procedura per ogni file JSON esportato dalla sezione precedente per ottenere i dati esportati nel database di Esplora dati di Azure come nuova tabella.

1. Selezionare con il pulsante destro del computer il nome del database in cui si desidera inserire i dati. Selezionare Recupera i dati.

   

2. Selezionare l'origine dati dall'elenco disponibile. In questa esercitazione, stai inserendo dati da un file locale .

3. Selezionare + Nuova tabella e immettere un nome di tabella in base al nome del file JSON che si sta importando, Dopo la prima importazione, la tabella esiste già ed è possibile selezionarla come tabella di destinazione per un'importazione successiva.

4. Seleziona Sfoglia file, seleziona il file JSON e fai clic su Avanti.

5. Azure Data Explorer rileva automaticamente lo schema e fornisce un'anteprima nella scheda ispeziona. Selezionare Fine per creare la tabella e importare i dati da quel file. Dopo aver inserito i dati, fare clic su Chiudi.

6. Ripetere ognuno dei passaggi precedenti per ognuno dei file JSON generati nella sezione precedente, per ognuna delle cartelle.

7. Se sono presenti molti file in una cartella, è possibile usare lightingest per importare il resto dopo la creazione della tabella.

Al termine di questi passaggi si avranno le tabelle EntraAccessReviewDefinitions, EntraAccessPackagese EntraAccessPackageAssignments, ReviewInstances, ReviewInstanceDecisionItems, ReviewInstanceContactedReviewers nel database, oltre alle tabelle create nella sezione 3.

6: Usare Esplora dati di Azure per creare report personalizzati

Con i dati ora disponibili in Esplora dati di Azure, è possibile iniziare a creare report personalizzati in base ai requisiti aziendali.

Azure Esplora dati è un potente strumento di analisi dei dati altamente scalabile e flessibile che offre un ambiente ideale per generare report di accesso utente personalizzati. Azure Data Explorer usa il linguaggio di query Kusto (KQL).

1. Accedi all'interfaccia Web utente di Azure Data Explorer .
2. Nel menu a sinistra selezionare Query.

Le query seguenti forniscono esempi di report comuni, ma è possibile personalizzarli in base alle proprie esigenze e creare report aggiuntivi.

È anche possibile visualizzare i report in Excel, selezionando la scheda Esporta e quindi selezionando Apri con Excel.

Esempio 1: Generare assegnazioni di ruolo dell'app per assegnazioni dirette e di gruppo per una data snapshot specifica

Questo report fornisce una visualizzazione degli utenti che hanno accesso e quando all'app di destinazione e possono essere usati per i controlli di sicurezza, la verifica della conformità e la comprensione dei modelli di accesso all'interno dell'organizzazione.

Questa query è destinata a un'applicazione specifica all'interno di Microsoft Entra AD e analizza le assegnazioni di ruolo a partire da una determinata data. La query recupera assegnazioni di ruolo dirette e basate su gruppo, unendo questi dati con i dettagli utente dalla tabella EntraUsers e dalle informazioni sui ruoli dalla tabella AppRoles. Nella query seguente impostare il targetSnapshotDate sul valore snapshotDate usato durante il caricamento dei dati.

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

Esempio 2: Creare un report revisore di base con i dati entra che mostrano chi ha avuto accesso a un'app tra queste due date

Questo report fornisce una visualizzazione degli utenti che hanno accesso all'app di destinazione tra due date e possono essere usati per i controlli di sicurezza, la verifica della conformità e la comprensione dei modelli di accesso all'interno dell'organizzazione.

Questa query è destinata a un'applicazione specifica all'interno di Microsoft Entra ID e analizza le assegnazioni di ruolo tra due date. La query recupera le assegnazioni di ruolo dirette dalla tabella AppRoleAssignments e unisce questi dati con i dettagli utente dalla tabella EntraUsers e dalle informazioni sul ruolo dalla tabella AppRoles.

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

Esempio 3: Ottenere utenti aggiunti a un'app tra due date di snapshot dei dati

Questi report forniscono una visualizzazione delle assegnazioni di ruolo dell'app all'applicazione di destinazione tra due date. Questi report possono essere usati per tenere traccia delle modifiche apportate all'accesso alle app nel tempo.

Questa query è destinata a un'applicazione specifica all'interno di Microsoft Entra ID e modifiche alle assegnazioni di ruolo tra una data di inizio e di fine.

// 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" 

Esempio 4: Verifiche di accesso

Completamento della revisione & Informazioni sulla sequenza temporale

Dopo aver caricato i dati, usare le query Kusto seguenti per esaminarli.

• Quando è stato completato l'ultimo ciclo di revisione di accesso? Quanto tempo è stato necessario?

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

• Il processo di verifica dell'accesso viene eseguito in tempo (ad esempio, trimestrale, annuale)?

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  

Rivedi partecipazione & Engagement

• Chi sono stati assegnati i revisori?

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

• Quali revisori hanno partecipato attivamente e fornito risposte?

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   

• Percentuale di revisori che hanno risposto alla richiesta di verifica di accesso.

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  

• Quando ogni revisore ha completato le attività?

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

• Quali revisori non hanno prese decisioni?

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 

• Percentuale di revisori che non hanno interagito.

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  

• Sono stati attivati promemoria per i revisori che non rispondono? Decisioni in sospeso?

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

Modifiche all'accesso degli utenti &

• Chi ha perso l'accesso a risorse specifiche durante la verifica di accesso?

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

• Gli utenti sono stati contrassegnati a causa dell'inattività?

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

• Data di rimozione dell'accesso e motivo per la perdita dell'accesso.

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

• Utenti senza decisioni prese.

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

• Recensioni senza revisori.

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

• Recensioni senza utenti.

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

Esaminare i dati delle decisioni

• Decisioni prese: approvato, negato o non modificato.

ReviewInstanceDecisionItems 
| summarize count() by Decision 

• Numero di utenti approvati o negati l'accesso.

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

• Sono stati documentati motivi di approvazione?

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

Controlli di qualità e conformità della verifica di accesso

• Le revoche di accesso sono state considerate per gli utenti inattivo?

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

• C'è stato un accesso che non è stato rimosso correttamente?

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

• I revisori hanno documentato le loro decisioni?

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

• I commenti sono stati acquisiti per ogni utente?

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

     

Configurare le importazioni in corso

Questa esercitazione illustra un processo ETL eseguito una sola volta per popolare Azure Data Explorer con un singolo snapshot per scopi di reportistica. Per la creazione di report continui o per confrontare le modifiche nel tempo, è possibile automatizzare il processo di riempire Azure Data Explorer da Microsoft Entra, in modo che il database disponga sempre di dati aggiornati.

È possibile utilizzare Automazione di Azure, un servizio cloud di Azure, per ospitare gli script PowerShell necessari a estrarre i dati da Microsoft Entra ID e Microsoft Entra ID Governance. Per altre informazioni, vedere Automatizzare le attività di governance di Microsoft Entra ID con Automazione di Azure.

È anche possibile usare le funzionalità di Azure o gli strumenti da riga di comando, ad esempio lightingest per inserire dati e popolare una tabella già esistente. Per ulteriori informazioni, vedi usa LightIngest per inserire dati su Esplora dati di Azure.

Ad esempio, per caricare un file EntraAccessPackages.json nella directory corrente nella tabella EntraAccessPackages come utente attualmente connesso:

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

Eseguire query sui dati in Monitoraggio di Azure

Se invii i log di controllo, accesso o altri log di Microsoft Entra ad Azure Monitor, puoi incorporare quei log dallo spazio di lavoro di Azure Monitor Log Analytics nelle tue query. Per altre informazioni sulla relazione tra Monitoraggio di Azure e Esplora dati di Azure, vedere Eseguire query sui dati in Monitoraggio di Azure usando Esplora dati di Azure.

1. Accedere all'interfaccia di amministrazione di Microsoft Entra.

2. Selezionare impostazioni di diagnostica.

3. Selezionare l'area di lavoro di Log Analytics in cui si inviano i log.

4. Nella panoramica dell'area di lavoro Log Analytics, registrare l'ID sottoscrizione, il nome del gruppo di risorse e il nome dell'area di lavoro.

5. Accedere al portale di Azure.

6. Accedere all'interfaccia utente web di Esplora Dati di Azure .

7. Assicurati che il cluster di Esplora dati di Azure sia presente nell'elenco.

8. Selezionare + Aggiungi quindi Connessione.

9. Nella finestra aggiungi connessione, inserire l'URL dell'area di lavoro Log Analytics, formato dal nome host specifico del cloud, ID sottoscrizione, nome del gruppo di risorse e Nome dell'area di lavoro Log Analytics di Azure Monitor, come descritto in Aggiungi un'area di lavoro Log Analytics.

10. Dopo aver stabilito la connessione, l'area di lavoro Log Analytics verrà visualizzata nel riquadro sinistro con il cluster nativo di Esplora dati di Azure.

11. Dal menu a sinistra, selezionare Querye poi selezionare il cluster Azure Data Explorer.

12. Nel riquadro query è quindi possibile fare riferimento alle tabelle di Monitoraggio di Azure contenenti i log di Microsoft Entra nelle query di Esplora dati di Azure. Per esempio:

    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
    

Inserire dati da altre origini

È anche possibile creare tabelle aggiuntive in Azure Data Explorer per acquisire dati da altre origini. Se i dati si trovano in un file JSON, simile agli esempi precedenti o in un file CSV, è possibile creare la tabella al momento della prima ottenere dati dal file. Una volta che la tabella è creata, è anche possibile usare LightIngest per inserire dati in Azure Data Explorer da un file JSON o CSV.

Per ulteriori informazioni sull'acquisizione dei dati, vedere panoramica dell'acquisizione dei dati di Esplora dati di Azure.

Esempio 5: Combinare le assegnazioni di applicazioni da Entra e una seconda origine per creare un report di tutti gli utenti che hanno avuto accesso a un'applicazione in un intervallo di date

Questo report illustra come combinare i dati di due sistemi separati per creare report personalizzati in Esplora dati di Azure. Aggrega i dati relativi a utenti, ruoli e altri attributi di due sistemi in un formato unificato per l'analisi o la creazione di report.

In questo esempio si presuppone che sia presente una tabella denominata salesforceAssignments con colonne UserName, Name, EmployeeId, Department, JobTitle, AppName, Rolee CreatedDateTime popolati tramite l'importazione di dati da un'altra applicazione.

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

Passaggi successivi

• Cos'è Gestione entitlement di Microsoft Entra?
• Utilizzare le librerie client .NET di Kusto da PowerShell