Guide du développeur Spring Boot Starter pour Microsoft Entra

Cet article s’applique à :✅ version 4.19.0 ✅ version 5.19.0

Cet article décrit les fonctionnalités et les scénarios principaux de Spring Boot Starter pour Microsoft Entra ID. L’article contient également des conseils sur les problèmes courants, les solutions de contournement et les étapes de diagnostic.

Lorsque vous créez une application web, la gestion des identités et des accès est des éléments fondamentaux. Azure offre un service d’identité basé sur le cloud qui a une intégration approfondie avec le reste de l’écosystème Azure.

Bien que Spring Security facilite la sécurisation de vos applications Spring, elle n’est pas adaptée à un fournisseur d’identité spécifique. L’ID Spring Boot Starter pour Microsoft Entra vous permet de connecter votre application web à un locataire Microsoft Entra 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.

Les liens suivants fournissent un accès au package de démarrage, à la documentation et aux exemples :

• Le package spring-cloud-azure-starter-active-directory (Maven)
• démarrage rapide
• Exemples

Conditions préalables

Pour suivre les instructions de ce guide, vous devez disposer des conditions préalables suivantes :

• Un abonnement Azure ; Si vous n’avez pas encore d’abonnement Azure, vous pouvez activer vos avantages abonné MSDN ou vous inscrire à un compte Azure gratuit .
• Kit de développement Java (JDK) pris en charge, version 8 ou ultérieure. Pour plus d’informations, consultez Prise en charge de Java sur Azure et Azure Stack.
• Apache Maven, version 3.0 ou ultérieure.
• Une application inscrite auprès de Microsoft Entra ID. Pour plus d’informations, consultez Démarrage rapide : Inscrire une application auprès de la plateforme d’identités Microsoft.

Important

Spring Boot version 2.5 ou ultérieure est nécessaire pour effectuer les étapes décrites dans cet article.

Scénarios principaux

Ce guide explique comment utiliser le démarrage Microsoft Entra dans les scénarios suivants :

• Accéder à une application web
• Accéder aux serveurs de ressources à partir d'une application web
• Protéger un serveur de ressources/API
• Accéder à d’autres serveurs de ressources à partir d’un serveur de ressources
• serveur d’applications web et de ressources dans une application

Une application web est une application web qui permet à un utilisateur de se connecter. Un serveur de ressources accepte ou refuse l’accès après la validation d’un jeton d’accès.

Accéder à une application web

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

Pour utiliser le démarrage Microsoft Entra dans ce scénario, procédez comme suit :

Paramétrez l’URI de redirection sur <application-base-uri>/login/oauth2/code/. Par exemple : http://localhost:8080/login/oauth2/code/. N’oubliez pas la barre oblique (/) à la fin. Pour plus d’informations sur l’URI de redirection, consultez Ajouter un URI de redirection dans Démarrage rapide : Inscrire une application auprès de la plateforme d’identités Microsoft.

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

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

Remarque

Pour plus d’informations sur la gestion des versions de bibliothèque Azure Spring Cloud à l’aide d’une liste de matériaux (BOM), consultez la section Prise en main du guide du développeur Spring Cloud Azure.

Ajoutez les propriétés suivantes à votre fichier application.yml. Vous pouvez obtenir les valeurs de ces propriétés à partir de l’inscription d’application que vous avez créée dans le portail Azure, comme décrit dans les conditions préalables.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <your-client-ID>
         client-secret: <your-client-secret>

Remarque

Les valeurs autorisées pour tenant-id sont : common, organizations, consumersou l’ID de locataire. Pour plus d’informations sur ces valeurs, consultez la section Utilisation d’un point de terminaison incorrect (comptes personnels et d’organisation) de l’article 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 application multilocataire sur Microsoft Entra ID.

Utilisez la configuration de sécurité par défaut ou fournissez votre propre configuration.

Spring Cloud Azure 5.x

Option 1 : Utilisez la configuration par défaut.

Avec cette option, vous n’avez rien à faire. La classe DefaultAadWebSecurityConfiguration est configurée automatiquement.

Option 2 : Fournir une configuration définie par soi-même.

Pour fournir une configuration, appliquez la méthode AadWebApplicationHttpSecurityConfigurer#aadWebApplication pour l'HttpSecurity, comme illustré dans l’exemple suivant :

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

   /**
    * Add configuration logic as needed.
    */
   @Bean
   SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
       http.apply(AadWebApplicationHttpSecurityConfigurer.aadWebApplication())
               .and()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
           // Do some custom configuration.
       return http.build();
   }
}

