Spring Cloud support Azure pour Spring Security

Article
12/06/2023

Cet article s’applique à : ✔️ Version 4.14.0 ✔️ Version 5.8.0

Cet article décrit comment Spring Cloud Azure et Spring Security peuvent être utilisés ensemble.

Spring Security avec l’ID Microsoft Entra

Lorsque vous créez une application web, la gestion des identités et des accès est toujours des éléments fondamentaux.

Azure offre une excellente plateforme pour démocratiser votre parcours de développement d’applications, car elle offre non seulement un service d’identité de base cloud, mais également une intégration approfondie avec le reste de l’écosystème Azure.

Spring Security a facilité la sécurisation de vos applications Spring avec des abstractions puissantes et des interfaces extensibles. Toutefois, aussi puissante que l’infrastructure Spring peut être, elle n’est pas adaptée à un fournisseur d’identité spécifique.

Le spring-cloud-azure-starter-active-directory moyen le plus optimal de connecter votre application web à un locataire Microsoft Entra ID (Microsoft Entra ID for short) et de protéger votre serveur de ressources avec l’ID Microsoft Entra. Il recourt au protocole OAuth 2.0 pour assurer la protection des applications web et des serveurs de ressources.

Accès à une application web

Ce scénario utilise le flux d’octroi de code d’autorisation OAuth 2.0 pour se connecter à un utilisateur avec un compte Microsoft.

Diagramme système

System diagram for a standalone web application.

Créer des ressources requises dans Azure

Lire le guide de démarrage rapide : Inscrire une application auprès du Plateforme d'identités Microsoft.
Créer une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.
Défini redirect URI sur APPLICATION_BASE_URI/login/oauth2/code/ - par exemple http://localhost:8080/login/oauth2/code/. La queue / est requise.

Ajouter les dépendances nécessaires

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

Ajouter les propriétés requises

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

Remarque

Les valeurs autorisées tenant-id sont : common, organizations, consumersou l’ID de locataire. Pour plus d’informations sur ces valeurs, consultez la section Utiliser le point de terminaison incorrect (comptes personnels et d’organisation) de l’erreur AADSTS50020 - Le compte d’utilisateur du fournisseur d’identité n’existe pas dans le locataire. Pour plus d’informations sur la conversion de votre application monolocataire, consultez Convertir une application monolocataire en multilocataire sur l’ID Microsoft Entra.

À présent, démarrez votre application et accédez à votre application via le navigateur. Vous êtes redirigé vers la page de connexion Microsoft.

Utilisations avancées

Ajouter des configurations de sécurité supplémentaires

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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
    }
}

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

Autoriser l’accès par les rôles d’application

Créez des ressources requises dans Azure :

Lisez Ajouter des rôles d’application à votre application et recevez-les dans le jeton.
Créez un rôle d’application avec les paramètres suivants :
- Nom complet : Administration
- Types de membres autorisés : utilisateurs/groupes
- Valeur : Administration
- Voulez-vous activer ce rôle d’application : oui

Remarque

Si vous souhaitez utiliser le contrôle d’accès en fonction du rôle d’application, vous ne pouvez pas placer de noms de groupe dans la role revendication. Pour plus d’informations, consultez la section Configuration des revendications facultatives des groupes de Fournir des revendications facultatives à votre application.

Protégez la méthode spécifique.

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

Autoriser l’accès par nom de groupe ou ID de groupe

Ajoutez les propriétés de configuration associées.

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

Protégez la méthode spécifique.

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

Utiliser Azure national au lieu d’Azure global

À présent, à l’exception du cloud Azure global, l’ID Microsoft Entra est déployé dans les clouds nationaux suivants :

Azure Government
Azure China 21Vianet
Azure Allemagne

Voici un exemple utilisant Azure China 21Vianet.

spring:
  cloud:
    azure:
      active-directory:
        enabled: true
        base-uri: https://login.partner.microsoftonline.cn
        graph-base-uri: https://microsoftgraph.chinacloudapi.cn

Pour plus d’informations, consultez déploiements de cloud nationaux.

Configurer le modèle d’URI de redirection

Les développeurs peuvent personnaliser l’URI de redirection.

System diagram for redirect URIs.

Ajoutez des redirect-uri-template propriétés dans votre fichier application.yml .

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

Mise à jour redirect-uri dans le Portail Azure.

