Compartilhar via

Tutorial: Criar relatórios personalizados no Azure Data Explorer usando dados do Microsoft Entra

Neste tutorial, você aprenderá a criar relatórios personalizados no Azure Data Explorer usando dados do Microsoft Entra ID e dos serviços de Governança de ID do Microsoft Entra.

Este tutorial complementa as opções de relatório, como arquivamento e relatórios com o Azure Monitor e o gerenciamento de direitos, que se concentra na exportação do log de auditoria para o Azure Monitor para retenção e análise. Em comparação, exportar dados da ID do Microsoft Entra e da Governança de ID do Microsoft Entra para o Azure Data Explorer fornece flexibilidade para criar relatórios personalizados em objetos do Microsoft Entra, incluindo objetos históricos e excluídos.

Aqui está um vídeo que fornece uma visão geral rápida dos relatórios sobre dados de Governança de ID do Microsoft Entra usando o Azure Data Explorer.

O uso do Azure Data Explorer também permite a agregação de dados de fontes adicionais, com escalabilidade maciça, esquemas flexíveis e políticas de retenção. O Azure Data Explorer é especialmente útil quando você precisa reter dados de acesso do usuário por anos, executar investigações ad hoc ou executar consultas personalizadas em dados de acesso.

Desenho conceitual mostrando extração de dados e consultas.

Este tutorial ilustra como mostrar a configuração, os usuários e os direitos de acesso exportados do Microsoft Entra juntamente com os dados exportados de outras fontes, como aplicativos com direitos de acesso em seus próprios bancos de dados SQL. Em seguida, você pode usar o KQL (Linguagem de Consulta Kusto) no Azure Data Explorer para criar relatórios personalizados de acordo com os requisitos da sua organização.

Neste tutorial, você:

  • Configure o Azure Data Explorer em uma assinatura do Azure ou crie um cluster gratuito.
  • Extraia dados da ID do Microsoft Entra usando scripts do PowerShell e o Microsoft Graph.
  • Crie tabelas e importe dados da ID do Microsoft Entra para o Azure Data Explorer.
  • Extraia dados do Microsoft Entra ID Governance.
  • Crie tabelas e importe dados da Governança de ID do Microsoft Entra para o Azure Data Explorer.
  • Crie uma consulta personalizada usando KQL.
  • Consultar dados no Azure Monitor.

Ao final deste tutorial, você poderá desenvolver exibições personalizadas dos direitos de acesso e das permissões dos usuários. Essas exibições abrangem vários aplicativos por meio de ferramentas com suporte da Microsoft. Você também pode trazer dados de bancos de dados ou aplicativos não Microsoft para relatar esses direitos de acesso e permissões.

Pré-requisitos

Se você for novo no Azure Data Explorer e quiser aprender os cenários que este tutorial mostra, poderá obter um cluster gratuito do Azure Data Explorer. Para uso com suporte em produção com um contrato de nível de serviço para o Azure Data Explorer, você precisa de uma assinatura do Azure para hospedar um cluster completo do Azure Data Explorer.