Spring Cloud Azure 4.x

Option 1 : Utilisez la configuration par défaut.

Avec cette option, vous n’avez rien à faire. La classe DefaultAadWebSecurityConfigurerAdapter est configurée automatiquement.

Option 2 : Fournir une configuration autodéfinie.

Pour fournir une configuration, étendez la classe AadWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme illustré dans l’exemple suivant :

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

Accéder aux serveurs de ressources à partir d’une application web

Pour utiliser le démarrage Microsoft Entra dans ce scénario, procédez comme suit :

Définissez l’URI de redirection comme décrit précédemment.

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

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

Remarque

Pour plus d’informations sur la gestion des versions des bibliothèques Azure Spring Cloud à l’aide d’une liste de matériaux (BOM), consultez la section Commencer du guide du développeur Spring Cloud Azure.

Ajoutez les propriétés suivantes à votre fichier application.yml, comme décrit précédemment :

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

Remarque

Les valeurs autorisées pour tenant-id sont : common, organizations, consumersou l’ID de locataire. Pour plus d’informations sur ces valeurs, consultez la section Utilisation d’un point de terminaison incorrect (comptes personnels et d’organisation) de l’article 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 application multilocataire sur Microsoft Entra ID.

Ici, graph est le nom de votre OAuth2AuthorizedClient, et scopes définit les étendues requises pour le consentement à la connexion.

Ajoutez du code à votre application comme dans l’exemple suivant :

@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 the resource server.
   return toJsonString(graphClient);
}

Ici, graph est l’ID client configuré à l’étape précédente. OAuth2AuthorizedClient contient le jeton d’accès, utilisé pour accéder au serveur de ressources.

Pour un exemple complet démontrant ce scénario, voir spring-cloud-azure-starter-active-directory sample : aad-web-application.

Protéger un serveur de ressources/UNE API

Ce scénario ne prend pas en charge la connexion, mais protège le serveur en validant le jeton d’accès. Si le jeton d’accès est valide, le serveur répond à la demande.

Pour utiliser le démarrage Microsoft Entra dans ce scénario, procédez comme suit :

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

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

Remarque

Pour plus d’informations sur la gestion des versions des bibliothèques Spring Cloud Azure à l’aide d’un fichier de nomenclature (BOM), consultez la section Prise en main du guide du développeur Spring Cloud Azure.

Ajoutez les propriétés suivantes à votre fichier application.yml, comme décrit précédemment :

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       credential:
         client-id: <your-client-ID>
       app-id-uri: <your-app-ID-URI>

Vous pouvez utiliser les valeurs <your-client-ID> et <your-app-ID-URI> pour vérifier le jeton d’accès. Vous pouvez obtenir la valeur <your-app-ID-URI> à partir du portail Azure, comme indiqué dans les images suivantes :

Utilisez la configuration de sécurité par défaut ou fournissez votre propre configuration.

Spring Cloud Azure 5.x

Option 1 : Utilisez la configuration par défaut.

Avec cette option, vous n’avez rien à faire. La classe DefaultAadResourceServerConfiguration est configurée automatiquement.

Option 2: Fournir une configuration autodéfinie.

Pour fournir une configuration, appliquez la méthode AadResourceServerHttpSecurityConfigurer#aadResourceServer pour l'HttpSecurity, comme illustré dans l’exemple suivant :

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

   /**
    * Add configuration logic as needed.
    */
   @Bean
   public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
       http.apply(AadResourceServerHttpSecurityConfigurer.aadResourceServer())
               .and()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
       return http.build();
   }
}

Spring Cloud Azure 4.x

Option 1 : Utilisez la configuration par défaut.

Avec cette option, vous n’avez rien à faire. La classe DefaultAadResourceServerWebSecurityConfigurerAdapter est configurée automatiquement.

Option 2 : Fournir une configuration autodéfinie.

Pour fournir une configuration, étendez la classe AadResourceServerWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme illustré dans l’exemple suivant :

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

Pour un exemple complet démontrant ce scénario, voir spring-cloud-azure-starter-active-directory sample : aad-resource-server.

Accéder à d’autres serveurs de ressources à partir d’un serveur de ressources

