Condividi tramite

Esercitazione: Creare report personalizzati in Azure Data Explorer utilizzando i dati da Microsoft Entra

In questa esercitazione si apprenderà come creare report personalizzati in Esplora dati di Azure usando i dati dei servizi Microsoft Entra ID e Microsoft Entra ID Governance.

Questa esercitazione integra opzioni di creazione di report, ad esempio archiviazione e creazione di report con Monitoraggio di Azure e gestione delle autorizzazioni, che si concentra sull'esportazione del registro delle verifiche in Monitoraggio di Azure per la conservazione e l'analisi. Per confronto, l'esportazione di dati di Governance di Microsoft Entra ID e 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.

Ecco un video che offre una rapida panoramica della creazione di report sui dati di governance di Microsoft Entra ID con Esplora dati di Azure.

L'uso di Esplora dati di Azure consente anche l'aggregazione dei dati da origini aggiuntive, con scalabilità elevata, schemi flessibili e criteri di conservazione. Esplora dati di Azure è particolarmente utile quando è necessario conservare i dati di accesso degli utenti per anni, eseguire indagini ad hoc o eseguire query personalizzate sui dati di accesso.

Disegno concettuale che mostra l'estrazione e le query dei dati.

Questa esercitazione 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.

In questa esercitazione, farai:

  • Configurare Azure Data Explorer in una sottoscrizione di Azure o creare un cluster gratuito.
  • Estrarre dati da Microsoft Entra ID usando script di PowerShell e Microsoft Graph.
  • Creare tabelle e importare dati da Microsoft Entra ID in Esplora dati di Azure.
  • Estrarre dati da Microsoft Entra ID Governance.
  • Creare tabelle e importare dati da Microsoft Entra ID Governance in Esplora dati di Azure.
  • Compilare una query personalizzata utilizzando KQL.
  • Eseguire query sui dati in Monitoraggio di Azure.

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

Prerequisiti

Se sei nuovo a Azure Data Explorer e vuoi apprendere gli scenari illustrati in questa esercitazione, è possibile ottenere un cluster gratuito di Azure Data Explorer. Per l'uso supportato dall'ambiente di produzione con un contratto di servizio per Esplora dati di Azure, è necessaria una sottoscrizione di Azure per ospitare un cluster completo di Esplora dati di Azure.

Determinare i dati da includere nei report. Gli script di questa esercitazione forniscono esempi con dati specifici di utenti, gruppi e applicazioni di Microsoft Entra. Questi esempi illustrano 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.

  • Questa esercitazione illustra il recupero di dati da Microsoft Entra come utente connesso. A tale scopo, assicurarsi di disporre delle assegnazioni di ruolo necessarie. Sono necessari i ruoli con le autorizzazioni appropriate per esportare il tipo di dati di Microsoft Entra che si vuole usare:

    • Dati utente: Amministratore globale, Amministratore ruolo con privilegi, Amministratore utenti
    • Dati del gruppo: Amministratore globale, Amministratore ruolo con privilegi, Amministratore gruppo
    • Applicazioni e assegnazioni di ruolo dell'app: Amministratore globale, Amministratore ruolo con privilegi, Amministratore applicazioni, Amministratore applicazioni cloud

  • Microsoft Graph PowerShell deve fornire il consenso per recuperare gli oggetti Microsoft Entra tramite Microsoft Graph. Gli esempi in questa esercitazione richiedono le autorizzazioni delegate User.Read.All, Group.Read.All, Application.Read.Alle Directory.Read.All. Se si prevede di recuperare i dati usando l'automazione senza un utente connesso, fornire invece il consenso alle autorizzazioni dell'applicazione corrispondenti. Per altre informazioni, vedere le Informazioni di riferimento per le autorizzazioni dell'API Microsoft Graph.

    Se non è già stato concesso il consenso di Microsoft Graph PowerShell 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 più ruoli e autorizzazioni.

  • Nel computer in cui è installato Microsoft Graph PowerShell, assicurarsi di disporre dell'accesso in scrittura alla directory del file system. Questa directory consente di installare i moduli di Microsoft Graph PowerShell 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 vuole anche incorporare tali dati in Esplora dati di Azure.