Determine quais dados você deseja incluir em seus relatórios. Os scripts neste tutorial fornecem exemplos com dados específicos de usuários, grupos e aplicativos do Microsoft Entra. Esses exemplos ilustram os tipos de relatórios que você pode gerar com essa abordagem, mas suas necessidades de relatórios específicas podem variar e exigir dados diferentes ou adicionais. Você pode começar com esses objetos e trazer mais tipos de objetos do Microsoft Entra com o tempo.

  • Este tutorial ilustra a recuperação de dados do Microsoft Entra como um usuário logado. Para fazer isso, verifique se você tem as atribuições de função necessárias. Você precisa das funções com as permissões certas para exportar o tipo de dados do Microsoft Entra com os quais deseja trabalhar:

    • Dados do usuário: Administrador Global, Administrador de Funções Privilegiadas, Administrador de Usuário
    • Dados do grupo: Administrador Global, Administrador de Funções Com Privilégios, Administrador de Grupo
    • Atribuições de função de aplicativos e aplicativos: Administrador Global, Administrador de Funções Privilegiadas, Administrador de Aplicativos, Administrador de Aplicativos na Nuvem

  • O Microsoft Graph PowerShell precisa de consentimento para recuperar objetos do Microsoft Entra por meio do Microsoft Graph. Os exemplos neste tutorial exigem as permissões delegadas User.Read.All, Group.Read.All, Application.Read.All, e Directory.Read.All. Se você estiver planejando recuperar dados usando a automação sem um usuário autenticado, conceda consentimento para as permissões de aplicativo correspondentes. Para obter mais informações, confira Referência de permissões do Microsoft Graph.

    Se você ainda não deu consentimento do Microsoft Graph PowerShell para essas permissões, precisará ser um Administrador Global para executar essa operação de consentimento.

  • Este tutorial não ilustra atributos de segurança personalizados. Por padrão, o administrador global e outras funções de administrador não incluem permissões para ler atributos de segurança personalizados de usuários do Microsoft Entra. Se você estiver planejando recuperar atributos de segurança personalizados, talvez precise de mais funções e permissões.

  • No computador em que o Microsoft Graph PowerShell está instalado, verifique se você tem acesso de gravação ao diretório do sistema de arquivos. Esse diretório é onde você instala os módulos necessários do Microsoft Graph PowerShell e onde os dados exportados do Microsoft Entra são salvos.

  • Verifique se você tem permissões para recuperar dados de outras fontes de dados além do Microsoft Entra, se também quiser incorporar esses dados ao Azure Data Explorer.

Configurar o Azure Data Explorer

Se você ainda não usou o Azure Data Explorer anteriormente, precisará configurá-lo primeiro. Você pode criar um cluster gratuito sem uma assinatura do Azure ou cartão de crédito. Ou você pode criar um cluster completo, que requer uma assinatura do Azure. Para começar, consulte Início Rápido: Criar um cluster e um banco de dados do Azure Data Explorer.

Extrair dados da ID do Microsoft Entra usando o PowerShell

Nesta seção, você instalará os módulos do Microsoft Graph PowerShell. No PowerShell, você se conecta ao Microsoft Graph para extrair dados da ID do Microsoft Entra.

Na primeira vez que sua organização usa esses módulos para esse cenário, você precisa ter uma função de Administrador Global para permitir que o Microsoft Graph PowerShell conceda consentimento para uso em seu locatário. As interações seguintes podem usar uma função com privilégios mais baixos.

  1. Abra o PowerShell.

  2. Caso você não tenha todos os módulos do PowerShell do Microsoft Graph já instalados, instale os módulos necessários do Microsoft Graph. Os módulos a seguir são necessários para esta seção do tutorial: Microsoft.Graph.Authentication, , Microsoft.Graph.Users, Microsoft.Graph.Groups, e Microsoft.Graph.ApplicationsMicrosoft.Graph.DirectoryObjects. Se você já tiver esses módulos instalados, ignore esta etapa.

       $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. Importe os módulos para a sessão atual do PowerShell:

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

  4. Conecte-se ao Microsoft Graph. Esta seção do tutorial ilustra a leitura de usuários, grupos e aplicativos, portanto, requer os escopos de permissão User.Read.All, Group.Read.All, Application.Read.All e Directory.Read.All. Para obter mais informações sobre permissões, confira Referência de permissões do Microsoft Graph.

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

    Esse comando solicita que você entre com suas credenciais do Microsoft Entra. Depois de entrar, talvez seja necessário consentir com as permissões necessárias se for a primeira vez que se conectar ou se novas permissões forem necessárias.

Consultas do PowerShell para extrair dados da ID do Microsoft Entra para relatórios personalizados

As consultas a seguir extraem dados da ID do Microsoft Entra do Microsoft Graph usando o PowerShell e exportam os dados para arquivos JSON. Você importa esses arquivos para o Azure Data Explorer em uma seção posterior deste tutorial.

