Suporte do Spring Cloud Azure para Spring Security

Este artigo se aplica 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 a ID do Microsoft Entra

Quando você estiver criando um aplicativo Web, o gerenciamento de identidade e acesso sempre serão peças fundamentais.

O Azure oferece uma ótima plataforma para democratizar seu percurso de desenvolvimento de aplicativos, pois ele não só oferece um serviço de identidade de base de nuvem, mas também uma profunda integração com o restante do ecossistema do Azure.

O Spring Security facilitou a segurança de seus aplicativos baseados em Spring com abstrações avançadas e interfaces extensíveis. No entanto, por mais poderoso 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 a ID do Microsoft Entra. Ele usa o protocolo Oauth 2.0 para proteger aplicativos Web e servidores de recursos.

Acessando um aplicativo Web

Esse cenário usa a concessão de código de autorização do OAuth 2.0 fluxo para fazer logon em um usuário com uma conta da Microsoft.

Diagrama do Sistema

Criar recursos necessários no Azure

1. Leia 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_IDe AZURE_CLIENT_SECRET.

3. Defina redirect URI como APPLICATION_BASE_URI/login/oauth2/code/ – por exemplo, http://localhost:8080/login/oauth2/code/. O / de rejeito é necessário.

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}

Agora, inicie seu aplicativo e acesse seu aplicativo por meio do navegador. Você será redirecionado para a página de logon da Microsoft.

Usos avançados

Adicionar configurações de segurança extras

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

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

Autorizar o acesso por funções de aplicativo

Criar recursos necessários no Azure:

• Leia Adicionar funções de aplicativo ao aplicativo e receba-as no token.

• Crie uma função de aplicativo com os seguintes parâmetros:

  • Nome de exibição: Administrador
  • Tipos de membro permitidos: Usuários/Grupos
  • Valor: Administrador
  • Você deseja habilitar essa 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

Adicionar 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, a ID do Microsoft Entra é implantada nas seguintes nuvens nacionais:

• Azure Governamental

• 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 o modelo de URI de redirecionamento

Os desenvolvedores podem personalizar o redirecionamento-uri.

Adicione redirect-uri-template propriedades ao 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-template, precisamos atualizar o construtor de segurança:

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

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

Conectando-se à ID do Microsoft Entra por meio de proxy

Para conectar a ID do Microsoft Entra por meio de proxy, forneça um bean RestTemplateCustomizer 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

1. Leia 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_IDe AZURE_CLIENT_SECRET.

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

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

Aqui, graph é o nome de OAuth2AuthorizedClient, scopes significa os escopos necessários para consentir ao fazer logon.

Usar 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 logon da Microsoft.

Usos avançados

Fluxo de credenciais do cliente

O fluxo padrão é fluxo de código de autorização, se você quiser usar fluxo de credenciais do cliente, você pode configurar desta forma:

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

Em seguida, você pode usar OAuth2AuthorizedClient em um aplicativo 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

Esse cenário não dá suporte ao logon, basta proteger o servidor validando o token de acesso. Se o token de acesso for válido, o servidor atenderá à solicitação.

Diagrama do Sistema

Criar recursos necessários no Azure

1. Leia 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. Início Rápido do de Leitura: Configurar um aplicativo para expor umde API Web.

4. Expor uma API 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 Web do aplicativo.

1. Você obterá 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 pela ID do Microsoft Entra.

   • nbf: a hora atual não pode ser antes de nbf.

   • exp: a hora atual não pode após exp.

   • aud: se spring.cloud.azure.active-directory.credential.client-id ou spring.cloud.azure.active-directory.credential.app-id-uri configurado, o público-alvo deverá ser igual ao client-id ou app-id-uriconfigurado. 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 da plataforma de identidade da Microsoft.

Usos avançados

Adicionar configurações de segurança extras

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

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

Validar a permissão por escopos

1. Criar recursos necessários no Azure.

   • Início Rápido do de Leitura: Configurar um aplicativo para expor umde API Web.

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

• scp: o valor deve conter Scope1.

Validar permissão por funções de aplicativo

1. Criar recursos necessários no Azure.

   • Leia Adicionar funções de aplicativo ao aplicativo e receba-as no token.

   • Crie uma função de aplicativo com os seguintes parâmetros:

     • Nome de exibição: AppRole1
     • Tipos de membro permitidos: Usuários/Grupos
     • Valor: AppRole1
     • Você deseja habilitar essa 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 acesso /app-role1 ponto de extremidade, as seguintes declarações no token de acesso serão validadas:

• roles: o valor deve conter AppRole1.

Usar a autenticação do cliente JWT

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

1. Consulte a seção Registrar seu certificado na plataforma de identidade da Microsoft seção credenciais de certificado de autenticação de 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 . PFX ou . Certificado de P12.
4. Adicione a propriedade spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt configuração ao cliente a ser autenticada 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 de 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

Conectando-se à ID do Microsoft Entra por meio de proxy

Para conectar a ID do Microsoft Entra por meio de proxy, forneça um RestTemplateCustomizer bean. Para obter mais informações, consulte a seção Conectar-se à ID do Microsoft Entra por meio da seção 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

1. Leia 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_IDe AZURE_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

Usar 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