Configurare Azure Esplora Dati

Se Esplora dati di Azure non è stato usato in precedenza, è necessario configurarlo per primo. È possibile creare un cluster gratuito senza una sottoscrizione di Azure o una carta di credito. In alternativa, è possibile creare un cluster completo, che richiede una sottoscrizione di Azure. Per iniziare, consulta Avvio rapido: Crea un cluster e un database di Esplora dati di Azure.

Estrarre i dati di Microsoft Entra ID tramite PowerShell

In questa sezione si installare i moduli di PowerShell di Microsoft Graph. 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 avere 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.Applicationse Microsoft.Graph.DirectoryObjects. Se questi moduli sono già installati, ignorare questo passaggio.

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

  3. 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 
  }

  4. Connettersi a Microsoft Graph. Questa sezione dell'esercitazione illustra la lettura di utenti, gruppi e applicazioni, quindi 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 per i report personalizzati

Le query seguenti estraggono i dati di Microsoft Entra ID da Microsoft Graph usando PowerShell ed esportano i dati in file JSON. Questi file vengono importati in Esplora dati di Azure in una sezione successiva di questa esercitazione.

Gli scenari per la generazione di report con questo tipo di dati includono:

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

È anche possibile inserire dati in Esplora dati di Azure da origini diverse da Microsoft Entra. Uno scenario per questa funzionalità potrebbe essere:

  • 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 un database SQL.

Questi tipi di report non sono incorporati in Microsoft Entra ID. È tuttavia possibile creare manualmente questi report estraendo i dati dall'ID Microsoft Entra e combinando i dati usando query personalizzate in Esplora dati di Azure. Questa esercitazione illustra questo processo in un secondo momento, nell'articolo Portare dati da altre origini .

Per questa esercitazione si estraggono i dati di Microsoft Entra ID da queste aree:

  • Informazioni sull'utente, ad esempio nome visualizzato, UPN e dettagli del lavoro
  • Informazioni sui gruppi, incluse le appartenenze
  • Applicazioni e assegnazioni ai ruoli delle applicazioni

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

Nota

I tenant di dimensioni maggiori potrebbero riscontrare limitazioni delle risorse e errori 429 gestiti dal modulo Microsoft Graph. Esplora dati di Azure potrebbe 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 che seguono sono incluse in questi esempi perché vengono usati per illustrare i tipi di report che è possibile creare in Esplora dati di Azure. Poiché è probabile che le esigenze di creazione di report specifiche variano a seconda di quanto illustrato in questa esercitazione, è necessario includere le proprietà specifiche in questi script che si è interessati a visualizzare nei report. Tuttavia, è possibile seguire lo stesso modello illustrato per compilare gli script.

Seleziona una data di istantanea

Una data di snapshot codificata rigidamente identifica i dati nel file JSON con una data specifica. È possibile usarlo per 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 Microsoft Entra

Questo script esporta le proprietà selezionate dall'oggetto utente Microsoft Entra in un file JSON. Questo file e i dati aggiuntivi 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 da includere 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 | Foreach-Object {
       $groupObject = @{} 
       $groupObject["Id"] = $_.Id
       $groupObject["DisplayName"] = $_.DisplayName
       $groupObject["SecurityEnabled"] = $_.SecurityEnabled
       $groupObject["MailEnabled"] = $_.MailEnabled
       $groupObject["MailNickname"] = $_.MailNickname
       $groupObject["SecurityIdentifier"] = $_.SecurityIdentifier
       $date = [datetime]::Parse($_.CreatedDateTime) 
       $groupObject["CreatedDateTime"] = $date.ToString("yyyy-MM-dd") 
       $groupObject["SnapshotDate"] = $SnapshotDate
      [pscustomobject]$groupObject 
    }
    # Export the groups to a JSON file 
    $groups | ConvertTo-Json | Set-Content ".\EntraGroups.json"