Os cenários para gerar relatórios com esse tipo de dados incluem:

  • Um auditor quer ver um relatório que lista os membros de 10 grupos, organizados pelo departamento de cada membro.
  • Um auditor deseja ver um relatório de todos os usuários que tiveram acesso a um aplicativo entre duas datas.

Você também pode trazer dados para o Azure Data Explorer de fontes além do Microsoft Entra. Um cenário para essa funcionalidade pode ser:

  • Um administrador deseja exibir todos os usuários adicionados a um aplicativo da ID do Microsoft Entra e seus direitos de acesso no repositório do próprio aplicativo, como um banco de dados SQL.

Esses tipos de relatórios não são integrados à ID do Microsoft Entra. No entanto, você pode criar esses relatórios por conta própria extraindo dados da ID do Microsoft Entra e combinando dados usando consultas personalizadas no Azure Data Explorer. Este tutorial aborda esse processo posteriormente, no artigo Trazer dados de outras fontes .

Para este tutorial, você extrairá dados da ID do Microsoft Entra dessas áreas:

  • Informações do usuário, como nome de exibição, UPN e detalhes do trabalho
  • Informações de grupo, incluindo suas associações
  • Aplicativos e atribuições para funções de aplicativo

Esse conjunto de dados permite que você execute um amplo conjunto de consultas em torno de quem recebeu acesso a um aplicativo, com suas informações de função de aplicativo e o período associado. Lembre-se de que estas são consultas de exemplo, e seus dados e requisitos específicos podem variar do que é mostrado aqui.

Observação

Locatários maiores podem enfrentar limitações e erros 429 que o módulo Microsoft Graph manipula. O Azure Data Explorer também pode limitar os tamanhos de carregamento de arquivo.

Nesses scripts do PowerShell, você exporta as propriedades selecionadas dos objetos do Microsoft Entra para arquivos JSON. Os dados dessas propriedades exportadas são usados para gerar relatórios personalizados no Azure Data Explorer.

As propriedades específicas a seguir são incluídas nesses exemplos porque estamos usando esses dados para ilustrar os tipos de relatórios que você pode criar no Azure Data Explorer. Como suas necessidades de relatório específicas provavelmente variam do que este tutorial mostra, você deve incluir as propriedades específicas nesses scripts que você está interessado em exibir em seus relatórios. No entanto, você pode seguir o mesmo padrão mostrado para ajudar a criar seus scripts.

Selecionar uma data de captura

Uma data de instantâneo codificada identifica os dados no arquivo JSON com uma data específica. Você pode usá-lo para acompanhar conjuntos de dados semelhantes ao longo do tempo no Azure Data Explorer. A data do instantâneo também é útil para comparar alterações nos dados entre duas datas de captura.

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

Obter dados do usuário do Microsoft Entra

Esse script exporta as propriedades selecionadas do objeto de usuário do Microsoft Entra para um arquivo JSON. Você importará esse arquivo e dados adicionais de outros arquivos JSON para o Azure Data Explorer em uma seção posterior deste tutorial.

  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

Obter dados do grupo

Gere um arquivo JSON com nomes de grupos e IDs que são usados para criar exibições personalizadas no Azure Data Explorer. O exemplo inclui todos os grupos, mas você pode incluir filtragem adicional, se necessário. Se você estiver filtrando para incluir apenas determinados grupos, convém incluir lógica em seu script para verificar se há grupos aninhados.

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

Obter dados de associação de grupo

Gere um arquivo JSON com associação de grupo, que é usado para criar exibições personalizadas no Azure Data Explorer. O exemplo inclui todos os grupos, mas você pode incluir filtragem adicional, se necessário.

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

Obter dados do aplicativo e da entidade de serviço

Gere um arquivo JSON com todos os aplicativos e as entidades de serviço correspondentes no locatário. Você importará esses dados para o Azure Data Explorer em uma seção posterior deste tutorial, para que você possa gerar relatórios personalizados relacionados a aplicativos com base nesses dados.

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

Obter dados de função do aplicativo

