Podpora Spring Cloud Azure pro Spring Security
Tento článek se vztahuje na:✅ verze 4.19.0 ✅ verze 5.19.0
Tento článek popisuje, jak je možné společně používat Spring Cloud Azure a Spring Security.
Spring Security s Microsoft Entra ID
Při vytváření webové aplikace bude správa identit a přístupu vždy základem.
Azure nabízí skvělou platformu pro demokratizaci vaší cesty vývoje aplikací, protože nabízí nejen službu cloudové základní identity, ale také hlubokou integraci se zbytkem ekosystému Azure.
Spring Security usnadňuje zabezpečení aplikací založených na Springu pomocí výkonných abstrakcí a rozšiřitelných rozhraní. Stejně výkonné jako architektura Spring ale není přizpůsobená konkrétnímu zprostředkovateli identity.
spring-cloud-azure-starter-active-directory
poskytuje optimální způsob, jak připojit webovou aplikaci k tenantovi Microsoft Entra ID (Microsoft Entra ID for short) a chránit váš server prostředků pomocí Microsoft Entra ID. K ochraně webových aplikací a serverů prostředků používá protokol Oauth 2.0.
Přístup k webové aplikaci
Tento scénář používá Autorizační kód OAuth 2.0 uděluje toku k přihlášení uživatele pomocí účtu Microsoft.
Systémový diagram
Vytvoření požadovaných prostředků v Azure
Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .
Vytvořte registraci aplikace. Získejte
AZURE_TENANT_ID
,AZURE_CLIENT_ID
aAZURE_CLIENT_SECRET
.Nastavte
redirect URI
naAPPLICATION_BASE_URI/login/oauth2/code/
– napříkladhttp://localhost:8080/login/oauth2/code/
. Chvost/
je povinný.
Přidání požadovaných závislostí
<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>
Přidání požadovaných vlastností
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Teď spusťte aplikaci a přejděte k aplikaci prostřednictvím prohlížeče. Budete přesměrováni na přihlašovací stránku Microsoftu.
Pokročilé využití
Přidání dalších konfigurací zabezpečení
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {
/**
* Add configuration logic as needed.
*/
@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
.and()
.authorizeHttpRequests()
.anyRequest().authenticated();
// Do some custom configuration.
return http.build();
}
}
Autorizace přístupu podle rolí aplikací
Vytvoření požadovaných prostředků v Azure:
Přečtěte si Přidání rolí aplikace do aplikace a jejich přijetí v tokenu.
Vytvořte roli aplikace s následujícími parametry:
- Zobrazovaný název: Správce
- Povolené typy členů: Uživatelé/skupiny
- Hodnota: Správce
- Chcete povolit tuto roli aplikace: Ano
Poznámka
Pokud chcete použít řízení přístupu na základě role aplikace, nemůžete do deklarace identity role
vložit názvy skupin. Další informace najdete v části Konfigurace volitelných deklarací identity skupin části Zadání volitelných deklarací identity doaplikace.
Chraňte konkrétní metodu.
class Demo {
@GetMapping("Admin")
@ResponseBody
@PreAuthorize("hasAuthority('APPROLE_Admin')")
public String admin() {
return "Admin message";
}
}
Autorizace přístupu podle názvu skupiny nebo ID skupiny
Přidejte související vlastnosti konfigurace.
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
Chraňte konkrétní metodu.
@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";
}
}
Použití Národního Azure místo globálního Azure
Teď kromě globálního cloudu Azure se ID Microsoft Entra nasadí v následujících národních cloudech:
Azure Government
Azure China 21Vianet
Azure Germany
Tady je ukázka s využitím Azure China 21Vianet.
spring:
cloud:
azure:
active-directory:
enabled: true
base-uri: https://login.partner.microsoftonline.cn
graph-base-uri: https://microsoftgraph.chinacloudapi.cn
Další informace najdete v tématu nasazení národních cloudů.
Konfigurace šablony identifikátoru URI přesměrování
Vývojáři můžou identifikátor URI přesměrování přizpůsobit.
Do souboru redirect-uri-template
přidejte vlastnosti.
spring:
cloud:
azure:
active-directory:
enabled: true
redirect-uri-template: ${REDIRECT-URI-TEMPLATE}
Aktualizujte redirect-uri
na webu Azure Portal.
Po nastavení redirect-uri-template
musíme aktualizovat tvůrce zabezpečení:
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {
/**
* Add configuration logic as needed.
*/
@Bean
public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
// @formatter:off
http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
.and()
.oauth2Login()
.loginProcessingUrl("${REDIRECT-URI-TEMPLATE}")
.and()
.authorizeHttpRequests()
.anyRequest().authenticated();
// @formatter:on
return http.build();
}
}
Připojení k MICROSOFT Entra ID přes proxy server
Pokud chcete připojit ID Microsoft Entra prostřednictvím proxy serveru, zadejte RestTemplateCustomizer
bean jako ten, který je znázorněn v následujícím příkladu:
@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);
};
}
}
Vzorky
Ukázkový projekt: aad-web-application .
Webová aplikace přistupující k serverům prostředků
Systémový diagram
Vytvoření požadovaných prostředků v Azure
Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .
Vytvořte registraci aplikace. Získejte
AZURE_TENANT_ID
,AZURE_CLIENT_ID
aAZURE_CLIENT_SECRET
.Nastavte
redirect URI
naAPPLICATION_BASE_URI/login/oauth2/code/
, napříkladhttp://localhost:8080/login/oauth2/code/
. Chvost/
je povinný.
Přidání požadovaných závislostí
<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>
Přidání požadovaných vlastností
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Tady graph
je název OAuth2AuthorizedClient
, scopes
znamená rozsahy potřebné k vyjádření souhlasu při přihlášení.
Použití OAuth2AuthorizedClient ve vaší aplikaci
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);
}
}
Teď spusťte aplikaci a přejděte k aplikaci v prohlížeči. Pak budete přesměrováni na přihlašovací stránku Microsoftu.
Pokročilé využití
Tok přihlašovacích údajů klienta
Výchozí tok je tok autorizačního kódu, pokud chcete použít tok přihlašovacích údajů klienta , můžete ho nakonfigurovat takto:
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Přístup k více serverům prostředků
V jedné webové aplikaci můžete získat přístup k více serverům prostředků tak, že nakonfigurujete následující:
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Pak můžete v aplikaci použít OAuth2AuthorizedClient
takto:
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);
}
}
Vzorky
Ukázkový projekt: aad-web-application .
Přístup k serveru prostředků
Tento scénář nepodporuje přihlášení, stačí chránit server ověřením přístupového tokenu. Pokud je přístupový token platný, server žádost obsluhuje.
Systémový diagram
Vytvoření požadovaných prostředků v Azure
Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .
Vytvořte registraci aplikace. Získejte
AZURE_CLIENT_ID
.Rychlý start ke čtení : Konfigurace aplikace pro zveřejnění webového rozhraní API.
Zveřejnění webového rozhraní API s oborem s názvem
Scope-1
.
Přidání požadovaných závislostí
<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>
Přidání požadovaných vlastností
spring:
cloud:
azure:
active-directory:
enabled: true
credential:
client-id: ${AZURE_CLIENT_ID}
Teď spusťte aplikaci a získejte přístup k webovému rozhraní API vaší aplikace.
401 získáte bez přístupového tokenu.
Přístup k aplikaci pomocí přístupového tokenu Ověří se následující deklarace identity v přístupovém tokenu:
iss
: Přístupový token musí být vystavený id Microsoft Entra.nbf
: Aktuální čas nemůže být přednbf
.exp
: Aktuální čas nemůže poexp
.aud
: Pokud je nakonfigurovanáspring.cloud.azure.active-directory.credential.client-id
nebospring.cloud.azure.active-directory.credential.app-id-uri
, musí se cílová skupina rovnat nakonfigurovanýmclient-id
neboapp-id-uri
. Pokud tyto dvě vlastnosti nejsou nakonfigurované, tato deklarace identity se neověří.
Další informace o přístupovém tokenu najdete v tématu dokumentace MS o přístupových tokenech platformy Microsoft Identity Platform.
Pokročilé využití
Přidání dalších konfigurací zabezpečení
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2ResourceServerSecurityConfig {
/**
* Add configuration logic as needed.
*/
@Bean
public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
// @formatter:off
http.apply(AadResourceServerHttpSecurityConfigurer.aadResourceServer())
.and()
.authorizeHttpRequests()
.anyRequest().authenticated();
// @formatter:on
return http.build();
}
}
Ověření oprávnění podle oborů
Vytvořte požadované prostředky v Azure.
Rychlý start ke čtení : Konfigurace aplikace pro zveřejnění webového rozhraní API.
Zveřejnění webového rozhraní API s oborem s názvem
Scope1
.
Chraňte konkrétní metodu.
class Demo { @GetMapping("scope1") @ResponseBody @PreAuthorize("hasAuthority('SCOPE_Scope1')") public String scope1() { return "Congratulations, you can access `scope1` endpoint."; } }
Tímto způsobem se při přístupu /scope1
koncovému bodu ověří následující deklarace identity v přístupovém tokenu:
-
scp
: Hodnota musí obsahovatScope1
.
Ověření oprávnění podle rolí aplikací
Vytvořte požadované prostředky v Azure.
Přečtěte si Přidání rolí aplikace do aplikace a jejich přijetí v tokenu.
Vytvořte roli aplikace s následujícími parametry:
- Zobrazovaný název: AppRole1
- Povolené typy členů: Uživatelé/skupiny
- Hodnota: AppRole1
- Chcete povolit tuto roli aplikace: Ano
Chraňte konkrétní metodu.
class Demo { @GetMapping("app-role1") @ResponseBody @PreAuthorize("hasAuthority('APPROLE_AppRole1')") public String appRole1() { return "Congratulations, you can access `app-role1` endpoint."; } }
Tímto způsobem se při přístupu /app-role1
koncovému bodu ověří následující deklarace identity v přístupovém tokenu:
-
roles
: Hodnota musí obsahovatAppRole1
.
Použití ověřování klienta JWT
Pokud chcete pro ověřování klientů použít webový token JSON (JWT), postupujte následovně:
- Viz část Registrace certifikátu v platformě Microsoft Identity Platform přihlašovacích údajů ověřovacího certifikátu aplikace Microsoft Identity Platform.
- Nahrajte do aplikace zaregistrované na webu Azure Portal certifikát .pem.
- Nakonfigurujte cestu k certifikátu a heslo . PFX nebo . Certifikát P12
- Přidejte do klienta konfiguraci
spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt
vlastnosti, která se má ověřit prostřednictvím ověřování klienta JWT.
Následující ukázkový konfigurační soubor je určený pro scénář webové aplikace. Informace o certifikátu jsou nakonfigurovány v globálních vlastnostech.
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Můžete také nakonfigurovat informace o certifikátu ve vlastnostech služby active-directory
, jak je znázorněno v tomto příkladu:
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Připojení k MICROSOFT Entra ID přes proxy server
Pokud chcete propojit ID Microsoft Entra prostřednictvím proxy serveru, zadejte RestTemplateCustomizer
bean. Další informace najdete v části Připojení k Microsoft Entra ID prostřednictvím proxy.
Vzorky
Ukázkový projekt: aad-resource-server .
Server prostředků, který navštíví ostatní servery prostředků
Systémový diagram
Vytvoření požadovaných prostředků v Azure
Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .
Vytvořte registraci aplikace. Získejte
AZURE_TENANT_ID
,AZURE_CLIENT_ID
aAZURE_CLIENT_SECRET
.
Přidání požadovaných závislostí
<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>
Přidání požadovaných vlastností
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Použití OAuth2AuthorizedClient ve vaší aplikaci
public class SampleController {
@GetMapping("call-graph")
public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
return callMicrosoftGraphMeEndpoint(graph);
}
}
Vzorky
Ukázkový projekt: aad-resource-server-obo .
Webová aplikace a server prostředků v jedné aplikaci
Vytvoření požadovaných prostředků v Azure
Přečtěte si Rychlý start: Registrace aplikace vMicrosoft Identity Platform .
Vytvořte registraci aplikace. Získejte
AZURE_TENANT_ID
,AZURE_CLIENT_ID
aAZURE_CLIENT_SECRET
.
Přidání požadovaných závislostí
<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>
Přidání požadovaných vlastností
Nastavte vlastnost spring.cloud.azure.active-directory.application-type
na web_application_and_resource_server
a zadejte typ autorizace pro každého autorizačního klienta.
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Definování atributu SecurityFilterChain
Nakonfigurujte více instancí SecurityFilterChain
.
AadWebApplicationAndResourceServerConfig
obsahuje dvě konfigurace řetězu filtrů zabezpečení pro server prostředků a webovou aplikaci.
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadWebApplicationAndResourceServerConfig {
@Bean
@Order(1)
public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
http.apply(AadResourceServerHttpSecurityConfigurer.aadResourceServer())
.and()
// All the paths that match `/api/**`(configurable) work as the resource server. Other paths work as the web application.
.securityMatcher("/api/**")
.authorizeHttpRequests()
.anyRequest().authenticated();
return http.build();
}
@Bean
public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
// @formatter:off
http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
.and()
.authorizeHttpRequests()
.requestMatchers("/login").permitAll()
.anyRequest().authenticated();
// @formatter:on
return http.build();
}
}
Konfigurace
Konfigurovatelné vlastnosti spring-cloud-azure-starter-active-directory:
Jméno | Popis |
---|---|
spring.cloud.azure.active-directory.app-id-uri | Identifikátor URI ID aplikace, který se může použít v deklaraci identity "aud" id_token. |
spring.cloud.azure.active-directory.application-type | Typ aplikace Microsoft Entra. |
spring.cloud.azure.active-directory.authenticate-additional-parameters | Přidejte další parametry do adresy URL autorizace. |
spring.cloud.azure.active-directory.authorization-clients | Autorizační klienti OAuth2. |
spring.cloud.azure.active-directory.credential.client-id | ID klienta, které se má použít při ověřování instančního objektu v Azure. |
spring.cloud.azure.active-directory.credential.client-secret | Tajný klíč klienta, který se má použít při ověřování instančního objektu v Azure. |
spring.cloud.azure.active-directory.jwk-set-cache-životnost | Životnost sady JWK uložené v mezipaměti před vypršením platnosti je výchozí 5 minut. |
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time | Doba aktualizace sady JWK uložená v mezipaměti před vypršením platnosti je výchozí 5 minut. |
spring.cloud.azure.active-directory.jwt-connect-timeout | Vypršení časového limitu připojení pro volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.jwt-read-timeout | Časový limit čtení pro volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.jwt-size-limit | Omezení velikosti v bajtech volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.post-logout-redirect-uri | Identifikátor URI přesměrování po odhlášení. |
spring.cloud.azure.active-directory.profile.cloud-type | Název cloudu Azure, ke kterému se chcete připojit. Podporované typy jsou: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER. |
spring.cloud.azure.active-directory.profile.environment | Vlastnosti koncových bodů Microsoft Entra |
spring.cloud.azure.active-directory.profile.tenant-id | ID tenanta Azure. Hodnoty povolené pro tenant-id jsou: common , organizations , consumers nebo ID tenanta. |
spring.cloud.azure.active-directory.redirect-uri-template | Koncový bod přesměrování: Autorizační server používá k vrácení odpovědí obsahujících autorizační přihlašovací údaje klientovi prostřednictvím uživatelského agenta vlastníka prostředku. Výchozí hodnota je {baseUrl}/login/oauth2/code/ . |
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map | Nakonfigurujte, která deklarace identity se použije k sestavení GrantedAuthority, a předponu řetězcové hodnoty GrantedAuthority. Výchozí hodnota je: "scp" –> "SCOPE_", "roles" –> "APPROLE_". |
spring.cloud.azure.active-directory.resource-server.principal-claim-name | Nakonfigurujte, která deklarace identity v přístupového tokenu se vrátí v souboru AuthenticatedPrincipal#getName. Výchozí hodnota je sub. |
spring.cloud.azure.active-directory.session-stateless | Pokud true aktivuje bezstavový ověřovací filtr AadAppRoleStatelessAuthenticationFilter. Výchozí hodnota je false, která aktivuje AadAuthenticationFilter. |
spring.cloud.azure.active-directory.user-group.allowed-group-ids | ID skupiny lze použít k vytvoření GrantedAuthority. |
spring.cloud.azure.active-directory.user-group.allowed-group-names | Názvy skupin lze použít k vytvoření GrantedAuthority. |
spring.cloud.azure.active-directory.user-group.use-transitive-members | Pokud je hodnota true, získejte členy pomocí příkazu v1.0/me/transitiveMemberOf. V opačném případě použijte "v1.0/me/memberOf". Výchozí hodnota je false . |
spring.cloud.azure.active-directory.user-name-attribute | Rozhodněte, která deklarace identity má být názvem objektu zabezpečení. |
Tady je několik příkladů použití těchto vlastností:
Typ aplikace
Typ aplikace lze odvodit ze závislostí: spring-security-oauth2-client
nebo spring-security-oauth2-resource-server
. Pokud odvozená hodnota není požadovanou hodnotou, můžete zadat typ aplikace. Tady je tabulka platných hodnot a odvozených hodnot:
Typ spring-cloud-azure-starter-active-directory
aplikace:
Má závislost: spring-security-oauth2-client |
Má závislost: spring-security-oauth2-resource-server |
Platné hodnoty typu aplikace | Odvozená hodnota |
---|---|---|---|
Ano | Ne | web_application |
web_application |
Ne | Ano | resource_server |
resource_server |
Ano | Ano |
web_application , resource_server , resource_server_with_obo , web_application_and_resource_server |
resource_server_with_obo |
Spring Security s Využitím Azure Active Directory B2C
Azure Active Directory (Azure AD) B2C je služba pro správu identit, která umožňuje přizpůsobit a řídit, jak se zákazníci registrují, přihlašují a spravují své profily při používání aplikací. Azure AD B2C umožňuje tyto akce a současně chrání identity vašich zákazníků.
Nastavení závislostí
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory-b2c</artifactId>
</dependency>
</dependencies>
Konfigurace
Konfigurovatelné vlastnosti spring-cloud-azure-starter-active-directory-b2c:
Jméno | Popis |
---|---|
spring.cloud.azure.active-directory.b2c.app-id-uri | Identifikátor URI ID aplikace, který se může použít v deklaraci identity tokenu "aud". |
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters | Další parametry pro ověřování. |
spring.cloud.azure.active-directory.b2c.authorization-clients | Zadejte konfiguraci klienta. |
spring.cloud.azure.active-directory.b2c.base-uri | Identifikátor URI základního koncového bodu Azure AD B2C |
spring.cloud.azure.active-directory.b2c.credential | Informace o přihlašovacích údaji Azure AD B2C |
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout | Vypršení časového limitu připojení pro volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.b2c.jwt-read-timeout | Časový limit čtení pro volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.b2c.jwt-size-limit | Omezení velikosti v bajtech volání vzdálené adresy URL JWKSet |
spring.cloud.azure.active-directory.b2c.login-flow | Zadejte primární klíč toku přihlašování. Výchozí hodnota je sign-up-or-sign-in . |
spring.cloud.azure.active-directory.b2c.logout-success-url | Adresa URL přesměrování po odhlášení Výchozí hodnota je http://localhost:8080/login . |
spring.cloud.azure.active-directory.b2c.profile | Informace o profilu Azure AD B2C |
spring.cloud.azure.active-directory.b2c.reply-url | Adresa URL odpovědi po získání autorizačního kódu Výchozí hodnota je {baseUrl}/login/oauth2/code/ . |
spring.cloud.azure.active-directory.b2c.user-flow | Toky uživatelů |
spring.cloud.azure.active-directory.b2c.user-name-attribute-name | Název atributu uživatelského jména. |
Pokud chcete úplné konfigurace, zkontrolujte vlastnosti konfigurace Spring Cloud Azure.
Základní využití
webová aplikace je libovolná webová aplikace, která umožňuje přihlášení uživatele pomocí Microsoft Entra ID, zatímco server prostředků přijme nebo odepře přístup po ověření access_token získané z ID Microsoft Entra. V této příručce probereme 4 scénáře:
Přístup k webové aplikaci
Webová aplikace, která přistupuje k serverům prostředků
Přístup k serveru prostředků
Server prostředků, který přistupuje k jiným serverům prostředků.
Použití 1: Přístup k webové aplikaci
Tento scénář používá Autorizační kód OAuth 2.0 uděluje toku pro přihlášení uživatele s uživatelem Azure AD B2C.
V nabídce portálu vyberte
Zadejte název aplikace
V aplikaci vyberte Klíče, vyberte Vygenerovat klíč a vygenerujte WEB_APP_AZURE_CLIENT_SECRET
a pak vyberte Uložit.
Vyberte Toky uživatelů vlevo a pak vyberte Nový tok uživatele.
Zvolte Registrace nebo v, úpravy profilua resetování hesla vytvářet toky uživatelů. Zadejte tok uživatele Název a Atributy uživatele adeklarací identity a pak vyberte Vytvořit.
Vyberte
Udělení souhlasu správce pro oprávnění Graph
Do souboru pom.xml přidejte následující závislosti.
<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-springsecurity6</artifactId>
</dependency>
</dependencies>
Přidejte do souboru application.yml vlastnosti pomocí hodnot, které jste vytvořili dříve, jak je znázorněno v následujícím příkladu:
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}
Napište kód Java.
Kód kontroleru najdete v následujícím příkladu:
@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";
}
}
Kód konfigurace zabezpečení najdete v následujícím příkladu:
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
public class WebSecurityConfiguration {
private final AadB2cOidcLoginConfigurer configurer;
public WebSecurityConfiguration(AadB2cOidcLoginConfigurer configurer) {
this.configurer = configurer;
}
@Bean
SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
// @formatter:off
http.authorizeHttpRequests()
.anyRequest().authenticated()
.and()
.apply(configurer);
// @formatter:on
return http.build();
}
}
Zkopírujte
Sestavte a otestujte aplikaci. Nechte Webapp
běžet na portu 8080
.
Po sestavení a spuštění aplikace Maven otevřete http://localhost:8080/
ve webovém prohlížeči. Měli byste být přesměrováni na přihlašovací stránku.
Vyberte odkaz s tokem přihlašovacího uživatele. Měli byste být přesměrováni na Azure AD B2C a zahájit proces ověřování.
Po úspěšném přihlášení byste měli vidět ukázkovou home page
z prohlížeče.
Využití 2: Webová aplikace přistupující k serverům prostředků
Tento scénář vychází ze scénáře Přístup k webové aplikaci, aby aplikace mohla přistupovat k jiným prostředkům. Tento scénář je přihlašovací údaje klienta OAuth 2.0 udělovat tok.
V nabídce portálu vyberte
Zadejte název aplikace
V aplikaci vyberte Klíče, vyberte Vygenerovat klíč a vygenerujte WEB_API_A_AZURE_CLIENT_SECRET
a pak vyberte Uložit.
V navigačním podokně vyberte Zveřejnit rozhraní API a pak vyberte Nastavit. Poznamenejte identifikátor URI ID aplikace jako WEB_API_A_APP_ID_URL
a pak vyberte Uložit.
V navigačním podokně vyberte manifestu a vložte následující segment JSON do pole appRoles
. Poznamenejte si identifikátor URI ID aplikace jako WEB_API_A_APP_ID_URL
, poznamenejte si hodnotu role aplikace jako WEB_API_A_ROLE_VALUE
a pak vyberte Uložit.
{
"allowedMemberTypes": [
"Application"
],
"description": "WebApiA.SampleScope",
"displayName": "WebApiA.SampleScope",
"id": "04989db0-3efe-4db6-b716-ae378517d2b7",
"isEnabled": true,
"value": "WebApiA.SampleScope"
}
Vyberte oprávnění rozhraní API>Přidat oprávnění>moje rozhraní API, vyberte Název aplikace WebApiA, vyberte Oprávnění aplikace, vyberte Oprávnění WebApiA.SampleScope a pak vyberte Přidat oprávnění proces dokončit.
Udělení souhlasu správce pro oprávnění WebApiA
Přidejte následující závislost na základě přístupu k webové aplikaci scénář.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Přidejte následující konfiguraci na základě Přístup k webové aplikaci scénář.
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
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Napište svůj kód Webapp
Javy.
Kód kontroleru najdete v následujícím příkladu:
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.");
}
}
Kód konfigurace zabezpečení je stejný jako ve scénáři Přístup k webové aplikaci. Následujícím způsobem přidejte další webClient
bean:
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Pokud chcete napsat kód WebApiA
Javy, přečtěte si část Přístup k serveru prostředků části.
Sestavte a otestujte aplikaci. Nechte Webapp
a WebApiA
běžet na portech 8080
a 8081
. Spusťte aplikace Webapp
a WebApiA
. Po úspěšném přihlášení se vraťte na domovskou stránku. Pak můžete získat přístup k http://localhost:8080/webapp/webApiA
a získat odpověď na WebApiA
prostředku.
Použití 3: Přístup k serveru prostředků
Tento scénář nepodporuje přihlášení. Stačí server chránit ověřením přístupového tokenu a pokud je platný, žádost se zobrazí.
Pokud chcete vytvořit oprávnění WebApiA
, přečtěte si téma Usage 2: Web Application Accessing Resource Servers.
Přidejte WebApiA
oprávnění a udělte správci souhlas pro vaši webovou aplikaci.
Do souboru pom.xml přidejte následující závislosti.
<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>
Přidejte následující konfiguraci.
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}
Poznámka
Hodnoty povolené pro tenant-id
jsou: common
, organizations
, consumers
nebo ID tenanta. Další informace o těchto hodnotách najdete v části Použití nesprávného koncového bodu (osobní a organizační účty) části Chyba AADSTS50020 – Uživatelský účet od zprostředkovatele identity vtenanta neexistuje . Informace o převodu aplikace s jedním tenantem najdete v tématu Převod jednoklientských aplikací na víceklienta vMicrosoft Entra ID .
Napište kód Java.
Kód kontroleru najdete v následujícím příkladu:
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.";
}
}
Kód konfigurace zabezpečení najdete v následujícím příkladu:
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class ResourceServerConfiguration {
@Bean
public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
JwtAuthenticationConverter authenticationConverter = new JwtAuthenticationConverter();
JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
jwtGrantedAuthoritiesConverter.setAuthorityPrefix("APPROLE_");
authenticationConverter.setJwtGrantedAuthoritiesConverter(jwtGrantedAuthoritiesConverter);
// @formatter:off
http.authorizeHttpRequests((requests) -> requests.anyRequest().authenticated())
.oauth2ResourceServer()
.jwt()
.jwtAuthenticationConverter(authenticationConverter);
// @formatter:on
return http.build();
}
}
Sestavte a otestujte aplikaci. Nechte WebApiA
běžet na portu 8081
. Získejte přístupový token pro prostředek webApiA
a pak získejte přístup k http://localhost:8081/webApiA/sample
jako autorizační hlavičku Bearer.
Využití 4: Server prostředků, který přistupuje k jiným serverům prostředků
Tento scénář je upgradem Přístup k serveru prostředkůa podporuje přístup k jiným prostředkům aplikace na základě toku přihlašovacích údajů klienta OAuth2.
V předchozích krocích vytvoříme WebApiB
aplikaci a zveřejníme oprávnění aplikace WebApiB.SampleScope
.
{
"allowedMemberTypes": [
"Application"
],
"description": "WebApiB.SampleScope",
"displayName": "WebApiB.SampleScope",
"id": "04989db0-3efe-4db6-b716-ae378517d2b7",
"isEnabled": true,
"lang": null,
"origin": "Application",
"value": "WebApiB.SampleScope"
}
Udělení souhlasu správce pro oprávnění WebApiB
Na základě Přístup kserveru prostředků přidejte do souboru pom.xml následující závislost.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Na základě konfigurace Přístup k serveru prostředků scénář přidejte následující konfiguraci.
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
Napište kód Java.
Kód kontroleru WebApiA
najdete v následujícím příkladu:
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.");
}
}
Kód kontroleru WebApiB
najdete v následujícím příkladu:
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.";
}
}
Kód konfigurace zabezpečení je stejný s přístupem k serveru prostředků scénář, další webClient
bean je přidán následujícím způsobem:
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Sestavte a otestujte aplikaci. Nechte WebApiA
a WebApiB
běžet na portech 8081
a 8082
. Spusťte WebApiA
a WebApiB
aplikace, získejte přístupový token pro prostředek webApiA
a jako autorizační hlavičku beareru získejte přístup k http://localhost:8081/webApiA/webApiB/sample
.
Vzorky
Další informace najdete v ukázkách spring-cloud-azure-starter-active-directory-b2c.