Ottenere i dati di appartenenza ai gruppi

Generare un file JSON con appartenenza al gruppo, che viene 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 ID 
    $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 "EntraGroupMemberships.json"

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

Generare un file JSON con tutte le applicazioni e le entità servizio corrispondenti nel tenant. Questi dati verranno importati in Esplora dati di Azure in una sezione successiva di questa esercitazione, in modo da poter generare report personalizzati correlati alle applicazioni in base a questi dati.

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

Ottieni i dati del ruolo dell'app

Generare un file JSON di tutti i ruoli dell'app per le app aziendali in Microsoft Entra. Dopo aver importato questi dati in Esplora dati di Azure, verrà usato per generare report che coinvolgono assegnazioni di ruolo dell'app per gli utenti.

    # Get a list of all applications, and 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 by using its app ID 
      $spFilter = "appId eq '$($app.AppId)'" 
      $sp = Get-MgServicePrincipal -Filter $spFilter | Select-Object -First 1 
      # Process app roles, 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'

Ottieni i dati dell'assegnazione di ruolo dell'app

Generare un file JSON di tutte le assegnazioni di ruolo dell'app degli 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 necessary 
        $result += [PSCustomObject]@{ 
          Id = $_.Id
          AppRoleId      = $_.AppRoleId
          CreatedDateTime   = $createdDateTime
          PrincipalDisplayName = $user.DisplayName
          PrincipalId     = $user.Id
          AssignmentPrincipalType = $_.PrincipalType
          AssignmentPrincipalDisplayName = $_.PrincipalDisplayName
          AssignmentPrincipalId     = $_.PrincipalId
          ResourceDisplayName = $_.ResourceDisplayName
          ResourceId      = $_.ResourceId
          SnapshotDate     = $SnapshotDate
        } 
      } 
    } 
    $result | ConvertTo-Json -Depth 10 | Out-File "AppRoleAssignments.json"

Creare tabelle e importare file JSON con dati da Microsoft Entra ID in Esplora dati di Azure

In questa sezione si importano i file JSON appena creati per i servizi Microsoft Entra ID come tabelle in Esplora dati di Azure per ulteriori analisi. Nella prima importazione tramite l'interfaccia utente Web di Esplora dati di Azure si creano le tabelle basate sugli schemi suggeriti dall'interfaccia utente Web da ogni file JSON.

  1. Accedere all'interfaccia utente Web di Azure Esplora dati.

  2. Passa al database che hai configurato nel tuo cluster di Azure Data Explorer o nel cluster gratuito all'inizio di questa esercitazione.

  3. Nel menu a sinistra selezionare Query.

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

    1. Fare clic con il pulsante destro del mouse sul nome del database in cui si desidera inserire i dati. Selezionare quindi Recupera dati.

      Screenshot di una scheda query, con un menu di scelta rapida per un database e il comando per ottenere i dati evidenziati.

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

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

    4. Selezionare Cerca file, selezionare il file JSON e quindi selezionare 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, selezionare Chiudi.

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

Al termine di questi passaggi, sono disponibili le tabelle EntraUsers, EntraGroups, EntraGroupMemberships, Applications, AppRolese AppRoleAssignments nel database.

Estrarre i dati di governance di Microsoft Entra ID tramite PowerShell

In questa sezione si usa PowerShell per estrarre i dati dai servizi di governance di Microsoft Entra ID. Se non hai Microsoft Entra ID Governance, Microsoft Entra ID P2 o Microsoft Entra Suite, vai alla sezione Usare Esplora dati di Azure per creare report personalizzati.