Une fois que nous avons défini redirect-uri-template, nous devons mettre à jour le générateur de sécurité :

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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();
    }
}

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

Connecter ing à Microsoft Entra ID via proxy

Pour connecter Microsoft Entra ID via proxy, fournissez un RestTemplateCustomizer bean comme celui indiqué dans l’exemple suivant :

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

Exemples

Exemple de projet : aad-web-application.

Application web accédant aux serveurs de ressources

Diagramme système

System diagram for a web application accessing resource servers.

Créer des ressources requises dans Azure

Lire le guide de démarrage rapide : Inscrire une application auprès du Plateforme d'identités Microsoft.
Créer une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.
Défini redirect URI sur APPLICATION_BASE_URI/login/oauth2/code/, par exemple http://localhost:8080/login/oauth2/code/. La queue / est requise.

Ajouter les dépendances nécessaires

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

Ajouter les propriétés requises

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

Remarque

graph Voici le nom de , scopes signifie que les étendues nécessaires au consentement lors de OAuth2AuthorizedClientla connexion.

Utiliser OAuth2AuthorizedClient dans votre application

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

À présent, démarrez votre application et accédez à votre application dans le navigateur. Ensuite, vous êtes redirigé vers la page de connexion Microsoft.

Utilisations avancées

Flux d’informations d’identification du client

Le flux par défaut est un flux de code d’autorisation, si vous souhaitez utiliser le flux d’informations d’identification du client, vous pouvez le configurer comme suit :

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

Remarque

Accéder à plusieurs serveurs de ressources

Dans une application web, vous pouvez accéder à plusieurs serveurs de ressources en configurant comme suit :

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

Remarque

Vous pouvez ensuite utiliser OAuth2AuthorizedClient dans l’application comme ceci

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

Exemples

Exemple de projet : aad-web-application.

Accès à un serveur de ressources

Ce scénario ne prend pas en charge la connexion, il vous suffit de protéger le serveur en validant le jeton d’accès. Si le jeton d’accès est valide, le serveur répond à la requête.

Diagramme système

System diagram for standalone resource server usage.

Créer des ressources requises dans Azure

Lire le guide de démarrage rapide : Inscrire une application auprès du Plateforme d'identités Microsoft.
Créer une inscription d’application. Obtenir AZURE_CLIENT_ID.
Lire le guide de démarrage rapide : Configurer une application pour exposer une API web.
Exposer une API web avec une étendue nommée Scope-1.

Ajouter les dépendances nécessaires

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

Ajouter les propriétés requises

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

Démarrez maintenant votre application et accédez à l’API web de votre application.

Vous obtiendrez 401 sans jeton d’accès.
Accédez à votre application avec un jeton d’accès. Les revendications suivantes dans le jeton d’accès sont validées :
- iss: Le jeton d’accès doit être émis par l’ID Microsoft Entra.
- nbf: l’heure actuelle ne peut pas être antérieure nbf.
- exp: l’heure actuelle ne peut pas après exp.
- aud: s’il spring.cloud.azure.active-directory.credential.client-id est configuré ou spring.cloud.azure.active-directory.credential.app-id-uri configuré, l’audience doit être égale à celle configurée client-id ou app-id-uri. Si les deux propriétés ne sont pas configurées, cette revendication ne sera pas validée.

Pour plus d’informations sur le jeton d’accès, consultez la documentation MS sur Plateforme d'identités Microsoft jetons d’accès.

Utilisations avancées

Ajouter des configurations de sécurité supplémentaires

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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());
    }
}

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

Valider l’autorisation par étendues

Créez des ressources requises dans Azure.
- Lire le guide de démarrage rapide : Configurer une application pour exposer une API web.
- Exposer une API web avec une étendue nommée Scope1.

Protégez la méthode spécifique.

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

En procédant ainsi, lorsque le point de terminaison d’accès /scope1 , les revendications suivantes dans le jeton d’accès sont validées :

scp: la valeur doit contenir Scope1.

Valider l’autorisation par les rôles d’application

Créez des ressources requises dans Azure.
- Lisez Ajouter des rôles d’application à votre application et recevez-les dans le jeton.
- Créez un rôle d’application avec les paramètres suivants :
  - Nom complet : AppRole1
  - Types de membres autorisés : utilisateurs/groupes
  - Valeur : AppRole1
  - Voulez-vous activer ce rôle d’application : oui

