Gestire gli utenti di un'applicazione che non supporta il provisioning - Microsoft PowerShell

  • Articolo

Esistono tre scenari comuni in cui è necessario popolare l'ID Microsoft Entra con gli utenti esistenti di un'applicazione prima di usare l'applicazione con una funzionalità di governance dell'ID di Microsoft Entra, ad esempio le verifiche di accesso.

  • Applicazione migrata all'ID Microsoft Entra dopo aver usato il proprio provider di identità
  • Applicazione che non usa Microsoft Entra ID come unico provider di identità
  • L'applicazione non usa Microsoft Entra ID come provider di identità né supporta il provisioning

Per altre informazioni su questi primi due scenari, in cui l'applicazione supporta il provisioning o usa una directory LDAP, un database SQL, dispone di un'API SOAP o REST o si basa su Microsoft Entra ID come provider di identità, vedere l'articolo che regola gli utenti esistenti di un'applicazione. Questo articolo illustra come usare le funzionalità di governance delle identità per gli utenti esistenti di tali categorie di applicazioni.

Questo articolo illustra il terzo scenario. Per alcune applicazioni legacy potrebbe non essere possibile rimuovere altri provider di identità o l'autenticazione delle credenziali locali dall'applicazione o abilitare il supporto per i protocolli di provisioning per tali applicazioni. Per tali applicazioni, se si vuole usare Microsoft Entra ID per verificare chi ha accesso a tale applicazione o rimuovere l'accesso di un utente da tale applicazione, è necessario creare assegnazioni in Microsoft Entra ID che rappresentano gli utenti dell'applicazione. Questo articolo illustra lo scenario di un'applicazione che non usa Microsoft Entra ID come provider di identità e non supporta il provisioning.

Requisiti di licenza

L'uso di questa funzionalità richiede le licenze di Microsoft Entra ID Governance. Per trovare la licenza appropriata per i requisiti, vedere Nozioni fondamentali sulla governance degli ID di Microsoft Entra ID.

Terminologia

Questo articolo illustra il processo di gestione delle assegnazioni di ruolo dell'applicazione usando i cmdlet di PowerShell di Microsoft Graph. Usa la terminologia di Microsoft Graph seguente.

Diagramma che illustra la terminologia di Microsoft Graph.

In Microsoft Entra ID, un'entità servizio (ServicePrincipal) rappresenta un'applicazione nella directory di una determinata organizzazione. ServicePrincipal dispone di una proprietà denominata AppRoles che elenca i ruoli supportati da un'applicazione, ad esempio Marketing specialist. AppRoleAssignment collega un utente a un'entità servizio e specifica il ruolo che l'utente ha in tale applicazione.

È anche possibile usare i pacchetti di accesso alla gestione entitlement di Microsoft Entra per concedere agli utenti l'accesso limitato al tempo all'applicazione. Nella gestione AccessPackage entitlement, contiene uno o più ruoli delle risorse, potenzialmente da più entità servizio. AccessPackage include anche assegnazioni (Assignment) per gli utenti al pacchetto di accesso.

Quando si crea un'assegnazione per un utente a un pacchetto di accesso, la gestione entitlement di Microsoft Entra crea automaticamente le istanze necessarie AppRoleAssignment per l'utente a ogni applicazione. Per altre informazioni, vedere l'esercitazione Gestire l'accesso alle risorse nella gestione entitlement di Microsoft Entra su come creare pacchetti di accesso tramite PowerShell.

Operazioni preliminari

  • È necessario avere una delle licenze seguenti nel tenant:

    • Microsoft Entra ID P2 o Microsoft Entra ID Governance
    • Licenza Enterprise Mobility + Security E5

  • È necessario avere un ruolo amministrativo appropriato. Se è la prima volta che si eseguono questi passaggi, è necessario il ruolo Global Amministrazione istrator per autorizzare l'uso di Microsoft Graph PowerShell nel tenant.

  • L'applicazione necessita di un'entità servizio nel tenant. Se un'entità servizio non esiste già, è possibile registrare un'applicazione per rappresentarla in Microsoft Entra ID.