Gere um arquivo JSON de todas as funções de aplicativo para aplicativos empresariais no Microsoft Entra. Depois de importar esses dados para o Azure Data Explorer, você os usará para gerar relatórios que envolvam atribuições de função de aplicativo para usuários.

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

Obter dados de atribuição de função de aplicativo

Gere um arquivo JSON de todas as atribuições de funções de aplicativo dos usuários no locatário:

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

Criar tabelas e importar arquivos JSON com dados da ID do Microsoft Entra para o Azure Data Explorer

Nesta seção, você importará os arquivos JSON recém-criados para os serviços de ID do Microsoft Entra como tabelas no Azure Data Explorer para análise posterior. Na primeira importação por meio da interface do usuário da Web do Azure Data Explorer, você cria as tabelas com base nos esquemas que a interface do usuário da Web sugere de cada arquivo JSON.

  1. Entre na interface do usuário da Web do Azure Data Explorer.

  2. Acesse o banco de dados que você configurou no cluster do Azure Data Explorer ou no cluster gratuito anteriormente neste tutorial.

  3. No menu à esquerda, selecione Consulta.

  4. Siga estas etapas para cada arquivo JSON exportado, para obter seus dados exportados para esse banco de dados do Azure Data Explorer como uma nova tabela:

    1. Clique com o botão direito do mouse no nome do banco de dados em que você deseja ingerir os dados. Em seguida, selecione Obter dados.

      Captura de tela de uma guia de consulta, com um menu de atalho para um banco de dados e o comando para obter dados realçados.

    2. Selecione a fonte de dados na lista disponível. Neste tutorial, você está ingerindo dados de um arquivo local, portanto, selecione Arquivo local.

    3. Selecione + Nova tabela e insira um nome de tabela, com base no nome do arquivo JSON que você está importando. Por exemplo, se você estiver importando EntraUsers.json, nomeie a tabela EntraUsers. Após a primeira importação, a tabela já existe e você pode selecioná-la como a tabela de destino para uma importação seguinte.

    4. Selecione Procurar arquivos, selecione o arquivo JSON e selecione Avançar.

    5. O Azure Data Explorer detecta automaticamente o esquema e fornece uma visualização na guia Inspecionar . Selecione Concluir para criar a tabela e importar os dados desse arquivo. Depois que os dados forem ingeridos, selecione Fechar.

    6. Repita as etapas anteriores para cada um dos arquivos JSON gerados na seção anterior.

No final dessas etapas, você tem as tabelasEntraUsers, EntraGroups, , EntraGroupMemberships, ApplicationsAppRolese AppRoleAssignments no banco de dados.

Extrair dados de governança da ID do Microsoft Entra usando o PowerShell

Nesta seção, você usará o PowerShell para extrair dados dos serviços de Governança de ID do Microsoft Entra. Se você não tiver a Governança de ID do Microsoft Entra, o Microsoft Entra ID P2 ou o Microsoft Entra Suite, continue na seção Usar o Azure Data Explorer para criar relatórios personalizados.

Para as etapas a seguir, talvez seja necessário instalar módulos do Microsoft Graph PowerShell para extrair dados de Governança da ID do Microsoft Entra. Na primeira vez que sua organização usa esses módulos para esse cenário, você precisa ter uma função de Administrador Global para permitir que o Microsoft Graph PowerShell conceda consentimento para uso em seu locatário. As interações seguintes podem usar uma função com privilégios mais baixos.

  1. Abra o PowerShell.

  2. Caso você não tenha todos os módulos do PowerShell do Microsoft Graph já instalados, instale os módulos necessários do Microsoft Graph. O módulo a seguir é necessário para esta seção do tutorial: Microsoft.Graph.Identity.Governance. Se você já tiver os módulos instalados, vá para a próxima etapa.

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

  3. Importe os módulos para a sessão atual do PowerShell:

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

  4. Conecte-se ao Microsoft Graph. Essa seção do tutorial ilustra a recuperação de dados do gerenciamento de direitos e revisões de acesso, portanto, requer os escopos de permissão AccessReview.Read.All e EntitlementManagement.Read.All. Para outros casos de uso de relatórios, como para Privileged Identity Management (PIM) ou fluxos de trabalho de ciclo de vida, atualize o parâmetro Scopes com as permissões necessárias. Para obter mais informações sobre permissões, confira Referência de permissões do Microsoft Graph.

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

    Esse comando solicita que você entre com suas credenciais do Microsoft Entra. Depois de entrar, talvez seja necessário consentir com as permissões necessárias se for a primeira vez que se conectar ou se novas permissões forem necessárias.