Protégez la méthode spécifique.

class Demo {
    @GetMapping("app-role1")
    @ResponseBody
    @PreAuthorize("hasAuthority('APPROLE_AppRole1')")
    public String appRole1() {
        return "Congratulations, you can access `app-role1` endpoint.";
    }
}

En procédant ainsi, lorsque le point de terminaison d’accès /app-role1 , les revendications suivantes dans le jeton d’accès sont validées :

roles: la valeur doit contenir AppRole1.

Utiliser l’authentification du client JWT

Pour utiliser un jeton web JSON (JWT) pour l’authentification du client, procédez comme suit :

Consultez la section Inscrire votre certificat avec Plateforme d'identités Microsoft section Plateforme d'identités Microsoft informations d’identification du certificat d’authentification d’application.
Chargez un certificat .pem dans l’application inscrite dans le Portail Azure.
Configurez le chemin d’accès et le mot de passe du certificat d’un . PFX ou . Certificat P12 .
Ajoutez la configuration de propriété spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt au client à authentifier via l’authentification du client JWT.

L’exemple de fichier de configuration suivant concerne un scénario d’application web. Les informations de certificat sont configurées dans les propriétés 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

Remarque

Vous pouvez également configurer les informations de certificat dans les propriétés du active-directory service, comme illustré dans cet exemple :

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

Remarque

Connecter ing à Microsoft Entra ID via proxy

Pour connecter Microsoft Entra ID via proxy, fournissez un RestTemplateCustomizer bean. Pour plus d’informations, consultez la section Connecter ing à Microsoft Entra ID via proxy.

Exemples

Exemple de projet : aad-resource-server.

Serveur de ressources visitant d’autres serveurs de ressources

Diagramme système

System diagram for a resource server visiting other resource servers.

Créer des ressources requises dans Azure

Lire le guide de démarrage rapide : Inscrire une application auprès du Plateforme d'identités Microsoft.
Créer une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

Ajouter les dépendances nécessaires

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

Ajouter les propriétés requises

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

Remarque

Utiliser OAuth2AuthorizedClient dans votre application

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

Exemples

Exemple de projet : aad-resource-server-obo.

Application web et serveur de ressources dans une même application

Créer des ressources requises dans Azure

Lire le guide de démarrage rapide : Inscrire une application auprès du Plateforme d'identités Microsoft.
Créer une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

Ajouter les dépendances nécessaires

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

Ajouter les propriétés requises

Définissez la propriété spring.cloud.azure.active-directory.application-typeweb_application_and_resource_serversur , puis spécifiez le type d’autorisation pour chaque client d’autorisation.

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

Remarque

Définir SecurityFilterChain

Configurez plusieurs SecurityFilterChain instances. AadWebApplicationAndResourceServerConfig contient deux configurations de chaîne de filtre de sécurité pour le serveur de ressources et l’application web.

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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
        }
    }
}

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

Configuration

Propriétés configurables de spring-cloud-azure-starter-active-directory :

