Proteggere le app Java JBoss EAP usando gruppi e attestazioni di gruppo

Questo articolo illustra come creare un'app Java JBoss EAP che consente agli utenti di accedere con Libreria di Autenticazione Microsoft (MSAL) per Java. L'app limita anche l'accesso alle pagine in base all'appartenenza al gruppo di sicurezza Microsoft Entra ID.

Il diagramma seguente illustra la topologia dell'app:

Diagramma che mostra la topologia dell'app.

L'app client usa MSAL per Java (MSAL4J) per consentire agli utenti di accedere a un tenant di Microsoft Entra ID e ottenere un token ID da Microsoft Entra ID. Il token ID dimostra che un utente è autenticato con questo tenant. L'app protegge le route in base allo stato di autenticazione e all'appartenenza al gruppo dell'utente.

Per un video che illustra questo scenario, vedere Implementare l'autorizzazione nelle applicazioni usando ruoli dell'app, gruppi di sicurezza, ambiti e ruoli di directory.

Prerequisiti

• JDK versione 8 o successive
• Maven 3
• Tenant di Microsoft Entra ID. Per altre informazioni, vedere Come ottenere un tenant di Microsoft Entra ID.
• Un account utente nel proprio tenant Microsoft Entra ID.
• Due gruppi di sicurezza, e , contenenti gli utenti che si desidera testare.

• JBoss EAP
• Visual Studio Code
• Strumenti di Azure per Visual Studio Code

Consigli

• Una certa familiarità con Java / Jakarta Servlets.
• Una certa familiarità con il terminale Linux/OSX.
• jwt.ms per esaminare i tuoi token.
• Fiddler per monitorare l'attività di rete e risolvere i problemi.
• Segui il blog di Microsoft Entra per rimanere up-to-date con gli ultimi sviluppi.

Configurare l'esempio

Le sezioni seguenti illustrano come configurare l'applicazione di esempio.

Clonare o scaricare il repository di esempio

Per clonare l'esempio, aprire una finestra Bash e usare il comando seguente:

git clone https://github.com/Azure-Samples/ms-identity-msal-java-samples.git
cd 3-java-servlet-web-app/3-Authorization-II/groups

In alternativa, passa al repository ms-identity-msal-java-samples, quindi scaricalo come file .zip ed estrailo sul disco rigido.

Registrare l'applicazione di esempio nel tenant di Microsoft Entra ID

In questo esempio è presente un progetto. Le sezioni seguenti illustrano come registrare l'app usando il portale di Azure.

Scegliere il tenant microsoft Entra ID in cui si desidera creare le applicazioni

Per scegliere il tenant, seguire questa procedura:

1. Accedi al portale di Azure.

2. Se l'account è presente in più tenant di Microsoft Entra ID, selezionare il profilo nell'angolo del portale di Azure e quindi selezionare Cambia directory per modificare la sessione nel tenant di Microsoft Entra ID desiderato.

Registrare l'app (java-servlet-webapp-groups)

Per prima cosa, registrare una nuova app nel portale di Azure, seguendo le istruzioni in Guida introduttiva: Registrare un'applicazione con la piattaforma di Microsoft Identity.

Usare quindi la procedura seguente per completare la registrazione:

1. Passare alla pagina Registrazioni app della piattaforma di identità Microsoft per sviluppatori.

2. Seleziona Nuova registrazione.

3. Nella pagina Registra un'applicazione che viene visualizzata, immetti le seguenti informazioni di registrazione dell'app:

   • Nella sezione Name, immettere un nome significativo per l'applicazione da mostrare agli utenti dell'app - per esempio, .
   • In Tipi di account supportati, seleziona Account solo in questa directory dell'organizzazione.
   • Nella sezione Redirect URI, seleziona Web nella casella combinata e immetti il seguente URI di reindirizzamento: .

4. Selezionare Registra per creare l'applicazione.

5. Nella pagina di registrazione dell'app, trova e copia il valore ID applicazione (client) da utilizzare in seguito. Questo valore viene usato nel file o nei file di configurazione dell'app.

