Tutorial: Informes personalizados en Azure Data Explorer mediante datos de Microsoft Entra

Artículo
02/05/2025

En este tutorial, aprenderá a crear informes personalizados en Azure Data Explorer (ADX) mediante datos de Microsoft Entra ID y servicios Gobierno de Microsoft Entra ID. En este tutorial se complementan otras opciones de informes, como Archivo e informe con Azure Monitor y administración de derechos, que se centra en exportar el registro de auditoría a Azure Monitor para su retención y análisis. En comparación, la exportación de datos de Microsoft Entra ID a Azure Data Explorer proporciona flexibilidad para crear informes personalizados en objetos de Microsoft Entra, incluidos los objetos históricos y eliminados. Además, el uso de Azure Data Explorer permite la agregación de datos de orígenes adicionales, con directivas de escalabilidad masiva, esquema flexible y retención. Azure Data Explorer es especialmente útil cuando necesita conservar los datos de acceso durante años, realizar investigaciones ad hoc o ejecutar consultas personalizadas en datos de acceso de usuario.

En este artículo se muestra cómo mostrar los derechos de configuración, usuarios y acceso exportados desde Microsoft Entra junto con los datos exportados desde otros orígenes, como las aplicaciones con derechos de acceso en sus propias bases de datos SQL. A continuación, puede usar el lenguaje de consulta kusto (KQL) en Azure Data Explorer para crear informes personalizados en función de los requisitos de su organización.

Siga estos pasos para crear estos informes:

Configurar Azure Data Explorer en una suscripción de Azure o crear un clúster gratuito.
Extraer datos de Microsoft Entra ID mediante scripts de PowerShell y Microsoft Graph.
Crear tablas e importar esos datos de Microsoft Entra ID en Azure Data Explorer.
Extraer datos de la gobernanza de Microsoft Entra ID.
Crear tablas e importar dichos datos de la Gobernanza de Microsoft Entra ID en Azure Data Explorer.
Cree una consulta personalizada mediante el lenguaje de consulta Kusto.

Al final de este tutorial, podrá desarrollar vistas personalizadas de los derechos de acceso y los permisos de los usuarios. Estas vistas abarcan diferentes aplicaciones con herramientas compatibles con Microsoft. También puede traer datos de bases de datos o aplicaciones de terceros para informar sobre ellos.

Requisitos previos

Si no está familiarizado con Azure Data Explorer y desea conocer los escenarios que se muestran en este artículo, puede obtener un clúster de Azure Data Explorer gratuito. Para su uso compatible con producción con un contrato de nivel de servicio para Azure Data Explorer, necesita una suscripción de Azure para hospedar un clúster completo de Azure Data Explorer.

Determine qué datos desea incluir en los informes. Los scripts de este artículo proporcionan ejemplos con datos específicos de usuarios, grupos y aplicaciones de Microsoft Entra. Estos ejemplos están diseñados para ilustrar los tipos de informes que puede generar con este enfoque, pero sus necesidades de informes específicas pueden variar y requerir datos diferentes o adicionales. Puede empezar con estos objetos y traer más tipos de objetos de Microsoft Entra con el tiempo.

En este artículo se muestra cómo recuperar datos de Microsoft Entra como un usuario que ha iniciado sesión. Para ello, asegúrese de que tiene las asignaciones de roles necesarias para recuperar datos de Microsoft Entra. Necesita los roles con los permisos adecuados para exportar el tipo de datos de Microsoft Entra con los que desea trabajar.
- Datos de usuario: Administrador global, Administrador de funciones privilegiadas, Administrador de usuarios
- Datos de grupos: Administrador global, Administrador de roles con privilegios, Administrador de grupos
- Aplicaciones/Asignación de roles: Administrador global, Administrador de roles privilegiados, Administrador de aplicaciones, Administrador de aplicaciones en la nube
Se debe otorgar consentimiento a Microsoft Graph PowerShell para permitir que se recuperen objetos de Microsoft Entra a través de Microsoft Graph. Los ejemplos de este tutorial requieren los permisos User.Read.All, Group.Read.All, Application.Read.All y Directory.Read.All delegados. Si planea recuperar datos mediante automatización sin un usuario que haya iniciado sesión, dé su consentimiento en su lugar a los permisos de aplicación correspondientes. Consulte Referencia de permisos de Microsoft Graph para obtener más información. Si aún no ha dado su consentimiento a Microsoft Graph PowerShell para esos permisos, debe ser administrador global para realizar esta operación de consentimiento.
En este tutorial no se muestran los atributos de seguridad personalizados. De forma predeterminada, el administrador global y otros roles de administrador no incluyen permisos para leer atributos de seguridad personalizados de los usuarios de Microsoft Entra. Si planea recuperar atributos de seguridad personalizados, es posible que se necesiten más roles y permisos.
En el equipo donde está instalado Microsoft Graph PowerShell, asegúrese de que tiene acceso de escritura al directorio del sistema de archivos. Aquí es donde se instalan los módulos de PowerShell de Microsoft Graph necesarios y donde se guardan los datos exportados de Microsoft Entra.
Asegúrese de que tiene permisos para recuperar datos de otros orígenes de datos más allá de Microsoft Entra, si desea incorporarlos también a Azure Data Explorer.