Raccogliere utenti esistenti da un'applicazione

Il primo passo per garantire che tutti gli utenti vengano registrati in Microsoft Entra ID consiste nel raccogliere l'elenco degli utenti esistenti che hanno accesso all'applicazione.

Alcune applicazioni potrebbero avere un comando predefinito per esportare un elenco di utenti correnti dall'archivio dati. In altri casi, l'applicazione potrebbe basarsi su una directory o un database esterno.

In alcuni ambienti, l'applicazione potrebbe trovarsi in un segmento di rete o in un sistema non appropriato per la gestione dell'accesso a Microsoft Entra ID. Potrebbe quindi essere necessario estrarre l'elenco di utenti da tale applicazione, directory o database e quindi trasferirlo come file in un altro sistema che può essere usato per le interazioni con Microsoft Entra.

Se l'applicazione ha una directory LDAP o un database SQL, vedere Raccogliere utenti esistenti da un'applicazione per consigli su come estrarre la raccolta utenti.

In caso contrario, se l'applicazione non dispone di una directory o di un database, sarà necessario contattare il proprietario dell'applicazione e specificare un elenco di utenti. Può trattarsi di un formato, ad esempio un file CSV, con una riga per utente. Assicurarsi che un campo di ogni utente nel file contenga un identificatore univoco, ad esempio un indirizzo di posta elettronica, presente anche per gli utenti in Microsoft Entra ID.

Se il sistema non dispone dei cmdlet di Microsoft Graph PowerShell installati o non dispone della connettività all'ID Microsoft Entra, trasferire il file CSV che contiene l'elenco di utenti a un sistema in cui sono installati i cmdlet di Microsoft Graph PowerShell.

Verificare che Microsoft Entra ID abbia utenti che corrispondono agli utenti dell'applicazione

Ora che si dispone di un elenco di tutti gli utenti ottenuti dall'applicazione, sarà possibile associare gli utenti dall'archivio dati dell'applicazione con gli utenti in Microsoft Entra ID.

Recuperare gli ID degli utenti in Microsoft Entra ID

Questa sezione illustra come interagire con Microsoft Entra ID usando i cmdlet di PowerShell di Microsoft Graph.

La prima volta che l'organizzazione usa questi cmdlet per questo scenario, è necessario trovarsi in un ruolo globale Amministrazione istrator per consentire l'uso di Microsoft Graph PowerShell nel tenant. Le interazioni successive possono usare un ruolo con privilegi inferiori, ad esempio:

  • Utente Amministrazione istrator, se si prevede di creare nuovi utenti.
  • Application Amministrazione istrator o Identity Governance Amministrazione istrator, se si gestiscono solo le assegnazioni di ruolo dell'applicazione.

  1. Aprire PowerShell.

  2. Se i moduli di Microsoft Graph PowerShell non sono già installati, installare il Microsoft.Graph.Users modulo e altri usando questo comando:

    Install-Module Microsoft.Graph

    Se i moduli sono già installati, assicurarsi di usare una versione recente:

    Update-Module microsoft.graph.users,microsoft.graph.identity.governance,microsoft.graph.applications

  3. Connessione a Microsoft Entra ID:

    $msg = Connect-MgGraph -ContextScope Process -Scopes "User.ReadWrite.All,Application.ReadWrite.All,AppRoleAssignment.ReadWrite.All,EntitlementManagement.ReadWrite.All"

  4. Se è la prima volta che è stato usato questo comando, potrebbe essere necessario fornire il consenso per consentire agli strumenti della riga di comando di Microsoft Graph di avere queste autorizzazioni.

  5. Leggere l'elenco degli utenti ottenuti dall'archivio dati dell'applicazione nella sessione di PowerShell. Se l'elenco degli utenti si trovava in un file CSV, è possibile usare il cmdlet Import-Csv di PowerShell e specificare il nome del file della sezione precedente come argomento.

    Ad esempio, se il file ottenuto da SAP Cloud Identity Services è denominato Users-exported-from-sap.csv e si trova nella directory corrente, immettere questo comando.

    $filename = ".\Users-exported-from-sap.csv"