6. Seleziona Salva per salvare le modifiche.

7. Nella pagina di registrazione dell'app selezionare Certificati e segreti nel riquadro di spostamento per aprire la pagina in cui è possibile generare segreti e caricare i certificati.

8. Nella sezione Segreti client seleziona Nuovo segreto client.

9. Digitare una descrizione, ad esempio il segreto dell'app.

10. Selezionare una scadenza per il segreto o specificare una durata personalizzata. I segreti client sono limitati a una durata massima di 24 mesi e Microsoft consiglia una scadenza inferiore a 12 mesi. Per le app di produzione, preferire un certificato o credenziali di identità federate rispetto a un segreto client.

11. Selezionare Aggiungi. Viene visualizzato il valore generato.

12. Copiare e salvare il valore generato da usare nei passaggi successivi. Questo valore è necessario per i file di configurazione del codice. Questo valore non viene visualizzato di nuovo e non è possibile recuperarlo con altri mezzi. Assicurarsi quindi di salvarlo dal portale di Azure prima di passare a qualsiasi altra schermata o riquadro.

13. Nella pagina di registrazione dell'app selezionare Autorizzazioni API nel riquadro di spostamento per aprire la pagina per aggiungere l'accesso alle API necessarie per l'applicazione.

14. Selezionare Aggiungi autorizzazione.

15. Verificare che la scheda API Microsoft sia selezionata.

16. Nella sezione API Microsoft più usate selezionare Microsoft Graph.

17. Nella sezione Autorizzazioni delegate, selezionare User.Read e GroupMember.Read.All dall'elenco. Se necessario, usare la casella di ricerca.

18. Selezionare Aggiungi autorizzazioni.

19. richiede il consenso dell'amministratore, quindi seleziona Concedi/revoca il consenso amministratore per {tenant}, quindi seleziona Sì quando ti viene chiesto se vuoi concedere il consenso per le autorizzazioni richieste per tutti gli account nel tenant. Per eseguire questa azione, è necessario essere un amministratore tenant di Microsoft Entra ID.

Configura l'app (java-servlet-webapp-groups) per utilizzare la registrazione dell'applicazione

Usare la procedura seguente per configurare l'app:

1. Aprire il progetto nell'IDE.

2. Apri il file ./src/main/resources/authentication.properties.

3. Trova la stringa . Sostituisci il valore esistente con l'ID del tenant Microsoft Entra se hai registrato l'app con l'opzione Account solo in questa directory organizzativa.

4. Individuare la stringa e sostituire il valore esistente con l'ID dell'applicazione o il dell'applicazione copiato dal portale di Azure.

5. Trova la stringa e sostituisci il valore esistente con il valore che hai salvato durante la creazione dell'app nel portale di Azure.

Configurare i gruppi di sicurezza

Sono disponibili le opzioni seguenti su come configurare ulteriormente le applicazioni per ricevere l'attestazione dei gruppi:

• Ricevere tutti i gruppi a cui l'utente connesso è assegnato in un tenant di Microsoft Entra ID, inclusi i gruppi annidati. Per altre informazioni, vedere la sezione Configurare l'applicazione per ricevere tutti i gruppi a cui è assegnato l'utente che ha effettuato l'accesso, inclusi i gruppi annidati.

• Ricevi i valori delle attestazioni di gruppo da un insieme filtrato di gruppi con cui l'applicazione è programmata per funzionare. Per altre informazioni, vedere la sezione Configurare l'applicazione per ricevere i valori dell'attestazione dei gruppi da un insieme filtrato di gruppi a cui potrebbe essere assegnato un utente. Questa opzione non è disponibile nell'edizione Microsoft Entra ID Free.

Configurare l'applicazione per ricevere tutti i gruppi a cui viene assegnato l'utente connesso, inclusi i gruppi annidati

Per configurare l'applicazione, seguire questa procedura:

1. Nella pagina di registrazione dell'app, seleziona Token Configuration nel riquadro di spostamento per aprire la pagina in cui puoi configurare le attestazioni fornite nei token rilasciati all'applicazione.

2. Seleziona Aggiungi attestazione di gruppo per aprire la schermata Modifica attestazione di gruppo.

3. Selezionare Gruppi di sicurezza OPPURE l'opzione Tutti i gruppi (incluse le liste di distribuzione ma non i gruppi assegnati all'applicazione). La scelta di entrambe le opzioni nega l'effetto dell'opzione Gruppi di sicurezza.

4. Nella sezione ID, selezionare ID del gruppo. Questa selezione fa sì che Microsoft Entra ID invii l'ID oggetto dei gruppi a cui l'utente è assegnato nell'attestazione dei gruppi del token ID che l'app riceve dopo l'accesso dell'utente.

Configurare l'applicazione per ricevere i valori delle attestazioni dei gruppi da un set filtrato di gruppi a cui potrebbe essere assegnato un utente

Questa opzione è utile quando si verificano i casi seguenti:

• L'applicazione è interessata a un set selezionato di gruppi a cui potrebbe essere assegnato un utente di accesso.
• L'applicazione non è interessata a ogni gruppo di sicurezza a cui l'utente viene assegnato nel tenant.

Questa opzione aiuta l'applicazione a evitare il problema di superamento.

Questa funzionalità non è disponibile nell'edizione Microsoft Entra ID Free.

Le assegnazioni di gruppi annidate non sono disponibili quando si usa questa opzione.

Per abilitare questa opzione nell'app, seguire questa procedura:

1. Nella pagina di registrazione dell'app, seleziona Token Configuration nel riquadro di spostamento per aprire la pagina in cui puoi configurare le attestazioni fornite nei token rilasciati all'applicazione.

2. Seleziona Aggiungi attestazione di gruppo per aprire la schermata Modifica attestazione di gruppo.