1: Configuración de Azure Data Explorer

Si no ha usado anteriormente Azure Data Explorer, primero debe configurarlo. Puede crear un clúster gratuito sin una suscripción de Azure o una tarjeta de crédito o un clúster completo que requiera una suscripción de Azure. Consulte Inicio rápido: Cree un clúster y una base de datos Azure Data Explorer para empezar.

2: Extraer datos de Microsoft Entra ID con PowerShell

En esta sección, instale los módulos de PowerShell de Microsoft Graph y, en PowerShell, conéctese a Microsoft Graph para extraer datos de Microsoft Entra ID.

La primera vez que su organización use estos módulos para este escenario, debe tener un rol de administrador global para permitir que Microsoft Graph PowerShell conceda consentimiento para su uso en el inquilino. Las interacciones posteriores pueden usar un rol con privilegios inferiores.

Abra PowerShell.
Si no tiene todos los módulos de PowerShell de Microsoft Graph ya instalados, instale los módulos de Microsoft Graph necesarios. Los siguientes módulos son necesarios para esta sección del tutorial: Microsoft.Graph.Authentication, Microsoft.Graph.Users, Microsoft.Graph.Groups, Microsoft.Graph.Applications, Microsoft.Graph.DirectoryObjects. Si ya tiene instalados estos módulos, continúe en el paso siguiente.

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

Importe los módulos en la sesión actual de PowerShell.

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

Conéctese a Microsoft Graph. En esta sección del tutorial se muestra la lectura de usuarios, grupos y aplicaciones, por lo que requiere los ámbitos de permisos User.Read.All, Group.Read.All, Application.Read.All y Directory.Read.All. Para obtener más información sobre los permisos, consulte Referencia de permisos de Microsoft Graph.

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

Este comando le pide que inicie sesión con sus credenciales de Microsoft Entra. Después de iniciar sesión, es posible que tenga que dar su consentimiento a los permisos necesarios si es la primera vez que se conecta o si se requieren nuevos permisos.

Consultas de PowerShell para extraer datos de Microsoft Entra ID necesarios para crear informes personalizados en Azure Data Explorer

Las consultas siguientes extraen los datos de Microsoft Entra ID de Microsoft Graph mediante PowerShell y exportan los datos a archivos JSON que se importan en Azure Data Explorer en la sección 3 posterior. Puede haber varios escenarios para generar informes con este tipo de datos, entre los que se incluyen:

Un auditor desea ver un informe que enumera los miembros del grupo para 10 grupos, organizados por el departamento de los miembros.
Un auditor desea ver un informe de todos los usuarios que tenían acceso a una aplicación entre dos fechas.

También puede incorporar datos a Azure Data Explorer desde otros orígenes más allá de Microsoft Entra. Esto habilita escenarios como:

Un administrador desea ver todos los usuarios agregados a una aplicación de Microsoft Entra ID y sus derechos de acceso en el propio repositorio de la aplicación, como las bases de datos SQL.

Estos tipos de informes no están integrados en Microsoft Entra ID. Sin embargo, puede crear estos informes usted mismo extrayendo datos de Entra y combinándolos mediante consultas personalizadas en Azure Data Explorer. Esto se abordará más adelante en el tutorial, en la sección de incorporación de datos de otras fuentes.