Ce scénario prend en charge un serveur de ressources visitant d’autres serveurs de ressources.

Pour utiliser le démarrage Microsoft Entra dans ce scénario, procédez comme suit :

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

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

Remarque

Pour plus d’informations sur la gestion des versions de bibliothèque Spring Cloud Azure à l’aide d’une liste de matériaux (BOM), consultez la section Getting started du guide du développeur Spring Cloud Azure.

Ajoutez les propriétés suivantes à votre fichier application.yml :

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <web-API-A-client-ID>
         client-secret: <web-API-A-client-secret>
       app-id-uri: <web-API-A-app-ID-URI>
       authorization-clients:
         graph:
           scopes:
              - https://graph.microsoft.com/User.Read

Remarque

Les valeurs autorisées pour tenant-id sont : common, organizations, consumersou l’ID de locataire. Pour plus d’informations sur ces valeurs, consultez la section Utilisation d’un point de terminaison incorrect (comptes personnels et d’organisation) de l’article 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 à locataire unique, consultez Convertir une application à locataire unique en multilocataire sur Microsoft Entra ID.

Utilisez l’attribut @RegisteredOAuth2AuthorizedClient dans votre code pour accéder au serveur de ressources associé, comme illustré dans l’exemple suivant :

@PreAuthorize("hasAuthority('SCOPE_Obo.Graph.Read')")
@GetMapping("call-graph")
public String callGraph(@RegisteredOAuth2AuthorizedClient("graph") OAuth2AuthorizedClient graph) {
   return callMicrosoftGraphMeEndpoint(graph);
}

Pour un exemple complet de ce scénario, voir spring-cloud-azure-starter-active-directory sample : aad-resource-server-obo.

Application web et serveur de ressources dans une application

Ce scénario prend en charge Accéder à une application web et Protéger un serveur de ressources/un API dans une seule application.

Pour utiliser aad-starter dans ce scénario, procédez comme suit :

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

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

Remarque

Pour plus d'informations sur la gestion des versions des bibliothèques Spring Cloud Azure à l'aide d'une liste de matériels (BOM), consultez la section Prise en main du guide du développeur Spring Cloud Azure.

Mettez à jour votre fichier application.yml. 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, comme indiqué dans l’exemple suivant.

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       profile:
         tenant-id: <tenant>
       credential:
         client-id: <Web-API-C-client-id>
         client-secret: <Web-API-C-client-secret>
       app-id-uri: <Web-API-C-app-id-url>
       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

Les valeurs autorisées pour tenant-id sont : common, organizations, consumersou l’ID de locataire. Pour plus d’informations sur ces valeurs, consultez la section Utilisation d’un point de terminaison incorrect (comptes personnels et d’organisation) de l’article 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 à locataire unique, consultez Convertir une application à locataire unique en application à locataires multiples avec Microsoft Entra ID.

Écrivez du code Java pour configurer plusieurs instances de HttpSecurity.

Spring Cloud Azure 5.x

Dans l’exemple de code suivant, AadWebApplicationAndResourceServerConfig contient deux beans de chaîne de filtres de sécurité, un pour un serveur de ressources et un pour une application web. Le apiFilterChain bean a une priorité élevée pour configurer le générateur de sécurité du serveur de ressources. Le htmlFilterChain bean a une faible priorité pour configurer le générateur de sécurité des applications 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();
    }
}

Spring Cloud Azure 4.x

Dans l’exemple de code suivant, AadWebApplicationAndResourceServerConfig contient deux configurations de sécurité, une pour un serveur de ressources et une pour une application web. La classe ApiWebSecurityConfigurationAdapter a une priorité élevée pour configurer l’adaptateur de sécurité du serveur de ressources. La classe HtmlWebSecurityConfigurerAdapter a une priorité faible pour configurer l’adaptateur de sécurité d’application web.

@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class AadWebApplicationAndResourceServerConfig {

   @Order(1)
   @Configuration
   public static class ApiWebSecurityConfigurationAdapter extends AadResourceServerWebSecurityConfigurerAdapter {
       protected void configure(HttpSecurity http) throws Exception {
           super.configure(http);
           // All the paths that match `/api/**`(configurable) work as the resource server. Other paths work as  the 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
       }
   }
}

Type d’application