Nom	Description
spring.cloud.azure.active-directory.app-id-uri	URI d’ID d’application qui peut être utilisé dans la revendication « aud » d’un id_token.
spring.cloud.azure.active-directory.application-type	Type de l’application Microsoft Entra.
spring.cloud.azure.active-directory.authenticate-additional-parameters	Ajoutez des paramètres supplémentaires à l’URL d’autorisation.
spring.cloud.azure.active-directory.authorization-clients	Clients d’autorisation OAuth2.
spring.cloud.azure.active-directory.credential.client-id	ID client à utiliser lors de l’exécution de l’authentification du principal de service avec Azure.
spring.cloud.azure.active-directory.credential.client-secret	Clé secrète client à utiliser lors de l’authentification du principal de service avec Azure.
spring.cloud.azure.active-directory.jwk-set-cache-durée de vie	La durée de vie du JWK mis en cache défini avant son expiration, la valeur par défaut est de 5 minutes.
spring.cloud.azure.active-directory.jwk-set-cache-refresh-time	L’heure d’actualisation du JWK mis en cache défini avant son expiration, la valeur par défaut est de 5 minutes.
spring.cloud.azure.active-directory.jwt-connect-timeout	Connecter ion Timeout for the JWKSet Remote URL call.
spring.cloud.azure.active-directory.jwt-read-timeout	Délai d’attente de lecture pour l’appel d’URL distante JWKSet.
spring.cloud.azure.active-directory.jwt-size-limit	Limite de taille en octets de l’appel d’URL distante JWKSet.
spring.cloud.azure.active-directory.post-logout-redirect-uri	URI de redirection après la déconnexion.
spring.cloud.azure.active-directory.profile.cloud-type	Nom du cloud Azure auquel se connecter. Les types pris en charge sont : AZURE, AZURE_CHINA, AZURE_GERMANY, AZURE_US_GOVERNMENT, OTHER.
spring.cloud.azure.active-directory.profile.environment	Propriétés des points de terminaison Microsoft Entra.
spring.cloud.azure.active-directory.profile.tenant-id	ID de locataire Azure. Les valeurs autorisées `tenant-id` sont : `common`, `organizations`, `consumers`ou l’ID de locataire.
spring.cloud.azure.active-directory.redirect-uri-template	Point de terminaison de redirection : utilisé par le serveur d’autorisation pour renvoyer des réponses contenant des informations d’identification d’autorisation au client via l’agent utilisateur du propriétaire de la ressource. La valeur par défaut est `{baseUrl}/login/oauth2/code/`.
spring.cloud.azure.active-directory.resource-server.claim-to-authority-prefix-map	Configurez la revendication qui sera utilisée pour générer GrantedAuthority et le préfixe de la valeur de chaîne de GrantedAuthority. La valeur par défaut est : « scp » -> « SCOPE_ », « roles » -> « APPROLE_ ».
spring.cloud.azure.active-directory.resource-server.principal-claim-name	Configurez la revendication dans le jeton d’accès à retourner dans AuthenticatedPrincipal#getName. La valeur par défaut est « sub ».
spring.cloud.azure.active-directory.session-stateless	Si true active le filtre d’authentification sans état AadAppRoleStatelessAuthenticationFilter. La valeur par défaut est false qui active AadAuthenticationFilter.
spring.cloud.azure.active-directory.user-group.allowed-group-ids	Les ID de groupe peuvent être utilisés pour construire GrantedAuthority.
spring.cloud.azure.active-directory.user-group.allowed-group-names	Les noms de groupe peuvent être utilisés pour construire GrantedAuthority.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Si la valeur est « true », utilisez « v1.0/me/transitiveMemberOf » pour obtenir des membres. Sinon, utilisez « v1.0/me/memberOf ». La valeur par défaut est `false`.
spring.cloud.azure.active-directory.user-name-attribute	Décidez quelle revendication doit être le nom du principal.

Voici quelques exemples sur l’utilisation de ces propriétés :

Type d'application

Le type d’application peut être déduit des dépendances : spring-security-oauth2-client ou spring-security-oauth2-resource-server. Si la valeur déduite n’est pas la valeur souhaitée, vous pouvez spécifier le type d’application. Voici la table des valeurs valides et des valeurs déduites :

Type d’application :spring-cloud-azure-starter-active-directory

A une dépendance : `spring-security-oauth2-client`	A une dépendance : `spring-security-oauth2-resource-server`	Valeurs valides de type d’application	Valeur déduite
Oui	Non	`web_application`	`web_application`
Non	Oui	`resource_server`	`resource_server`
Oui	Oui	`web_application`, `resource_server`, `resource_server_with_obo`, `web_application_and_resource_server`	`resource_server_with_obo`

Spring Security avec Azure Active Directory B2C

Azure Active Directory (Azure AD) B2C est un service de gestion des identités qui vous permet de personnaliser et contrôler la façon dont les clients s’inscrivent, se connectent et gèrent leurs profils lorsqu’ils utilisent vos applications. Azure AD B2C permet ces actions tout en protégeant les identités de vos clients.

Configuration des dépendances

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

Configuration

Propriétés configurables de spring-cloud-azure-starter-active-directory-b2c :