En este tutorial, extraemos datos de Microsoft Entra ID de varias áreas:

Información del usuario, como el nombre para mostrar, el UPN y los detalles del trabajo
Información de grupo, incluidas sus pertenencias
Asignaciones de aplicaciones y roles de aplicación

Este conjunto de datos nos permite realizar un amplio conjunto de consultas en torno a quién se le ha concedido acceso a una aplicación, con su información de rol de aplicación y el período de tiempo asociado. Tenga en cuenta que se trata de consultas de ejemplo y los datos y requisitos específicos pueden variar de lo que se muestra aquí.

Nota:

Los inquilinos más grandes pueden experimentar errores de limitación o 429 que administra el módulo de Microsoft Graph. Azure Data Explorer también puede limitar los tamaños de carga de archivos.

En estos scripts de PowerShell, exportamos las propiedades seleccionadas de los objetos Microsoft Entra a archivos JSON. Los datos de estas propiedades exportadas se usan para generar informes personalizados en Azure Data Explorer. Las propiedades específicas siguientes se incluyeron en estos ejemplos, ya que usamos estos datos para ilustrar los tipos de informes que puede crear en Azure Data Explorer. Dado que sus necesidades de informes específicas pueden variar de las que se muestran, debe incluir las propiedades específicas en estos scripts que le interesen ver en los informes. Sin embargo, puede seguir el mismo patrón que se muestra para ayudar a crear los scripts.

Seleccione una fecha de instantánea

Hemos incluido una fecha de instantánea codificada que identifica los datos en el archivo JSON con una fecha específica y nos permite mantener un seguimiento de conjuntos de datos similares a lo largo del tiempo en Azure Data Explorer. La fecha de instantánea también es útil para comparar los cambios en los datos entre dos fechas de instantáneas.

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

Obtención de datos de usuario de Entra

Este script exporta las propiedades seleccionadas del objeto de usuario Entra a un archivo JSON. Importaremos estos datos y otros datos de otros archivos JSON en Azure Data Explorer en una sección posterior de este 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

Obtener datos de grupo

Genere un archivo JSON con nombres de grupo e identificadores que se usan para crear vistas personalizadas en Azure Data Explorer. El ejemplo incluye todos los grupos, pero se puede incluir un filtrado adicional si es necesario. Si va a filtrar para incluir solo determinados grupos, es posible que quiera incluir lógica en el script para comprobar si hay grupos anidados.

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

Obtener datos de pertenencia de grupo

Genere un archivo JSON con pertenencia a grupos que se usa para crear vistas personalizadas en Azure Data Explorer. El ejemplo incluye todos los grupos, pero se puede incluir un filtrado adicional si es necesario.

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

Obtener datos de aplicación y entidad de servicio principal

Genera un archivo JSON con todas las aplicaciones y las entidades de servicio correspondientes en el inquilino. Importaremos estos datos en Azure Data Explorer en una sección posterior de este tutorial que nos permite generar informes personalizados relacionados con aplicaciones basadas en estos datos.

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

Obtención de datos de AppRole

Genere un archivo JSON de todos los appRoles para aplicaciones de empresas en Microsoft Entra. Una vez importados a Azure Data Explorer, usamos estos datos para generar informes que implican asignaciones de roles de aplicación para los usuarios.

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

Obtención de datos de asignación de AppRole

Genere un archivo JSON de todas las asignaciones de roles de aplicaciones de los usuarios en la organización inquilina.

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

3: Creación de tablas e importación de archivos JSON con datos de Microsoft Entra ID en Azure Data Explorer

En esta sección, se importan los archivos JSON recién creados para los servicios de Microsoft Entra ID como tablas en Azure Data Explorer para su posterior análisis. En la primera importación mediante la interfaz de usuario web de Azure Data Explorer, creará las tablas en función del esquema que sugiere la interfaz de usuario web de cada archivo JSON.

Una vez que haya configurado una base de datos en el clúster de Azure Data Explorer o en un clúster gratuito, como se describe en la primera sección de este artículo, vaya a esa base de datos.

Inicie sesión en la interfaz de usuario web de Azure Data Explorer.
En el menú de la izquierda, seleccione Consulta.