$dbusers = Import-Csv -Path $filename -Encoding UTF8

    Per un altro esempio se si usa un database o una directory, se il file è denominato users.csv e si trova nella directory corrente, immettere questo comando:

    $filename = ".\users.csv"
$dbusers = Import-Csv -Path $filename -Encoding UTF8

  6. Scegliere la colonna del file users.csv che corrisponderà a un attributo di un utente in Microsoft Entra ID.

    Se si usa SAP Cloud Identity Services, il mapping predefinito è l'attributo userName SAP SCIM con l'attributo userPrincipalNameMICROSOFT Entra ID :

    $db_match_column_name = "userName"
$azuread_match_attr_name = "userPrincipalName"

    Per un altro esempio se si usa un database o una directory, è possibile che siano presenti utenti in un database in cui il valore nella colonna denominata EMail è lo stesso valore dell'attributo userPrincipalNameMicrosoft Entra :

    $db_match_column_name = "EMail"
$azuread_match_attr_name = "userPrincipalName"

  7. Recuperare gli ID di tali utenti in Microsoft Entra ID.

    Lo script di PowerShell seguente usa i $dbusersvalori , $db_match_column_namee $azuread_match_attr_name specificati in precedenza. Eseguirà una query su Microsoft Entra ID per individuare un utente con un attributo con un valore corrispondente per ogni record nel file di origine. Se sono presenti molti utenti nel file ottenuto dall'origine SAP Cloud Identity Services, dal database o dalla directory, il completamento di questo script potrebbe richiedere alcuni minuti. Se non si dispone di un attributo in Microsoft Entra ID che ha il valore e che deve usare un'espressione contains di filtro o un'altra, sarà necessario personalizzare questo script e che nel passaggio 11 riportato di seguito per usare un'espressione di filtro diversa.

    $dbu_not_queried_list = @()
$dbu_not_matched_list = @()
$dbu_match_ambiguous_list = @()
$dbu_query_failed_list = @()
$azuread_match_id_list = @()
$azuread_not_enabled_list = @()
$dbu_values = @()
$dbu_duplicate_list = @()

foreach ($dbu in $dbusers) { 
   if ($null -ne $dbu.$db_match_column_name -and $dbu.$db_match_column_name.Length -gt 0) { 
      $val = $dbu.$db_match_column_name
      $escval = $val -replace "'","''"
      if ($dbu_values -contains $escval) { $dbu_duplicate_list += $dbu; continue } else { $dbu_values += $escval }
      $filter = $azuread_match_attr_name + " eq '" + $escval + "'"
      try {
         $ul = @(Get-MgUser -Filter $filter -All -Property Id,accountEnabled -ErrorAction Stop)
         if ($ul.length -eq 0) { $dbu_not_matched_list += $dbu; } elseif ($ul.length -gt 1) {$dbu_match_ambiguous_list += $dbu } else {
            $id = $ul[0].id; 
            $azuread_match_id_list += $id;
            if ($ul[0].accountEnabled -eq $false) {$azuread_not_enabled_list += $id }
         } 
      } catch { $dbu_query_failed_list += $dbu } 
    } else { $dbu_not_queried_list += $dbu }
}

  8. Visualizzare i risultati delle query precedenti. Verificare se uno degli utenti in SAP Cloud Identity Services, il database o la directory non è stato possibile trovare in Microsoft Entra ID, a causa di errori o corrispondenze mancanti.

    Lo script di PowerShell seguente visualizzerà i conteggi dei record che non si trovano:

    $dbu_not_queried_count = $dbu_not_queried_list.Count
