Compatibilidad de Spring Cloud con Azure para Spring Security

En este artículo se describe cómo se puede usar Spring Cloud Azure y Spring Security juntos.

Spring Security con el identificador de Entra de Microsoft

Al desarrollar una aplicación web, la gestión de identidades y accesos siempre serán elementos fundamentales.

Azure ofrece una excelente plataforma para democratizar el recorrido de desarrollo de aplicaciones, ya que no solo ofrece un servicio de identidad base en la nube, sino también una integración profunda con el resto del ecosistema de Azure.

Spring Security ha facilitado la protección de las aplicaciones basadas en Spring con potentes abstracciones e interfaces extensibles. Sin embargo, tan eficaz como puede ser el marco de Spring, no se adapta a un proveedor de identidades específico.

El spring-cloud-azure-starter-active-directory proporciona la manera más óptima de conectar la aplicación web a un inquilino de Microsoft Entra ID (Microsoft Entra ID for short) y proteger el servidor de recursos con el identificador de Microsoft Entra. Usa el protocolo Oauth 2.0 para proteger las aplicaciones web y los servidores de recursos.

Acceso a una aplicación web

En este escenario se utiliza el flujo de concesión de código de autorización de OAuth 2.0 para iniciar sesión de un usuario con una cuenta de Microsoft.

Diagrama del sistema

Creación de recursos necesarios en Azure

1. Lea Inicio rápido: Registro de una aplicación con la plataforma de identidad de Microsoft.

2. Cree un registro de aplicación. Obtenga AZURE_TENANT_ID, AZURE_CLIENT_IDy AZURE_CLIENT_SECRET.

3. Establezca redirect URI en APPLICATION_BASE_URI/login/oauth2/code/; por ejemplo, http://localhost:8080/login/oauth2/code/. El final / es obligatorio.

Adición de dependencias necesarias

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

Adición de propiedades necesarias

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Ahora, inicie la aplicación y acceda a la aplicación a través del explorador. Se le redirigirá a la página de inicio de sesión de Microsoft.

Usos avanzados

Adición de configuraciones de seguridad adicionales

Spring Cloud Azure 6.x/7.x

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {

   /**
    * Add configuration logic as needed.
    */
   @Bean
   SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       http.with(AadWebApplicationHttpSecurityConfigurer.aadWebApplication(), Customizer.withDefaults())
           .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated());
           // Do some custom configuration.
       return http.build();
   }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

@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 el acceso mediante roles de aplicación

Cree recursos necesarios en Azure:

• Lea Incorporación de roles de aplicación a una aplicación y su recepción en el token.

• Cree un rol de aplicación con los parámetros siguientes:

  • Nombre para mostrar: Administrador
  • Tipos de miembros permitidos: Usuarios o grupos
  • Valor: Administrador
  • ¿Desea habilitar este rol de aplicación: sí

Nota

Si desea usar el control de acceso basado en roles de aplicación, no puede incluir nombres de grupo en la reclamación role. Para obtener más información, consulte la sección Configuración de notificaciones opcionales de grupos de Proporcionar notificaciones opcionales a la aplicación.

Proteja el método específico.

class Demo {
   @GetMapping("Admin")
   @ResponseBody
   @PreAuthorize("hasAuthority('APPROLE_Admin')")
   public String admin() {
       return "Admin message";
   }
}

Autorización del acceso por nombre de grupo o identificador de grupo

Agregue propiedades de configuración 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 el 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";
   }
}

Uso de Azure nacional en lugar de Azure global

Ahora, excepto la nube global de Azure, microsoft Entra ID se implementa en las siguientes nubes nacionales:

• Azure Government (servicio de nube de Microsoft para el gobierno)

• Azure China 21Vianet

• Azure Alemania

Este es un ejemplo con 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 obtener más información, consulte implementaciones en la nube nacionales.

Configura la plantilla de URI de redirección

Los desarrolladores pueden personalizar el URI de redirección.

diagrama del sistema

Agregue propiedades redirect-uri-template en el archivo application.yml.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       redirect-uri-template: ${REDIRECT-URI-TEMPLATE}

Actualice redirect-uri en el portal de Azure.