A continuación, siga estos pasos para cada archivo JSON exportado para obtener los datos exportados en esa base de datos de Azure Data Explorer como una nueva tabla.

Haga clic derecho sobre el nombre de la base de datos donde desea cargar los datos. Seleccione para obtener datos.
Seleccione el origen de datos de la lista disponible. En este tutorial, vas a importar datos de un archivo local .
Seleccione + Nueva tabla y escriba un nombre de tabla, en función del nombre del archivo JSON que va a importar, por ejemplo, si va a importar EntraUsers.json, asigne el nombre EntraUsers a la tabla. Después de la primera importación, la tabla ya existe y puede seleccionarla como tabla de destino para una importación posterior.
Seleccione Explorar archivos, seleccione el archivo JSON y seleccione Siguiente.
Azure Data Explorer detecta automáticamente el esquema y proporciona una vista previa en la pestaña Inspeccionar. Seleccione Finalizar para crear la tabla e importar los datos de ese archivo. Una vez que se ingieren los datos, haga clic en Cerrar.
Repita cada uno de los pasos anteriores para cada uno de los archivos JSON que generó en la sección anterior.

Al final de esos pasos tendrá las tablas EntraUsers, EntraGroups, EntraGroupMembership, Applications, AppRolesy AppRoleAssignments en la base de datos.

4: Extracción de datos de Gobierno de Microsoft Entra ID con PowerShell

En esta sección, usará PowerShell para extraer datos de los servicios de Gobierno de Microsoft Entra ID. Si no tiene Microsoft Entra ID Governance, Microsoft Entra ID P2 o Microsoft Entra Suite, puede continuar con la sección para usar Azure Data Explorer y crear informes personalizados.

Para ello, es posible que tenga que instalar módulos de Microsoft Graph PowerShell para extraer datos de la gobernanza de Microsoft Entra ID. La primera vez que su organización use estos módulos para este escenario, debe tener un rol de administrador global para permitir que Microsoft Graph PowerShell conceda consentimiento para su uso en el inquilino. Las interacciones posteriores pueden usar un rol con privilegios inferiores.

Abra PowerShell.
Si no tiene todos los módulos de PowerShell de Microsoft Graph ya instalados, instale los módulos de Microsoft Graph necesarios. Los siguientes módulos son necesarios para esta sección del tutorial: Microsoft.Graph.Identity.Governance. Si ya tiene instalados estos módulos, continúe en el paso siguiente.

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

Importe los módulos en la sesión actual de PowerShell.

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

Conéctese a Microsoft Graph. En esta sección del tutorial se muestra cómo recuperar datos de revisiones de acceso y administración de derechos, por lo que requiere los ámbitos de permisos AccessReview.Read.All y EntitlementManagement.Read.All. Para otros casos de uso de informes, como para flujos de trabajo de PIM o ciclo de vida, actualice el parámetro Scopes con los permisos necesarios. Para obtener más información sobre los permisos, consulte Referencia de permisos de Microsoft Graph.

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

Consultas de PowerShell para obtener datos de gobernanza de ID de Entra de Microsoft necesarios para crear informes personalizados en Azure Data Explorer

Puede usar consultas para extraer datos de gobernanza de Microsoft Entra ID desde Microsoft Graph mediante PowerShell y exportar los datos a archivos JSON, que se importan en Azure Data Explorer en la sección siguiente. Puede haber varios escenarios para generar informes con este tipo de datos, entre los que se incluyen:

informes sobre las revisiones de acceso históricas
Elaboración de informes sobre asignaciones a través de la administración de derechos

Acceder a los datos de la definición del cronograma de revisión

Genere un archivo JSON con nombres de definición de revisión de acceso e identificadores que se usan para crear vistas personalizadas en Azure Data Explorer. El ejemplo incluye todas las revisiones de acceso, pero se puede incluir un filtrado adicional si es necesario. Para obtener más información, consulte y utilice el parámetro de consulta 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"

Acceder a los datos de instancia de revisión de Access

Para exportar todas las definiciones, instancias y decisiones de Access Review en un formato de carpeta estructurado mediante PowerShell, puede usar Microsoft Graph API. Este enfoque garantiza que los datos se organizan jerárquicamente y se alinean con la estructura de carpetas especificada.