Per i passaggi seguenti, potrebbe essere necessario installare i moduli Microsoft Graph PowerShell per estrarre i dati di governance di Microsoft Entra ID. La prima volta che l'organizzazione usa questi moduli per questo scenario, è necessario avere 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 è necessario il modulo seguente: Microsoft.Graph.Identity.Governance. Se i moduli sono già installati, passare al passaggio successivo.

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

  3. Importare i moduli nella sessione di PowerShell corrente:

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

  4. Connettersi a Microsoft Graph. Questa sezione dell'esercitazione illustra il recupero di dati dalla gestione dei diritti e dalle revisioni degli accessi, pertanto richiede gli ambiti di autorizzazione AccessReview.Read.All e EntitlementManagement.Read.All. Per altri casi d'uso di report, ad esempio per la Gestione delle Identità con Privilegi (PIM) o i workflow 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 governance di Microsoft Entra ID per i report personalizzati

Le query seguenti estraggono i dati di governance di Microsoft Entra ID da Microsoft Graph usando PowerShell ed esportano i dati in file JSON. Questi file vengono importati in Esplora dati di Azure in una sezione successiva di questa esercitazione.

Gli scenari per la generazione di report con questo tipo di dati includono:

  • Redazione di report sulle revisioni storiche degli accessi.
  • Creazione di report sulle assegnazioni attraverso la gestione delle autorizzazioni.

Ottieni i dati sulla definizione della pianificazione delle revisioni degli accessi

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 altre informazioni, vedere 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"

Ottenere i dati dell'istanza per le verifiche di accesso

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

Prima di iniziare, tenere presente quanto segue:

  • Assicurarsi di disporre delle autorizzazioni necessarie per accedere ai dati di revisione 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.

Per ottenere i dati dell'istanza:

  1. Scaricare lo script Export_Access_Reviews.ps1 e salvarlo in locale.

  2. In Esplora file sbloccare lo script in modo che sia possibile eseguirlo in PowerShell.

  3. Esegui il comando seguente: L'output inserisce tutti i dati in tre sottocartelle: ReviewInstances, ReviewInstanceDecisionItemse ReviewInstanceContactedReviewers.

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

Accedere ai dati dei pacchetti di accesso per la 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"

Accedere ai dati di assegnazione dei pacchetti di accesso per la gestione delle autorizzazioni

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"

Creare tabelle e importare file JSON con dati da Microsoft Entra ID Governance in Esplora dati di Azure

In questa sezione si importano i file JSON appena creati per i servizi di governance di Microsoft Entra ID in Esplora dati di Azure per ulteriori analisi. Questi file vengono aggiunti ai dati già importati per i servizi MICROSOFT Entra ID. Nella prima importazione tramite l'interfaccia utente Web di Esplora dati di Azure si creano tabelle basate sugli schemi suggeriti dall'interfaccia utente Web da ogni file JSON.

  1. Accedere all'interfaccia utente Web di Azure Esplora dati.

  2. Nel tuo cluster di Esplora dati di Azure o nel cluster gratuito, vai al database che contiene i dati di Microsoft Entra ID.

  3. Nel menu a sinistra selezionare Query.

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

    1. Fare clic con il pulsante destro del mouse sul nome del database in cui si desidera inserire i dati. Selezionare quindi Recupera dati.

      Screenshot di una scheda query, con un menu di scelta rapida per un database e il comando per ottenere i dati evidenziati.

    2. Selezionare l'origine dati dall'elenco disponibile. In questa esercitazione, stai inserendo dati da un File locale, quindi seleziona 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. Selezionare Cerca file, selezionare il file JSON e quindi selezionare 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, selezionare Chiudi.

    6. Ripetere i 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, sono disponibili le tabelle EntraAccessReviewDefinitions, EntraAccessPackages, EntraAccessPackageAssignments, ReviewInstances, ReviewInstanceDecisionItemse ReviewInstanceContactedReviewers nel database, oltre alle tabelle create in precedenza.

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:

  1. Accedere all'interfaccia utente Web di Azure Esplora dati.

  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: Generare assegnazioni di ruolo dell'app per assegnazioni dirette e di gruppo per una data snapshot specifica

Questo report offre una visualizzazione di chi ha accesso e quando all'app di destinazione. È possibile usarlo per controlli di sicurezza, verifica della conformità e informazioni sui modelli di accesso all'interno dell'organizzazione.

