Partager via

Prise en charge de Spring Cloud Azure pour Spring Security

  • Article

Cet article s’applique à :✅ version 4.19.0 ✅ version 5.19.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 offre le 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 utilise le protocole Oauth 2.0 pour protéger les applications web et les serveurs de ressources.

Accès à une application web

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

Diagramme système

diagramme système pour une application web autonome.

Créer des ressources requises dans Azure

  1. Lisez démarrage rapide : Inscrivez une application auprès de la plateforme d’identités Microsoft.

  2. Créez une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

  3. Définissez redirect URI sur APPLICATION_BASE_URI/login/oauth2/code/ , par exemple http://localhost:8080/login/oauth2/code/. La / de queue est requise.

Ajouter des dépendances requises

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

Note

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

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

Note

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 revendication role. 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.

diagramme système pour les URI de redirection.

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

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

Mettez à jour redirect-uri dans le portail Azure.

configurer le modèle d’URI de redirection.

Après avoir défini redirect-uri-template, nous devons mettre à jour le générateur de sécurité :

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

Connexion à l’ID Microsoft Entra via un 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);
        };
    }
}

Échantillons

Exemple de projet : aad-web-application .

Application web accédant aux serveurs de ressources

Diagramme système

diagramme système pour une application web accédant aux serveurs de ressources.

Créer des ressources requises dans Azure

  1. Lisez démarrage rapide : Inscrivez une application auprès de la plateforme d’identités Microsoft.

  2. Créez une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

  3. Définissez redirect URI sur APPLICATION_BASE_URI/login/oauth2/code/, par exemple http://localhost:8080/login/oauth2/code/. La / de queue est requise.

Ajouter des dépendances requises

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

Note

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

Ici, graph est le nom de OAuth2AuthorizedClient, scopes signifie que les étendues nécessaires au consentement lors de la 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 flux de code d’autorisation, si vous souhaitez utiliser flux d’informations d’identification du client, vous pouvez 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

Note

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

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

Note

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

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

Échantillons

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

Diagramme système

diagramme système pour l’utilisation du serveur de ressources autonome.

Créer des ressources requises dans Azure

  1. Lisez démarrage rapide : Inscrivez une application auprès de la plateforme d’identités Microsoft.

  2. Créez une inscription d’application. Obtenir AZURE_CLIENT_ID.

  3. Lisez démarrage rapide : Configurer une application pour exposer uned’API web.

  4. Exposez une API web avec une étendue nommée Scope-1.

Ajouter des dépendances requises

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

  1. Vous obtiendrez 401 sans jeton d’accès.

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

    • exp: l’heure actuelle ne peut pas après exp.

    • aud: si spring.cloud.azure.active-directory.credential.client-id ou spring.cloud.azure.active-directory.credential.app-id-uri configuré, l’audience doit être égale au client-id configuré 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 documentation MS sur les jetons d’accès de plateforme d’identités Microsoft.

Utilisations avancées

Ajouter des configurations de sécurité supplémentaires
@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

  1. Créez des ressources requises dans Azure.

  2. 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 l’accès /scope1 point de terminaison, 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

  1. Créez des ressources requises dans Azure.

  2. 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 l’accès /app-role1 point de terminaison, 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 :

  1. Consultez la section Inscrire votre certificat auprès de la plateforme d’identités Microsoft section informations d’identification de certificat d’authentification d’application de plateforme d’identités Microsoft.
  2. Chargez un certificat .pem sur l’application inscrite dans le portail Azure.
  3. Configurez le chemin d’accès et le mot de passe du certificat d’un . PFX ou . Certificat P12.
  4. Ajoutez la propriété spring.cloud.azure.active-directory.authorization-clients.azure.client-authentication-method=private_key_jwt configuration 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

Note

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

Vous pouvez également configurer les informations de certificat dans les propriétés du service active-directory, 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

Note

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

Connexion à l’ID Microsoft Entra via un proxy

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

Échantillons

Exemple de projet : aad-resource-server .

Serveur de ressources visitant d’autres serveurs de ressources

Diagramme système

diagramme système d’un serveur de ressources visitant d’autres serveurs de ressources.

Créer des ressources requises dans Azure

  1. Lisez démarrage rapide : Inscrivez une application auprès de la plateforme d’identités Microsoft.

  2. Créez une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

Ajouter des dépendances requises

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

Note

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

Utiliser OAuth2AuthorizedClient dans votre application

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

Échantillons

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

Application web et serveur de ressources dans une application

Créer des ressources requises dans Azure

  1. Lisez démarrage rapide : Inscrivez une application auprès de la plateforme d’identités Microsoft.

  2. Créez une inscription d’application. Obtenir AZURE_TENANT_ID, AZURE_CLIENT_IDet AZURE_CLIENT_SECRET.

Ajouter des dépendances requises