if ($dbu_not_queried_count -ne 0) {
  Write-Error "Unable to query for $dbu_not_queried_count records as rows lacked values for $db_match_column_name."
}
$dbu_duplicate_count = $dbu_duplicate_list.Count
if ($dbu_duplicate_count -ne 0) {
  Write-Error "Unable to locate Microsoft Entra ID users for $dbu_duplicate_count rows as multiple rows have the same value"
}
$dbu_not_matched_count = $dbu_not_matched_list.Count
if ($dbu_not_matched_count -ne 0) {
  Write-Error "Unable to locate $dbu_not_matched_count records in Microsoft Entra ID by querying for $db_match_column_name values in $azuread_match_attr_name."
}
$dbu_match_ambiguous_count = $dbu_match_ambiguous_list.Count
if ($dbu_match_ambiguous_count -ne 0) {
  Write-Error "Unable to locate $dbu_match_ambiguous_count records in Microsoft Entra ID as attribute match ambiguous."
}
$dbu_query_failed_count = $dbu_query_failed_list.Count
if ($dbu_query_failed_count -ne 0) {
  Write-Error "Unable to locate $dbu_query_failed_count records in Microsoft Entra ID as queries returned errors."
}
$azuread_not_enabled_count = $azuread_not_enabled_list.Count
if ($azuread_not_enabled_count -ne 0) {
 Write-Error "$azuread_not_enabled_count users in Microsoft Entra ID are blocked from sign-in."
}
if ($dbu_not_queried_count -ne 0 -or $dbu_duplicate_count -ne 0 -or $dbu_not_matched_count -ne 0 -or $dbu_match_ambiguous_count -ne 0 -or $dbu_query_failed_count -ne 0 -or $azuread_not_enabled_count) {
 Write-Output "You will need to resolve those issues before access of all existing users can be reviewed."
}
$azuread_match_count = $azuread_match_id_list.Count
Write-Output "Users corresponding to $azuread_match_count records were located in Microsoft Entra ID."

  9. Al termine dello script, indicherà un errore se eventuali record dell'origine dati non si trovano in Microsoft Entra ID. Se non tutti i record per gli utenti dell'archivio dati dell'applicazione potrebbero trovarsi come utenti in Microsoft Entra ID, è necessario analizzare quali record non corrispondono e perché.

    Ad esempio, l'indirizzo di posta elettronica di un utente e userPrincipalName potrebbe essere stato modificato nell'ID Microsoft Entra senza aggiornare la proprietà corrispondente mail nell'origine dati dell'applicazione. In alternativa, l'utente potrebbe aver già lasciato l'organizzazione, ma si trova ancora nell'origine dati dell'applicazione. In alternativa, potrebbe essere presente un account fornitore o amministratore con privilegi avanzati nell'origine dati dell'applicazione che non corrisponde a una persona specifica nell'ID Microsoft Entra.

  10. Se sono presenti utenti che non potevano trovarsi in Microsoft Entra ID o non erano attivi e non sono stati in grado di accedere, ma si vuole avere l'accesso esaminato o i relativi attributi aggiornati in SAP Cloud Identity Services, nel database o nella directory, è necessario aggiornare l'applicazione, la regola di corrispondenza o aggiornare o creare utenti di Microsoft Entra per loro. Per altre informazioni sulle modifiche da apportare, vedere Gestire mapping e account utente nelle applicazioni che non corrispondono agli utenti in Microsoft Entra ID.

    Se si sceglie l'opzione di creazione di utenti in Microsoft Entra ID, è possibile creare utenti in blocco usando uno dei due elementi seguenti:

    Assicurarsi che questi nuovi utenti siano popolati con gli attributi necessari per Microsoft Entra ID per associarli in un secondo momento agli utenti esistenti nell'applicazione e gli attributi richiesti dall'ID Microsoft Entra, inclusi userPrincipalName, mailNickname e displayName. Deve userPrincipalName essere univoco tra tutti gli utenti nella directory.

    Ad esempio, si potrebbero avere utenti in un database in cui il valore nella colonna denominata EMail è il valore che si vuole usare come nome dell'entità utente Microsoft Entra, il valore nella colonna Alias contiene il nome alternativo della posta elettronica microsoft Entra ID e il valore nella colonna Full name contiene il nome visualizzato dell'utente:

    $db_display_name_column_name = "Full name"