Antes de comenzar, tenga en cuenta lo siguiente:

Asegúrese de que tiene los permisos necesarios para acceder a los datos de revisiones de acceso en Microsoft Graph.
Según el volumen de datos, el tiempo de ejecución del script puede variar. Supervise el proceso y ajuste los parámetros según sea necesario.

Descargue el script Export_Access_Reviews.ps1 y guárdelo localmente.
En el Explorador de archivos, desbloquee el script para que se pueda ejecutar en PowerShell.
Ejecute el comando siguiente, que generará todos los datos en tres subcarpetas ReviewInstances, ReviewInstanceDecisionItems y ReviewInstanceContactedReviewers.

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

Obtención de datos del paquete de acceso de administración de derechos

Genere un archivo JSON con nombres de paquete de acceso e identificadores que se usan para crear vistas personalizadas en Azure Data Explorer. El ejemplo incluye todos los paquetes de acceso, pero se puede incluir un filtrado adicional si es necesario.

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

Obtener datos de asignación de paquetes de acceso para gestión de autorizaciones

Genere un archivo JSON con asignaciones para acceder a paquetes que se usan para crear vistas personalizadas en Azure Data Explorer. El ejemplo incluye todas las asignaciones que se entregan, pero se puede incluir un filtrado adicional si es necesario.

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

5: Creación de tablas e importación de archivos JSON con datos de Gobierno de Microsoft Entra ID en Azure Data Explorer

En esta sección, se importan los archivos JSON recién creados para los servicios de Gobierno de Microsoft Entra ID en Azure Data Explorer, junto con los datos ya importados para los servicios de Microsoft Entra ID, para su posterior análisis. En la primera importación mediante la interfaz de usuario web de Azure Data Explorer, creará tablas basadas en el esquema que sugiere la interfaz de usuario web de cada archivo JSON.

En el clúster de Azure Data Explorer o en el clúster gratuito, vaya a la base de datos que contiene los datos de Microsoft Entra ID.

Inicie sesión en la interfaz de usuario web de Azure Data Explorer.
En el menú de la izquierda, seleccione Consulta.

A continuación, siga estos pasos para cada archivo JSON exportado de la sección anterior para obtener los datos exportados en esa base de datos de Azure Data Explorer como una nueva tabla.

Haga clic derecho sobre el nombre de la base de datos donde desea cargar los datos. Seleccione para obtener datos.
Seleccione el origen de datos de la lista disponible. En este tutorial, vas a importar datos de un archivo local .
Seleccione + Nueva tabla y escriba un nombre de tabla, en función del nombre del archivo JSON que va a importar. Después de la primera importación, la tabla ya existe y puede seleccionarla como tabla de destino para una importación posterior.
Seleccione Explorar archivos, seleccione el archivo JSON y seleccione Siguiente.
Azure Data Explorer detecta automáticamente el esquema y proporciona una vista previa en la pestaña Inspeccionar. Seleccione Finalizar para crear la tabla e importar los datos de ese archivo. Una vez que se ingieren los datos, haga clic en Cerrar.
Repita cada uno de los pasos anteriores para cada uno de los archivos JSON que generó en la sección anterior, para cada una de las carpetas.
Si hay muchos archivos en una carpeta, puede usar lightingest para importar el resto una vez creada la tabla.

Al final de esos pasos tendrá las tablas EntraAccessReviewDefinitions, EntraAccessPackagesy EntraAccessPackageAssignments, ReviewInstances, ReviewInstanceDecisionItems, ReviewInstanceContactedReviewers en la base de datos, además de las tablas creadas en la sección 3.

6: Uso de Azure Data Explorer para crear informes personalizados

Con los datos ahora disponibles en Azure Data Explorer, está listo para empezar a crear informes personalizados en función de sus requisitos empresariales.

Azure Data Explorer es una eficaz herramienta de análisis de datos que es altamente escalable y flexible, lo que proporciona un entorno ideal para generar informes de acceso de usuarios personalizados. Azure Data Explorer usa el lenguaje de consulta Kusto (KQL).

Inicie sesión en la interfaz de usuario web de Azure Data Explorer.
En el menú de la izquierda, seleccione Consulta.