Después de establecer redirect-uri-template, es necesario actualizar el generador de seguridad:

Spring Cloud Azure 6.x/7.x

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2LoginSecurityConfig {

    /**
     * Add configuration logic as needed.
     */
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.with(AadWebApplicationHttpSecurityConfigurer.aadWebApplication(), Customizer.withDefaults())
            .oauth2Login(login -> login.loginProcessingUrl("${REDIRECT-URI-TEMPLATE}"))
            .authorizeHttpRequests(auth -> auth.anyRequest().authenticated());
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Conexión a Microsoft Entra ID a través del proxy

Para conectar el identificador de Entra de Microsoft a través del proxy, proporcione un RestTemplateCustomizer bean como el que se muestra en el ejemplo siguiente:

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

Muestras

Proyecto de ejemplo: aad-web-application.

Aplicación web que accede a los servidores de recursos

Diagrama del sistema

Creación de recursos necesarios en Azure

1. Lea Inicio rápido: Registro de una aplicación con la plataforma de identidad de Microsoft.

2. Cree un registro de aplicación. Obtenga AZURE_TENANT_ID, AZURE_CLIENT_IDy AZURE_CLIENT_SECRET.

3. Establezca redirect URI en APPLICATION_BASE_URI/login/oauth2/code/, por ejemplo, http://localhost:8080/login/oauth2/code/. El final / es obligatorio.

Adición de dependencias necesarias

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

Adición de propiedades necesarias

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            scopes: https://graph.microsoft.com/Analytics.Read, email

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Aquí, graph es el nombre de OAuth2AuthorizedClient y scopes significa los permisos necesarios para otorgar el consentimiento al iniciar sesión.

Uso de OAuth2AuthorizedClient en la aplicación

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

Ahora, inicie la aplicación y acceda a la aplicación en el explorador. A continuación, se le redirigirá a la página de inicio de sesión de Microsoft.

Usos avanzados

Flujo de credenciales de cliente

El flujo predeterminado es flujo de código de autorización, si desea usar flujo de credenciales de cliente, puede configurar de esta manera:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            authorization-grant-type: client_credentials # Change type to client_credentials
            scopes: https://graph.microsoft.com/Analytics.Read, email

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Acceso a varios servidores de recursos

En una aplicación web, puede acceder a varios servidores de recursos mediante la configuración de la siguiente manera:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          resource-server-1:
            scopes: # Scopes for resource-server-1
          resource-server-2:
            scopes: # Scopes for resource-server-2

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

A continuación, puede usar OAuth2AuthorizedClient en la aplicación como esta

public class Demo {
    @GetMapping("/resource-server-1")
    @ResponseBody
    public String graph1(
    @RegisteredOAuth2AuthorizedClient("resource-server-1") OAuth2AuthorizedClient client) {
        return callResourceServer1(client);
    }

    @GetMapping("/resource-server-2")
    @ResponseBody
    public String graph2(
    @RegisteredOAuth2AuthorizedClient("resource-server-2") OAuth2AuthorizedClient client) {
        return callResourceServer2(client);
    }
}

Muestras

Proyecto de ejemplo: aad-web-application.

Acceso a un servidor de recursos

Este escenario no admite el inicio de sesión, solo tiene que proteger el servidor validando el token de acceso. Si el token de acceso es válido, el servidor atiende la solicitud.

Diagrama del sistema

Creación de recursos necesarios en Azure

1. Lea Inicio rápido: Registro de una aplicación con la plataforma de identidad de Microsoft.

2. Cree un registro de aplicación. Obtenga AZURE_CLIENT_ID.

3. Lea Inicio rápido: Configuración de una aplicación para exponer una API web.

4. Exponga una API web con un ámbito denominado Scope-1.

Adición de dependencias necesarias

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

Adición de propiedades necesarias

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        credential:
          client-id: ${AZURE_CLIENT_ID}

Ahora inicie la aplicación y acceda a la API web de la aplicación.

1. Recibirás un error 401 si no tienes un token de acceso.

2. Acceda a la aplicación con un token de acceso. Se validarán las siguientes declaraciones del token de acceso:

   • iss: el token de acceso debe ser emitido por el identificador de Entra de Microsoft.

   • nbf: la hora actual no puede ser anterior a nbf.

   • exp: La hora actual no puede ser posterior a exp.

   • aud: Si se ha configurado spring.cloud.azure.active-directory.credential.client-id o spring.cloud.azure.active-directory.credential.app-id-uri, el valor de audience debe coincidir con el valor configurado de client-id o app-id-uri. Si las dos propiedades no están configuradas, esta declaración no se validará.

Para obtener más información sobre el token de acceso, consulte documentos de MS sobre los tokens de acceso de la plataforma de identidad de Microsoft.

Usos avanzados

Adición de configuraciones de seguridad adicionales

Spring Cloud Azure 6.x/7.x

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadOAuth2ResourceServerSecurityConfig {

    /**
     * Add configuration logic as needed.
     */
    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.with(AadResourceServerHttpSecurityConfigurer.aadResourceServer(), Customizer.withDefaults())
            .authorizeHttpRequests(authorize -> authorize.anyRequest().authenticated());
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Validación del permiso por ámbitos

1. Cree recursos necesarios en Azure.

   • Lea Inicio rápido: Configuración de una aplicación para exponer una API web.

   • Exponga una API web con un ámbito denominado Scope1.

2. Proteja el método específico.

   class Demo {
       @GetMapping("scope1")
       @ResponseBody
       @PreAuthorize("hasAuthority('SCOPE_Scope1')")
       public String scope1() {
           return "Congratulations, you can access `scope1` endpoint.";
       }
   }
   

Al hacerlo, al acceder al punto de conexión /scope1, se validarán las siguientes declaraciones en el token de acceso:

• scp: el valor debe contener Scope1.

Validar el permiso mediante los roles de la aplicación

1. Cree recursos necesarios en Azure.

   • Lea Incorporación de roles de aplicación a una aplicación y su recepción en el token.

   • Cree un rol de aplicación con los parámetros siguientes:

     • Nombre para mostrar: AppRole1
     • Tipos de miembros permitidos: Usuarios o grupos
     • Valor: AppRole1
     • ¿Desea habilitar este rol de aplicación: sí

2. Proteja el 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.";
       }
   }
   

