Spring Cloud supporto tecnico di Azure for Spring Security
Questo articolo si applica a: ✔️ Versione 4.14.0 ✔️ versione 5.8.0
Questo articolo descrive in che modo Spring Cloud Azure e Spring Security possono essere usati insieme.
Quando si crea un'applicazione Web, la gestione delle identità e degli accessi sarà sempre un elemento fondamentale.
Azure offre un'ottima piattaforma per democratizzare il percorso di sviluppo delle applicazioni, poiché offre non solo un servizio di gestione delle identità di base cloud, ma anche una profonda integrazione con il resto dell'ecosistema di Azure.
Spring Security ha reso più semplice proteggere le applicazioni basate su Spring con potenti astrazioni ed interfacce estendibili. Tuttavia, il framework Spring può essere potente, non è personalizzato per un provider di identità specifico.
Fornisce spring-cloud-azure-starter-active-directory
il modo più ottimale per connettere l'applicazione Web a un tenant Microsoft Entra ID (Microsoft Entra ID for short) e proteggere il server di risorse con Microsoft Entra ID. Usa il protocollo Oauth 2.0 per proteggere applicazioni Web e server di risorse.
Questo scenario usa il flusso di concessione del codice di autorizzazione OAuth 2.0 per accedere a un utente con un account Microsoft.
Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.
Crea una registrazione dell'app. Ottenere
AZURE_TENANT_ID
,AZURE_CLIENT_ID
eAZURE_CLIENT_SECRET
.Impostare
redirect URI
suAPPLICATION_BASE_URI/login/oauth2/code/
, ad esempiohttp://localhost:8080/login/oauth2/code/
. La coda/
è obbligatoria.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
</dependencies>
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
A questo punto, avviare l'applicazione e accedere all'applicazione tramite il browser. Si verrà reindirizzati alla pagina di accesso Microsoft.
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2LoginSecurityConfig extends AadWebSecurityConfigurerAdapter {
/**
* Add configuration logic as needed.
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
http.authorizeRequests()
.anyRequest().authenticated();
// Do some custom configuration
}
}
Creare le risorse necessarie in Azure:
Leggere Aggiungere i ruoli dell'app all'applicazione e riceverli nel token.
Creare un ruolo app con i parametri seguenti:
- Nome visualizzato: Amministrazione
- Tipi di membri consentiti: Utenti/Gruppi
- Valore: Amministrazione
- Abilitare questo ruolo dell'app: sì
Nota
Se si vuole usare il controllo degli accessi in base al ruolo dell'app, non è possibile inserire i nomi dei gruppi nell'attestazione role
. Per altre informazioni, vedere la sezione Configurazione di attestazioni facoltative dei gruppi in Fornire attestazioni facoltative all'app.
Proteggere il metodo specifico.
class Demo {
@GetMapping("Admin")
@ResponseBody
@PreAuthorize("hasAuthority('APPROLE_Admin')")
public String admin() {
return "Admin message";
}
}
Aggiungere proprietà di configurazione correlate.
spring:
cloud:
azure:
active-directory:
enabled: true
user-group:
allowed-group-names: group1_name_1, group2_name_2
# 1. If allowed-group-ids == all, then all group ID will take effect.
# 2. If "all" is used, we should not configure other group ids.
# 3. "all" is only supported for allowed-group-ids, not supported for allowed-group-names.
allowed-group-ids: group_id_1, group_id_2
Proteggere il metodo specifico.
@Controller
public class RoleController {
@GetMapping("group1")
@ResponseBody
@PreAuthorize("hasRole('ROLE_group1')")
public String group1() {
return "group1 message";
}
@GetMapping("group2")
@ResponseBody
@PreAuthorize("hasRole('ROLE_group2')")
public String group2() {
return "group2 message";
}
@GetMapping("group1Id")
@ResponseBody
@PreAuthorize("hasRole('ROLE_<group1-id>')")
public String group1Id() {
return "group1Id message";
}
@GetMapping("group2Id")
@ResponseBody
@PreAuthorize("hasRole('ROLE_<group2-id>')")
public String group2Id() {
return "group2Id message";
}
}
Ora, ad eccezione del cloud di Azure globale, Microsoft Entra ID viene distribuito nei cloud nazionali seguenti:
Azure Government
Azure Cina 21Vianet
Azure Germania
Ecco un esempio che usa Azure China 21Vianet.
spring:
cloud:
azure:
active-directory:
enabled: true
base-uri: https://login.partner.microsoftonline.cn
graph-base-uri: https://microsoftgraph.chinacloudapi.cn
Per altre informazioni, vedere Distribuzioni cloud nazionali.
Gli sviluppatori possono personalizzare l'URI di reindirizzamento.
Aggiungere redirect-uri-template
proprietà nel file application.yml .
spring:
cloud:
azure:
active-directory:
enabled: true
redirect-uri-template: ${REDIRECT-URI-TEMPLATE}
Eseguire l'aggiornamento redirect-uri
nel portale di Azure.
Dopo aver impostato redirect-uri-template
, è necessario aggiornare il generatore di sicurezza:
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2LoginSecurityConfig extends AadWebSecurityConfigurerAdapter {
/**
* Add configuration logic as needed.
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
http.oauth2Login()
.loginProcessingUrl("${REDIRECT-URI-TEMPLATE}")
.and()
.authorizeRequests()
.anyRequest().authenticated();
}
}
Per connettere Microsoft Entra ID tramite proxy, specificare un RestTemplateCustomizer
bean simile a quello illustrato nell'esempio seguente:
@Configuration
class DemoConfiguration {
@Bean
public RestTemplateCustomizer proxyRestTemplateCustomizer() {
return (RestTemplate restTemplate) -> {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(PROXY_SERVER_HOST, PROXY_SERVER_PORT));
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setProxy(proxy);
restTemplate.setRequestFactory(requestFactory);
};
}
}
Progetto di esempio: aad-web-application.
Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.
Crea una registrazione dell'app. Ottenere
AZURE_TENANT_ID
,AZURE_CLIENT_ID
eAZURE_CLIENT_SECRET
.Impostare
redirect URI
suAPPLICATION_BASE_URI/login/oauth2/code/
, ad esempiohttp://localhost:8080/login/oauth2/code/
. La coda/
è obbligatoria.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
</dependencies>
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
authorization-clients:
graph:
scopes: https://graph.microsoft.com/Analytics.Read, email
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
In questo caso, graph
è il nome di OAuth2AuthorizedClient
, scopes
indica gli ambiti necessari per fornire il consenso durante l'accesso.
public class Demo {
@GetMapping("/graph")
@ResponseBody
public String graph(
@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graphClient) {
// toJsonString() is just a demo.
// oAuth2AuthorizedClient contains access_token. We can use this access_token to access resource server.
return toJsonString(graphClient);
}
}
A questo punto, avviare l'applicazione e accedere all'applicazione nel browser. Si verrà quindi reindirizzati alla pagina di accesso Microsoft.
Il flusso predefinito è il flusso del codice di autorizzazione, se si vuole usare il flusso delle credenziali client, è possibile configurare come segue:
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
authorization-clients:
graph:
authorization-grant-type: client_credentials # Change type to client_credentials
scopes: https://graph.microsoft.com/Analytics.Read, email
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
In un'applicazione Web è possibile accedere a più server di risorse configurando come segue:
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
authorization-clients:
resource-server-1:
scopes: # Scopes for resource-server-1
resource-server-2:
scopes: # Scopes for resource-server-2
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
È quindi possibile usare OAuth2AuthorizedClient
in un'applicazione come questa
public class Demo {
@GetMapping("/resource-server-1")
@ResponseBody
public String graph(
@RegisteredOAuth2AuthorizedClient("resource-server-1") OAuth2AuthorizedClient client) {
return callResourceServer1(client);
}
@GetMapping("/resource-server-2")
@ResponseBody
public String graph(
@RegisteredOAuth2AuthorizedClient("resource-server-2") OAuth2AuthorizedClient client) {
return callResourceServer2(client);
}
}
Progetto di esempio: aad-web-application.
Questo scenario non supporta l'accesso, ma solo proteggere il server convalidando il token di accesso. Se il token di accesso è valido, il server gestisce la richiesta.
Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.
Crea una registrazione dell'app. Ottenere
AZURE_CLIENT_ID
.Leggere Avvio rapido: Configurare un'applicazione per esporre un'API Web.
Esporre un'API Web con un ambito denominato
Scope-1
.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
</dependencies>
spring:
cloud:
azure:
active-directory:
enabled: true
credential:
client-id: ${AZURE_CLIENT_ID}
Avviare l'applicazione e accedere all'API Web dell'applicazione.
Si otterrà 401 senza un token di accesso.
Accedere all'applicazione con un token di accesso. Le attestazioni seguenti nel token di accesso verranno convalidate:
iss
: il token di accesso deve essere rilasciato da Microsoft Entra ID.nbf
: l'ora corrente non può essere precedente anbf
.exp
: l'ora corrente non può dopoexp
.aud
: sespring.cloud.azure.active-directory.credential.client-id
ospring.cloud.azure.active-directory.credential.app-id-uri
configurato, il gruppo di destinatari deve essere uguale all'oggetto configuratoclient-id
oapp-id-uri
. Se le due proprietà non sono configurate, questa attestazione non verrà convalidata.
Per altre informazioni sul token di accesso, vedere la documentazione ms sui token di accesso di Microsoft Identity Platform.
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadOAuth2ResourceServerSecurityConfig extends AadResourceServerWebSecurityConfigurerAdapter {
/**
* Add configuration logic as needed.
*/
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
http.authorizeRequests((requests) -> requests.anyRequest().authenticated());
}
}
Creare le risorse necessarie in Azure.
Leggere Avvio rapido: Configurare un'applicazione per esporre un'API Web.
Esporre un'API Web con un ambito denominato
Scope1
.
Proteggere il metodo specifico.
class Demo { @GetMapping("scope1") @ResponseBody @PreAuthorize("hasAuthority('SCOPE_Scope1')") public String scope1() { return "Congratulations, you can access `scope1` endpoint."; } }
In questo modo, quando si accede all'endpoint /scope1
, verranno convalidate le attestazioni seguenti nel token di accesso:
scp
: il valore deve contenereScope1
.
Creare le risorse necessarie in Azure.
Leggere Aggiungere i ruoli dell'app all'applicazione e riceverli nel token.
Creare un ruolo app con i parametri seguenti:
- Nome visualizzato: AppRole1
- Tipi di membri consentiti: Utenti/Gruppi
- Valore: AppRole1
- Abilitare questo ruolo dell'app: sì
Proteggere il metodo specifico.
class Demo { @GetMapping("app-role1") @ResponseBody @PreAuthorize("hasAuthority('APPROLE_AppRole1')") public String appRole1() { return "Congratulations, you can access `app-role1` endpoint."; } }
In questo modo, quando si accede all'endpoint /app-role1
, verranno convalidate le attestazioni seguenti nel token di accesso:
roles
: il valore deve contenereAppRole1
.
Per usare un token JSON Web (JWT) per l'autenticazione client, seguire questa procedura:
- Vedere la sezione Registrare il certificato con Microsoft Identity Platform delle credenziali del certificato di autenticazione delle applicazioni di Microsoft Identity Platform.
- Caricare un certificato con estensione pem nell'applicazione registrata nel portale di Azure.
- Configurare il percorso del certificato e la password di un oggetto . PFX o . Certificato P12 .
- Aggiungere la configurazione della proprietà
spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt
al client da autenticare tramite l'autenticazione client JWT.
Il file di configurazione di esempio seguente è relativo a uno scenario di applicazione Web. Le informazioni sul certificato sono configurate nelle proprietà globali.
spring:
cloud:
azure:
credential:
client-id: ${AZURE_CLIENT_ID}
client-certificate-path: ${AZURE_CERTIFICATE_PATH}
client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
profile:
tenant-id: <tenant>
active-directory:
enabled: true
user-group:
allowed-group-names: group1,group2
allowed-group-ids: <group1-id>,<group2-id>
post-logout-redirect-uri: http://localhost:8080
authorization-clients:
azure:
client-authentication-method: private_key_jwt
arm:
client-authentication-method: private_key_jwt
scopes: https://management.core.windows.net/user_impersonation
graph:
client-authentication-method: private_key_jwt
scopes:
- https://graph.microsoft.com/User.Read
- https://graph.microsoft.com/Directory.Read.All
webapiA:
client-authentication-method: private_key_jwt
scopes:
- ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
webapiB:
client-authentication-method: private_key_jwt
scopes:
- ${WEB_API_B_APP_ID_URL}/.default
authorization-grant-type: client_credentials
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
È anche possibile configurare le informazioni sul certificato nelle proprietà del active-directory
servizio, come illustrato in questo esempio:
spring:
cloud:
azure:
active-directory:
enabled: true
credential:
client-id: ${AZURE_CLIENT_ID}
client-certificate-path: ${AZURE_CERTIFICATE_PATH}
client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
profile:
tenant-id: <tenant>
user-group:
allowed-group-names: group1,group2
allowed-group-ids: <group1-id>,<group2-id>
post-logout-redirect-uri: http://localhost:8080
authorization-clients:
azure:
client-authentication-method: private_key_jwt
arm:
client-authentication-method: private_key_jwt
scopes: https://management.core.windows.net/user_impersonation
graph:
client-authentication-method: private_key_jwt
scopes:
- https://graph.microsoft.com/User.Read
- https://graph.microsoft.com/Directory.Read.All
webapiA:
client-authentication-method: private_key_jwt
scopes:
- ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
webapiB:
client-authentication-method: private_key_jwt
scopes:
- ${WEB_API_B_APP_ID_URL}/.default
authorization-grant-type: client_credentials
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
Per connettere Microsoft Entra ID tramite proxy, specificare un RestTemplateCustomizer
bean. Per altre informazioni, vedere la sezione Connessione ing to Microsoft Entra ID via proxy .
Progetto di esempio: aad-resource-server.
Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.
Crea una registrazione dell'app. Ottenere
AZURE_TENANT_ID
,AZURE_CLIENT_ID
eAZURE_CLIENT_SECRET
.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
</dependencies>
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
authorization-clients:
graph:
scopes:
- https://graph.microsoft.com/User.Read
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
public class SampleController {
@GetMapping("call-graph")
public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
return callMicrosoftGraphMeEndpoint(graph);
}
}
Progetto di esempio: aad-resource-server-obo.
Leggere Avvio rapido: Registrare un'applicazione con Microsoft Identity Platform.
Crea una registrazione dell'app. Ottenere
AZURE_TENANT_ID
,AZURE_CLIENT_ID
eAZURE_CLIENT_SECRET
.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
</dependencies>
Impostare la proprietà spring.cloud.azure.active-directory.application-type
su web_application_and_resource_server
e specificare il tipo di autorizzazione per ogni client di autorizzazione.
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
app-id-uri: ${WEB_API_ID_URI}
application-type: web_application_and_resource_server # This is required.
authorization-clients:
graph:
authorizationGrantType: authorization_code # This is required.
scopes:
- https://graph.microsoft.com/User.Read
- https://graph.microsoft.com/Directory.Read.All
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
Configurare più SecurityFilterChain
istanze. AadWebApplicationAndResourceServerConfig
contiene due configurazioni della catena di filtri di sicurezza per il server di risorse e l'applicazione Web.
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadWebApplicationAndResourceServerConfig {
@Order(1)
@Configuration
public static class ApiWebSecurityConfigurationAdapter extends AadResourceServerWebSecurityConfigurerAdapter {
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
// All the paths that match `/api/**`(configurable) work as `Resource Server`, other paths work as `Web application`.
http.antMatcher("/api/**")
.authorizeRequests().anyRequest().authenticated();
}
}
@Configuration
public static class HtmlWebSecurityConfigurerAdapter extends AadWebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
// @formatter:off
http.authorizeRequests()
.antMatchers("/login").permitAll()
.anyRequest().authenticated();
// @formatter:on
}
}
}
Proprietà configurabili di spring-cloud-azure-starter-active-directory:
Nome | Descrizione |
---|---|
spring.cloud.azure.active-directory.app-id-uri | URI ID app che può essere usato nell'attestazione "aud" di un id_token. |
spring.cloud.azure.active-directory.application-type | Tipo di applicazione Microsoft Entra. |
spring.cloud.azure.active-directory.authenticate-additional-parameters | Aggiungere altri parametri all'URL di autorizzazione. |
spring.cloud.azure.active-directory.authorization-clients | Client di autorizzazione OAuth2. |
spring.cloud.azure.active-directory.credential.client-id | ID client da usare quando si esegue l'autenticazione dell'entità servizio con Azure. |
spring.cloud.azure.active-directory.credential.client-secret | Segreto client da usare quando si esegue l'autenticazione dell'entità servizio con Azure. |
spring.cloud.azure.active-directory.jwk-set-cache-durata | La durata del set JWK memorizzato nella cache prima della scadenza, il valore predefinito è 5 minuti. |
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time | L'ora di aggiornamento del JWK memorizzato nella cache impostata prima della scadenza, il valore predefinito è 5 minuti. |
spring.cloud.azure.active-directory.jwt-connect-timeout | Connessione out di timeout per la chiamata all'URL remoto JWKSet. |
spring.cloud.azure.active-directory.jwt-read-timeout | Valore Timeout di lettura per la chiamata a URL remoto JWKSet. |
spring.cloud.azure.active-directory.jwt-size-limit | Limite di dimensioni in byte della chiamata URL remota JWKSet. |
spring.cloud.azure.active-directory.post-logout-redirect-uri | URI di reindirizzamento dopo la disconnessione. |
spring.cloud.azure.active-directory.profile.cloud-type | Nome del cloud di Azure a cui connettersi. I tipi supportati sono: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER. |
spring.cloud.azure.active-directory.profile.environment | Proprietà per gli endpoint di Microsoft Entra. |
spring.cloud.azure.active-directory.profile.tenant-id | ID tenant di Azure. I valori consentiti per tenant-id sono: common , organizations , consumers o l'ID tenant. |
spring.cloud.azure.active-directory.redirect-uri-template | Endpoint di reindirizzamento: usato dal server di autorizzazione per restituire risposte contenenti credenziali di autorizzazione al client tramite l'agente utente del proprietario della risorsa. Il valore predefinito è {baseUrl}/login/oauth2/code/ . |
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map | Configurare l'attestazione che verrà usata per compilare GrantedAuthority e il prefisso del valore stringa di GrantedAuthority. Il valore predefinito è: "scp" -> "SCOPE_", "roles" -> "APPROLE_". |
spring.cloud.azure.active-directory.resource-server.principal-claim-name | Configurare l'attestazione nel token di accesso da restituire in AuthenticatedPrincipal#getName. Il valore predefinito è "sub". |
spring.cloud.azure.active-directory.session-stateless | Se true attiva il filtro di autenticazione senza stato AadAppRoleStatelessAuthenticationFilter. Il valore predefinito è false che attiva AadAuthenticationFilter. |
spring.cloud.azure.active-directory.user-group.allowed-group-ids | Gli ID gruppo possono essere usati per costruire GrantedAuthority. |
spring.cloud.azure.active-directory.user-group.allowed-group-names | I nomi dei gruppi possono essere usati per costruire GrantedAuthority. |
spring.cloud.azure.active-directory.user-group.use-transitive-members | Se "true", usare "v1.0/me/transitiveMemberOf" per ottenere i membri. In caso contrario, usare "v1.0/me/memberOf". Il valore predefinito è false . |
spring.cloud.azure.active-directory.user-name-attribute | Decidere quale attestazione deve essere il nome dell'entità. |
Ecco alcuni esempi su come usare queste proprietà:
Il tipo di applicazione può essere dedotto dalle dipendenze: spring-security-oauth2-client
o spring-security-oauth2-resource-server
. Se il valore dedotto non è il valore desiderato, è possibile specificare il tipo di applicazione. Ecco la tabella dei valori validi e dei valori dedotti:
Tipo di applicazione di spring-cloud-azure-starter-active-directory
:
Ha una dipendenza: spring-security-oauth2-client |
Ha una dipendenza: spring-security-oauth2-resource-server |
Valori validi del tipo di applicazione | Valore dedotto |
---|---|---|---|
Sì | No | web_application |
web_application |
No | Sì | resource_server |
resource_server |
Sì | Sì | web_application , resource_server , resource_server_with_obo , web_application_and_resource_server |
resource_server_with_obo |
Azure Active Directory (Azure AD) B2C è un servizio di gestione delle identità che consente di personalizzare e controllare il modo in cui i clienti si iscrivono, accedono e gestiscono i rispettivi profili quando usano le applicazioni, Azure AD B2C consente queste azioni proteggendo al tempo stesso le identità dei clienti.
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory-b2c</artifactId>
</dependency>
</dependencies>
Proprietà configurabili di spring-cloud-azure-starter-active-directory-b2c:
Nome | Descrizione |
---|---|
spring.cloud.azure.active-directory.b2c.app-id-uri | URI ID app che potrebbe essere usato nell'attestazione "aud" di un token. |
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters | Parametri aggiuntivi per l'autenticazione. |
spring.cloud.azure.active-directory.b2c.authorization-clients | Specificare la configurazione client. |
spring.cloud.azure.active-directory.b2c.base-uri | URI di base dell'endpoint di Azure AD B2C. |
spring.cloud.azure.active-directory.b2c.credential | Informazioni sulle credenziali di Azure AD B2C. |
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout | Connessione out di timeout per la chiamata all'URL remoto JWKSet. |
spring.cloud.azure.active-directory.b2c.jwt-read-timeout | Valore Timeout di lettura per la chiamata a URL remoto JWKSet. |
spring.cloud.azure.active-directory.b2c.jwt-size-limit | Limite di dimensioni in byte della chiamata URL remota JWKSet. |
spring.cloud.azure.active-directory.b2c.login-flow | Specificare la chiave del flusso di accesso primario. Il valore predefinito è sign-up-or-sign-in . |
spring.cloud.azure.active-directory.b2c.logout-success-url | URL di reindirizzamento dopo la disconnessione. Il valore predefinito è http://localhost:8080/login . |
spring.cloud.azure.active-directory.b2c.profile | Informazioni sul profilo di Azure AD B2C. |
spring.cloud.azure.active-directory.b2c.reply-url | URL di risposta dopo aver ottenuto il codice di autorizzazione. Il valore predefinito è {baseUrl}/login/oauth2/code/ . |
spring.cloud.azure.active-directory.b2c.user-flows | Flussi utente. |
spring.cloud.azure.active-directory.b2c.user-name-attribute-name | Nome attributo nome utente. |
Per le configurazioni complete, controllare le proprietà di configurazione di Spring Cloud Azure.
Un'applicazione Web è qualsiasi applicazione basata sul Web che consente all'utente di accedere con l'ID Microsoft Entra, mentre un server di risorse accetterà o negherà l'accesso dopo aver convalidato access_token ottenuto da Microsoft Entra ID. In questa guida verranno illustrati 4 scenari:
Accesso a un'applicazione Web.
Applicazione Web che accede ai server delle risorse.
Accesso a un server di risorse.
Server di risorse che accede ad altri server di risorse.
Questo scenario usa il flusso di concessione del codice di autorizzazione OAuth 2.0 per accedere a un utente con l'utente di Azure AD B2C.
Selezionare Azure AD B2C dal menu del portale, selezionare Applicazioni e quindi selezionare Aggiungi.
Specificare il nome dell'applicazione , ad esempio webapp
, aggiungere http://localhost:8080/login/oauth2/code/
per l'URL di risposta, registrare l'ID applicazione come WEB_APP_AZURE_CLIENT_ID
e quindi selezionare Salva.
Selezionare Chiavi dall'applicazione, selezionare Genera chiave per generare WEB_APP_AZURE_CLIENT_SECRET
e quindi selezionare Salva.
Selezionare Flussi utente a sinistra e quindi nuovo flusso utente.
Scegliere Iscrizione o accesso, Modifica profilo e Reimpostazione password rispettivamente per creare flussi utente. Specificare il nome del flusso utente e gli attributi utente e le attestazioni, quindi selezionare Crea.
Selezionare Autorizzazioni>API Aggiungi un'autorizzazione>API Microsoft, selezionare Microsoft Graph, selezionare Autorizzazioni delegate, selezionare le autorizzazioni offline_access e openid e quindi selezionare Aggiungi autorizzazione per completare il processo.
Concedere il consenso amministratore per le autorizzazioni Graph .
Aggiungere le dipendenze seguenti al file pom.xml .
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter-active-directory-b2c</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-springsecurity5</artifactId>
</dependency>
</dependencies>
Aggiungere proprietà al file application.yml usando i valori creati in precedenza, come illustrato nell'esempio seguente:
spring:
cloud:
azure:
active-directory:
b2c:
enabled: true
authenticate-additional-parameters:
domain_hint: xxxxxxxxx # optional
login_hint: xxxxxxxxx # optional
prompt: [login,none,consent] # optional
base-uri: ${BASE_URI}
credential:
client-id: ${WEBAPP_AZURE_CLIENT_ID}
client-secret: ${WEBAPP_AZURE_CLIENT_SECRET}
login-flow: ${LOGIN_USER_FLOW_KEY} # default to sign-up-or-sign-in, will look up the user-flows map with provided key.
logout-success-url: ${LOGOUT_SUCCESS_URL}
user-flows:
${YOUR_USER_FLOW_KEY}: ${USER_FLOW_NAME}
user-name-attribute-name: ${USER_NAME_ATTRIBUTE_NAME}
Scrivere il codice Java.
Per il codice del controller, è possibile fare riferimento all'esempio seguente:
@Controller
public class WebController {
private void initializeModel(Model model, OAuth2AuthenticationToken token) {
if (token != null) {
final OAuth2User user = token.getPrincipal();
model.addAllAttributes(user.getAttributes());
model.addAttribute("grant_type", user.getAuthorities());
model.addAttribute("name", user.getName());
}
}
@GetMapping(value = { "/", "/home" })
public String index(Model model, OAuth2AuthenticationToken token) {
initializeModel(model, token);
return "home";
}
}
Per il codice di configurazione della sicurezza, è possibile fare riferimento all'esempio seguente:
@EnableWebSecurity
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
private final AadB2cOidcLoginConfigurer configurer;
public WebSecurityConfiguration(AadB2cOidcLoginConfigurer configurer) {
this.configurer == configurer;
}
@Override
protected void configure(HttpSecurity http) throws Exception {
// @formatter:off
http.authorizeRequests()
.anyRequest().authenticated()
.and()
.apply(configurer);
// @formatter:off
}
}
Copiare home.html dall'esempio aad-b2c-web-application e sostituire e PROFILE_EDIT_USER_FLOW
PASSWORD_RESET_USER_FLOW
con i nomi dei flussi utente usati in precedenza.
Compilare e testare l'app. Eseguire Webapp
sulla porta 8080.
Dopo che l'applicazione è stata compilata e avviata da Maven, aprire http://localhost:8080/
in un Web browser. Si dovrebbe essere reindirizzati alla pagina di accesso.
Selezionare il collegamento con il flusso utente di accesso. Si dovrebbe essere reindirizzati in Azure AD B2C per avviare il processo di autenticazione.
Dopo aver eseguito l'accesso, verrà visualizzato l'esempio home page
dal browser.
Questo scenario si basa sullo scenario Accesso a un'applicazione Web per consentire a un'applicazione di accedere ad altre risorse. Questo scenario è Il flusso di concessione delle credenziali client OAuth 2.0.
Selezionare Azure AD B2C dal menu del portale, selezionare Applicazioni e quindi selezionare Aggiungi.
Specificare il nome dell'applicazione ( ad esempio webApiA
), registrare l'ID applicazione come WEB_API_A_AZURE_CLIENT_ID
, quindi selezionare Salva.
Selezionare Chiavi dall'applicazione, selezionare Genera chiave per generare WEB_API_A_AZURE_CLIENT_SECRET
e quindi selezionare Salva.
Selezionare Esporre un'API nel riquadro di spostamento e quindi selezionare Imposta. Registrare l'URI ID applicazione come WEB_API_A_APP_ID_URL
, quindi selezionare Salva.
Selezionare Manifesto nel riquadro di spostamento e quindi incollare il segmento JSON seguente nella appRoles
matrice. Registrare l'URI ID applicazione come WEB_API_A_APP_ID_URL
, registrare il valore del ruolo dell'app come WEB_API_A_ROLE_VALUE
, quindi selezionare Salva.
{
"allowedMemberTypes": [
"Application"
],
"description": "WebApiA.SampleScope",
"displayName": "WebApiA.SampleScope",
"id": "04989db0-3efe-4db6-b716-ae378517d2b7",
"isEnabled": true,
"value": "WebApiA.SampleScope"
}
Selezionare Autorizzazioni>API Aggiungi un'autorizzazione>Api personali, selezionare Nome applicazione WebApiA , selezionare Autorizzazioni applicazione, selezionare WebApiA.SampleScope autorizzazione e quindi selezionare Aggiungi autorizzazione per completare il processo.
Concedere il consenso amministratore per le autorizzazioni WebApiA.
Aggiungere la dipendenza seguente in base allo scenario Accesso a un'applicazione Web.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Aggiungere la configurazione seguente in base allo scenario Accesso a un'applicazione Web.
spring:
cloud:
azure:
active-directory:
b2c:
enabled: true
base-uri: ${BASE_URI} # Such as: https://xxxxb2c.b2clogin.com
profile:
tenant-id: <tenant>
authorization-clients:
${RESOURCE_SERVER_A_NAME}:
authorization-grant-type: client_credentials
scopes: ${WEB_API_A_APP_ID_URL}/.default
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
Scrivere il Webapp
codice Java.
Per il codice del controller, è possibile fare riferimento all'esempio seguente:
class Demo {
/**
* Access to protected data from Webapp to WebApiA through client credential flow. The access token is obtained by webclient, or
* <p>@RegisteredOAuth2AuthorizedClient("webApiA")</p>. In the end, these two approaches will be executed to
* DefaultOAuth2AuthorizedClientManager#authorize method, get the access token.
*
* @return Respond to protected data from WebApi A.
*/
@GetMapping("/webapp/webApiA")
public String callWebApiA() {
String body = webClient
.get()
.uri(LOCAL_WEB_API_A_SAMPLE_ENDPOINT)
.attributes(clientRegistrationId("webApiA"))
.retrieve()
.bodyToMono(String.class)
.block();
LOGGER.info("Call callWebApiA(), request '/webApiA/sample' returned: {}", body);
return "Request '/webApiA/sample'(WebApi A) returned a " + (body != null ? "success." : "failure.");
}
}
Il codice di configurazione della sicurezza è uguale a quello dello scenario Accesso a un'applicazione Web. Aggiungere un altro bean webClient
come segue:
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Per scrivere il WebApiA
codice Java, vedere la sezione Accesso a un server di risorse.
Compilare e testare l'app. Consentire Webapp
e WebApiA
eseguire rispettivamente sulla porta 8080 e 8081 . Avviare le Webapp
applicazioni e WebApiA
. Tornare alla home page dopo l'accesso. È quindi possibile accedere http://localhost:8080/webapp/webApiA
per ottenere la risposta della WebApiA
risorsa.
Questo scenario non supporta l'accesso. È sufficiente proteggere il server convalidando il token di accesso e, se valido, viene usata la richiesta.
Per compilare l'autorizzazione WebApiA
, vedere Utilizzo 2: Applicazione Web che accede ai server risorse.
Aggiungere WebApiA
l'autorizzazione e concedere il consenso amministratore per l'applicazione Web.
Aggiungere le dipendenze seguenti al file pom.xml .
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>azure-spring-boot-starter-active-directory-b2c</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
Aggiungere la configurazione seguente.
spring:
cloud:
azure:
active-directory:
b2c:
enabled: true
base-uri: ${BASE_URI} # Such as: https://xxxxb2c.b2clogin.com
profile:
tenant-id: <tenant>
app-id-uri: ${APP_ID_URI} # If you're using v1.0 token, configure app-id-uri for `aud` verification
credential:
client-id: ${AZURE_CLIENT_ID} # If you're using v2.0 token, configure client-id for `aud` verification
user-flows:
sign-up-or-sign-in: ${SIGN_UP_OR_SIGN_IN_USER_FLOW_NAME}
Nota
I valori consentiti per tenant-id
sono: common
, organizations
, consumers
o l'ID tenant. Per altre informazioni su questi valori, vedere la sezione Usato l'endpoint errato (account personali e dell'organizzazione) di Errore AADSTS50020 - L'account utente del provider di identità non esiste nel tenant. Per informazioni sulla conversione dell'app a tenant singolo, vedere Convertire l'app a tenant singolo in multi-tenant in Microsoft Entra ID.
Scrivere il codice Java.
Per il codice del controller, è possibile fare riferimento all'esempio seguente:
class Demo {
/**
* webApiA resource api for web app
* @return test content
*/
@PreAuthorize("hasAuthority('APPROLE_WebApiA.SampleScope')")
@GetMapping("/webApiA/sample")
public String webApiASample() {
LOGGER.info("Call webApiASample()");
return "Request '/webApiA/sample'(WebApi A) returned successfully.";
}
}
Per il codice di configurazione della sicurezza, è possibile fare riferimento all'esempio seguente:
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfiguration extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests((requests) -> requests.anyRequest().authenticated())
.oauth2ResourceServer()
.jwt()
.jwtAuthenticationConverter(new AadJwtBearerTokenAuthenticationConverter());
}
}
Compilare e testare l'app. Eseguirla WebApiA
sulla porta 8081. Ottenere il token di accesso per la webApiA
risorsa e quindi accedere http://localhost:8081/webApiA/sample
come intestazione di autorizzazione bearer.
Questo scenario è un aggiornamento dell'accesso a un server di risorse e supporta l'accesso ad altre risorse dell'applicazione, in base al flusso di credenziali client OAuth2.
Facendo riferimento ai passaggi precedenti, si crea un'applicazione WebApiB
ed espongono un'autorizzazione WebApiB.SampleScope
dell'applicazione .
{
"allowedMemberTypes": [
"Application"
],
"description": "WebApiB.SampleScope",
"displayName": "WebApiB.SampleScope",
"id": "04989db0-3efe-4db6-b716-ae378517d2b7",
"isEnabled": true,
"lang": null,
"origin": "Application",
"value": "WebApiB.SampleScope"
}
Concedere il consenso amministratore per WebApiB
le autorizzazioni.
In base all'accesso a un server di risorse, aggiungere la dipendenza seguente al file pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Aggiungere la configurazione seguente in base alla configurazione dello scenario Accesso a un server di risorse.
spring:
cloud:
azure:
active-directory:
b2c:
enabled: true
credential:
client-secret: ${WEB_API_A_AZURE_CLIENT_SECRET}
authorization-clients:
${RESOURCE_SERVER_B_NAME}:
authorization-grant-type: client_credentials
scopes: ${WEB_API_B_APP_ID_URL}/.default
Scrivere il codice Java.
Per il WebApiA
codice del controller, è possibile fare riferimento all'esempio seguente:
public class SampleController {
/**
* Access to protected data from WebApiA to WebApiB through client credential flow. The access token is obtained by webclient, or
* <p>@RegisteredOAuth2AuthorizedClient("webApiA")</p>. In the end, these two approaches will be executed to
* DefaultOAuth2AuthorizedClientManager#authorize method, get the access token.
*
* @return Respond to protected data from WebApi B.
*/
@GetMapping("/webApiA/webApiB/sample")
@PreAuthorize("hasAuthority('APPROLE_WebApiA.SampleScope')")
public String callWebApiB() {
String body = webClient
.get()
.uri(LOCAL_WEB_API_B_SAMPLE_ENDPOINT)
.attributes(clientRegistrationId("webApiB"))
.retrieve()
.bodyToMono(String.class)
.block();
LOGGER.info("Call callWebApiB(), request '/webApiB/sample' returned: {}", body);
return "Request 'webApiA/webApiB/sample'(WebApi A) returned a " + (body != null ? "success." : "failure.");
}
}
Per il WebApiB
codice del controller, è possibile fare riferimento all'esempio seguente:
public class SampleController {
/**
* webApiB resource api for other web application
* @return test content
*/
@PreAuthorize("hasAuthority('APPROLE_WebApiB.SampleScope')")
@GetMapping("/webApiB/sample")
public String webApiBSample() {
LOGGER.info("Call webApiBSample()");
return "Request '/webApiB/sample'(WebApi B) returned successfully.";
}
}
Il codice di configurazione della sicurezza è lo stesso con Accesso a uno scenario del server di risorse, viene aggiunto un altro bean webClient
come indicato di seguito
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Compilare e testare l'app. Consentire WebApiA
e WebApiB
eseguire rispettivamente sulla porta 8081 e 8082 . Avviare le WebApiA
applicazioni e WebApiB
, ottenere il token di accesso per webApiA
la risorsa e accedere http://localhost:8081/webApiA/webApiB/sample
come intestazione di autorizzazione bearer.
Per altre informazioni, vedere gli esempi spring-cloud-azure-starter-active-directory-b2c.