La query seguente è destinata a un'applicazione specifica all'interno di Microsoft Entra ID e analizza le assegnazioni di ruolo a partire da una determinata data. La query recupera le assegnazioni di ruolo dirette e basate su gruppo. Unisce questi dati con i dettagli utente della tabella EntraUsers e delle informazioni sui ruoli della tabella AppRoles. Nella query, imposta targetSnapshotDate sul valore snapshotDate che hai 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 a string for easier comparison 

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

// Prepare role data from the 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 EntraGroupMemberships on $left.PrincipalId == $right.GroupId // Join with group membership 
    | mvexpand Members // Expand group members 
    | extend MembersStr = tostring(Members) // Convert the member ID to a 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: Creare un report revisore di base con i dati di Microsoft Entra che mostrano chi ha accesso a un'app tra due date

Questo report offre una visualizzazione degli utenti che hanno accesso all'app di destinazione tra due date. È possibile usarlo per controlli di sicurezza, verifica della conformità e informazioni sui modelli di accesso all'interno dell'organizzazione.

La query seguente è 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: Visualizzare gli utenti aggiunti a un'app tra due date di snapshot dei dati

Questi report forniscono una visualizzazione dei casi in cui gli utenti hanno ricevuto un'assegnazione di ruolo dell'app all'applicazione di destinazione tra due date. È possibile usare questi report 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 alle modifiche delle assegnazioni di ruolo effettuate tra le date 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: query diverse che utilizzano le revisioni di accesso

Visualizzare le informazioni sul completamento della verifica di accesso e sulla sequenza temporale

Dopo il caricamento dei 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)?

    ReviewInstances 
| extend ExpectedFrequency = "Quarterly" // Replace with the 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

Visualizzare la partecipazione alla verifica di accesso e l'impegno

  • Chi sono stati i revisori assegnati?

    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

  • Quale percentuale di revisori ha 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 nonresponders
| 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

  • Quale percentuale di revisori non ha 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 nonresponders
| 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 revisori non rispondenti o 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 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 nonresponsive 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

Visualizzare gli utenti e le modifiche di accesso risultanti dalle verifiche di accesso

  • 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

  • Qual è la data di rimozione dell'accesso e il motivo della perdita dell'accesso?

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

  • Quali utenti non hanno preso decisioni?

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

  • Quali recensioni non avevano revisori?

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

  • Quali recensioni non avevano utenti?

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

Riepilogare le decisioni relative alla verifica di accesso

  • Quali decisioni hanno preso gli utenti: approvato, negato o invariato?

    ReviewInstanceDecisionItems
| summarize count() by Decision

  • Quale numero di utenti è stato approvato o negato 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

Confermare la qualità della revisione dell'accesso e controllare la completezza

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

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

  • Qualche accesso 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 usare Azure Automation, un servizio cloud di Azure, per ospitare gli script di PowerShell di cui hai bisogno per 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 tramite Automazione di Azure e Microsoft Graph.

È anche possibile usare le funzionalità di Azure o gli strumenti da riga di comando, ad esempio lightingest per inserire dati e popolare una tabella esistente. Per altre informazioni, vedere Usare LightIngest per inserire dati in Azure Data Explorer.

Ad esempio, per caricare il file EntraAccessPackages.json, presente nella directory corrente, nella tabella EntraAccessPackages come utente attualmente connesso, utilizzare questo comando:

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

Creazione di report sui dati da più origini

È anche possibile inserire dati in Esplora dati di Azure da origini diverse da Microsoft Entra. Lo scenario per questa funzionalità include:

  • Un amministratore vuole visualizzare gli eventi nel log di controllo con dettagli aggiuntivi su utenti, pacchetti di accesso o altri oggetti che non fanno parte del record di controllo stesso.
  • 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 un database SQL.

Per altre informazioni, vedere Creare report personalizzati in Esplora dati di Azure usando i dati di altre origini.

Contenuto correlato