Nom	Description
spring.cloud.azure.active-directory.b2c.app-id-uri	URI d’ID d’application qui peut être utilisé dans la revendication « aud » d’un jeton.
spring.cloud.azure.active-directory.b2c.authenticate-additional-parameters	Paramètres supplémentaires pour l’authentification.
spring.cloud.azure.active-directory.b2c.authorization-clients	Spécifiez la configuration du client.
spring.cloud.azure.active-directory.b2c.base-uri	URI de base du point de terminaison Azure AD B2C.
spring.cloud.azure.active-directory.b2c.credential	Informations d’identification Azure AD B2C.
spring.cloud.azure.active-directory.b2c.jwt-connect-timeout	Connecter ion Timeout for the JWKSet Remote URL call.
spring.cloud.azure.active-directory.b2c.jwt-read-timeout	Délai d’attente de lecture pour l’appel d’URL distante JWKSet.
spring.cloud.azure.active-directory.b2c.jwt-size-limit	Limite de taille en octets de l’appel d’URL distante JWKSet.
spring.cloud.azure.active-directory.b2c.login-flow	Spécifiez la clé de flux de connexion principale. La valeur par défaut est `sign-up-or-sign-in`.
spring.cloud.azure.active-directory.b2c.logout-success-url	URL de redirection après la déconnexion. La valeur par défaut est `http://localhost:8080/login`.
spring.cloud.azure.active-directory.b2c.profile	Informations de profil Azure AD B2C.
spring.cloud.azure.active-directory.b2c.reply-url	URL de réponse après obtention du code d’autorisation. La valeur par défaut est `{baseUrl}/login/oauth2/code/`.
spring.cloud.azure.active-directory.b2c.user-flow	Flux utilisateur.
spring.cloud.azure.active-directory.b2c.user-name-attribute-name	Nom d’attribut de nom d’utilisateur.

Pour des configurations complètes, case activée propriétés de configuration Azure Spring Cloud.

Utilisation de base

Une application web est une application web qui permet à l’utilisateur de se connecter avec l’ID Microsoft Entra, tandis qu’un serveur de ressources accepte ou refuse l’accès après avoir validé access_token obtenu à partir de l’ID Microsoft Entra. Nous aborderons 4 scénarios dans ce guide :

Accès à une application web.
Application web accédant aux serveurs de ressources.
Accès à un serveur de ressources.
Serveur de ressources accédant à d’autres serveurs de ressources.

System diagram of web application interaction with Microsoft Entra ID and resource servers.

Utilisation 1 : Accès à une application web

Ce scénario utilise le flux d’octroi de code d’autorisation OAuth 2.0 pour se connecter à un utilisateur avec votre utilisateur Azure AD B2C.

Sélectionnez Azure AD B2C dans le menu du portail, sélectionnez Applications, puis Ajoutez.

Spécifiez le nom de votre application (par exemplewebapp), ajoutez http://localhost:8080/login/oauth2/code/ pour l’URL de réponse, enregistrez l’ID d’application comme votreWEB_APP_AZURE_CLIENT_ID, puis sélectionnez Enregistrer.

Sélectionnez Clés dans votre application, sélectionnez Générer une clé pour générer WEB_APP_AZURE_CLIENT_SECRET, puis sélectionnez Enregistrer.

Sélectionnez Flux utilisateur sur votre gauche, puis sélectionnez Nouveau flux d’utilisateur.

Choisissez s’inscrire ou in, modifier le profil et réinitialiser le mot de passe pour créer des flux utilisateur respectivement. Spécifiez les attributs et revendications devotre flux d’utilisateur, puis sélectionnez Créer.

Sélectionnez autorisations>d’API Ajouter une autorisation>Microsoft API, sélectionnez Microsoft Graph, sélectionnez Autorisations déléguées, sélectionnez les autorisations offline_access et openid, puis sélectionnez Ajouter une autorisation pour terminer le processus.

Accordez le consentement administrateur pour les autorisations Graph .

Ajoutez les dépendances suivantes dans votre fichier pom.xml.

Spring Cloud Azure 4.x
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-springsecurity5</artifactId>
   </dependency>
</dependencies>

<dependencies>
   <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>azure-spring-boot-starter-active-directory-b2c</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-thymeleaf</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-security</artifactId>
   </dependency>
   <dependency>
       <groupId>org.thymeleaf.extras</groupId>
       <artifactId>thymeleaf-extras-springsecurity6</artifactId>
   </dependency>
</dependencies>

Ajoutez des propriétés à votre fichier application.yml à l’aide des valeurs que vous avez créées précédemment, comme illustré dans l’exemple suivant :

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}

Écrivez votre code Java.

Pour votre code de contrôleur, vous pouvez vous référer à l’exemple suivant :

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

