Suporte do Spring Cloud Azure para o Spring Security

Este artigo aplica-se a: ✔️ Versão 4.14.0 Versão 5.8.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 fluxo de concessão de código de autorização OAuth 2.0 para fazer logon em um usuário com uma conta da Microsoft.

Diagrama do Sistema

Criar recursos necessários no Azure

1. Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.

2. Crie um registro de aplicativo. Obter AZURE_TENANT_ID, AZURE_CLIENT_ID, e AZURE_CLIENT_SECRET.

3. Defina redirect URI como APPLICATION_BASE_URI/login/oauth2/code/ - por exemplo http://localhost:8080/login/oauth2/code/, . O rejeito / é obrigatório.

Adicionar as 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}

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

@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
    }
}

@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

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

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 definirmos redirect-uri-templateo , precisamos atualizar o construtor de segurança:

@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();
    }
}

@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);
        };
    }
}

Exemplos

Projeto de exemplo: aad-web-application.

Aplicativo Web acessando servidores de recursos

Diagrama do Sistema

Criar recursos necessários no Azure

1. Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.

2. Crie um registro de aplicativo. Obter AZURE_TENANT_ID, AZURE_CLIENT_ID, e AZURE_CLIENT_SECRET.

3. Defina redirect URI como APPLICATION_BASE_URI/login/oauth2/code/, por exemplo http://localhost:8080/login/oauth2/code/. O rejeito / é obrigatório.

Adicionar as 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

Aqui, é o nome de OAuth2AuthorizedClient, scopesgraph 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 é o fluxo de código de autorização, se você quiser usar o fluxo de credenciais do 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

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

Então você pode usar OAuth2AuthorizedClient em aplicação como esta

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);
    }
}

Exemplos

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

1. Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.

2. Crie um registro de aplicativo. Obter AZURE_CLIENT_ID.

3. Leia Guia de início rápido: configurar um aplicativo para expor uma API da Web.

4. Exponha uma API da Web com um escopo chamado Scope-1.

Adicionar as 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.

1. Você receberá 401 sem um token de acesso.

2. 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 antes nbf.

   • exp: A hora atual não pode depois de exp.

   • aud: Se spring.cloud.azure.active-directory.credential.client-id ou configurado, o público deve ser igual ao configurado client-id ou app-id-urispring.cloud.azure.active-directory.credential.app-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 MS docs sobre tokens de acesso da plataforma de identidade da Microsoft.

Utilizações avançadas

Adicionar configurações de segurança adicionais

@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());
    }
}

@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

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

2. 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, quando o ponto de extremidade de acesso, as seguintes declarações no token de acesso /scope1 serão validadas:

• scp: O valor deve conter Scope1.

Validar permissão por funções de aplicativo

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

2. 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, quando o ponto de extremidade de acesso, as seguintes declarações no token de acesso /app-role1 serão validadas:

• roles: O valor deve conter AppRole1.

Usar autenticação de cliente JWT

Para usar um JSON Web Token (JWT) para autenticação de cliente, use as seguintes etapas:

1. Consulte a seção Registrar seu certificado com a plataforma de identidade da Microsoft das credenciais do certificado de autenticação do aplicativo da plataforma de identidade da Microsoft.
2. Carregue um certificado .pem para o aplicativo registrado no portal do Azure.
3. Configure o caminho do certificado e a senha de um arquivo . PFX ou . Certificado P12 .
4. Adicione a configuração da propriedade spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt 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

Você também pode configurar as informações do certificado nas propriedades do active-directory serviço, 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

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 .

Exemplos

Projeto de exemplo: aad-resource-server.

Servidor de recursos visitando outros servidores de recursos

Diagrama do Sistema

Criar recursos necessários no Azure

1. Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.

2. Crie um registro de aplicativo. Obter AZURE_TENANT_ID, AZURE_CLIENT_ID, e AZURE_CLIENT_SECRET.

Adicionar as 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

Use OAuth2AuthorizedClient em seu aplicativo

public class SampleController {
    @GetMapping("call-graph")
    public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
        return callMicrosoftGraphMeEndpoint(graph);
    }
}

Exemplos

Projeto de exemplo: aad-resource-server-obo.

Aplicativo Web e servidor de recursos em um aplicativo

Criar recursos necessários no Azure

1. Leia Guia de início rápido: registrar um aplicativo com a plataforma de identidade da Microsoft.

2. Crie um registro de aplicativo. Obter AZURE_TENANT_ID, AZURE_CLIENT_ID, e AZURE_CLIENT_SECRET.

Adicionar as 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

Definir SecurityFilterChain

Configure várias SecurityFilterChain instâncias. AadWebApplicationAndResourceServerConfig Contém duas configurações de cadeia de filtros de segurança para o servidor de recursos e o aplicativo 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
        }
    }
}

@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:

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 de spring-cloud-azure-starter-active-directory:

Spring Security com o Azure Ative Directory B2C

O Azure Active Directory (Azure AD) B2C é um serviço de gestão de identidades que lhe permite personalizar e controlar a forma como os clientes se inscrevem, iniciam sessão e gerem os respetivos perfis quando utilizam as suas aplicações. O Azure AD B2C permite estas ações ao mesmo tempo que protege as identidades dos 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:

Para obter configurações completas, verifique as propriedades de configuração do Spring Cloud Azure.

Utilização básica

Um aplicativo Web é qualquer aplicativo baseado na Web que permite que o usuário faça login com o Microsoft Entra ID, enquanto um servidor de recursos aceitará ou negará o acesso após validar access_token obtido do Microsoft Entra ID. Abordaremos 4 cenários neste guia:

1. Aceder a uma aplicação Web.

2. Aplicação Web que acede a servidores de recursos.

3. Acessando um servidor de recursos.

4. Servidor de recursos acessando outros servidores de recursos.

Uso 1: Acessando um aplicativo Web

Este cenário usa o fluxo de concessão de código de autorização OAuth 2.0 para fazer logon em um usuário com seu usuário do Azure AD B2C.

Selecione Azure AD B2C no menu do portal, selecione Aplicativos e selecione Adicionar.

Especifique o Nome do aplicativo (como webapp), adicione http://localhost:8080/login/oauth2/code/ para a URL de resposta, registre a ID do aplicativo como sua WEB_APP_AZURE_CLIENT_IDe selecione Salvar.

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 entrar, Edição de perfil e Redefinição de senha para criar fluxos de usuário, respectivamente. Especifique o nome do fluxo de usuário e os atributos e declarações do usuário e selecione Criar.

Selecione Permissões de API Adicione uma permissão APIs da Microsoft, selecione Microsoft Graph, selecione Permissões> delegadas, selecione as permissões offline_access e openid e selecione Adicionar permissão> para concluir o processo.

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-springsecurity5</artifactId>
   </dependency>
</dependencies>

<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 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:

@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
   }
}

@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 do exemplo aad-b2c-web-application e substitua o PROFILE_EDIT_USER_FLOWe PASSWORD_RESET_USER_FLOW pelos nomes de fluxo de usuário usados anteriormente.

Crie e teste seu aplicativo. Deixe Webapp correr 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 cenário Acessando um aplicativo Web para permitir que um aplicativo acesse outros recursos. Este cenário é O fluxo de concessão de credenciais do cliente OAuth 2.0.

Selecione Azure AD B2C no menu do portal, selecione Aplicativos e selecione Adicionar.

Especifique o Nome do aplicativo (como webApiA), registre a ID do aplicativo como seu WEB_API_A_AZURE_CLIENT_IDe selecione Salvar.

Selecione Chaves do seu aplicativo, selecione Gerar chave para gerar WEB_API_A_AZURE_CLIENT_SECRETe, em seguida, selecione Salvar.

Selecione Expor uma API no painel de navegação e, em seguida, selecione Definir. Registre o URI da ID do aplicativo como seu WEB_API_A_APP_ID_URLe, em seguida, selecione Salvar.

Selecione Manifesto no painel de navegação e cole o seguinte segmento JSON na appRoles matriz. Registre o URI da ID do Aplicativo como seu , registre o valor da função do aplicativo como seu WEB_API_A_APP_ID_URLWEB_API_A_ROLE_VALUEe selecione Salvar.

{
 "allowedMemberTypes": [
   "Application"
 ],
 "description": "WebApiA.SampleScope",
 "displayName": "WebApiA.SampleScope",
 "id": "04989db0-3efe-4db6-b716-ae378517d2b7",
 "isEnabled": true,
 "value": "WebApiA.SampleScope"
}

Selecione Permissões>de API Adicione uma permissão Minhas APIs, selecione Nome do aplicativo WebApiA, 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 WebApiA.

Adicione a seguinte dependência com base no cenário Acessando um aplicativo Web.

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

Adicione a seguinte configuração com base no cenário Acessando um aplicativo 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

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 Acessando um aplicativo Web. Adicione outro feijão 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 WebApiA código Java, consulte a seção Acessando um servidor de recursos.

Crie e teste seu aplicativo. Deixe Webapp e execute nas portas 8080 e WebApiA8081, 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 WebApiA recurso.

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 WebApiA permissão, 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}

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:

@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());
   }
}

@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 e, em seguida, acesse http://localhost:8081/webApiA/sample como o webApiA cabeçalho de autorização do portador.

Uso 4: Servidor de recursos acessando outros servidores de recursos

Este cenário é uma atualização de Acessando um 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 WebApiB aplicativo e expomos uma permissão WebApiB.SampleScopede aplicativo.

{
   "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 em 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 na configuração do cenário Acessando um servidor de recursos.

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, você pode consultar o WebApiA 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, você pode consultar o WebApiB 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 cenário de servidor de recursos, outro bean webClient é 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 execute nas portas 8081 e WebApiB8082, respectivamente. Inicie os WebApiA aplicativos e , obtenha o token de acesso para webApiA o recurso e WebApiB acesse http://localhost:8081/webApiA/webApiB/sample como o cabeçalho de autorização do portador.

Exemplos

Para obter mais informações, consulte os exemplos de spring-cloud-azure-starter-active-directory-b2c.