Consultas do PowerShell para extrair dados de governança da ID do Microsoft Entra para relatórios personalizados

As consultas a seguir extraem dados de governança da ID do Microsoft Entra do Microsoft Graph usando o PowerShell e exportam os dados para arquivos JSON. Você importa esses arquivos para o Azure Data Explorer em uma seção posterior deste tutorial.

Os cenários para gerar relatórios com esse tipo de dados incluem:

  • Relatórios sobre revisões históricas de acesso.
  • Relatórios sobre atribuições por meio do gerenciamento de direitos.

Obter dados de definição de agenda de revisão de acesso

Gere um arquivo JSON com nomes de definições de revisão de acesso e IDs que são usados para criar exibições personalizadas no Azure Data Explorer. O exemplo inclui todas as revisões de acesso, mas você pode incluir filtragem adicional, se necessário. Para obter mais informações, consulte Usar o parâmetro de consulta de 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"

Obter dados de instância para revisões de acesso

Para exportar todas as definições, instâncias e decisões de revisão de acesso para um formato de pasta estruturado usando o PowerShell, você pode usar a API do Microsoft Graph. Essa abordagem garante que seus dados sejam organizados hierarquicamente e estejam alinhados com a estrutura de pastas especificada.

Antes de começar, lembre-se dos seguintes pontos:

  • Verifique se você tem as permissões necessárias para acessar dados de revisão no Microsoft Graph.
  • Dependendo do volume de dados, o tempo de execução do script pode variar. Monitore o processo e ajuste os parâmetros conforme necessário.

Para obter os dados da instância:

  1. Baixe o script Export_Access_Reviews.ps1 e salve-o localmente.

  2. No Explorador de Arquivos, desbloqueie o script para que você possa executá-lo no PowerShell.

  3. Execute o comando a seguir. A saída coloca todos os dados em três subpastas: ReviewInstances, ReviewInstanceDecisionItemse ReviewInstanceContactedReviewers.

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

Obter dados do pacote de acesso para o gerenciamento de direitos

Gere um arquivo JSON com nomes de pacotes de acesso que são usados para criar exibições personalizadas no Azure Data Explorer. O exemplo inclui todos os pacotes de acesso, mas você pode incluir filtragem adicional, se necessário.

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

Obter dados de atribuição do pacote de acesso para o gerenciamento de direitos

Gere um arquivo JSON com atribuições para acessar pacotes que são usados para criar exibições personalizadas no Azure Data Explorer. O exemplo inclui todas as atribuições entregues, mas você pode incluir filtragem adicional, se necessário.

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

Criar tabelas e importar arquivos JSON com dados da Governança de ID do Microsoft Entra para o Azure Data Explorer