Pour votre code de configuration de sécurité, vous pouvez vous référer à l’exemple suivant :

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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:off
   }
}

@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
public class WebSecurityConfiguration {

    private final AadB2cOidcLoginConfigurer configurer;

    public WebSecurityConfiguration(AadB2cOidcLoginConfigurer configurer) {
        this.configurer = configurer;
    }

    @Bean
    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.authorizeHttpRequests()
                .anyRequest().authenticated()
                .and()
            .apply(configurer);
        // @formatter:on
        return http.build();
    }
}

Copiez le fichier home.html à partir de l’exemple aad-b2c-web-application, puis remplacez les PROFILE_EDIT_USER_FLOW noms de PASSWORD_RESET_USER_FLOW flux d’utilisateur que vous avez utilisés précédemment.

Générez et testez votre application. Exécutez Webapp le port 8080.

Quand vous avez généré et démarré votre application dans Maven, ouvrez http://localhost:8080/ dans un navigateur web. Vous devez être redirigé vers la page de connexion.

Sélectionnez le lien avec le flux utilisateur de connexion. Vous devez être redirigé vers Azure AD B2C pour démarrer le processus d’authentification.

Une fois connecté, vous devez voir l’exemple home page à partir du navigateur.

Utilisation 2 : Application web accédant aux serveurs de ressources

Ce scénario est basé sur l’accès à un scénario d’application web pour permettre à une application d’accéder à d’autres ressources. Ce scénario est le flux d’octroi des informations d’identification du client OAuth 2.0.

Sélectionnez Azure AD B2C dans le menu du portail, sélectionnez Applications, puis Ajoutez.

Spécifiez le nom de votre application (par exemplewebApiA), enregistrez l’ID d’applicationcomme votreWEB_API_A_AZURE_CLIENT_ID, puis sélectionnez Enregistrer.

Sélectionnez Clés dans votre application, sélectionnez Générer une clé pour générer WEB_API_A_AZURE_CLIENT_SECRET, puis sélectionnez Enregistrer.

Sélectionnez Exposer une API dans le volet de navigation, puis sélectionnez Définir. Enregistrez l’URI de l’ID d’application en tant que votreWEB_API_A_APP_ID_URL, puis sélectionnez Enregistrer.

Sélectionnez Manifeste dans le volet de navigation, puis collez le segment JSON suivant dans appRoles le tableau. Enregistrez l’URI de l’ID d’application en tant que votreWEB_API_A_APP_ID_URL, enregistrez la valeur du rôle d’application en tant que votreWEB_API_A_ROLE_VALUE, puis sélectionnez Enregistrer.

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

Sélectionnez autorisations>d’API Ajouter une autorisation>Mes API, sélectionnez Nom de l’application WebApiA, autorisations d’application, autorisation WebApiA.SampleScope, puis ajouter une autorisation pour terminer le processus.

Accordez le consentement administrateur pour les autorisations WebApiA.

Ajoutez la dépendance suivante en fonction du scénario d’accès à une application web.

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

Ajoutez la configuration suivante en fonction du scénario d’accès à une application 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

Remarque

Écrivez votre Webapp code Java.

Pour votre code de contrôleur, vous pouvez vous référer à l’exemple suivant :

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

Le code de configuration de la sécurité est le même que dans le scénario d’accès à une application web. Ajoutez un autre haricot webClient comme suit :

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

Pour écrire votre WebApiA code Java, consultez la section Accès à un serveur de ressources .

Générez et testez votre application. Laissez et WebApiA exécutez Webapp respectivement sur le port 8080 et 8081. Démarrez les applications et WebApiA les Webapp applications. Revenez à la page d’accueil après la connexion réussie. Vous pouvez ensuite accéder http://localhost:8080/webapp/webApiA à la réponse de la WebApiA ressource.

Utilisation 3 : Accès à un serveur de ressources

Ce scénario ne prend pas en charge la connexion. Protégez simplement le serveur en validant le jeton d’accès et, s’il est valide, il répond à la demande.

Pour générer votre WebApiA autorisation, consultez Utilisation 2 : Application web accédant aux serveurs de ressources.

Ajoutez l’autorisation et accordez WebApiA le consentement administrateur pour votre application web.

Ajoutez les dépendances suivantes dans votre fichier 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>

Ajoutez la configuration suivante.

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}

Remarque