Las siguientes consultas proporcionan ejemplos de informes comunes, pero puede personalizar estos informes para satisfacer sus necesidades y crear informes adicionales.

También puede ver los informes en Excel, seleccionando la pestaña Exportar y luego seleccionando Abrir en Excel.

Ejemplo 1: Generación de asignaciones de roles de aplicación para asignaciones directas y de grupo para una fecha de instantánea específica

Este informe proporciona una vista de quién tenía el acceso y cuándo a la aplicación de destino y se puede usar para auditorías de seguridad, comprobación de cumplimiento y comprensión de los patrones de acceso dentro de la organización.

Esta consulta tiene como destino una aplicación específica dentro de Microsoft Entra AD y analiza las asignaciones de roles a partir de una fecha determinada. La consulta recupera asignaciones de roles directas y basadas en grupos, combinando estos datos con los detalles del usuario de la tabla EntraUsers y la información de roles de la tabla AppRoles. En la consulta siguiente, establezca targetSnapshotDate en el valor snapshotDate que se usó al cargar los datos.

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

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

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

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

// Process group-based assignments 

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

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

Ejemplo 2: Creación de un informe de auditoría básico con datos entra que muestran quién tenía acceso a una aplicación entre estas dos fechas

Este informe proporciona una vista de quién tenía el acceso a la aplicación de destino entre dos fechas y se puede usar para auditorías de seguridad, comprobación de cumplimiento y comprensión de los patrones de acceso dentro de la organización.

Esta consulta tiene como destino una aplicación específica dentro del identificador de Microsoft Entra y analiza las asignaciones de roles entre dos fechas. La consulta recupera asignaciones de roles directas de la tabla AppRoleAssignments y combina estos datos con los detalles del usuario de la tabla de EntraUsers y la información de roles de la tabla 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()

Ejemplo 3: Obtención de usuarios agregados a una aplicación entre dos fechas de instantánea de datos

Estos informes proporcionan una vista de los usuarios a los que se les ha asignado una asignación de roles de aplicación a la aplicación de destino entre dos fechas. Estos informes se pueden usar para realizar un seguimiento de los cambios en el acceso a la aplicación a lo largo del tiempo.

Esta consulta tiene como destino una aplicación específica dentro del identificador de Entra de Microsoft y cambia a las asignaciones de roles entre una fecha de inicio y finalización.

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

Ejemplo 4: Revisiones de acceso

Revisar la información de finalización y escala de tiempo

Una vez cargados los datos, use las siguientes consultas de Kusto para revisarlos.

¿Cuándo se completó el último ciclo de revisión de acceso? ¿Cuánto tiempo tardó?

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

¿Se lleva a cabo el proceso de revisión de acceso a tiempo (por ejemplo, trimestralmente, anualmente)?

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

Revisar participación e involucración

¿Quiénes fueron los revisores asignados?

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

¿Qué revisores participaron activamente y proporcionaron respuestas?

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

Porcentaje de revisores que respondieron a la solicitud de revisión de acceso.

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

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

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

¿Cuándo completó cada revisor sus tareas?

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

¿Qué revisores no tomaron ninguna decisión?

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

Porcentaje de revisores que no interactuaron.

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

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

¿Se desencadenaron recordatorios para revisores que no responden? ¿Hay decisiones pendientes?

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

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

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

Cambios de usuarios y acceso

¿Quién perdió el acceso a recursos específicos durante la revisión de acceso?

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

¿Se marcaron los usuarios debido a la inactividad?

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

Fecha de eliminación de acceso y razonamiento para perder el acceso.

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

Usuarios sin decisiones tomadas.

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

Opiniones sin revisores.

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

Reseñas sin usuarios.

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

Revisar los datos de decisión

Decisiones tomadas: Aprobada, Denegada o Sin cambios.

ReviewInstanceDecisionItems 
| summarize count() by Decision

Número de usuarios aprobados o denegados de acceso.

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

¿Se documentaron los motivos de aprobación?

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

Comprobaciones de calidad y cumplimiento de la revisión de acceso

¿Se han considerado revocaciones de acceso para los usuarios inactivos?

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

¿Hubo algún acceso que no se eliminó correctamente?

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

¿Los revisores documentaron sus decisiones?

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