Al hacerlo, al acceder al punto de conexión /app-role1, se validarán las siguientes declaraciones en el token de acceso:

• roles: el valor debe contener AppRole1.

Uso de la autenticación de cliente JWT

Para usar un token web JSON (JWT) para la autenticación de cliente, siga estos pasos:

1. Consulte la sección Registrar el certificado con la plataforma de identidad de Microsoft de credenciales de certificado de autenticación de aplicaciones de plataforma de identidad de Microsoft.
2. Cargue un certificado .pem en la aplicación registrada en el portal de Azure.
3. Configure la ruta y la contraseña de un certificado .PFX o .P12.
4. Agregue la configuración de la propiedad spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt en el cliente para que se autentique mediante autenticación de cliente JWT.

El siguiente archivo de configuración de ejemplo es para un escenario de aplicación web. La información del certificado se configura en las propiedades globales.

spring:
  cloud:
    azure:
      credential:
        client-id: ${AZURE_CLIENT_ID}
        client-certificate-path: ${AZURE_CERTIFICATE_PATH}
        client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
      profile:
        tenant-id: <tenant>
      active-directory:
        enabled: true
        user-group:
          allowed-group-names: group1,group2
          allowed-group-ids: <group1-id>,<group2-id>
        post-logout-redirect-uri: http://localhost:8080
        authorization-clients:
          azure:
            client-authentication-method: private_key_jwt
          arm:
            client-authentication-method: private_key_jwt
            scopes: https://management.core.windows.net/user_impersonation
          graph:
            client-authentication-method: private_key_jwt
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All
          webapiA:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
          webapiB:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_B_APP_ID_URL}/.default
            authorization-grant-type: client_credentials

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