$db_user_principal_name_column_name = "Email"
$db_mail_nickname_column_name = "Alias"

    È quindi possibile usare questo script per creare utenti di Microsoft Entra per quelli in SAP Cloud Identity Services, nel database o nella directory che non corrispondono agli utenti in Microsoft Entra ID. Si noti che potrebbe essere necessario modificare questo script per aggiungere altri attributi di Microsoft Entra necessari nell'organizzazione o se non è né mailNicknameuserPrincipalName, per fornire l'attributo $azuread_match_attr_name Microsoft Entra.

    $dbu_missing_columns_list = @()
$dbu_creation_failed_list = @()
foreach ($dbu in $dbu_not_matched_list) {
   if (($null -ne $dbu.$db_display_name_column_name -and $dbu.$db_display_name_column_name.Length -gt 0) -and
       ($null -ne $dbu.$db_user_principal_name_column_name -and $dbu.$db_user_principal_name_column_name.Length -gt 0) -and
       ($null -ne $dbu.$db_mail_nickname_column_name -and $dbu.$db_mail_nickname_column_name.Length -gt 0)) {
      $params = @{
         accountEnabled = $false
         displayName = $dbu.$db_display_name_column_name
         mailNickname = $dbu.$db_mail_nickname_column_name
         userPrincipalName = $dbu.$db_user_principal_name_column_name
         passwordProfile = @{
           Password = -join (((48..90) + (96..122)) * 16 | Get-Random -Count 16 | % {[char]$_})
         }
      }
      try {
        New-MgUser -BodyParameter $params
      } catch { $dbu_creation_failed_list += $dbu; throw }
   } else {
      $dbu_missing_columns_list += $dbu
   }
}

  11. Dopo aver aggiunto gli utenti mancanti all'ID Microsoft Entra, eseguire di nuovo lo script del passaggio 7. Eseguire quindi lo script dal passaggio 8. Verificare che non vengano segnalati errori.

    $dbu_not_queried_list = @()
$dbu_not_matched_list = @()
$dbu_match_ambiguous_list = @()
$dbu_query_failed_list = @()
$azuread_match_id_list = @()
$azuread_not_enabled_list = @()
$dbu_values = @()
$dbu_duplicate_list = @()

foreach ($dbu in $dbusers) { 
   if ($null -ne $dbu.$db_match_column_name -and $dbu.$db_match_column_name.Length -gt 0) { 
      $val = $dbu.$db_match_column_name
      $escval = $val -replace "'","''"
      if ($dbu_values -contains $escval) { $dbu_duplicate_list += $dbu; continue } else { $dbu_values += $escval }
      $filter = $azuread_match_attr_name + " eq '" + $escval + "'"
      try {
         $ul = @(Get-MgUser -Filter $filter -All -Property Id,accountEnabled -ErrorAction Stop)
         if ($ul.length -eq 0) { $dbu_not_matched_list += $dbu; } elseif ($ul.length -gt 1) {$dbu_match_ambiguous_list += $dbu } else {
            $id = $ul[0].id; 
            $azuread_match_id_list += $id;
            if ($ul[0].accountEnabled -eq $false) {$azuread_not_enabled_list += $id }
         } 
      } catch { $dbu_query_failed_list += $dbu } 
    } else { $dbu_not_queried_list += $dbu }
}