La propriété spring.cloud.azure.active-directory.application-type est facultative, car sa valeur peut être déduite par des dépendances. Vous devez définir manuellement la propriété uniquement lorsque vous utilisez la valeur web_application_and_resource_server.

A une dépendance : spring-security-oauth2-client	A une dépendance : spring-security-oauth2-resource-server	Valeurs valides du type d’application	Valeur par défaut
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

Propriétés configurables

L’ID Spring Boot Starter pour Microsoft Entra fournit les propriétés suivantes :

Propriétés	Description
spring.cloud.azure.active-directory.app-id-uri	Utilisé par le serveur de ressources pour valider l’audience dans le jeton d’accès. Le jeton d’accès est valide uniquement lorsque l’audience est égale aux valeurs <your-client-ID> ou <your-app-ID-URI> décrites précédemment.
spring.cloud.azure.active-directory.authorization-clients	Carte qui configure les API de ressource que l’application va visiter. Chaque élément correspond à une API de ressource que l’application va visiter. Dans votre code Spring, chaque élément correspond à un objet OAuth2AuthorizedClient.
spring.cloud.azure.active-directory.authorization-clients.<your-client-name>.scopes	Autorisations d’API d’un serveur de ressources que l’application va acquérir.
spring.cloud.azure.active-directory.authorization-clients.<your-client-name>.authorization-grant-type	Type de client d’autorisation. Les types pris en charge sont authorization_code (type par défaut pour webapp), on_behalf_of (type par défaut pour le serveur de ressources), client_credentials.
spring.cloud.azure.active-directory.application-type	Reportez-vous à : Type d’application.
spring.cloud.azure.active-directory.profile.environment.active-directory-endpoint	URI de base pour le serveur d’autorisation. La valeur par défaut est https://login.microsoftonline.com/.
spring.cloud.azure.active-directory.credential.client-id	ID d'application enregistré dans Microsoft Entra ID.
spring.cloud.azure.active-directory.credential.client-secret	Clé secrète client de l’application inscrite.
spring.cloud.azure.active-directory.user-group.use-transitive-members	Utilisez v1.0/me/transitiveMemberOf pour obtenir des groupes si la valeur est true. Sinon, utilisez /v1.0/me/memberOf.
spring.cloud.azure.active-directory.post-logout-redirect-uri	URI de redirection pour la post-déconnexion.
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.user-group.allowed-group-names	Les groupes d’utilisateurs attendus auxquels une autorité sera accordée, s'ils figurent dans la réponse de l'appel de l'API Graph MemberOf.
spring.cloud.azure.active-directory.user-name-attribute	Indique quelle revendication sera le nom du principal.

Les exemples suivants vous montrent comment utiliser ces propriétés :

Property example 1 : Pour utiliser Azure China 21Vianet au lieu d’Azure Global, suivez la démarche suivante.

• Ajoutez les propriétés suivantes à votre fichier application.yml :

  spring:
     cloud:
       azure:
         active-directory:
           enabled: true
           profile:
             environment:
               active-directory-endpoint: https://login.partner.microsoftonline.cn
  

Avec cette méthode, vous pouvez utiliser un cloud souverain ou national Azure au lieu du cloud public Azure.

Propriété 2 : Pour utiliser un nom de groupe pour protéger une méthode dans une application web, procédez comme suit :

Ajoutez la propriété suivante à votre fichier application.yml :

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       user-group:
         allowed-groups: group1, group2

Utilisez la configuration de sécurité par défaut ou fournissez votre propre configuration.

Spring Cloud Azure 5.x

Option 1 : Utilisez la configuration par défaut. Avec cette option, vous n’avez rien à faire. La classe DefaultAadWebSecurityConfiguration est configurée automatiquement.

Option 2: Fournir une configuration autodéfinie. Pour fournir une configuration, appliquez la méthode AadWebApplicationHttpSecurityConfigurer#aadWebApplication pour l'HttpSecurity, comme illustré dans l’exemple suivant :

@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()
           .authorizeHttpRequests()
               .anyRequest().authenticated();
       // @formatter:on
       // Do some custom configuration.
       return http.build();
   }
}

Spring Cloud Azure 4.x

Option 1 : Utilisez la configuration par défaut. Avec cette option, vous n’avez rien à faire. La classe DefaultAadWebSecurityConfigurerAdapter est configurée automatiquement.

