Proteggere le app Java Spring Boot con Azure Active Directory B2C
Questo articolo illustra un'app Web Java Spring Boot che consente agli utenti di accedere al tenant di Azure Active Directory B2C usando la libreria client Spring Boot Starter di Azure AD B2C per Java. Usa il protocollo OpenID Connect.
Il diagramma seguente illustra la topologia dell'app:
L'app client usa la libreria client Spring Boot Starter di Azure AD B2C per Java per accedere a un utente e ottenere un token ID da Azure AD B2C. Il token ID dimostra che l'utente è autenticato con Azure AD B2C e consente all'utente di accedere alle route protette.
Prerequisiti
- JDK versione 15. Questo esempio è stato sviluppato in un sistema con Java 15, ma potrebbe essere compatibile con altre versioni.
- Maven 3
- Java Extension Pack per Visual Studio Code è consigliato per l'esecuzione di questo esempio in Visual Studio Code.
- Un tenant di Azure AD B2C. Per altre informazioni, vedere Esercitazione: Creare un tenant di Azure Active Directory B2C
- Visual Studio Code
- Strumenti di Azure per Visual Studio Code
Consigli
- Una certa familiarità con Spring Framework
- Familiarità con il terminale Linux/OSX o Windows PowerShell
- 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 4-spring-web-app/1-Authentication/sign-in-b2c
In alternativa, passare al repository ms-identity-msal-java-samples , quindi scaricarlo come file .zip ed estrarlo nel disco rigido.
Importante
Per evitare limitazioni di lunghezza del percorso di file in Windows, clonare o estrarre il repository in una directory vicino alla radice del disco rigido.
Questo esempio viene fornito con un'applicazione preregistrata a scopo dimostrativo. Se si vuole usare un tenant e un'applicazione Azure AD B2C personalizzati, registrare e configurare l'applicazione nel portale di Azure. Per altre informazioni, vedere la sezione Registrare l'app . In caso contrario, continuare con i passaggi nella sezione Esegui l'esempio .
Scegliere il tenant di Azure AD B2C in cui si vogliono creare le applicazioni
Per scegliere il tenant, seguire questa procedura:
Accedere al portale di Azure.
Se l'account è presente in più tenant di Azure AD B2C, selezionare il profilo nell'angolo del portale di Azure e quindi selezionare Cambia directory per modificare la sessione nel tenant di Azure AD B2C desiderato.
Creare flussi utente e criteri personalizzati
Per creare flussi utente comuni come l'iscrizione, l'accesso, la modifica del profilo e la reimpostazione della password, vedere Esercitazione: Creare flussi utente in Azure Active Directory B2C.
È consigliabile prendere in considerazione anche la creazione di criteri personalizzati in Azure Active Directory B2C. Tuttavia, questa attività non rientra nell'ambito di questa esercitazione. Per altre informazioni, vedere Panoramica dei criteri personalizzati di Azure AD B2C.
Aggiungere provider di identità esterni
Vedere Esercitazione: Aggiungere provider di identità alle applicazioni in Azure Active Directory B2C.
Registrare l'app (java-spring-webapp-auth-b2c)
Per registrare l'app, seguire questa procedura:
Passare al portale di Azure e selezionare Azure AD B2C.
Selezionare Registrazioni app nel riquadro di spostamento e quindi selezionare Nuova registrazione.
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-spring-webapp-auth-b2c
ad esempio . - Sotto Tipi di account supportati, seleziona Account in qualsiasi provider di identità o directory dell'organizzazione (per autenticare gli utenti con flussi utente).
- Nella sezione URI di reindirizzamento (facoltativo) selezionare Web nella casella combinata e immettere l'URI di reindirizzamento seguente:
http://localhost:8080/login/oauth2/code/
.
- Nella sezione Nome immettere un nome di applicazione significativo da visualizzare agli utenti dell'app,
Selezionare Registra per creare l'applicazione.
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.
Seleziona Salva per salvare le modifiche.
Nella pagina di registrazione dell'app selezionare il riquadro Certificati e segreti nel riquadro di spostamento per aprire la pagina per generare segreti e caricare i certificati.
Nella sezione Segreti client seleziona Nuovo segreto client.
Digitare una descrizione, ad esempio il segreto dell'app.
Selezionare una delle durate disponibili in base ai problemi di sicurezza, ad esempio In 2 anni.
Selezionare Aggiungi. Viene visualizzato il valore generato.
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 (java-spring-webapp-auth-b2c) per usare la registrazione dell'app
Usare la procedura seguente per configurare l'app:
Nota
Nei passaggi seguenti è ClientID
uguale Application ID
a o AppId
.
Aprire il progetto nell'IDE.
Aprire il file src/main/resources/application.yml .
Trovare la
client-id
proprietà e sostituire il valore esistente con l'ID applicazione oclientId
dell'applicazionejava-spring-webapp-auth-b2c
dal portale di Azure.Trovare la
client-secret
proprietà e sostituire il valore esistente con il valore salvato durante la creazione dell'applicazionejava-spring-webapp-auth-b2c
dal portale di Azure.Trovare la
base-uri
proprietà e sostituire le due istanze del valorefabrikamb2c
con il nome del tenant di Azure AD B2C in cui è stata creata l'applicazionejava-spring-webapp-auth-b2c
nel portale di Azure.Trovare la
sign-up-or-sign-in
proprietà e sostituirla con il nome del criterio di iscrizione/accesso del flusso utente creato nel tenant di Azure AD B2C in cui è stata creata l'applicazionejava-spring-webapp-auth-b2c
nel portale di Azure.Trovare la
profile-edit
proprietà e sostituirla con il nome dei criteri del flusso utente di reimpostazione della password creati nel tenant di Azure AD B2C in cui è stata creata l'applicazionejava-spring-webapp-auth-b2c
nel portale di Azure.Trovare la
password-reset
proprietà e sostituirla con il nome del criterio di modifica del flusso utente del profilo creato nel tenant di Azure AD B2C in cui è stata creata l'applicazionejava-spring-webapp-auth-b2c
nel portale di Azure.Aprire il file src/main/resources/templates/navbar.html .
Trovare i riferimenti ai
b2c_1_susi
flussi eb2c_1_edit_profile
e sostituirli con isign-up-sign-in
flussi utente eprofile-edit
.
Eseguire l'esempio
Le sezioni seguenti illustrano come distribuire l'esempio in Azure Spring Apps.
Prerequisiti
Se si distribuisce un'istanza del piano Enterprise di Azure Spring Apps per la prima volta nella sottoscrizione di destinazione, vedere la sezione Requisiti del piano Enterprise in Azure Marketplace.
Plug-in Maven per App Spring di Azure. Se Maven non è lo strumento di sviluppo preferito, vedere le esercitazioni simili seguenti che usano altri strumenti:
Preparare il progetto Spring
Per preparare il progetto, seguire questa procedura:
Usare il comando Maven seguente per compilare il progetto:
mvn clean package
Eseguire il progetto di esempio in locale usando il comando seguente:
mvn spring-boot:run
Configurare il plug-in Maven
Eseguire il comando seguente nella radice del progetto per configurare l'app usando il plug-in Maven per Azure Spring Apps:
mvn com.microsoft.azure:azure-spring-apps-maven-plugin:1.19.0:config
L'elenco seguente descrive le interazioni con i comandi:
- Accesso OAuth2: è necessario autorizzare l'accesso ad Azure in base al protocollo OAuth2.
- Selezionare la sottoscrizione: selezionare il numero di elenco delle sottoscrizioni in cui si vuole creare l'istanza di Azure Spring Apps, che per impostazione predefinita corrisponde alla prima sottoscrizione nell'elenco. Per usare il numero predefinito, premere INVIO.
- Immettere il nome di App Spring di Azure: immettere il nome per l'istanza di spring apps che si vuole creare. Per usare il nome predefinito, premere INVIO.
- Immettere il nome del gruppo di risorse: immettere il nome del gruppo di risorse in cui si vuole creare l'istanza di spring apps. Per usare il nome predefinito, premere INVIO.
- SKU: selezionare lo SKU da usare per l'istanza di spring apps. Per usare il numero predefinito, premere INVIO.
- Immettere il nome dell'app (demo): specificare un nome dell'app. Se si vuole usare l'ID artefatto predefinito del progetto, premere INVIO.
- Runtime: selezionare il runtime che si vuole usare per l'istanza di spring apps. In questo caso, è consigliabile usare il numero predefinito, quindi premere INVIO.
- Esporre l'accesso pubblico per questa app (boot-for-azure): premere y.
- Confermare di salvare tutte le configurazioni precedenti: premere y. Se si preme n, la configurazione non viene salvata nel file pom .
L'esempio seguente mostra l'output del processo di distribuzione:
Summary of properties:
Subscription id : 12345678-1234-1234-1234-123456789101
Resource group name : rg-ms-identity-spring-boot-webapp
Azure Spring Apps name : cluster-ms-identity-spring-boot-webapp
Runtime Java version : Java 11
Region : eastus
Sku : Standard
App name : ms-identity-spring-boot-webapp
Public access : true
Instance count/max replicas : 1
CPU count : 1
Memory size(GB) : 2
Confirm to save all the above configurations (Y/n):
[INFO] Configurations are saved to: /home/user/ms-identity-msal-java-samples/4-spring-web-app/1-Authentication/sign-in/pom. xml
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:57 min
[INFO] Finished at: 2024-02-14T13:50:44Z
[INFO] ------------------------------------------------------------------------
Dopo aver confermato le scelte, il plug-in aggiunge l'elemento e le impostazioni del plug-in necessari al file di pom.xml del progetto per configurare l'app per l'esecuzione in Azure Spring Apps.
La parte pertinente del file pom.xml dovrebbe essere simile all'esempio seguente:
<plugin>
<groupId>com.microsoft.azure</groupId>
<artifactId>azure-spring-apps-maven-plugin</artifactId>
<version>1.19.0</version>
<configuration>
<subscriptionId>12345678-1234-1234-1234-123456789101</subscriptionId>
<resourceGroup>rg-ms-identity-spring-boot-webapp</resourceGroup>
<clusterName>cluster-ms-identity-spring-boot-webapp</clusterName>
<region>eastus</region>
<sku>Standard</sku>
<appName>ms-identity-spring-boot-webapp</appName>
<isPublic>true</isPublic>
<deployment>
<cpu>1</cpu>
<memoryInGB>2</memoryInGB>
<instanceCount>1</instanceCount>
<runtimeVersion>Java 11</runtimeVersion>
<resources>
<resource>
<directory>${project.basedir}/target</directory>
<includes>
<include>*.jar</include>
</includes>
</resource>
</resources>
</deployment>
</configuration>
</plugin>
È possibile modificare le configurazioni per Azure Spring Apps direttamente nel file pom.xml . Alcune configurazioni comuni sono elencate nella tabella seguente:
Proprietà | Richiesto | Descrizione |
---|---|---|
subscriptionId |
false | ID della sottoscrizione. |
resourceGroup |
true | Gruppo di risorse di Azure per l'istanza di Azure Spring Apps. |
clusterName |
true | Nome del cluster di Azure Spring Apps. Se si usa una sottoscrizione e un gruppo di risorse in cui è già distribuita un'istanza di Azure Spring Apps, è anche possibile usare questo cluster esistente per la distribuzione. |
appName |
true | Nome dell'app in Azure Spring Apps. |
region |
false | Area in cui ospitare l'istanza di Azure Spring Apps. Il valore predefinito è eastus . Per le aree valide, vedere Aree supportate. |
sku |
false | Piano tariffario per l'istanza di Azure Spring Apps. Il valore predefinito è Basic , adatto solo per gli ambienti di sviluppo e test. |
runtime |
false | Configurazione dell'ambiente di runtime. Per altre informazioni, vedere Dettagli di configurazione. |
deployment |
false | Configurazione della distribuzione. Per altre informazioni, vedere Dettagli di configurazione. |
Per l'elenco completo delle configurazioni, vedere la documentazione di riferimento sul plug-in. Tutti i plug-in Azure Maven condividono un set comune di configurazioni. Per queste configurazioni, vedere Configurazioni comuni. Per le configurazioni specifiche di Azure Spring Apps, vedere Azure Spring Apps: Configuration Details (App Azure Spring: Dettagli configurazione).
Assicurarsi di salvare i clusterName
valori e appName
per usarli in un secondo momento.
Preparare l'app per la distribuzione
Quando si distribuisce l'applicazione in Azure Spring Apps, l'URL di reindirizzamento viene modificato nell'URL di reindirizzamento dell'istanza dell'app distribuita in Azure Spring Apps. Usare la procedura seguente per modificare queste impostazioni nel file application.yml :
Passare al file src\main\resources\application.yml dell'app e modificare il valore di
post-logout-redirect-uri
in base al nome di dominio dell'app distribuita, come illustrato nell'esempio seguente. Ad esempio, se si scegliecluster-ms-identity-spring-boot-webapp
per l'istanza di Azure Spring Apps nel passaggio precedente ems-identity-spring-boot-webapp
per il nome dell'app, è ora necessario usarehttps://cluster-ms-identity-spring-boot-webapp-ms-identity-spring-boot-webapp.azuremicroservices.io
per ilpost-logout-redirect-uri
valore .post-logout-redirect-uri: https://<cluster-name>-<app-name>.azuremicroservices.io
Dopo aver salvato questo file, usare il comando seguente per ricompilare l'app:
mvn clean package
Importante
Il file application.yml dell'applicazione contiene attualmente il valore del segreto client nel client-secret
parametro . Non è consigliabile mantenere questo valore in questo file. Se si esegue il commit in un repository Git, è anche possibile che si verifichi un rischio.
Come passaggio di sicurezza aggiuntivo, è possibile archiviare questo valore in Azure Key Vault e caricare il segreto da Key Vault per renderlo disponibile nell'applicazione.
Aggiornare la registrazione dell'app Microsoft Entra ID
Poiché l'URI di reindirizzamento cambia nell'app distribuita in Azure Spring Apps, è anche necessario modificare l'URI di reindirizzamento nella registrazione dell'app Microsoft Entra ID. Attenersi alla seguente procedura per apportare questa modifica:
Passare alla pagina Registrazioni app di Microsoft Identity Platform per sviluppatori.
Usare la casella di ricerca per cercare la registrazione dell'app,
java-servlet-webapp-authentication
ad esempio .Aprire la registrazione dell'app selezionandone il nome.
Seleziona Autenticazione dal menu.
Nella sezione URI di reindirizzamento Web - selezionare Aggiungi URI.
Compilare l'URI dell'app, aggiungendo
/login/oauth2/code/
, ad esempio .https://<cluster-name>-<app-name>.azuremicroservices.io/login/oauth2/code/
Seleziona Salva.
Distribuire l'app
Usare il comando seguente per distribuire l'app:
mvn azure-spring-apps:deploy
L'elenco seguente descrive l'interazione con il comando:
- Accesso OAuth2: è necessario autorizzare l'accesso ad Azure in base al protocollo OAuth2.
Dopo l'esecuzione del comando, è possibile visualizzare i messaggi di log seguenti che la distribuzione ha avuto esito positivo:
[INFO] Deployment(default) is successfully created
[INFO] Starting Spring App after deploying artifacts...
[INFO] Deployment Status: Running
[INFO] InstanceName:demo-default-x-xxxxxxxxxx-xxxxx Status:Running Reason:null DiscoverStatus:UNREGISTERED
[INFO] InstanceName:demo-default-x-xxxxxxxxx-xxxxx Status:Terminating Reason:null DiscoverStatus:UNREGISTERED
[INFO] Getting public url of app(demo)...
[INFO] Application url: https://<your-Azure-Spring-Apps-instance-name>-demo.azuremicroservices.io
Convalidare l'app
Al termine della distribuzione, accedere all'applicazione con l'URL dell'applicazione di output. Usare la procedura seguente per controllare i log dell'app per analizzare eventuali problemi di distribuzione:
Accedere all'URL dell'applicazione di output dalla pagina Output della sezione Distribuzione .
Nel riquadro di spostamento della pagina Panoramica dell'istanza di Azure Spring Apps selezionare Log per controllare i log dell'app.
Esaminare l'esempio
Per esplorare l'esempio, seguire questa procedura:
- Si noti lo stato di accesso o disconnesso visualizzato al centro della schermata.
- Selezionare il pulsante sensibile al contesto nell'angolo. Questo pulsante legge Accedi quando si esegue l'app per la prima volta. In alternativa, selezionare il collegamento ai dettagli del token. Poiché questa pagina è protetta e richiede l'autenticazione, si viene reindirizzati automaticamente alla pagina di accesso.
- Nella pagina successiva seguire le istruzioni e accedere con un account del provider di identità scelto. È anche possibile scegliere di iscriversi o accedere a un account locale nel tenant B2C usando un indirizzo di posta elettronica.
- Al termine del flusso di accesso, si dovrebbe essere reindirizzati alla home page, che mostra lo stato di accesso o la pagina dei dettagli del token, a seconda del pulsante che ha attivato il flusso di accesso.
- Si noti che il pulsante sensibile al contesto ora indica Disconnetti e visualizza il nome utente.
- Se si è nella home page, selezionare ID Token Details (Dettagli token ID) per visualizzare alcune delle attestazioni decodificate del token ID.
- Modificare il profilo. Selezionare Modifica profilo per modificare i dettagli, ad esempio il nome visualizzato, il luogo di residenza e la professione.
- Usare il pulsante nell'angolo per disconnettersi. La pagina di stato riflette il nuovo stato.
Informazioni sul codice
Questo esempio illustra come usare la libreria client Spring Boot Starter di Azure AD B2C per Java per consentire agli utenti di accedere al tenant di Azure AD B2C. L'esempio usa anche gli starter Spring Oauth2 Client e Spring Web Boot. L'esempio usa le attestazioni del token ID ottenuto da Azure AD B2C per visualizzare i dettagli dell'utente connesso.
Contenuto
La tabella seguente illustra il contenuto della cartella del progetto di esempio:
File/cartella | Descrizione |
---|---|
pom.xml | Dipendenze dell'applicazione. |
src/main/resources/templates/ | Modelli thymeleaf per l'interfaccia utente. |
src/main/resources/application.yml | Configurazione della libreria Application e Microsoft Entra Boot Starter. |
src/main/java/com/microsoft/azuresamples/msal4j/msidentityspringbootwebapp/ | Questa directory contiene i principali punti di ingresso, controller e classi di configurazione dell'applicazione. |
.../MsIdentitySpringBootWebappApplication.java | Classe principale. |
.../SampleController.java | Controller con mapping degli endpoint. |
.../SecurityConfig.java | Configurazione di sicurezza, ad esempio le route che richiedono l'autenticazione. |
.../Utilities.java | Classe di utilità, ad esempio attestazioni del token ID filtro. |
CHANGELOG.md | Elenco delle modifiche apportate all'esempio. |
CONTRIBUTING.md | Linee guida per contribuire all'esempio. |
LICENZA | Licenza per l'esempio. |
Attestazioni del token ID
Per estrarre i dettagli del token, l'app usa l'oggetto e OidcUser
di AuthenticationPrincipal
Spring Security in un mapping delle richieste, come illustrato nell'esempio seguente, come illustrato nell'esempio seguente. Per informazioni dettagliate su come questa app usa le attestazioni del token ID, vedi Controller di esempio.
import org.springframework.security.oauth2.core.oidc.user.OidcUser;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
//...
@GetMapping(path = "/some_path")
public String tokenDetails(@AuthenticationPrincipal OidcUser principal) {
Map<String, Object> claims = principal.getIdToken().getClaims();
}
Collegamenti di accesso e disconnesso
Per l'accesso, l'app effettua una richiesta all'endpoint di accesso di Azure AD B2C configurato automaticamente dalla libreria client Spring Boot Starter di Azure AD B2C per Java, come illustrato nell'esempio seguente:
<a class="btn btn-success" href="/oauth2/authorization/{your-sign-up-sign-in-user-flow}">Sign In</a>
Per la disconnessione, l'app effettua una richiesta POST all'endpoint logout
, come illustrato nell'esempio seguente:
<form action="#" th:action="@{/logout}" method="post">
<input class="btn btn-warning" type="submit" value="Sign Out" />
</form>
Elementi dell'interfaccia utente dipendenti dall'autenticazione
L'app ha una logica semplice nelle pagine del modello di interfaccia utente per determinare il contenuto da visualizzare in base all'autenticazione dell'utente, come illustrato nell'esempio seguente usando i tag Spring Security Thymeleaf:
<div sec:authorize="isAuthenticated()">
this content only shows to authenticated users
</div>
<div sec:authorize="isAnonymous()">
this content only shows to not-authenticated users
</div>
Proteggere le route con WebSecurityConfigurerAdapter
Per impostazione predefinita, l'app protegge la pagina Id Token Details (Dettagli token ID) in modo che solo gli utenti connessi possano accedervi. L'app configura queste route dalla app.protect.authenticated
proprietà dal file application.yml . Per configurare i requisiti specifici dell'app, è possibile estendere WebSecurityConfigurerAdapter
in una delle classi. Per un esempio, vedi la classe SecurityConfig dell'app, illustrata nel codice seguente:
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Value("${app.protect.authenticated}")
private String[] protectedRoutes;
private final AADB2COidcLoginConfigurer configurer;
public SecurityConfig(AADB2COidcLoginConfigurer configurer) {
this.configurer = configurer;
}
@Override
protected void configure(HttpSecurity http) throws Exception {
// @formatter:off
http.authorizeRequests()
.antMatchers(protectedRoutes).authenticated() // limit these pages to authenticated users (default: /token_details)
.antMatchers("/**").permitAll() // allow all other routes.
.and()
.apply(configurer)
;
// @formatter:off
}
}
Ulteriori informazioni
- Microsoft Identity Platform (MICROSOFT Entra ID per sviluppatori)
- Panoramica di Microsoft Authentication Library (MSAL)
- Guida introduttiva: Registrare un'applicazione con Microsoft Identity Platform
- Guida introduttiva: Configurare un'applicazione client per accedere alle API Web
- Informazioni sulle esperienze di consenso dell'applicazione Microsoft Entra ID
- Informazioni sul consenso dell'utente e dell'amministratore
- Oggetti applicazione ed entità servizio in Microsoft Entra ID
- Cloud nazionali
- Esempi di codice MSAL
- Libreria client Spring Boot Starter di Microsoft Entra ID per Java
- Libreria client Spring Boot Starter di Azure Active Directory B2C per Java
- Microsoft Authentication Library per Java (MSAL4J)
- MSAL4J Wiki
- Token ID
- Token di accesso in Microsoft Identity Platform
Per altre informazioni sul funzionamento dei protocolli OAuth 2.0 in questo scenario e in altri scenari, vedere Scenari di autenticazione per Microsoft Entra ID.