Abilitare l'accesso per le app Java Tomcat con Microsoft Entra ID

Questo articolo illustra un'app Java Tomcat che consente agli utenti di accedere al tenant di Microsoft Entra ID usando Microsoft Authentication Library (MSAL) per Java.

Il diagramma seguente illustra la topologia dell'app:

L'app client usa MSAL per Java (MSAL4J) per consentire agli utenti di accedere al proprio tenant 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 dell'utente.

Prerequisiti

• JDK versione 8 o successiva
• Maven 3
• Tenant di Microsoft Entra ID. Per altre informazioni, vedere Come ottenere un tenant di Microsoft Entra ID.
• Un account utente nel tenant microsoft Entra ID se si vuole usare solo gli account nella directory organizzativa, ovvero in modalità a tenant singolo. Se non è stato creato un account utente nel tenant di Microsoft Entra ID, è consigliabile farlo prima di procedere. Per altre informazioni, vedere Come creare, invitare ed eliminare utenti.
• Un account utente nel tenant di Microsoft Entra ID di qualsiasi organizzazione se si vuole usare gli account in qualsiasi directory organizzativa, ovvero in modalità multi-tenant. È necessario modificare questo esempio per lavorare con un account Microsoft personale. Se non è ancora stato creato un account utente nel tenant di Microsoft Entra ID, è necessario farlo prima di procedere. Per altre informazioni, vedere Come creare, invitare ed eliminare utenti.
• Un account Microsoft personale, ad esempio Xbox, Hotmail, Live e così via, se vuoi lavorare con account Microsoft personali.

• Tomcat 9
• Visual Studio Code
• Strumenti di Azure per Visual Studio Code

Consigli

• Familiarità con Java /Jakarta Servlets.
• Una certa familiarità con il terminale Linux/OSX.
• jwt.ms per controllare i token.
• Fiddler per monitorare l'attività di rete e la risoluzione dei problemi.
• Segui il blog di Microsoft Entra ID per rimanere aggiornato 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/1-Authentication/sign-in

In alternativa, passare al repository ms-identity-msal-java-samples , quindi scaricarlo come file .zip ed estrarlo nel disco rigido.

Registrare l'applicazione di esempio con il tenant di Microsoft Entra ID

In questo esempio è presente un progetto. Questa sezione illustra come registrare l'app.

Prima di tutto, registrare l'app nel portale di Azure seguendo le istruzioni riportate in Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.

Usare quindi la procedura seguente per completare la registrazione:

1. Passare alla pagina Registrazioni app di Microsoft Identity Platform per sviluppatori.

2. Seleziona Nuova registrazione.

3. Nella pagina Registra un'applicazione visualizzata immettere le informazioni di registrazione dell'applicazione seguenti:

   • Nella sezione Nome immettere un nome di applicazione significativo da visualizzare agli utenti dell'app, java-servlet-webapp-authenticationad esempio .

   • In Tipi di account supportati selezionare una delle opzioni seguenti:

     • Selezionare Account in questa directory organizzativa solo se si compila un'applicazione per l'uso solo da parte degli utenti nel tenant, ovvero un'applicazione a tenant singolo.
     • Selezionare Account in qualsiasi directory organizzativa se si vuole che gli utenti in qualsiasi tenant di Microsoft Entra ID possano usare l'applicazione, ovvero un'applicazione multi-tenant .
     • Selezionare Account in qualsiasi directory organizzativa e account Microsoft personali per il set più ampio di clienti, ovvero un'applicazione multi-tenant che supporta anche gli account personali Microsoft.
     • Selezionare Account Microsoft personali per l'uso solo da parte degli utenti di account Microsoft personali, ad esempio Hotmail, Live, Skype e Xbox.

   • Nella sezione URI di reindirizzamento selezionare Web nella casella combinata e immettere l'URI di reindirizzamento seguente: http://localhost:8080/msal4j-servlet-auth/auth/redirect.

4. Selezionare Registra per creare l'applicazione.

5. Nella pagina di registrazione dell'app trovare e copiare il valore ID applicazione (client) da usare in un secondo momento. Questo valore viene usato nel file o nei file di configurazione dell'app.

6. Nella pagina di registrazione dell'app selezionare Certificati e segreti nel riquadro di spostamento per aprire la pagina per generare segreti e caricare i certificati.

7. Nella sezione Segreti client seleziona Nuovo segreto client.

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

9. Selezionare una delle durate disponibili: in 1 anno, in 2 anni o Mai scadute.

10. Selezionare Aggiungi. Viene visualizzato il valore generato.

11. 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.

Configurare l'app per l'uso della registrazione dell'app

Usare la procedura seguente per configurare l'app:

1. Aprire il progetto nell'IDE.

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

3. Trovare la stringa {enter-your-tenant-id-here}. Sostituire il valore esistente con uno dei valori seguenti:

   • ID tenant di Microsoft Entra ID se hai registrato l'app con l'opzione Account solo in questa directory organizzativa.
   • Parola organizations se hai registrato l'app con l'opzione Account in qualsiasi directory organizzativa.
   • Parola common se hai registrato l'app con l'opzione Account in qualsiasi directory organizzativa e account Microsoft personali.
   • Parola consumers se hai registrato l'app con l'opzione Account Microsoft personali.

4. Trovare la stringa {enter-your-client-id-here} e sostituire il valore esistente con l'ID applicazione o clientId l'applicazione java-servlet-webapp-authentication copiata dal portale di Azure.