3. Selezionare Gruppi assegnati all'applicazione.

   Scegliendo altre opzioni, ad esempio Gruppi di sicurezza o Tutti i gruppi (incluse le liste di distribuzione ma non i gruppi assegnati all'applicazione), nega i vantaggi derivanti dalla scelta dell'app per usare questa opzione.

4. Nella sezione ID, selezionare ID del gruppo. Questa selezione comporta che Microsoft Entra ID invii l'ID oggetto dei gruppi a cui è assegnato l'utente nel claim groups del token ID.

5. Se si espone un'API Web usando l'opzione Esporre un'API , è anche possibile scegliere l'opzione ID gruppo nella sezione Accesso . Questa opzione comporta che Microsoft Entra ID invii l'ID oggetto dei gruppi a cui l'utente è assegnato nell'attestazione "groups" del token di accesso.

6. Nella pagina di registrazione dell'app selezionare Panoramica nel riquadro di spostamento per aprire la schermata di panoramica dell'applicazione.

7. Selezionare il collegamento con il nome dell'applicazione in Applicazione gestita nella directory locale. Questo titolo di campo potrebbe essere troncato - ad esempio . Quando si seleziona questo collegamento, si viene reindirizzati alla pagina Panoramica dell'applicazione aziendale associata all'entità servizio della tua applicazione nel tenant in cui è stata creata. È possibile tornare alla pagina di registrazione dell'app usando il pulsante Indietro del browser.

8. Selezionare Utenti e gruppi nel riquadro di spostamento per aprire la pagina in cui è possibile assegnare utenti e gruppi all'applicazione.

9. Seleziona Aggiungi utente.

10. Selezionare Utenti e gruppi nella schermata risultante.

11. Scegliere i gruppi da assegnare a questa applicazione.

12. Selezionare Seleziona per completare la selezione dei gruppi.

13. Selezionare Assegna per completare il processo di assegnazione del gruppo.

    L'applicazione riceve ora questi gruppi selezionati nell'attestazione dei gruppi quando un utente che accede all'app è membro di uno o più gruppi assegnati.

14. Selezionare Proprietà nel riquadro di spostamento per aprire la pagina in cui sono elencate le proprietà di base dell'applicazione. Impostare il flag Assegnazione utente obbligatoria? su Sì.

Configurare l'app (java-servlet-webapp-groups) per riconoscere gli ID gruppo

Usare la procedura seguente per configurare l'app:

1. Apri il file ./src/main/resources/authentication.properties.

2. Individua la stringa e sostituisci il valore esistente con l'ID oggetto del gruppo , che hai copiato dal portale di Azure. Rimuovi anche le parentesi graffe dal valore del segnaposto.

3. Individuare la stringa e sostituire il valore esistente con l'ID oggetto del gruppo , che hai copiato dal portale di Azure. Rimuovi anche le parentesi graffe dal valore del segnaposto.

Compilare l'esempio

Per compilare l'esempio usando Maven, passare alla directory contenente il file pom.xml per l'esempio e quindi eseguire il comando seguente:

mvn clean package

Questo comando genera un file .war che puoi eseguire su vari server applicativi.

Esegui l'esempio

Please confirm webapp properties
AppName : msal4j-servlet-auth-1707220080695
ResourceGroup : msal4j-servlet-auth-1707220080695-rg
Region : centralus
PricingTier : P1v3
OS : Linux
Java Version: Java 11
Web server stack: JBosseap 7
Deploy to slot : false
Confirm (Y/N) [Y]:
[INFO] Saving configuration to pom.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  26.196 s
[INFO] Finished at: 2024-02-06T11:48:16Z
[INFO] ------------------------------------------------------------------------

<build>
    <plugins>
        <plugin>
            <groupId>com.microsoft.azure</groupId>
            <artifactId>>azure-webapp-maven-plugin</artifactId>
            <version>x.xx.x</version>
            <configuration>
                <schemaVersion>v2</schemaVersion>
                <resourceGroup>your-resourcegroup-name</resourceGroup>
                <appName>your-app-name</appName>
            ...
            </configuration>
        </plugin>
    </plugins>
</build>

az login

mvn package azure-webapp:deploy

Esaminare l'esempio

Per esplorare l'esempio, seguire questa procedura:

1. Notare lo stato di accesso o di disconnessione visualizzato al centro dello schermo.
2. Selezionare il pulsante sensibile al contesto nell'angolo. Questo pulsante mostra Accedi quando avvii l'app per la prima volta.
3. Nella pagina successiva seguire le istruzioni e accedere con un account di Microsoft Entra ID tenant.
4. Nella schermata di consenso notare gli ambiti richiesti.
5. Si noti che il pulsante sensibile al contesto ora indica Disconnetti e visualizza il nome utente.
6. Selezionare Dettagli token ID per vedere alcune delle dichiarazioni decodificate del token ID.
7. Selezionare Gruppi per visualizzare le informazioni sull'appartenenza al gruppo di sicurezza per l'utente connesso.
8. Selezionare Solo amministratore o Utente normale per accedere agli endpoint protetti dal claim groups.
   • Se l'utente che ha effettuato l'accesso appartiene al gruppo , può accedere a entrambe le pagine.
   • Se l'utente che ha effettuato l'accesso è nel gruppo , può accedere solo alla pagina Utente normale.
   • Se l'utente connesso non è in nessun gruppo, l'utente non può accedere a una delle due pagine.
9. Usare il pulsante nell'angolo per disconnettersi.
10. Dopo aver effettuato la disconnessione, selezionare ID Token Details per verificare che l'app visualizzi un errore anziché i claims del token ID quando l'utente non è autorizzato.

Informazioni sul codice

Questo esempio usa MSAL per Java (MSAL4J) per effettuare l'accesso di un utente e ottenere un token di ID che potrebbe contenere il claim dei gruppi. Se sono presenti troppi gruppi per l'emissione nel token ID, l'esempio usa Microsoft Graph SDK per Java per ottenere i dati di appartenenza al gruppo da Microsoft Graph. A seconda dei gruppi a cui appartiene l'utente, l'utente autenticato può accedere a nessuna, una sola o entrambe le pagine protette, e .

Se si vuole replicare il comportamento di questo esempio, è necessario aggiungere MSAL4J e Microsoft Graph SDK ai progetti usando Maven. È possibile copiare il file pom.xml e il contenuto delle cartelle helper e authservlets nella cartella src/main/java/com/microsoft/azuresamples/msal4j . È inoltre necessario il authentication.properties file. Queste classi e file contengono codice generico che è possibile usare in un'ampia gamma di applicazioni. È anche possibile copiare il resto dell'esempio, ma le altre classi e file vengono compilati in modo specifico per soddisfare l'obiettivo di questo esempio.

Contenuto

La tabella seguente illustra il contenuto della cartella del progetto di esempio:

Elaborare un'attestazione di gruppi nei token, inclusa la gestione dell'eccedenza

Le sezioni seguenti descrivono come l'app elabora un'attestazione dei gruppi.

I gruppi affermano

L'ID oggetto dei gruppi di sicurezza di cui l'utente autenticato è membro viene restituito nella claim "groups" del token, come mostrato nell'esempio seguente:

{
  ...
  "groups": [
    "0bbe91cc-b69e-414d-85a6-a043d6752215",
    "48931dac-3736-45e7-83e8-015e6dfd6f7c",]
  ...
}

Richiesta di eccedenza dei gruppi

Per garantire che la dimensione del token non superi i limiti di dimensione delle intestazioni HTTP, la piattaforma di gestione delle identità Microsoft limita il numero di ID oggetto inclusi nel claim relativo ai gruppi.

Il limite di eccedenza è 150 per i token SAML, 200 per i token JWT e 6 per le applicazioni a pagina singola. Se un utente appartiene a più gruppi del limite massimo consentito, Microsoft Identity Platform non include gli ID dei gruppi nel claim groups del token. Include invece nel token un claim di eccedenza che indica all'applicazione di interrogare Microsoft API Graph per recuperare l'appartenenza dell'utente ai gruppi, come illustrato nell'esempio seguente:

{
  ...
  "_claim_names": {
    "groups": "src1"
    },
    {
   "_claim_sources": {
    "src1": {
        "endpoint":"[Graph Url to get this user's group membership from]"
        }
    }
  ...
}

Creare lo scenario di eccedenza in questo esempio per il test

Per creare lo scenario di eccedenza, è possibile seguire questa procedura:

1. È possibile usare il file BulkCreateGroups.ps1 fornito nella cartella AppCreationScripts per creare un numero elevato di gruppi e assegnare loro utenti. Questo file consente di testare gli scenari di eccedenza durante lo sviluppo. Ricordarsi di modificare il dell'utente fornito nello script BulkCreateGroups.ps1.

2. Quando si esegue questo esempio e si verifica un'eccedenza, viene visualizzato il _claim_names nella home page dopo il login dell'utente.

3. È consigliabile usare la funzionalità di filtro dei gruppi, se possibile, per evitare di incorrere in eccedenze di gruppo. Per altre informazioni, vedere la sezione Configurare l'applicazione per ricevere i valori dell'attestazione dei gruppi da un insieme filtrato di gruppi a cui potrebbe essere assegnato un utente.

4. Nel caso in cui non sia possibile evitare il superamento del limite dei gruppi, ti consigliamo di utilizzare i passaggi seguenti per gestire la dichiarazione dei gruppi nel token:

   1. Verifica la richiesta _claim_names con uno dei valori che è gruppi. Questa attestazione indica l'eccedenza.
   2. Se trovato, effettuare una chiamata all'endpoint specificato in _claim_sources per recuperare i gruppi dell'utente.
   3. Se non viene trovato nulla, esaminare l'attestazione groups relativa ai gruppi dell'utente.

ConfidentialClientApplication

Un'istanza di viene creata nel file AuthHelper.java, come mostrato nell'esempio seguente. Questo oggetto consente di creare l'URL di autorizzazione di Microsoft Entra e consente anche di scambiare il token di autenticazione per un token di accesso.

// getConfidentialClientInstance method
IClientSecret secret = ClientCredentialFactory.createFromSecret(SECRET);
confClientInstance = ConfidentialClientApplication
                      .builder(CLIENT_ID, secret)
                      .authority(AUTHORITY)
                      .build();

Per l'istanziazione vengono utilizzati i seguenti parametri:

• ID client dell'app.
• Il segreto del client, necessario per le applicazioni client confidenziali.
• L'autorità Microsoft Entra ID, che include l'ID del tenant Microsoft Entra.

In questo esempio questi valori vengono letti dal file authentication.properties usando un lettore di proprietà nel file Config.java .

Procedura dettagliata

I passaggi seguenti forniscono una procedura dettagliata delle funzionalità dell'app:

1. Il primo passaggio del processo di accesso consiste nell'inviare una richiesta all'endpoint per il tenant Microsoft Entra ID. L'istanza di MSAL4J viene utilizzata per costruire un URL della richiesta di autorizzazione. L'app reindirizza il browser a questo URL, dove l'utente accede.

   final ConfidentialClientApplication client = getConfidentialClientInstance();
   AuthorizationRequestUrlParameters parameters = AuthorizationRequestUrlParameters.builder(Config.REDIRECT_URI, Collections.singleton(Config.SCOPES))
           .responseMode(ResponseMode.QUERY).prompt(Prompt.SELECT_ACCOUNT).state(state).nonce(nonce).build();
   
   final String authorizeUrl = client.getAuthorizationRequestUrl(parameters).toString();
   contextAdapter.redirectUser(authorizeUrl);
   

   L'elenco seguente descrive le funzionalità di questo codice:

   • : parametri che devono essere impostati per costruire un AuthorizationRequestUrl.
   • : posizione in cui Microsoft Entra reindirizza il browser, insieme al codice di autorizzazione, dopo aver raccolto le credenziali dell'utente. Deve corrispondere all'URI di reindirizzamento nella registrazione dell'app Microsoft Entra ID nel portale di Azure.
   • : Scopes sono le autorizzazioni richieste dall'applicazione.
     • Normalmente, i tre scope sono sufficienti per ricevere una risposta con un token ID.
     • L'elenco completo degli ambiti richiesti dall'app è disponibile nel file authentication.properties . È possibile aggiungere altri scope, ad esempio .

2. L'utente riceve una richiesta di accesso da Microsoft Entra ID. Se il tentativo di accesso ha esito positivo, il browser dell'utente viene reindirizzato all'endpoint di reindirizzamento dell'app. Una richiesta valida per questo endpoint contiene un codice di autorizzazione.

3. L'istanza scambia quindi questo codice di autorizzazione con un token ID e un token di accesso ottenuti da Microsoft Entra ID.

   // First, validate the state, then parse any error codes in response, then extract the authCode. Then:
   // build the auth code params:
   final AuthorizationCodeParameters authParams = AuthorizationCodeParameters
           .builder(authCode, new URI(Config.REDIRECT_URI)).scopes(Collections.singleton(Config.SCOPES)).build();
   
   // Get a client instance and leverage it to acquire the token:
   final ConfidentialClientApplication client = AuthHelper.getConfidentialClientInstance();
   final IAuthenticationResult result = client.acquireToken(authParams).get();
   

   L'elenco seguente descrive le funzionalità di questo codice:

   • : Parametri che devono essere impostati per scambiare il codice di autorizzazione con un token ID e/o un token di accesso.
   • : Il codice di autorizzazione ricevuto all'endpoint di reindirizzamento.
   • : l'URI di reindirizzamento utilizzato nel passaggio precedente deve essere passato di nuovo.
   • : gli scope utilizzati nel passaggio precedente devono essere passati nuovamente.

4. Se ha esito positivo, vengono estratti i claims del token. Se il controllo del nonce ha esito positivo, i risultati vengono collocati in - un'istanza di - e salvati nella sessione. L'applicazione può quindi istanziare il dalla sessione tramite un'istanza di ogni volta che deve accedervi, come mostrato nel codice seguente:

   // parse IdToken claims from the IAuthenticationResult:
   // (the next step - validateNonce - requires parsed claims)
   context.setIdTokenClaims(result.idToken());
   
   // if nonce is invalid, stop immediately! this could be a token replay!
   // if validation fails, throws exception and cancels auth:
   validateNonce(context);
   
   // set user to authenticated:
   context.setAuthResult(result, client.tokenCache().serialize());
   
   // handle groups overage if it has occurred.
   handleGroupsOverage(contextAdapter);
   

5. Dopo il passaggio precedente, è possibile recuperare le appartenenze ai gruppi chiamando utilizzando un'istanza di .

6. Se l'utente fa parte di troppi gruppi, più di 200, una chiamata a potrebbe risultare vuota se non fosse per la chiamata a . Nel frattempo, restituisce , segnalando che si è verificato un superamento del limite e che per ottenere l'elenco completo dei gruppi è necessaria una chiamata a Microsoft Graph. Vedi il metodo in AuthHelper.java per capire come questa applicazione usa quando si verifica un superamento del limite.

Proteggere le route

Vedi AuthenticationFilter.java per vedere come l'app di esempio filtra l'accesso alle route. Nel file authentication.properties, la proprietà contiene le route separate da virgole a cui possono accedere solo gli utenti autenticati, come mostrato nell'esempio seguente:

# for example, /token_details requires any user to be signed in and does not require special groups claim
app.protect.authenticated=/token_details

Qualsiasi percorso elencato negli insiemi di regole separati da virgole sotto non è accessibile nemmeno agli utenti non autenticati, come mostrato nell'esempio seguente. Tuttavia, questi percorsi contengono anche un elenco di appartenenze a gruppi separato da spazi. Solo gli utenti appartenenti ad almeno uno dei gruppi corrispondenti possono accedere a queste route dopo l'autenticazione.

# define short names for group IDs here for the app. This is useful in the next property (app.protect.groups).
# EXCLUDE the curly braces, they are in this file only as delimiters.
# example:
# app.groups=groupA abcdef-qrstuvw-xyz groupB abcdef-qrstuv-wxyz
app.groups=admin {enter-your-admins-group-id-here}, user {enter-your-users-group-id-here}

# A route and its corresponding group(s) that can view it, <space-separated>; the start of the next route & its group(s) is delimited by a <comma-and-space-separator>
# this says: /admins_only can be accessed by admin group, /regular_user can be accessed by admin group and user group
app.protect.groups=/admin_only admin, /regular_user admin user

Ambiti

Scopes indicano a Microsoft Entra ID il livello di accesso che l'applicazione richiede.

In base agli ambiti richiesti, Microsoft Entra ID presenta una finestra di dialogo di consenso all'utente al momento dell'accesso. Se l'utente acconsente a uno o più scope e ottiene un token, gli scope a cui ha acconsentito vengono codificati nel risultante.

Per gli ambiti richiesti dall'applicazione, vedere authentication.properties. Per impostazione predefinita, l'applicazione imposta il valore di scopes su . Questo particolare ambito dell'API Microsoft Graph è necessario nel caso in cui l'applicazione debba chiamare Graph per ottenere le appartenenze ai gruppi dell'utente.

Ulteriori informazioni

• Libreria di Autenticazione Microsoft (MSAL) per Java
• Piattaforma di identità Microsoft (Microsoft Entra ID per gli sviluppatori)
• Guida introduttiva: registrare un'applicazione con la piattaforma di identità Microsoft
• Comprendere le esperienze di consenso delle applicazioni in Microsoft Entra ID
• Comprendere il consenso dell'utente e dell'amministratore
• Esempi di codice MSAL