También puede configurar la información del certificado en las propiedades del servicio active-directory, como se muestra en este ejemplo:

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-certificate-path: ${AZURE_CERTIFICATE_PATH}
          client-certificate-password: ${AZURE_CERTIFICATE_PASSWORD}
        profile:
          tenant-id: <tenant>
        user-group:
          allowed-group-names: group1,group2
          allowed-group-ids: <group1-id>,<group2-id>
        post-logout-redirect-uri: http://localhost:8080
        authorization-clients:
          azure:
            client-authentication-method: private_key_jwt
          arm:
            client-authentication-method: private_key_jwt
            scopes: https://management.core.windows.net/user_impersonation
          graph:
            client-authentication-method: private_key_jwt
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All
          webapiA:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_A_APP_ID_URL}/Obo.WebApiA.ExampleScope
          webapiB:
            client-authentication-method: private_key_jwt
            scopes:
              - ${WEB_API_B_APP_ID_URL}/.default
            authorization-grant-type: client_credentials

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Conexión a Microsoft Entra ID a través del proxy

Para conectar Microsoft Entra ID mediante un proxy, proporcione un bean RestTemplateCustomizer. Para obtener más información, consulte la sección Connecting to Microsoft Entra ID via proxy .

Muestras

Proyecto de ejemplo: aad-resource-server.

Servidor de recursos que visita otros servidores de recursos

Diagrama del sistema

Creación de recursos necesarios en Azure

1. Lea Inicio rápido: Registro de una aplicación con la plataforma de identidad de Microsoft.

2. Cree un registro de aplicación. Obtenga AZURE_TENANT_ID, AZURE_CLIENT_IDy AZURE_CLIENT_SECRET.

Adición de dependencias necesarias

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

Adición de propiedades necesarias

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        authorization-clients:
          graph:
            scopes:
              - https://graph.microsoft.com/User.Read

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Uso de OAuth2AuthorizedClient en la aplicación

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

Muestras

Proyecto de ejemplo: aad-resource-server-obo.

Aplicación web y servidor de recursos en una aplicación

Creación de recursos necesarios en Azure

1. Lea Inicio rápido: Registro de una aplicación con la plataforma de identidad de Microsoft.

2. Cree un registro de aplicación. Obtenga AZURE_TENANT_ID, AZURE_CLIENT_IDy AZURE_CLIENT_SECRET.

Adición de dependencias necesarias

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

Adición de propiedades necesarias

Establezca la propiedad spring.cloud.azure.active-directory.application-type en web_application_and_resource_servery especifique el tipo de autorización para cada cliente de autorización.

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        profile:
          tenant-id: <tenant>
        credential:
          client-id: ${AZURE_CLIENT_ID}
          client-secret: ${AZURE_CLIENT_SECRET}
        app-id-uri: ${WEB_API_ID_URI}
        application-type: web_application_and_resource_server  # This is required.
        authorization-clients:
          graph:
            authorizationGrantType: authorization_code # This is required.
            scopes:
              - https://graph.microsoft.com/User.Read
              - https://graph.microsoft.com/Directory.Read.All

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Definir SecurityFilterChain

Configure varias instancias de SecurityFilterChain. AadWebApplicationAndResourceServerConfig contiene dos configuraciones de cadena de filtros de seguridad para el servidor de recursos y la aplicación web.

Spring Cloud Azure 6.x/7.x

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
@EnableMethodSecurity
public class AadWebApplicationAndResourceServerConfig {

    @Bean
    @Order(1)
    public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
        http.with(AadResourceServerHttpSecurityConfigurer.aadResourceServer(), Customizer.withDefaults())
            // All the paths that match `/api/**`(configurable) work as the resource server. Other paths work as the web application.
            .securityMatcher("/api/**")
            .authorizeHttpRequests(auth -> auth.anyRequest().authenticated());
        return http.build();
    }

    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.with(AadWebApplicationHttpSecurityConfigurer.aadWebApplication(), Customizer.withDefaults())
            .authorizeHttpRequests(auth -> auth.requestMatchers("/login").permitAll().anyRequest().authenticated());
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Configuración

Propiedades configurables de spring-cloud-azure-starter-active-directory:

Nombre	Descripción
spring.cloud.azure.active-directory.app-id-uri	URI del ID de aplicación que podría usarse en la reclamación "aud" de un id_token.
spring.cloud.azure.active-directory.application-type	Tipo de la aplicación Microsoft Entra.
spring.cloud.azure.active-directory.authenticate-additional-parameters	Agregue parámetros adicionales a la dirección URL de autorización.
spring.cloud.azure.active-directory.authorization-clients	Los clientes de autorización de OAuth2.
spring.cloud.azure.active-directory.credential.client-id	Identificador de cliente que se va a usar al realizar la autenticación de entidad de servicio con Azure.
spring.cloud.azure.active-directory.credential.client-secret	Secreto de cliente que se usará al realizar la autenticación de entidad de servicio con Azure.
spring.cloud.azure.active-directory.jwk-set-cache-lifespan	La duración del JWK almacenado en caché establecido antes de que expire, el valor predeterminado es de 5 minutos.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time	El tiempo de actualización del JWK almacenado en caché establecido antes de que expire, el valor predeterminado es de 5 minutos.
spring.cloud.azure.active-directory.jwt-connect-timeout	Tiempo de espera de conexión agotado para la llamada a la URL remota de JWKSet.
spring.cloud.azure.active-directory.jwt-read-timeout	Lea Tiempo de espera para la llamada A URL remota de JWKSet.
spring.cloud.azure.active-directory.jwt-size-limit	Límite de tamaño en bytes de la llamada a la URL remota de JWKSet.
spring.cloud.azure.active-directory.post-logout-redirect-uri	La URI de redirección tras cerrar sesión.
spring.cloud.azure.active-directory.profile.cloud-type	Nombre de la nube de Azure a la que se va a conectar. Los tipos admitidos son: AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment	Propiedades de los puntos de conexión de Microsoft Entra.
spring.cloud.azure.active-directory.profile.tenant-id	Identificador de inquilino de Azure. Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino.
spring.cloud.azure.active-directory.redirect-uri-template	Punto de conexión de redireccionamiento: lo usa el servidor de autorización para devolver respuestas que contienen credenciales de autorización al cliente a través del agente de usuario del propietario del recurso. El valor predeterminado es {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map	Configure la reclamación que se usará para crear GrantedAuthority y el prefijo del valor de cadena de GrantedAuthority. El valor predeterminado es : "scp" -> "SCOPE_", "roles" -> "APPROLE_".
spring.cloud.azure.active-directory.resource-server.principal-claim-name	Configure la reclamación del token de acceso se devolverá en AuthenticatedPrincipal#getName. El valor predeterminado es "sub".
spring.cloud.azure.active-directory.session-stateless	Si es verdadero, activa el filtro de autenticación sin estado AadAppRoleStatelessAuthenticationFilter. El valor predeterminado es false que activa AadAuthenticationFilter.
spring.cloud.azure.active-directory.user-group.allowed-group-ids	Los identificadores de grupo se pueden usar para construir GrantedAuthority.
spring.cloud.azure.active-directory.user-group.allowed-group-names	Los nombres de grupo se pueden usar para construir GrantedAuthority.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Si es "true", use "v1.0/me/transitiveMemberOf" para obtener miembros. De lo contrario, use "v1.0/me/memberOf". El valor predeterminado es false.
spring.cloud.azure.active-directory.user-name-attribute	Decida qué declaración será el nombre de la entidad.

Estos son algunos ejemplos sobre cómo usar estas propiedades:

Tipo de aplicación

El tipo de aplicación se puede deducir de las dependencias: spring-security-oauth2-client o spring-security-oauth2-resource-server. Si el valor inferido no es el valor que desea, puede especificar el tipo de aplicación. Esta es la tabla de valores válidos y valores inferidos:

Tipo de aplicación de spring-cloud-azure-starter-active-directory:

Tiene dependencia: spring-security-oauth2-client	Tiene dependencia: spring-security-oauth2-resource-server	Valores válidos del tipo de aplicación	Valor inferido
Sí	No	web_application	web_application
No	Sí	resource_server	resource_server
Sí	Sí	web_application, resource_server, , resource_server_with_obo, web_application_and_resource_server	resource_server_with_obo

Spring Security con Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C es un servicio de administración de identidades que permite personalizar y controlar cómo los clientes se registran, inician sesión y administran sus perfiles al usar las aplicaciones. Azure AD B2C habilita estas acciones al mismo tiempo que protege las identidades de los clientes.

Configuración de dependencias

<dependencies>
    <dependency>
        <groupId>com.azure.spring</groupId>
        <artifactId>spring-cloud-azure-starter-active-directory-b2c</artifactId>
    </dependency>
</dependencies>

Configuración

Propiedades configurables de spring-cloud-azure-starter-active-directory-b2c:

Nombre	Descripción
spring.cloud.azure.active-directory.b2c.app-id-uri	URI del identificador de la aplicación que podría usarse en la declaración "aud" de un token.
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters	Parámetros adicionales para la autenticación.
spring.cloud.azure.active-directory.b2c.authorization-clients	Especifique la configuración del cliente.
spring.cloud.azure.active-directory.b2c.base-uri	URI base del punto de conexión de Azure AD B2C.
spring.cloud.azure.active-directory.b2c.credential	Información de credenciales de Azure AD B2C.
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout	Tiempo de espera de conexión agotado para la llamada a la URL remota de JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout	Lea Tiempo de espera para la llamada A URL remota de JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-size-limit	Límite de tamaño en bytes de la llamada a la URL remota de JWKSet.
spring.cloud.azure.active-directory.b2c.login-flow	Especifique la clave de flujo de inicio de sesión principal. El valor predeterminado es sign-up-or-sign-in.
spring.cloud.azure.active-directory.b2c.logout-success-url	URL de redirección después del cierre de sesión. El valor predeterminado es http://localhost:8080/login.
spring.cloud.azure.active-directory.b2c.profile	Información del perfil de Azure AD B2C.
spring.cloud.azure.active-directory.b2c.reply-url	URL de respuesta después de obtener el código de autorización. El valor predeterminado es {baseUrl}/login/oauth2/code/.
spring.cloud.azure.active-directory.b2c.user-flows	Flujos de usuario.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name	Nombre del atributo del nombre de usuario.

Para obtener configuraciones completas, compruebe propiedades de configuración de Azure de Spring Cloud.

Uso básico

Una aplicación web es cualquier aplicación basada en web que permita al usuario iniciar sesión con el identificador de Microsoft Entra, mientras que un servidor de recursos aceptará o denegará el acceso después de validar access_token obtenido del identificador de Microsoft Entra. Trataremos 4 escenarios en esta guía:

1. Acceso a una aplicación web.

2. Aplicación web que accede a los servidores de recursos.

3. Acceso a un servidor de recursos.

4. Servidor de recursos que accede a otros servidores de recursos.

Uso 1: Acceso a una aplicación web

En este escenario se usa el flujo de código de autorización de OAuth 2.0 para que un usuario inicie sesión con su cuenta de Azure AD B2C.

Seleccione azure AD B2C en el menú del portal, seleccione Aplicacionesy, a continuación, seleccione Agregar.

Especifique el nombre de la aplicación (como ), agregue para la URL de respuesta, registre el ID. de aplicación como y, a continuación, seleccione Guardar.

Seleccione Claves en la aplicación, seleccione Generar clave para generar WEB_APP_AZURE_CLIENT_SECRETy, a continuación, seleccione Guardar.

Seleccione Flujos de usuario a la izquierda y, a continuación, seleccione Nuevo flujo de usuario.

Elija Registrarse o en, edición de perfilesy Restablecimiento de contraseña para crear flujos de usuario respectivamente. Especifique el flujo de usuario Nombre y Atributos de usuario y notificacionesy, a continuación, seleccione Crear.

Seleccione permisos de API>Agregar un permiso>API de Microsoft, seleccione Microsoft Graph, seleccione Permisos delegados, seleccione los permisos offline_access y permisos de openid y, a continuación, seleccione Agregar permiso para completar el proceso.

Conceda el consentimiento de administrador para los permisos de Graph.

Agregue las siguientes dependencias al archivo pom.xml.

Spring Cloud Azure 6.x.7.x

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

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Agregue propiedades al archivo application.yml mediante los valores que creó anteriormente, como se muestra en el ejemplo siguiente:

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}