$dbu_not_queried_count = $dbu_not_queried_list.Count
if ($dbu_not_queried_count -ne 0) {
  Write-Error "Unable to query for $dbu_not_queried_count records as rows lacked values for $db_match_column_name."
}
$dbu_duplicate_count = $dbu_duplicate_list.Count
if ($dbu_duplicate_count -ne 0) {
  Write-Error "Unable to locate Microsoft Entra ID users for $dbu_duplicate_count rows as multiple rows have the same value"
}
$dbu_not_matched_count = $dbu_not_matched_list.Count
if ($dbu_not_matched_count -ne 0) {
  Write-Error "Unable to locate $dbu_not_matched_count records in Microsoft Entra ID by querying for $db_match_column_name values in $azuread_match_attr_name."
}
$dbu_match_ambiguous_count = $dbu_match_ambiguous_list.Count
if ($dbu_match_ambiguous_count -ne 0) {
  Write-Error "Unable to locate $dbu_match_ambiguous_count records in Microsoft Entra ID as attribute match ambiguous."
}
$dbu_query_failed_count = $dbu_query_failed_list.Count
if ($dbu_query_failed_count -ne 0) {
  Write-Error "Unable to locate $dbu_query_failed_count records in Microsoft Entra ID as queries returned errors."
}
$azuread_not_enabled_count = $azuread_not_enabled_list.Count
if ($azuread_not_enabled_count -ne 0) {
 Write-Warning "$azuread_not_enabled_count users in Microsoft Entra ID are blocked from sign-in."
}
if ($dbu_not_queried_count -ne 0 -or $dbu_duplicate_count -ne 0 -or $dbu_not_matched_count -ne 0 -or $dbu_match_ambiguous_count -ne 0 -or $dbu_query_failed_count -ne 0 -or $azuread_not_enabled_count -ne 0) {
 Write-Output "You will need to resolve those issues before access of all existing users can be reviewed."
}
$azuread_match_count = $azuread_match_id_list.Count
Write-Output "Users corresponding to $azuread_match_count records were located in Microsoft Entra ID."

Registrare l'applicazione

Se l'applicazione è già registrata in Microsoft Entra ID, continuare con il passaggio successivo.

L'account in uso deve avere l'autorizzazione per gestire le applicazioni in Microsoft Entra ID. Uno dei seguenti ruoli di Microsoft Entra include le autorizzazioni necessarie:

  1. Creare l'applicazione e l'entità servizio.

    Ad esempio, se l'applicazione aziendale è denominata CORPDB1, immettere i comandi seguenti:

    $azuread_app_name = "CORPDB1"
$azuread_app = New-MgApplication -DisplayName $azuread_app_name
$azuread_sp = New-MgServicePrincipal -DisplayName $azuread_app_name -AppId $azuread_app.AppId

  2. Aggiungere un ruolo all'applicazione e contrassegnare l'applicazione come integrata con Microsoft Entra ID in modo che le assegnazioni possano essere esaminate. Ad esempio, se il nome del ruolo è General, specificare tale valore nei comandi di PowerShell seguenti:

    $ar0 = New-Object Microsoft.Graph.PowerShell.Models.MicrosoftGraphAppRole
$ar0.AllowedMemberTypes += "User"
$ar0.Description = "General role"
$ar0.DisplayName = "General"
$ar0.id = New-Guid
$ar0.IsEnabled = $true
$ar0.Value = "General"
$ara = @()
$ara += $ar0

$azuread_app_tags = @()
$azuread_app_tags += "WindowsAzureActiveDirectoryIntegratedApp"

$azuread_app_update = Update-MgApplication -ApplicationId $azuread_app.Id -AppRoles $ara -Tags $azuread_app_tags

Verificare la presenza di utenti non già assegnati all'applicazione

I passaggi precedenti hanno confermato che tutti gli utenti nell'archivio dati dell'applicazione esistono come utenti in Microsoft Entra ID. Tuttavia, potrebbero non essere tutti attualmente assegnati ai ruoli dell'applicazione in Microsoft Entra ID. I passaggi successivi sono quindi vedere quali utenti non hanno assegnazioni ai ruoli dell'applicazione.

  1. Cercare l'ID entità servizio per l'entità servizio dell'applicazione.

    Ad esempio, se l'applicazione aziendale è denominata CORPDB1, immettere i comandi seguenti:

    $azuread_app_name = "CORPDB1"