Écrivez votre code Java.

Pour votre code de contrôleur, vous pouvez vous référer à l’exemple suivant :

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

Pour votre code de configuration de sécurité, vous pouvez vous référer à l’exemple suivant :

Spring Cloud Azure 4.x
Spring Cloud Azure 5.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());
   }
}

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

Générez et testez votre application. Laissez WebApiA l’exécution sur le port 8081. Obtenez le jeton d’accès de la webApiA ressource, puis accédez http://localhost:8081/webApiA/sample en tant qu’en-tête d’autorisation du porteur.

Utilisation 4 : Serveur de ressources accédant à d’autres serveurs de ressources

Ce scénario est une mise à niveau de l’accès à un serveur de ressources et prend en charge l’accès à d’autres ressources d’application, en fonction du flux d’informations d’identification du client OAuth2.

En faisant référence aux étapes précédentes, nous créons une WebApiB application et exposons une autorisation WebApiB.SampleScoped’application.

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

Accordez le consentement administrateur pour WebApiB les autorisations.

Sur la base de l’accès à un serveur de ressources, ajoutez la dépendance suivante à votre fichier pom.xml.

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

Ajoutez la configuration suivante en fonction de la configuration d’accès à un scénario de serveur de ressources.

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

Écrivez votre code Java.

Pour votre WebApiA code de contrôleur, vous pouvez vous référer à l’exemple suivant :

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

Pour votre WebApiB code de contrôleur, vous pouvez vous référer à l’exemple suivant :

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

Le code de configuration de la sécurité est le même avec l’accès à un scénario de serveur de ressources , un autre bean webClient est ajouté comme suit :

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

Générez et testez votre application. Let WebApiA and WebApiB run on port 8081 and 8082 respectivement. Démarrez les WebApiA applications, WebApiB obtenez le jeton d’accès pour webApiA la ressource et accédez http://localhost:8081/webApiA/webApiB/sample en tant qu’en-tête d’autorisation du porteur.

Exemples

Pour plus d’informations, consultez les exemples spring-cloud-azure-starter-active-directory-b2c.

Spring Cloud support Azure pour Spring Security

Spring Security avec l’ID Microsoft Entra

Accès à une application web

Diagramme système

Créer des ressources requises dans Azure

Ajouter les dépendances nécessaires

Ajouter les propriétés requises

Utilisations avancées

Ajouter des configurations de sécurité supplémentaires

Autoriser l’accès par les rôles d’application

Autoriser l’accès par nom de groupe ou ID de groupe

Utiliser Azure national au lieu d’Azure global

Configurer le modèle d’URI de redirection

Connecter ing à Microsoft Entra ID via proxy

Exemples

Application web accédant aux serveurs de ressources

Diagramme système

Créer des ressources requises dans Azure

Ajouter les dépendances nécessaires

Ajouter les propriétés requises

Utiliser OAuth2AuthorizedClient dans votre application

Utilisations avancées

Flux d’informations d’identification du client

Accéder à plusieurs serveurs de ressources

Exemples

Accès à un serveur de ressources

Diagramme système

Créer des ressources requises dans Azure

Ajouter les dépendances nécessaires

Ajouter les propriétés requises

Utilisations avancées

Ajouter des configurations de sécurité supplémentaires

Valider l’autorisation par étendues

Valider l’autorisation par les rôles d’application

Utiliser l’authentification du client JWT

Connecter ing à Microsoft Entra ID via proxy

Exemples

Serveur de ressources visitant d’autres serveurs de ressources

Diagramme système

Créer des ressources requises dans Azure

Ajouter les dépendances nécessaires

Ajouter les propriétés requises

Utiliser OAuth2AuthorizedClient dans votre application

Exemples

Application web et serveur de ressources dans une même application

Créer des ressources requises dans Azure

Ajouter les dépendances nécessaires

Ajouter les propriétés requises

Définir SecurityFilterChain

Configuration

Type d'application

Spring Security avec Azure Active Directory B2C

Configuration des dépendances

Configuration

Utilisation de base

Utilisation 1 : Accès à une application web

Utilisation 2 : Application web accédant aux serveurs de ressources

Utilisation 3 : Accès à un serveur de ressources

Utilisation 4 : Serveur de ressources accédant à d’autres serveurs de ressources

Exemples

Commentaires

Commentaires

Ressources supplémentaires