Suporte do Spring Cloud Azure para o Spring Security
Este artigo aplica-se a:✅ Versão 4.19.0 ✅ Versão 5.19.0
Este artigo descreve como o Spring Cloud Azure e o Spring Security podem ser usados juntos.
Spring Security com Microsoft Entra ID
Quando você está criando um aplicativo Web, o gerenciamento de identidade e acesso sempre serão peças fundamentais.
O Azure oferece uma excelente plataforma para democratizar a sua jornada de desenvolvimento de aplicações, uma vez que não só oferece um serviço de identidade baseado na nuvem, mas também uma integração profunda com o resto do ecossistema do Azure.
O Spring Security facilitou a proteção de seus aplicativos baseados em Spring com abstrações poderosas e interfaces extensíveis. No entanto, por mais poderosa que a estrutura Spring possa ser, ela não é adaptada a um provedor de identidade específico.
O spring-cloud-azure-starter-active-directory fornece a maneira mais ideal de conectar seu aplicativo Web a um locatário do Microsoft Entra ID (Microsoft Entra ID para abreviar) e proteger seu servidor de recursos com o Microsoft Entra ID. Ele usa o protocolo Oauth 2.0 para proteger aplicativos da web e servidores de recursos.
Aceder a uma aplicação Web
Este cenário usa O código de autorização OAuth 2.0 concede fluxo para fazer logon em um usuário com uma conta da Microsoft.
Diagrama do Sistema
Criar recursos necessários no Azure
Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.
Crie um registro de aplicativo. Obtenha
AZURE_TENANT_ID,AZURE_CLIENT_IDeAZURE_CLIENT_SECRET.Defina
redirect URIcomoAPPLICATION_BASE_URI/login/oauth2/code/- por exemplo,http://localhost:8080/login/oauth2/code/. A/de cauda é necessária.
Adicionar dependências necessárias
<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>
Adicionar propriedades necessárias
spring:
cloud:
azure:
active-directory:
enabled: true
profile:
tenant-id: <tenant>
credential:
client-id: ${AZURE_CLIENT_ID}
client-secret: ${AZURE_CLIENT_SECRET}
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Agora, inicie seu aplicativo e acesse seu aplicativo através do navegador. Será redirecionado para a página de início de sessão da Microsoft.
Utilizações avançadas
Adicionar configurações de segurança adicionais
@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();
}
}
Autorizar o acesso por funções de aplicativo
Crie os recursos necessários no Azure:
Leia Adicionar funções de aplicativo ao seu aplicativo e receba-as no token.
Crie uma função de aplicativo com os seguintes parâmetros:
- Nome para exibição: Admin
- Tipos de membros permitidos: Utilizadores/Grupos
- Valor: Admin
- Deseja habilitar esta função de aplicativo: sim
Observação
Se você quiser usar o controle de acesso baseado em função de aplicativo, não poderá colocar nomes de grupo na declaração de role. Para obter mais informações, consulte a seção Configurando declarações opcionais de grupos de Fornecer declarações opcionais ao seu aplicativo.
Proteja o método específico.
class Demo {
@GetMapping("Admin")
@ResponseBody
@PreAuthorize("hasAuthority('APPROLE_Admin')")
public String admin() {
return "Admin message";
}
}
Autorizar o acesso por nome de grupo ou ID de grupo
Adicione propriedades de configuração relacionadas.
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
Proteja o método específico.
@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";
}
}
Usar o Azure Nacional em vez do Azure Global
Agora, exceto na nuvem global do Azure, o Microsoft Entra ID é implantado nas seguintes nuvens nacionais:
Azure Government
Azure China 21Vianet
Azure Alemanha
Aqui está um exemplo usando o Azure China 21Vianet.
spring:
cloud:
azure:
active-directory:
enabled: true
base-uri: https://login.partner.microsoftonline.cn
graph-base-uri: https://microsoftgraph.chinacloudapi.cn
Para obter mais informações, consulte Implantações de nuvem nacionais.
Configurar modelo de URI de redirecionamento
Os desenvolvedores podem personalizar o redirect-uri.
Adicione redirect-uri-template propriedades em seu arquivo application.yml.
spring:
cloud:
azure:
active-directory:
enabled: true
redirect-uri-template: ${REDIRECT-URI-TEMPLATE}
Atualize redirect-uri no portal do Azure.
Depois de definir redirect-uri-template, precisamos atualizar o security builder:
@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();
}
}
Conectando-se ao Microsoft Entra ID via proxy
Para conectar o Microsoft Entra ID via proxy, forneça um RestTemplateCustomizer bean como o mostrado no exemplo a seguir:
@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);
};
}
}
Amostras
Projeto de exemplo: aad-web-application.
Aplicativo Web acessando servidores de recursos
Diagrama do Sistema
Criar recursos necessários no Azure
Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.
Crie um registro de aplicativo. Obtenha
AZURE_TENANT_ID,AZURE_CLIENT_IDeAZURE_CLIENT_SECRET.Defina
redirect URIcomoAPPLICATION_BASE_URI/login/oauth2/code/, por exemplo,http://localhost:8080/login/oauth2/code/. A/de cauda é necessária.
Adicionar dependências necessárias
<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>
Adicionar propriedades necessárias
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Aqui, graph é o nome de OAuth2AuthorizedClient, scopes significa os escopos necessários para consentir ao fazer login.
Use OAuth2AuthorizedClient em seu aplicativo
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);
}
}
Agora, inicie seu aplicativo e acesse seu aplicativo no navegador. Em seguida, você será redirecionado para a página de login da Microsoft.
Utilizações avançadas
Fluxo de credenciais do cliente
O fluxo padrão é fluxo de código de autorização, se você quiser usar fluxo de credenciais de cliente, você pode configurar assim:
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Acessar vários servidores de recursos
Em um aplicativo Web, você pode acessar vários servidores de recursos configurando assim:
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Então você pode usar OAuth2AuthorizedClient em aplicativos como este
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);
}
}
Amostras
Projeto de exemplo: aad-web-application.
Acessando um servidor de recursos
Este cenário não suporta login, apenas protege o servidor validando o token de acesso. Se o token de acesso for válido, o servidor atende a solicitação.
Diagrama do Sistema
Criar recursos necessários no Azure
Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.
Crie um registro de aplicativo. Obtenha
AZURE_CLIENT_ID.Leia Guia de início rápido: configurar um aplicativo para expor uma API da Web.
Exponha uma API da Web com um escopo chamado
Scope-1.
Adicionar dependências necessárias
<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>
Adicionar propriedades necessárias
spring:
cloud:
azure:
active-directory:
enabled: true
credential:
client-id: ${AZURE_CLIENT_ID}
Agora inicie seu aplicativo e acesse a API da Web do seu aplicativo.
Você receberá 401 sem um token de acesso.
Acesse seu aplicativo com um token de acesso. As seguintes declarações no token de acesso serão validadas:
iss: O token de acesso deve ser emitido pelo Microsoft Entra ID.nbf: A hora atual não pode ser antesnbf.exp: A hora atual não pode depois deexp.aud: Sespring.cloud.azure.active-directory.credential.client-idouspring.cloud.azure.active-directory.credential.app-id-uriconfigurado, a audiência deve ser igual aoclient-idconfigurado ouapp-id-uri. Se as duas propriedades não estiverem configuradas, essa declaração não será validada.
Para obter mais informações sobre o token de acesso, consulte documentos MS sobre tokens de acesso à plataforma de identidade da Microsoft.
Utilizações avançadas
Adicionar configurações de segurança adicionais
@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();
}
}
Validar permissão por escopos
Crie os recursos necessários no Azure.
Leia Guia de início rápido: configurar um aplicativo para expor uma API da Web.
Exponha uma API da Web com um escopo chamado
Scope1.
Proteja o método específico.
class Demo { @GetMapping("scope1") @ResponseBody @PreAuthorize("hasAuthority('SCOPE_Scope1')") public String scope1() { return "Congratulations, you can access `scope1` endpoint."; } }
Ao fazer isso, ao acessar /scope1 ponto de extremidade, as seguintes declarações no token de acesso serão validadas:
-
scp: O valor deve conterScope1.
Validar permissão por funções de aplicativo
Crie os recursos necessários no Azure.
Leia Adicionar funções de aplicativo ao seu aplicativo e receba-as no token.
Crie uma função de aplicativo com os seguintes parâmetros:
- Nome para exibição: AppRole1
- Tipos de membros permitidos: Utilizadores/Grupos
- Valor: AppRole1
- Deseja habilitar esta função de aplicativo: sim
Proteja o método específico.
class Demo { @GetMapping("app-role1") @ResponseBody @PreAuthorize("hasAuthority('APPROLE_AppRole1')") public String appRole1() { return "Congratulations, you can access `app-role1` endpoint."; } }
Ao fazer isso, ao acessar /app-role1 ponto de extremidade, as seguintes declarações no token de acesso serão validadas:
-
roles: O valor deve conterAppRole1.
Usar autenticação de cliente JWT
Para usar um JSON Web Token (JWT) para autenticação de cliente, use as seguintes etapas:
- Consulte a seção Registrar seu certificado com a plataforma de identidade da Microsoft de credenciais de certificado de autenticação de aplicativo da plataforma de identidade da Microsoft.
- Carregue um certificado de .pem para o aplicativo registrado no portal do Azure.
- Configure o caminho do certificado e a senha de um . PFX ou . Certificado de P12.
- Adicione a propriedade
spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwtconfiguração ao cliente a ser autenticado por meio da autenticação do cliente JWT.
O arquivo de configuração de exemplo a seguir é para um cenário de aplicativo Web. As informações do certificado são configuradas nas propriedades globais.
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Você também pode configurar as informações do certificado nas propriedades do serviço active-directory, conforme mostrado neste exemplo:
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Conectando-se ao Microsoft Entra ID via proxy
Para conectar o Microsoft Entra ID via proxy, forneça um RestTemplateCustomizer bean. Para obter mais informações, consulte a seção Conectando-se ao Microsoft Entra ID via proxy.
Amostras
Projeto de exemplo: aad-resource-server.
Servidor de recursos visitando outros servidores de recursos
Diagrama do Sistema
Criar recursos necessários no Azure
Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.
Crie um registro de aplicativo. Obtenha
AZURE_TENANT_ID,AZURE_CLIENT_IDeAZURE_CLIENT_SECRET.
Adicionar dependências necessárias
<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>
Adicionar propriedades necessárias
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Use OAuth2AuthorizedClient em seu aplicativo
public class SampleController {
@GetMapping("call-graph")
public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
return callMicrosoftGraphMeEndpoint(graph);
}
}
Amostras
Projeto de exemplo: aad-resource-server-obo.
Aplicativo Web e servidor de recursos em um aplicativo
Criar recursos necessários no Azure
Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.
Crie um registro de aplicativo. Obtenha
AZURE_TENANT_ID,AZURE_CLIENT_IDeAZURE_CLIENT_SECRET.
Adicionar dependências necessárias
<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>
Adicionar propriedades necessárias
Defina a propriedade spring.cloud.azure.active-directory.application-type como web_application_and_resource_servere especifique o tipo de autorização para cada cliente de autorização.
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Definir SecurityFilterChain
Configure várias instâncias SecurityFilterChain.
AadWebApplicationAndResourceServerConfig contém duas configurações de cadeia de filtros de segurança para o servidor de recursos e o aplicativo Web.
@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();
}
}
Configuração
Propriedades configuráveis do spring-cloud-azure-starter-active-directory:
| Designação | Descrição |
|---|---|
| spring.cloud.azure.active-directory.app-id-uri | URI do ID do aplicativo que pode ser usado na declaração "aud" de um id_token. |
| spring.cloud.azure.active-directory.application-type | Tipo de aplicativo Microsoft Entra. |
| spring.cloud.azure.active-directory.authenticate-additional-parameters | Adicione parâmetros adicionais à URL de autorização. |
| spring.cloud.azure.active-directory.authorization-clients | Os clientes de autorização OAuth2. |
| spring.cloud.azure.active-directory.credential.client-id | ID do Cliente a ser usada ao executar a autenticação da entidade de serviço com o Azure. |
| spring.cloud.azure.active-directory.credential.client-secret | Segredo do cliente a ser usado ao executar a autenticação da entidade de serviço com o Azure. |
| spring.cloud.azure.active-directory.jwk-set-cache-lifespan | A vida útil do conjunto JWK armazenado em cache antes de expirar, o padrão é de 5 minutos. |
| spring.cloud.azure.active-directory.jwk-set-cache-refresh-time | O tempo de atualização do conjunto JWK armazenado em cache antes de expirar, o padrão é de 5 minutos. |
| spring.cloud.azure.active-directory.jwt-connect-timeout | Tempo limite de conexão para a chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.jwt-read-timeout | Leia Tempo limite para a chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.jwt-size-limit | Limite de tamanho em bytes da chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.post-logout-redirect-uri | O uri de redirecionamento após o logout. |
| spring.cloud.azure.active-directorydo tipo .profile.cloud | Nome da nuvem do Azure à qual se conectar. Os tipos suportados são: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER. |
| spring.cloud.azure.active-directory.profile.environment | Propriedades para pontos de extremidade do Microsoft Entra. |
| spring.cloud.azure.active-directory.profile.tenant-id | ID do locatário do Azure. Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. |
| spring.cloud.azure.active-directory.redirect-uri-template | Ponto de extremidade de redirecionamento: usado pelo servidor de autorização para retornar respostas contendo credenciais de autorização ao cliente por meio do user-agent do proprietário do recurso. O valor padrão é {baseUrl}/login/oauth2/code/. |
| spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map | Configure qual declaração será usada para criar GrantedAuthority e prefixo do valor da cadeia de caracteres de GrantedAuthority. O valor padrão é: "scp" -> "SCOPE_", "roles" -> "APPROLE_". |
| spring.cloud.azure.active-directory.resource-server.principal-claim-name | Configure qual declaração no token de acesso será retornada em AuthenticatedPrincipal#getName. O valor padrão é "sub". |
| spring.cloud.azure.active-directory.session-stateless | Se true ativa o filtro de autenticação sem estado AadAppRoleStatelessAuthenticationFilter. O padrão é false que ativa AadAuthenticationFilter. |
| spring.cloud.azure.active-directory.user-group.allowed-group-ids | As ids de grupo podem ser usadas para construir GrantedAuthority. |
| spring.cloud.azure.active-directory.user-group.allowed-group-names | Os nomes de grupo podem ser usados para construir GrantedAuthority. |
| spring.cloud.azure.active-directory.user-group.use-transitive-members | Se "true", use "v1.0/me/transitiveMemberOf" para obter membros. Caso contrário, use "v1.0/me/memberOf". O valor padrão é false. |
| spring.cloud.azure.active-directory.user-name-attribute | Decida qual reivindicação será o nome do mandante. |
Aqui estão alguns exemplos sobre como usar essas propriedades:
Tipo de aplicação
O tipo de aplicativo pode ser inferido a partir das dependências: spring-security-oauth2-client ou spring-security-oauth2-resource-server. Se o valor inferido não for o valor desejado, você poderá especificar o tipo de aplicativo. Aqui está a tabela de valores válidos e valores inferidos:
Tipo de aplicação do spring-cloud-azure-starter-active-directory:
Tem dependência: spring-security-oauth2-client |
Tem dependência: spring-security-oauth2-resource-server |
Valores válidos do tipo de aplicativo | Valor inferido |
|---|---|---|---|
| Sim | Não | web_application |
web_application |
| Não | Sim | resource_server |
resource_server |
| Sim | Sim |
web_application, resource_server, resource_server_with_obo, web_application_and_resource_server |
resource_server_with_obo |
Spring Security com o Azure Ative Directory B2C
O Azure Ative Directory (Azure AD) B2C é um serviço de gerenciamento de identidades que permite personalizar e controlar como os clientes se inscrevem, entram e gerenciam seus perfis ao usar seus aplicativos. O Azure AD B2C permite essas ações e, ao mesmo tempo, protege as identidades de seus clientes.
Configuração de dependência
<dependencies>
<dependency>
<groupId>com.azure.spring</groupId>
<artifactId>spring-cloud-azure-starter-active-directory-b2c</artifactId>
</dependency>
</dependencies>
Configuração
Propriedades configuráveis de spring-cloud-azure-starter-active-directory-b2c:
| Designação | Descrição |
|---|---|
| spring.cloud.azure.active-directory.b2c.app-id-uri | URI do ID do aplicativo que pode ser usado na declaração "aud" de um token. |
| spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters | Parâmetros adicionais para autenticação. |
| spring.cloud.azure.active-directory.b2c.authorization-clients | Especifique a configuração do cliente. |
| spring.cloud.azure.active-directory.b2c.base-uri | Uri da base de ponto de extremidade do Azure AD B2C. |
| spring.cloud.azure.active-directory.b2c.credential | Informações de credenciais do Azure AD B2C. |
| spring.cloud.azure.active-directory.b2c.jwt-connect-timeout | Tempo limite de conexão para a chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.b2c.jwt-read-timeout | Leia Tempo limite para a chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.b2c.jwt-size-limit | Limite de tamanho em bytes da chamada de URL remota JWKSet. |
| spring.cloud.azure.active-directory.b2c.login-flow | Especifique a chave de fluxo de entrada primária. O valor padrão é sign-up-or-sign-in. |
| spring.cloud.azure.active-directory.b2c.logout-success-url | URL de redirecionamento após o logout. O valor padrão é http://localhost:8080/login. |
| spring.cloud.azure.active-directory.b2c.profile | Informações de perfil do Azure AD B2C. |
| spring.cloud.azure.active-directory.b2c.reply-url | URL de resposta depois de obter o código de autorização. O valor padrão é {baseUrl}/login/oauth2/code/. |
| spring.cloud.azure.active-directory.b2c.user-flows | Fluxos de usuários. |
| spring.cloud.azure.active-directory.b2c.user-name-attribute-name | Nome do atributo Nome do usuário. |
Para obter configurações completas, verifique propriedades de configuração do Spring Cloud Azure.
Utilização básica
Um de aplicativo Web
Aceder a uma aplicação Web.
Aplicação Web que acede a servidores de recursos.
Acessando um servidor de recursos.
Servidor de recursos acessando outros servidores de recursos.
Uso 1: Acessando um aplicativo Web
Este cenário usa O código de autorização OAuth 2.0 concede fluxo para fazer logon em um usuário com seu usuário do Azure AD B2C.
Selecione do Azure AD B2C no menu do portal, selecione Aplicativose, em seguida, selecione Adicionar.
Especifique o Nome
Selecione Chaves do seu aplicativo, selecione Gerar chave para gerar WEB_APP_AZURE_CLIENT_SECRETe, em seguida, selecione Salvar.
Selecione Fluxos de usuário à esquerda e, em seguida, selecione Novo fluxo de usuário.
Escolha Inscrever-se ou em, de edição de perfil e de redefinição de senha para criar fluxos de usuário, respectivamente. Especifique seu fluxo de usuário Nome e Atributos de usuário e declaraçõese, em seguida, selecione Criar.
Selecione
Conceda consentimento de administrador para permissões do Graph.
Adicione as seguintes dependências ao seu arquivo 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-springsecurity6</artifactId>
</dependency>
</dependencies>
Adicione propriedades ao seu arquivo de application.yml usando os valores criados anteriormente, conforme mostrado no exemplo a seguir:
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}
Escreva seu código Java.
Para o código do controlador, você pode consultar o seguinte exemplo:
@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";
}
}
Para o código de configuração de segurança, você pode consultar o seguinte exemplo:
@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();
}
}
Copie o home.html de exemplo aad-b2c-web-applicatione substitua os PROFILE_EDIT_USER_FLOW e PASSWORD_RESET_USER_FLOW pelos nomes de fluxo de usuário usados anteriormente.
Crie e teste seu aplicativo. Deixe Webapp executar na porta 8080.
Depois que seu aplicativo for criado e iniciado pelo Maven, abra-http://localhost:8080/ em um navegador da Web. Você deve ser redirecionado para a página de login.
Selecione o link com o fluxo de usuário de login. Você deve ser redirecionado para o Azure AD B2C para iniciar o processo de autenticação.
Depois de iniciar sessão com êxito, deverá ver o exemplo home page a partir do browser.
Uso 2: Aplicativo Web acessando servidores de recursos
Este cenário baseia-se no Aceder a uma aplicação Web cenário para permitir que uma aplicação aceda a outros recursos. Este cenário é As credenciais do cliente OAuth 2.0 concedem fluxo.
Selecione do Azure AD B2C no menu do portal, selecione Aplicativose, em seguida, selecione Adicionar.
Especifique o Nome
Selecione Chaves do seu aplicativo, selecione Gerar chave para gerar WEB_API_A_AZURE_CLIENT_SECRETe, em seguida, selecione Salvar.
Selecione Expor um de API no painel de navegação e, em seguida, selecione Definir. Registre o de URI da ID do Aplicativo
Selecione de manifesto no painel de navegação e cole o seguinte segmento JSON em appRoles matriz. Registre o de URI da ID do Aplicativo
{
"allowedMemberTypes": [
"Application"
],
"description": "WebApiA.SampleScope",
"displayName": "WebApiA.SampleScope",
"id": "04989db0-3efe-4db6-b716-ae378517d2b7",
"isEnabled": true,
"value": "WebApiA.SampleScope"
}
Selecione permissões de API>Adicionar uma permissão>Minhas APIs, selecione WebApiA nome do aplicativo, selecione Permissões de Aplicativo, selecione permissão WebApiA.SampleScope e selecione Adicionar permissão para concluir o processo.
Conceda consentimento de administrador para permissões de WebApia.
Adicione a seguinte dependência com base na Acessando um aplicativo Web cenário.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Adicione a seguinte configuração com base na Acessando um aplicativo Web cenário.
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
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Escreva seu Webapp código Java.
Para o código do controlador, você pode consultar o seguinte exemplo:
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.");
}
}
O código de configuração de segurança é o mesmo que no cenário webClient da seguinte forma:
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Para escrever seu código WebApiA Java, consulte a seção Acessando um servidor de recursos.
Crie e teste seu aplicativo. Deixe Webapp e WebApiA executados na porta 8080 e 8081 respectivamente. Inicie o Webapp e WebApiA aplicativos. Regresse à página inicial depois de iniciar sessão com êxito. Em seguida, você pode acessar http://localhost:8080/webapp/webApiA para obter a resposta do recurso WebApiA.
Uso 3: Acessando um servidor de recursos
Este cenário não suporta login. Basta proteger o servidor validando o token de acesso e, se válido, ele atende à solicitação.
Para criar sua permissão de WebApiA, consulte Uso 2: Aplicativo Web acessando servidores de recursos.
Adicione WebApiA permissão e conceda consentimento de administrador para seu aplicativo Web.
Adicione as seguintes dependências ao seu arquivo 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>
Adicione a seguinte configuração.
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}
Observação
Os valores permitidos para tenant-id são: common, organizations, consumersou o ID do locatário. Para obter mais informações sobre esses valores, consulte a seção
Escreva seu código Java.
Para o código do controlador, você pode consultar o seguinte exemplo:
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.";
}
}
Para o código de configuração de segurança, você pode consultar o seguinte exemplo:
@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();
}
}
Crie e teste seu aplicativo. Deixe WebApiA executar na porta 8081. Obtenha o token de acesso para o recurso webApiA e, em seguida, acesse http://localhost:8081/webApiA/sample como o cabeçalho de autorização do Portador.
Uso 4: Servidor de recursos acessando outros servidores de recursos
Este cenário é uma atualização do Acessando umde servidor de recursos e oferece suporte ao acesso a outros recursos do aplicativo, com base no fluxo de credenciais do cliente OAuth2.
Referindo-se às etapas anteriores, criamos um aplicativo WebApiB e expomos uma permissão de aplicativo 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"
}
Conceda consentimento de administrador para WebApiB permissões.
Com base no Acessando um servidor de recursos, adicione a seguinte dependência ao seu arquivo pom.xml.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Adicione a seguinte configuração com base no Acessando um servidor de recursos configuração de cenário.
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
Escreva seu código Java.
Para o código do controlador WebApiA, você pode consultar o seguinte exemplo:
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.");
}
}
Para o código do controlador WebApiB, você pode consultar o seguinte exemplo:
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.";
}
}
O código de configuração de segurança é o mesmo com Acessando um servidor de recursos cenário, outro webClient de bean é adicionado da seguinte maneira
public class SampleConfiguration {
@Bean
public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
ServletOAuth2AuthorizedClientExchangeFilterFunction function =
new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
return WebClient.builder()
.apply(function.oauth2Configuration())
.build();
}
}
Crie e teste seu aplicativo. Deixe WebApiA e WebApiB executar na porta 8081 e 8082 respectivamente. Inicie o WebApiA e WebApiB aplicativos, obtenha o token de acesso para webApiA recurso e acesse http://localhost:8081/webApiA/webApiB/sample como o cabeçalho de autorização do portador.
Amostras
Para obter mais informações, consulte os exemplos de spring-cloud-azure-starter-active-directory-b2c.