1. Leia 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_IDe AZURE_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

Definir SecurityFilterChain

Configure várias instâncias de SecurityFilterChain. AadWebApplicationAndResourceServerConfig contém duas configurações de cadeia de filtro 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();
    }
}

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

Configuração

Propriedades configuráveis do spring-cloud-azure-starter-active-directory:

Aqui estão alguns exemplos sobre como usar essas propriedades:

Tipo de aplicativo

O tipo de aplicativo pode ser inferido 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 aplicativo de spring-cloud-azure-starter-active-directory:

Spring Security com o Azure Active Directory B2C

O Azure AD (Azure Active Directory) B2C é um serviço de gerenciamento de identidade que permite personalizar e controlar como os clientes se inscrevem, se inscrevem e gerenciam seus perfis ao usar seus aplicativos. O Azure AD B2C habilita essas ações ao mesmo tempo em que 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 do spring-cloud-azure-starter-active-directory-b2c:

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

Uso básico

Um aplicativo Web é qualquer aplicativo baseado na Web que permita que o usuário faça logon com a ID do Microsoft Entra, enquanto um servidor de recursos aceitará ou negará o acesso depois de validar access_token obtidos da ID do Microsoft Entra. Abordaremos 4 cenários neste guia:

1. Acessando um aplicativo Web.

2. Aplicativo Web acessando servidores de recursos.

3. Acessando um servidor de recursos.

4. Servidor de recursos acessando outros servidores de recursos.

Uso 1: Acessando um aplicativo Web

Esse cenário usa a concessão de código de autorização do OAuth 2.0 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 selecione Adicionar.

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

Selecione Chaves em seu aplicativo, selecione Gerar de chave para gerar WEB_APP_AZURE_CLIENT_SECRETe selecione Salvar.

Selecione Fluxos de usuário à esquerda e selecione Novo fluxo de usuário.

Escolha Inscrever-se ou em, de edição de perfil e redefinição de senha para criar fluxos de usuário, respectivamente. Especifique o fluxo de usuário Nome e Atributos e declarações do usuárioe selecione Criar.

Selecione permissões de API>Adicionar uma permissão>as APIs da Microsoft, selecione do 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 do administrador para permissões de do Graph.

Adicione as dependências a seguir ao 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>

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

Adicione propriedades ao 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:

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

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

Copie o home.html de de exemplo do aplicativo Web aad-b2c e substitua o PROFILE_EDIT_USER_FLOW e PASSWORD_RESET_USER_FLOW pelos nomes de fluxo de usuário usados anteriormente.

Crie e teste seu aplicativo. Permitir que Webapp seja executado na porta 8080.

Depois que o 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 logon.

Selecione o link com o fluxo de usuário de logon. Você deve ser redirecionado ao Azure AD B2C para iniciar o processo de autenticação.

Depois de fazer logon com êxito, você deverá ver o exemplo home page do navegador.

Uso 2: aplicativo Web acessando servidores de recursos

Esse cenário é baseado no Acessando um aplicativo Web cenário para permitir que um aplicativo acesse outros recursos. Esse cenário é o fluxo de de concessão de credenciais de cliente do OAuth 2.0.

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

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

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

Selecione Expor um de API no painel de navegação e selecione Definir. Registre o URI da ID do Aplicativo como seu WEB_API_A_APP_ID_URLe selecione Salvar.

Selecione manifesto no painel de navegação e cole o seguinte segmento JSON em appRoles matriz. Registre o URI da ID do Aplicativo como seu WEB_API_A_APP_ID_URL, registre o valor da função de aplicativo como seu WEB_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>Adicionar 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 do administrador para permissões de WebApiA.

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

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

Adicione a configuração a seguir com base no 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

Escreva seu código Java Webapp.

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 Acessando um aplicativo Web cenário. Adicione outro webClient de feijão da seguinte maneira:

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 Java WebApiA, consulte a seção Acessando um servidor de recursos.

Crie e teste seu aplicativo. Permitir que Webapp e WebApiA executem na porta 8080 e 8081 respectivamente. Inicie os aplicativos Webapp e WebApiA. Retorne à home page depois de fazer logon 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

Esse cenário não dá suporte ao logon. 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: Servidores de Recursos de Acesso a Aplicativos Web.

Adicione WebApiA permissão e conceda consentimento do administrador para seu aplicativo Web.

Adicione as dependências a seguir ao 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 configuração a seguir.

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:

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

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

Crie e teste seu aplicativo. Permitir que WebApiA seja executado na porta 8081. Obtenha o token de acesso para o recurso de 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

Esse cenário é uma atualização do Acessando um servidor de recursose dá suporte ao acesso a outros recursos de aplicativo, com base no fluxo de credenciais do cliente OAuth2.

Referindo-se às etapas anteriores, criamos um aplicativo WebApiB e expõemos 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 do administrador para permissões de WebApiB.

Com base em Acessando um servidor de recursos, adicione a seguinte dependência ao arquivo pom.xml.

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

Adicione a configuração a seguir 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 de 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 de 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. Permitir que WebApiA e WebApiB executem na porta 8081 e 8082 respectivamente. Inicie os aplicativos WebApiA e WebApiB, 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 spring-cloud-azure-starter-active-directory-b2c.