$azuread_sp_filter = "displayName eq '" + ($azuread_app_name -replace "'","''") + "'"
$azuread_sp = Get-MgServicePrincipal -Filter $azuread_sp_filter -All

  2. Recuperare gli utenti che hanno attualmente assegnazioni all'applicazione in Microsoft Entra ID.

    Questo si basa sulla $azuread_sp variabile impostata nel comando precedente.

    $azuread_existing_assignments = @(Get-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $azuread_sp.Id -All)

  3. Confrontare l'elenco di ID utente della sezione precedente con gli utenti attualmente assegnati all'applicazione:

    $azuread_not_in_role_list = @()
foreach ($id in $azuread_match_id_list) {
   $found = $false
   foreach ($existing in $azuread_existing_assignments) {
      if ($existing.principalId -eq $id) {
         $found = $true; break;
      }
   }
   if ($found -eq $false) { $azuread_not_in_role_list += $id }
}
$azuread_not_in_role_count = $azuread_not_in_role_list.Count
Write-Output "$azuread_not_in_role_count users in the application's data store are not assigned to the application roles."

    Se zero utenti non sono assegnati ai ruoli applicazione, a indicare che tutti gli utenti vengono assegnati ai ruoli applicazione, non è necessario apportare altre modifiche prima di eseguire una verifica di accesso.

    Tuttavia, se uno o più utenti non sono attualmente assegnati ai ruoli dell'applicazione, è necessario continuare la procedura e aggiungerli a uno dei ruoli dell'applicazione.

  4. Selezionare il ruolo dell'applicazione a cui assegnare gli utenti rimanenti.

    Un'applicazione potrebbe avere più di un ruolo. Usare questo comando per elencare i ruoli disponibili:

    $azuread_sp.AppRoles | where-object {$_.AllowedMemberTypes -contains "User"} | ft DisplayName,Id

    Selezionare il ruolo appropriato dall'elenco e ottenere il relativo ID ruolo. Ad esempio, se il nome del ruolo è General, specificare tale valore nei comandi di PowerShell seguenti:

    $azuread_app_role_name = "General"
$azuread_app_role_id = ($azuread_sp.AppRoles | where-object {$_.AllowedMemberTypes -contains "User" -and $_.DisplayName -eq $azuread_app_role_name}).Id
if ($null -eq $azuread_app_role_id) { write-error "role $azuread_app_role_name not located in application manifest"}

Creare assegnazioni di ruolo dell'app in Microsoft Entra ID

Affinché Microsoft Entra ID corrisponda agli utenti nell'applicazione con gli utenti in Microsoft Entra ID, è necessario creare assegnazioni di ruolo dell'applicazione in Microsoft Entra ID.

Quando viene creata un'assegnazione di ruolo dell'applicazione in Microsoft Entra ID per un utente a un'applicazione e l'applicazione non supporta il provisioning,

  • L'utente rimarrà all'interno dell'applicazione per un periodo illimitato, a meno che non venga aggiornato all'esterno dell'ID Microsoft Entra o fino a quando non viene rimossa l'assegnazione in Microsoft Entra ID.
  • Nella revisione successiva delle assegnazioni di ruolo dell'applicazione, l'utente verrà incluso nella revisione.
  • Se l'utente viene negato in una verifica di accesso, l'assegnazione di ruolo dell'applicazione verrà rimossa.

  1. Creare assegnazioni di ruolo dell'applicazione per gli utenti che non dispongono attualmente di assegnazioni di ruolo:

    foreach ($u in $azuread_not_in_role_list) {
   $res = New-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $azuread_sp.Id -AppRoleId $azuread_app_role_id -PrincipalId $u -ResourceId $azuread_sp.Id 
}

  2. Attendere un minuto per la propagazione delle modifiche all'interno di Microsoft Entra ID.

  3. Eseguire una query sull'ID Microsoft Entra per ottenere l'elenco aggiornato delle assegnazioni di ruolo:

    $azuread_existing_assignments = @(Get-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $azuread_sp.Id -All)

  4. Confrontare l'elenco di ID utente della sezione precedente con gli utenti ora assegnati all'applicazione:

    $azuread_still_not_in_role_list = @()