Nesta seção, você importará os arquivos JSON recém-criados para os serviços de Governança de ID do Microsoft Entra para o Azure Data Explorer para análise posterior. Esses arquivos ingressam nos dados que você já importou para os serviços de ID do Microsoft Entra. Na primeira importação por meio da interface do usuário da Web do Azure Data Explorer, você cria tabelas com base em esquemas que a interface do usuário da Web sugere de cada arquivo JSON.

  1. Entre na interface do usuário da Web do Azure Data Explorer.

  2. No cluster do Azure Data Explorer ou no cluster gratuito, vá para o banco de dados que contém os dados da ID do Microsoft Entra.

  3. No menu à esquerda, selecione Consulta.

  4. Siga estas etapas para cada arquivo JSON exportado, para obter seus dados exportados para esse banco de dados do Azure Data Explorer como uma nova tabela:

    1. Clique com o botão direito do mouse no nome do banco de dados no qual você deseja ingerir os dados. Em seguida, selecione Obter dados.

      Captura de tela de uma guia de consulta, com um menu de atalho para um banco de dados e o comando para obter dados realçados.

    2. Selecione a fonte de dados na lista disponível. Neste tutorial, você está ingerindo dados de um arquivo local, portanto, selecione Arquivo local.

    3. Selecione + Nova tabela e insira um nome de tabela, com base no nome do arquivo JSON que você está importando. Após a primeira importação, a tabela já existe e você pode selecioná-la como a tabela de destino para uma importação seguinte.

    4. Selecione Procurar arquivos, selecione o arquivo JSON e selecione Avançar.

    5. O Azure Data Explorer detecta automaticamente o esquema e fornece uma visualização na guia Inspecionar . Selecione Concluir para criar a tabela e importar os dados desse arquivo. Depois que os dados forem ingeridos, selecione Fechar.

    6. Repita as etapas anteriores para cada um dos arquivos JSON gerados na seção anterior, para cada uma das pastas.

    7. Se houver muitos arquivos em uma pasta, você poderá usar lightingest para importar o restante depois que a tabela for criada.

No final dessas etapas, você tem as tabelas EntraAccessReviewDefinitions, EntraAccessPackages, , EntraAccessPackageAssignments, ReviewInstancesReviewInstanceDecisionItemse ReviewInstanceContactedReviewers no banco de dados, além das tabelas que você criou anteriormente.

Usar o Azure Data Explorer para criar relatórios personalizados

Com os dados agora disponíveis no Azure Data Explorer, você está pronto para começar a criar relatórios personalizados com base em seus requisitos de negócios:

  1. Entre na interface do usuário da Web do Azure Data Explorer.

  2. No menu à esquerda, selecione Consulta.

As consultas a seguir fornecem exemplos de relatórios comuns, mas você pode personalizar esses relatórios para atender às suas necessidades e criar relatórios adicionais.

Você também pode exibir seus relatórios no Excel, selecionando a guia Exportar e selecionando Abrir no Excel.

Exemplo: gerar atribuições de função de aplicativo para atribuições diretas e de grupo para uma data de instantâneo específica

Este relatório fornece uma visão de quem teve quais acessos e quando ao aplicativo de destino. Você pode usá-lo para auditorias de segurança, verificação de conformidade e compreensão de padrões de acesso dentro da organização.

A consulta a seguir tem como destino um aplicativo específico dentro da ID do Microsoft Entra e analisa as atribuições de função a partir de uma determinada data. A consulta recupera tanto as atribuições de funções diretas quanto as baseadas em grupo. Ele mescla esses dados com os detalhes do usuário da EntraUsers tabela e das informações de função da AppRoles tabela. Na consulta, defina targetSnapshotDate como o snapshotDate valor que você usou quando carregou os dados.

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

Exemplo: criar um relatório de auditor básico com dados do Microsoft Entra que mostra quem teve acesso a um aplicativo entre duas datas

Este relatório fornece uma visão de quem teve acesso ao aplicativo de destino entre duas datas. Você pode usá-lo para auditorias de segurança, verificação de conformidade e compreensão de padrões de acesso dentro da organização.

A consulta a seguir tem como destino um aplicativo específico dentro da ID do Microsoft Entra e analisa as atribuições de função entre duas datas. A consulta recupera as atribuições de função diretas da tabela AppRoleAssignments e mescla esses dados com detalhes do usuário da tabela EntraUsers e informações de função da tabela 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()

Exemplo: ver os usuários adicionados a um aplicativo entre duas datas de instantâneo de dados

Esses relatórios fornecem uma exibição de quais usuários receberam uma atribuição de função de aplicativo para o aplicativo de destino entre duas datas. Você pode usar esses relatórios para controlar as alterações no acesso ao aplicativo ao longo do tempo.