¿Se capturaron comentarios para cada usuario?

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

Configurar importaciones continuas

En este tutorial se muestra un proceso de extracción, transformación y carga de datos de un solo uso (ETL) para rellenar Azure Data Explorer con una sola instantánea con fines de informes. Para los informes en curso o para comparar los cambios a lo largo del tiempo, puede automatizar el proceso de rellenar Azure Data Explorer desde Microsoft Entra, de modo que la base de datos siga teniendo datos actuales.

Puede usar Azure Automation, un servicio en la nube de Azure, para hospedar los scripts de PowerShell necesarios para extraer datos de Microsoft Entra ID y Microsoft Entra ID Governance. Para obtener más información, consulte Automatización de tareas de Gobierno de Microsoft Entra ID con Azure Automation.

También puede usar características de Azure o herramientas de línea de comandos, como lightingest para incorporar datos y rellenar una tabla ya existente. Para más información, consulte Uso de LightIngest para ingerir datos en Azure Data Explorer.

Por ejemplo, para cargar un archivo EntraAccessPackages.json en el directorio actual en la tabla EntraAccessPackages como usuario que ha iniciado sesión actualmente:

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

Consulta de datos en Azure Monitor

Si está enviando los registros de auditoría, de inicio de sesión u otros registros de Microsoft Entra a Azure Monitor, entonces puede incorporar estos registros desde esa área de trabajo de Log Analytics de Azure Monitor en sus consultas. Para más información sobre la relación de Azure Monitor y Azure Data Explorer, consulte Consulta de datos en Azure Monitor mediante Azure Data Explorer.

Inicie sesión en el Centro de administración de Microsoft Entra.
Seleccione configuración de diagnóstico.
Seleccione el área de trabajo de Log Analytics donde va a enviar los registros.
En la información general del área de trabajo de Log Analytics, registre el identificador de suscripción, el nombre del grupo de recursos y el nombre del área de trabajo.
Inicie sesión en Azure Portal.
Vaya a la interfaz de usuario web de Azure Data Explorer.
Asegúrese de que aparece el clúster de Azure Data Explorer.
Seleccione + Agregar y, a continuación, Conexión.
En la ventana Agregar conexión, escriba la dirección URL al área de trabajo de Log Analytics, formada a partir del nombre de host específico de la nube, el identificador de suscripción, el nombre del grupo de recursos y el nombre del área de trabajo de Log Analytics de Azure Monitor, como se describe en Agregar un área de trabajo de Log Analytics.
Una vez establecida la conexión, el área de trabajo de Log Analytics aparecerá en el panel izquierdo con el clúster nativo de Azure Data Explorer.
En el menú de la izquierda, seleccione Consultay seleccione el clúster de Azure Data Explorer.

En el panel de consulta, puede hacer referencia a las tablas de Azure Monitor que contienen los registros de Microsoft Entra en las consultas de Azure Data Explorer. Por ejemplo:

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

Incorporación de datos de otros orígenes

También puede crear tablas adicionales en Azure Data Explorer para ingerir datos de otros orígenes. Si los datos están en un archivo JSON, similar a los ejemplos anteriores, o en un archivo CSV, puede crear la tabla en el momento en que obtiene los datos del archivo por primera vez. Una vez que la tabla sea creada, también se puede usar LightIngest para ingerir datos en Azure Data Explorer desde un archivo JSON o CSV.

Para más información sobre la ingesta de datos, consulte introducción a la ingesta de datos de Azure Data Explorer.

Ejemplo 5: Combinar asignaciones de aplicaciones de Entra y otra fuente para crear un informe de todos los usuarios que tenían acceso a una aplicación entre dos fechas.

En este informe se muestra cómo puede combinar datos de dos sistemas independientes para crear informes personalizados en Azure Data Explorer. Agrega datos sobre los usuarios, sus roles y otros atributos de dos sistemas en un formato unificado para el análisis o los informes.

En este ejemplo se supone que hay una tabla denominada salesforceAssignments con columnas UserName, Name, EmployeeId, Department, JobTitle, AppName, Roley CreatedDateTime rellenados mediante la incorporación de datos de otra aplicación.

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

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

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

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

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

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

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

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

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

Compartir vía