<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 des propriétés requises

Définissez la propriété spring.cloud.azure.active-directory.application-type sur web_application_and_resource_serveret 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

Note

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

Définir SecurityFilterChain

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

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

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

    @Bean
    public SecurityFilterChain htmlFilterChain(HttpSecurity http) throws Exception {
        // @formatter:off
        http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
                .and()
            .authorizeHttpRequests()
                .requestMatchers("/login").permitAll()
                .anyRequest().authenticated();
        // @formatter:on
        return http.build();
    }
}

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 Délai d’expiration de connexion pour l’appel d’URL distante JWKSet.
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 pour tenant-id sont : common, organizations, consumersou 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 de 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 du 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 de contrôler la façon dont les clients s’inscrivent, se connectent et gèrent leurs profils lors de l’utilisation de vos applications. Azure AD B2C permet ces actions tout en protégeant les identités de vos clients en même temps.

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 Délai d’expiration de connexion pour l’appel d’URL distante JWKSet.
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 obtenir des configurations complètes, vérifiez propriétés de configuration d’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 acceptera ou refusera l’accès après avoir validé access_token obtenu à partir de l’ID Microsoft Entra. Nous aborderons 4 scénarios dans ce guide :

  1. Accès à une application web.

  2. Application web accédant aux serveurs de ressources.

  3. Accès à un serveur de ressources.

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

Utilisation 1 : Accès à une application web

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

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

Spécifiez l' nom de votre application (par exemple, ), ajoutez pour l’URL de réponse , enregistrez l’ID d’application en tant que , puis sélectionnez Enregistrer.

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

Sélectionnez flux utilisateur à gauche, puis sélectionnez nouveau flux utilisateur.

Choisissez s’inscrire ou dans, de modification de profil et Réinitialisation de mot de passe pour créer des flux utilisateur respectivement. Spécifiez votre flux utilisateur Nom et attributs utilisateur et revendications, puis sélectionnez Créer.

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

Accordez le consentement de l’administrateur pour les autorisations graph .

capture d’écran du portail Azure montrant l’écran Des autorisations d’API pour une application, avec des autorisations de graphe mises en surbrillance.

Ajoutez les dépendances suivantes à 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>
   <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 :

@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 home.html à partir de exemple aad-b2c-web-application, puis remplacez les PROFILE_EDIT_USER_FLOW et les PASSWORD_RESET_USER_FLOW par les noms de flux d’utilisateur que vous avez utilisés précédemment.

Générez et testez votre application. Laissez Webapp s’exécuter sur le port 8080.

Une fois votre application générée et démarrée par 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 de home page à partir du navigateur.

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

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

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

Spécifiez le nom de votre application (par exemple webApiA), enregistrez l’ID d’application en tant que WEB_API_A_AZURE_CLIENT_ID, puis sélectionnez Enregistrer.

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

Sélectionnez Exposer un d’API dans le volet de navigation, puis sélectionnez Définir. Enregistrez l’URI d’ID d’application en tant que WEB_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 tableau. Enregistrez l’URI d’ID d’application en tant que WEB_API_A_APP_ID_URL, enregistrez la valeur du rôle d’application en tant que WEB_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, sélectionnez autorisation WebApiA.SampleScope, puis sélectionnez Ajouter une autorisation pour terminer le processus.

Accordez le consentement administrateur pour les autorisations de WebApiA.

capture d’écran du portail Azure montrant l’écran Autorisations de l’API d’application.

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

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

Ajoutez la configuration suivante en fonction de la l’accès à une application web scénario.

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

Note

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

Écrivez votre code Java Webapp.

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 l’accès à une application web scénario. Ajoutez une autre webClient bean 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 code Java WebApiA, consultez la section Accès à un serveur de ressources.

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

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 autorisation de WebApiA, consultez Utilisation 2 : Application web accédant aux serveurs de ressources.

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

Ajoutez les dépendances suivantes à 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}

Note

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

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

@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 s’exécuter sur le port 8081. Obtenez le jeton d’accès de la ressource webApiA, 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 application WebApiB et exposons une autorisation d’application 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"
}

Accordez le consentement administrateur pour les autorisations de WebApiB.

capture d’écran du portail Azure montrant l’écran Autorisations de l’API WebApiA de l’application.

Sur la base de 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 du l’accès à un serveur de ressources configuration du scénario.

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 code de contrôleur de WebApiA, vous pouvez consulter 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 code de contrôleur de WebApiB, vous pouvez consulter 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 webClient bean 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. Laissez WebApiA et WebApiB s’exécuter sur le port 8081 et 8082 respectivement. Démarrez les applications WebApiA et WebApiB, obtenez le jeton d’accès pour webApiA ressource et accédez http://localhost:8081/webApiA/webApiB/sample en tant qu’en-tête d’autorisation du porteur.

Échantillons

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