5. Trovare la stringa {enter-your-client-secret-here} e sostituire il valore esistente con il valore salvato durante la creazione dell'appjava-servlet-webapp-authentication, nella portale di Azure.

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 con estensione war che è possibile eseguire in vari server applicazioni.

Eseguire l'esempio

Please confirm webapp properties
AppName : msal4j-servlet-auth-1707209552268
ResourceGroup : msal4j-servlet-auth-1707209552268-rg
Region : centralus
PricingTier : P1v2
OS : Linux
Java Version: Java 11
Web server stack: Tomcat 9.0
Deploy to slot : false
Confirm (Y/N) [Y]: [INFO] Saving configuration to pom.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  37.112 s
[INFO] Finished at: 2024-02-06T08:53:02Z
[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. Si noti lo stato di accesso o disconnesso visualizzato al centro della schermata.
2. Selezionare il pulsante sensibile al contesto nell'angolo. Questo pulsante legge Accedi quando si esegue l'app per la prima volta.
3. Nella pagina successiva seguire le istruzioni e accedere con un account nel tenant microsoft Entra ID.
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 ID Token Details (Dettagli token ID) per visualizzare alcune delle attestazioni decodificate del token ID.
7. Usare il pulsante nell'angolo per disconnettersi.
8. Dopo la disconnessione, selezionare ID Token Details (Dettagli token ID) per osservare che l'app visualizza un 401: unauthorized errore anziché le attestazioni del token ID quando l'utente non è autorizzato.

Informazioni sul codice

Questo esempio illustra come usare MSAL per Java (MSAL4J) per accedere agli utenti nel tenant di Microsoft Entra ID. Se si vuole usare MSAL4J nelle proprie applicazioni, è necessario aggiungerlo ai progetti usando Maven.

Per replicare il comportamento di questo esempio, è possibile copiare il file pom.xml e il contenuto delle cartelle helper e authservlets nella cartella src/main/java/com/microsoft/azuresamples/msal4j . È necessario anche il file authentication.properties . 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:

ConfidentialClientApplication

Viene creata un'istanza ConfidentialClientApplication nel file AuthHelper.java , come illustrato nell'esempio seguente. Questo oggetto consente di creare l'URL di autorizzazione di Microsoft Entra ID 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 la creazione di istanze vengono usati i parametri seguenti:

• ID client dell'app.
• Segreto client, che è un requisito per le applicazioni client riservate.
• Microsoft Entra ID Authority, che include l'ID tenant di Microsoft Entra ID.

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

Procedura

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 /authorize tenant di Microsoft Entra ID. L'istanza DI MSAL4J ConfidentialClientApplication viene usata 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:

   • AuthorizationRequestUrlParameters: parametri che devono essere impostati per compilare un oggetto AuthorizationRequestUrl.

   • REDIRECT_URI: dove Microsoft Entra ID reindirizza il browser, insieme al codice di autenticazione, dopo aver raccolto le credenziali utente. Deve corrispondere all'URI di reindirizzamento nella registrazione dell'app Microsoft Entra ID nel portale di Azure.

   • SCOPES: gli ambiti sono autorizzazioni richieste dall'applicazione. In genere, i tre ambiti openid profile offline_access sono sufficienti per ricevere una risposta del token ID.

     È possibile trovare un elenco completo degli ambiti richiesti dall'app nel file authentication.properties . È possibile aggiungere altri ambiti, ad esempio User.Read.

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 a questo endpoint contiene un codice di autorizzazione.

3. L'istanza ConfidentialClientApplication scambia quindi questo codice di autorizzazione per un token ID e un token di accesso 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:

   • AuthorizationCodeParameters: parametri che devono essere impostati per scambiare il codice di autorizzazione per un ID e/o un token di accesso.
   • authCode: codice di autorizzazione ricevuto nell'endpoint di reindirizzamento.
   • REDIRECT_URI: l'URI di reindirizzamento usato nel passaggio precedente deve essere passato di nuovo.
   • SCOPES: gli ambiti usati nel passaggio precedente devono essere passati di nuovo.

4. Se acquireToken ha esito positivo, vengono estratte le attestazioni del token. Se il controllo nonce viene superato, i risultati vengono inseriti in context , un'istanza di IdentityContextData , e salvati nella sessione. L'applicazione può quindi creare un'istanza IdentityContextData di dalla sessione tramite un'istanza di IdentityContextAdapterServlet ogni volta che deve accedervi, come illustrato 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());
   

Proteggere le route

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

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

Ambiti

Gli ambiti indicano a Microsoft Entra ID il livello di accesso richiesto dall'applicazione.

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ù ambiti e ottiene un token, gli ambiti con consenso vengono codificati nell'oggetto risultante access_token.

Per gli ambiti richiesti dall'applicazione, vedere authentication.properties. Questi tre ambiti vengono richiesti da MSAL e forniti da Microsoft Entra ID per impostazione predefinita.

Ulteriori informazioni

• Microsoft Authentication Library (MSAL) per Java
• Documentazione di riferimento su JAVA MSAL
• Microsoft Identity Platform (MICROSOFT Entra ID per sviluppatori)
• Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform
• Informazioni sulle esperienze di consenso dell'applicazione Microsoft Entra ID
• Informazioni sul consenso dell'utente e dell'amministratore
• Esempi di codice MSAL