foreach ($id in $azuread_match_id_list) {
   $found = $false
   foreach ($existing in $azuread_existing_assignments) {
      if ($existing.principalId -eq $id) {
         $found = $true; break;
      }
   }
   if ($found -eq $false) { $azuread_still_not_in_role_list += $id }
}
$azuread_still_not_in_role_count = $azuread_still_not_in_role_list.Count
if ($azuread_still_not_in_role_count -gt 0) {
   Write-Output "$azuread_still_not_in_role_count users in the application's data store are not assigned to the application roles."
}

    Se gli utenti non sono assegnati ai ruoli dell'applicazione, controllare il log di controllo di Microsoft Entra per un errore di un passaggio precedente.

Selezionare i revisori appropriati

Quando si crea ogni verifica di accesso, gli amministratori possono scegliere uno o più revisori. I revisori possono eseguire una verifica scegliendo gli utenti per l'accesso continuo a una risorsa o rimuovendoli.

In genere un proprietario della risorsa è responsabile dell'esecuzione di una revisione. Se si sta creando una revisione di un gruppo, come parte della revisione dell'accesso per un'applicazione integrata nel modello B, è possibile selezionare i proprietari del gruppo come revisori. Poiché le applicazioni in Microsoft Entra ID non hanno necessariamente un proprietario, l'opzione per selezionare il proprietario dell'applicazione come revisore non è possibile. Al contrario, quando si crea la revisione, è possibile specificare i nomi dei proprietari dell'applicazione come revisori.

È anche possibile scegliere, quando si crea una revisione di un gruppo o di un'applicazione, per avere una revisione a più fasi. Ad esempio, è possibile selezionare per fare in modo che il responsabile di ogni utente assegnato esegua la prima fase della revisione e il proprietario della risorsa la seconda fase. In questo modo il proprietario della risorsa può concentrarsi sugli utenti che sono già stati approvati dal manager.

Prima di creare le revisioni, verificare di disporre di postazioni sufficienti dello SKU di governance dell'ID Microsoft Entra P2 o Microsoft Entra ID Nel tenant. Verificare inoltre che tutti i revisori siano utenti attivi con indirizzi di posta elettronica. All'avvio delle verifiche di accesso, ogni utente esamina un messaggio di posta elettronica da Microsoft Entra ID. Se il revisore non dispone di una cassetta postale, non riceverà il messaggio di posta elettronica all'avvio della revisione o a un promemoria tramite posta elettronica. Inoltre, se non sono in grado di accedere a Microsoft Entra ID, non potranno eseguire la revisione.

Creare la revisione delle assegnazioni di ruolo dell'applicazione

Dopo che gli utenti si trovano nei ruoli dell'applicazione e i revisori sono identificati, è possibile configurare l'ID Microsoft Entra per avviare una revisione.

Seguire le istruzioni nella guida per la creazione di una verifica di accesso di gruppi o applicazioni per creare la revisione delle assegnazioni di ruolo dell'applicazione. Configurare la revisione per applicare i risultati al termine.

Recuperare le assegnazioni aggiornate al termine delle revisioni

  1. Al termine della verifica, è possibile recuperare l'elenco aggiornato degli utenti con assegnazioni di ruolo dell'applicazione.

    $res = (Get-MgServicePrincipalAppRoleAssignedTo -ServicePrincipalId $azuread_sp.Id -All)

  2. Le colonne PrincipalDisplayName e PrincipalId contengono i nomi visualizzati e gli ID utente di Microsoft Entra di ogni utente che mantiene un'assegnazione di ruolo dell'applicazione.

Configurare l'integrazione della gestione entitlement con ServiceNow per il ticketing (facoltativo)

Se si dispone di ServiceNow, è possibile configurare facoltativamente la creazione automatica di ticket ServiceNow usando l'integrazione della gestione entitlement tramite App per la logica. In questo scenario, la gestione entitlement può creare automaticamente ticket ServiceNow per il provisioning manuale degli utenti che hanno ricevuto assegnazioni di pacchetti di accesso.

Passaggi successivi