Option 2: Fournir une configuration autodéfinie. Pour fournir une configuration, étendez la classe AadWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme illustré dans l’exemple suivant :

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

Utilisez l’annotation @PreAuthorize pour protéger la méthode, comme illustré dans l’exemple suivant :

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

Exemple de propriété 3 : Pour activer le flux d'autorisations client dans un serveur de ressources qui accède à d'autres serveurs de ressources, procédez comme suit :

Ajoutez la propriété suivante à votre fichier application.yml :

spring:
 cloud:
   azure:
     active-directory:
       enabled: true
       authorization-clients:
         webapiC:   # When authorization-grant-type is null, on behalf of flow is used by default
           authorization-grant-type: client_credentials
           scopes:
             - <Web-API-C-app-id-url>/.default

Ajoutez du code à votre application comme dans l’exemple suivant :

@PreAuthorize("hasAuthority('SCOPE_Obo.WebApiA.ExampleScope')")
@GetMapping("webapiA/webapiC")
public String callClientCredential() {
   String body = webClient
       .get()
       .uri(CUSTOM_LOCAL_READ_ENDPOINT)
       .attributes(clientRegistrationId("webapiC"))
       .retrieve()
       .bodyToMono(String.class)
       .block();
   LOGGER.info("Response from Client Credential: {}", body);
   return "client Credential response " + (null != body ? "success." : "failed.");
}

Fonctionnalités avancées

Prise en charge du contrôle d’accès par jeton d’ID dans une application web

Le starter prend en charge la création d’un GrantedAuthority à partir de la revendication roles d’un jeton d’ID pour permettre l’autorisation par jeton d’ID dans une application web. Vous pouvez utiliser la fonctionnalité appRoles de Microsoft Entra ID pour créer une revendication roles et implémenter le contrôle d’accès.

Remarque

La requête roles générée à partir de appRoles est pourvue du préfixe APPROLE_.

Lorsque vous utilisez appRoles en tant que revendication de roles, évitez de configurer un attribut de groupe en tant que roles en même temps. Sinon, l’attribut de groupe remplacera la revendication pour contenir les informations de groupe au lieu d’appRoles. Vous devez éviter la configuration suivante dans votre manifeste :

"optionalClaims": {
    "idtoken": [{
        "name": "groups",
        "additionalProperties": ["emit_as_roles"]
    }]
}

Pour prendre en charge le contrôle d’accès par jeton d’ID dans une application web, procédez comme suit :

Ajoutez des rôles d’application dans votre application et attribuez-les à des utilisateurs ou des groupes. Pour plus d’informations, consultez Guide pratique pour ajouter des rôles d’application à votre application et les recevoir dans le jeton.

Ajoutez la configuration appRoles suivante au manifeste de votre application :

 "appRoles": [
   {
     "allowedMemberTypes": [
       "User"
     ],
     "displayName": "Admin",
     "id": "2fa848d0-8054-4e11-8c73-7af5f1171001",
     "isEnabled": true,
     "description": "Full admin access",
     "value": "Admin"
    }
 ]

Ajoutez du code à votre application comme dans l’exemple suivant :

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

Dépannage

Activer la journalisation du client

Les SDK Azure pour Java offrent une stratégie de journalisation cohérente pour vous aider à diagnostiquer et résoudre les erreurs d'application. Les journaux générés capturent le flux d’une application avant d’atteindre le terminal, ce qui permet de localiser le problème racine. Consultez le wiki sur la journalisation pour obtenir des conseils sur l’activation de la journalisation.

Activer la journalisation Sprint

Spring permet à tous les systèmes de journalisation pris en charge de définir des niveaux d’enregistreur d’événements dans l’environnement Spring ( par exemple, dans application.properties ) à l’aide de logging.level.<logger-name>=<level> où <level> est l’un des TRACE, DEBUG, INFO, WARN, ERROR, FATALou OFF. Vous pouvez configurer le journal racine avec logging.level.root.

L’exemple suivant montre les paramètres de journalisation potentiels dans le fichier application.properties :

logging.level.root=WARN
logging.level.org.springframework.web=DEBUG
logging.level.org.hibernate=ERROR

Pour plus d’informations sur la configuration de la journalisation dans Spring, consultez Journalisation dans la documentation Spring.

Étapes suivantes

Pour en savoir plus sur Spring et Azure, passez au centre de documentation Spring sur Azure.

Spring sur Azure