Essa consulta tem como destino um aplicativo específico na ID do Microsoft Entra e altera as atribuições de função entre as datas de início e término:

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

Exemplo: Várias consultas que usam revisões de acesso

Exibir informações de conclusão e linha do tempo da revisão de acesso

Após o upload dos dados, use as seguintes consultas do Kusto para revisá-los:

  • Quando o último ciclo de revisão de acesso foi concluído? Quanto tempo demorou?

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

  • O processo de revisão de acesso é realizado a tempo (por exemplo, trimestral)?

    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

Exibir participação e envolvimento da revisão de acesso

  • Quem foram os revisores atribuídos?

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

  • Quais revisores participaram ativamente e forneceram respostas?

    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

  • Qual porcentagem de revisores respondeu à solicitação de revisão de acesso?

    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 cada revisor concluiu suas tarefas?

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

  • Quais revisores não tomaram nenhuma decisão?

    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

  • Que percentual de revisores não interagiram?

    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 

  • Os lembretes foram acionados para revisores que não responderam ou para decisões pendentes?

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

Exibir usuários e acessar alterações resultantes de revisões de acesso

  • Quem perdeu o acesso a recursos específicos durante a revisão de acesso?

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

  • Os usuários foram sinalizados devido à inatividade?

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

  • Qual foi a data de remoção de acesso e o motivo para perder o acesso?

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

  • Quais usuários não tomaram nenhuma decisão?

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

  • Quais revisões não tinham revisores?

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

  • Quais avaliações não tinham usuários?

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

Resumir decisões de revisão de acesso

  • Quais decisões os usuários tomaram: aprovadas, negadas ou inalteradas?

    ReviewInstanceDecisionItems
| summarize count() by Decision

  • Que número de usuários foram aprovados ou tiveram acesso negado?

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

  • Os motivos de aprovação foram documentados?

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

Confirmar a qualidade da revisão de acesso e verificar a integridade

  • As revogações de acesso foram consideradas para usuários inativos?

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

  • Algum acesso não foi removido corretamente?

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

  • Os revisores documentaram suas decisões?

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

  • Os comentários foram capturados para cada usuário?

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

Configurar importações contínuas

Este tutorial ilustra um processo único de ETL (extração, transformação e carregamento) de dados para preencher o Azure Data Explorer com um instantâneo individual para fins de relatório. Para relatórios contínuos ou para comparar alterações ao longo do tempo, você pode automatizar o processo de preenchimento do Azure Data Explorer por meio do Microsoft Entra, para que o seu banco de dados continue tendo dados atuais.

Você pode usar a Automação do Azure, um serviço de nuvem do Azure, para hospedar os scripts do PowerShell necessários para extrair dados da ID do Microsoft Entra e da Governança de ID do Microsoft Entra. Para obter mais informações, consulte Automatizar tarefas de Governança de ID do Microsoft Entra por meio da Automação do Azure e do Microsoft Graph.

Você também pode usar recursos do Azure ou ferramentas de linha de comando, como lightingest trazer dados e preencher uma tabela existente. Para obter mais informações, consulte Usar o LightIngest para ingerir dados no Azure Data Explorer.

Por exemplo, para carregar o arquivo EntraAccessPackages.json no diretório atual na tabela EntraAccessPackages como o usuário conectado no momento, use este comando:

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

Relatórios sobre dados de mais fontes

Você também pode trazer dados para o Azure Data Explorer de fontes além do Microsoft Entra. O cenário para essa funcionalidade inclui:

  • Um administrador deseja exibir eventos no log de auditoria com detalhes adicionais sobre usuários, pacotes de acesso ou outros objetos que não fazem parte do próprio registro de auditoria.
  • Um administrador deseja exibir todos os usuários adicionados a um aplicativo da ID do Microsoft Entra e seus direitos de acesso no repositório do próprio aplicativo, como um banco de dados SQL.

Para obter mais informações, consulte Criar relatórios personalizados no Azure Data Explorer usando dados de outras fontes.

Conteúdo relacionado