Escriba el código Java.

Para el código del controlador, puede hacer referencia al ejemplo siguiente:

@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 el código de configuración de seguridad, puede consultar el ejemplo siguiente:

Spring Cloud Azure 6.x/7.x

@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(auth -> auth.anyRequest().authenticated())
            .with(configurer, Customizer.withDefaults());
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Copie el home.html de aad-b2c-web-application ejemploy reemplace el PROFILE_EDIT_USER_FLOW y PASSWORD_RESET_USER_FLOW por los nombres de flujo de usuario que usó anteriormente.

Compile y pruebe la aplicación. Deje que Webapp ejecute en el puerto 8080.

Una vez que Maven compila e inicia la aplicación, abra http://localhost:8080/ en un explorador web. Debe redirigirse a la página de inicio de sesión.

Seleccione el enlace correspondiente al flujo de usuario de inicio de sesión. Debería ser redirigido a Azure AD B2C para iniciar el proceso de autenticación.

Una vez que haya iniciado sesión correctamente, debería ver el home page de ejemplo desde el explorador.

Uso 2: Aplicación web que accede a los servidores de recursos

Este escenario se basa en el escenario Acceso a una aplicación web escenario para permitir que una aplicación acceda a otros recursos. Este escenario es el flujo de concesión de credenciales de cliente de OAuth 2.0.

Seleccione azure AD B2C en el menú del portal, seleccione Aplicacionesy, a continuación, seleccione Agregar.

Especifique el nombre de la aplicación (como ), registre el Id. de aplicación como su , y, a continuación, seleccione Guardar.

Seleccione Claves en la aplicación, seleccione Generar clave para generar WEB_API_A_AZURE_CLIENT_SECRETy, a continuación, seleccione Guardar.

Seleccione Exponer una api en el panel de navegación y, a continuación, seleccione Establecer. Registre el URI de identificador de aplicación como WEB_API_A_APP_ID_URLy, a continuación, seleccione Guardar.

Seleccione Manifest en el panel de navegación y, a continuación, pegue el siguiente segmento JSON en la matriz appRoles. Registre el Application ID URI como su , registre el valor del rol de la aplicación como su , y, a continuación, seleccione Guardar.

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

Seleccione permisos de API>Agregar un permiso>Mis API, seleccione nombre de aplicación de WebApiA, seleccione Permisos de aplicación, seleccione permiso WebApiA.SampleScope y, a continuación, seleccione Agregar permiso para completar el proceso.

Conceda el consentimiento de administrador para los permisos de WebApiA.

captura de pantalla de

Agregue la siguiente dependencia en función del escenario de Acceso a una aplicación web.

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

Agregue la siguiente configuración sobre la base del escenario Acceso a una aplicación web.

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         base-uri: ${BASE_URI}             # Such as: https://xxxxb2c.b2clogin.com
         profile:
           tenant-id: <tenant>
         authorization-clients:
           ${RESOURCE_SERVER_A_NAME}:
             authorization-grant-type: client_credentials
             scopes: ${WEB_API_A_APP_ID_URL}/.default

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Escriba su Webapp código Java.

Para el código del controlador, puede hacer referencia al ejemplo siguiente:

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

El código de configuración de seguridad es el mismo que en el escenario de Acceso a una aplicación web. Añada otro bean webClient de la siguiente manera:

public class SampleConfiguration {
   @Bean
   public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
       ServletOAuth2AuthorizedClientExchangeFilterFunction function =
           new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
       return WebClient.builder()
                       .apply(function.oauth2Configuration())
                       .build();
   }
}

Para escribir el código java de WebApiA, consulte la sección Acceso a un servidor de recursos.

Compile y pruebe la aplicación. Deje que Webapp y WebApiA se ejecuten en el puerto 8080 y en el puerto 8081, respectivamente. Inicie las aplicaciones Webapp y WebApiA. Vuelva a la página principal después de iniciar sesión correctamente. A continuación, puede acceder a http://localhost:8080/webapp/webApiA para obtener la respuesta de recursos WebApiA.

Uso 3: Acceso a un servidor de recursos

Este escenario no admite el inicio de sesión. Solo tiene que proteger el servidor validando el token de acceso y, si es válido, atiende la solicitud.

Para crear el permiso de WebApiA, consulte Uso 2: Servidores de recursos de acceso a aplicaciones web.

Agregue el permiso WebApiA y conceda el consentimiento de administrador para la aplicación web.

Agregue las siguientes dependencias al archivo 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>

Agregue la siguiente configuración.

spring:
 cloud:
   azure:
     active-directory:
       b2c:
         enabled: true
         base-uri: ${BASE_URI}             # Such as: https://xxxxb2c.b2clogin.com
         profile:
           tenant-id: <tenant>
         app-id-uri: ${APP_ID_URI}         # If you're using v1.0 token, configure app-id-uri for `aud` verification
         credential:
           client-id: ${AZURE_CLIENT_ID}           # If you're using v2.0 token, configure client-id for `aud` verification
         user-flows:
           sign-up-or-sign-in: ${SIGN_UP_OR_SIGN_IN_USER_FLOW_NAME}

Nota

Los valores permitidos para tenant-id son: common, organizations, consumerso el identificador de inquilino. Para obtener más información sobre estos valores, consulte la sección Uso del punto de conexión incorrecto (cuentas personales y de organización) de Error AADSTS50020: la cuenta de usuario del proveedor de identidades no existe en el inquilino. Para obtener información sobre cómo convertir la aplicación de un solo inquilino, consulte Convertir aplicación de un solo inquilino en multiinquilino en microsoft Entra ID.

Escriba el código Java.

Para el código del controlador, puede hacer referencia al ejemplo siguiente:

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 el código de configuración de seguridad, puede consultar el ejemplo siguiente:

Spring Cloud Azure 6.x/7.x

@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(auth -> auth.anyRequest().authenticated())
            .oauth2ResourceServer(o -> o.jwt(j -> j.jwtAuthenticationConverter(authenticationConverter)));
        // @formatter:on
        return http.build();
    }
}

Spring Cloud Azure 5.x

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

Spring Cloud Azure 4.x

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

Compile y pruebe la aplicación. Deje que WebApiA ejecute en el puerto 8081. Obtenga el token de acceso del recurso de webApiA y, a continuación, acceda a http://localhost:8081/webApiA/sample como encabezado de autorización de portador.

Uso 4: Servidor de recursos que accede a otros servidores de recursos

Este escenario es una actualización de Acceso a un servidor de recursosy admite el acceso a otros recursos de aplicación, en función del flujo de credenciales de cliente de OAuth2.

Siguiendo los pasos anteriores, creamos una aplicación WebApiB y exponemos un permiso de aplicación 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 el consentimiento del administrador para los permisos de WebApiB.

En función de Acceso a un servidor de recursos, agregue la siguiente dependencia al archivo pom.xml.

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

Añada la siguiente configuración basándose en la configuración del escenario Accessing a resource server.

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

Escriba el código Java.

Para el código del controlador de WebApiA, puede consultar el siguiente ejemplo:

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 el código del controlador de WebApiB, puede consultar el siguiente ejemplo:

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.";
   }
}

El código de configuración de seguridad es el mismo que en el escenario Acceso a un servidor de recursos; se añade otro bean webClient como se muestra a continuación.

public class SampleConfiguration {
   @Bean
   public WebClient webClient(OAuth2AuthorizedClientManager oAuth2AuthorizedClientManager) {
       ServletOAuth2AuthorizedClientExchangeFilterFunction function =
           new ServletOAuth2AuthorizedClientExchangeFilterFunction(oAuth2AuthorizedClientManager);
       return WebClient.builder()
                       .apply(function.oauth2Configuration())
                       .build();
   }
}

Compile y pruebe la aplicación. Deje que WebApiA y WebApiB se ejecuten en el puerto 8081 y en el puerto 8082, respectivamente. Inicie las aplicaciones WebApiA y WebApiB, obtenga el token de acceso para el recurso webApiA y acceda a http://localhost:8081/webApiA/webApiB/sample como encabezado de autorización Bearer.

Muestras

Para obtener más información, consulte los spring-cloud-azure-starter-active-directory-b2c ejemplos.