Guide du développeur Spring Boot Starter pour Microsoft Entra

Cet article s’applique à : ✔️ Version 4.16.0 ✔️ Version 5.10.0

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

Quand vous créez une application web, la gestion des identités et des accès est l’un des aspects fondamentaux à prendre en compte. Azure fournit un service d’identité basé sur le cloud qui s’intègre parfaitement aux autres composants de l’écosystème Azure.

Spring Security facilite la sécurisation de vos applications basées sur Spring, mais il peut aussi être utilisé pour d’autres fournisseurs d’identité. 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 recourt au protocole OAuth 2.0 pour assurer la protection des applications web et des serveurs de ressources.

Utilisez les liens suivants pour accéder au package de démarrage, à la documentation et à des exemples :

Prérequis

Pour être en mesure de suivre les instructions de ce guide, vous devez disposer des éléments suivants :

Important

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

Principaux scénarios

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

Une application web est une application basée sur le web qui permet à un utilisateur de se connecter. Un serveur de ressources accepte ou refuse l’accès après 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 :

Définissez l’URI de redirection vers <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 avec la plateforme d’identités Microsoft.

Screenshot of Azure portal showing Microsoft Entra App registrations page with sample-webapp highlighted.

Screenshot of Azure portal showing web app authentication page with redirect URI highlighted.

Ajoutez les dépendances suivantes dans 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 Spring Cloud Azure à l’aide d’une facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

Ajoutez les propriétés suivantes dans 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 cela est décrit dans la section des prérequis.

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.

Option 1 : Utilisez la configuration par défaut.

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

Option 2 : Fournir une configuration autodéfinis.

Pour fournir une configuration, étendez la classe AadWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme indiqué 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 à des 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 vous l’avez appris précédemment.

Ajoutez les dépendances suivantes dans 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 Spring Cloud Azure à l’aide d’une facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

Ajoutez les propriétés suivantes dans 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, sur le modèle de 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 qui a été configuré à l’étape précédente. OAuth2AuthorizedClient contient le jeton d’accès utilisé pour accéder au serveur de ressources.

Pour obtenir un exemple complet illustrant ce scénario, consultez l’exemple spring-cloud-azure-starter-active-directory : aad-web-application.

Protéger une API/un serveur de ressources

Ce scénario ne permet pas la connexion, mais il protège le serveur en validant le jeton d’accès. Si le jeton d’accès est valide, le serveur répond à la requête.

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

Ajoutez les dépendances suivantes dans 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 de bibliothèque Spring Cloud Azure à l’aide d’une facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

Ajoutez les propriétés suivantes dans 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 de l’Portail Azure, comme indiqué dans les images suivantes :

Screenshot of Azure portal showing Microsoft Entra App registrations page with sample-resource-server highlighted.

Screenshot of Azure portal showing web app Expose an API page with Application ID URI highlighted.

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

Option 1 : Utilisez la configuration par défaut.

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

Option 2 : Fournir une configuration autodéfinis.

Pour fournir une configuration, étendez la classe AadResourceServerWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme indiqué 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 obtenir un exemple complet illustrant ce scénario, consultez l’exemple spring-cloud-azure-starter-active-directory : aad-resource-server.

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

Ce scénario permet à un serveur de ressources d’accéder à 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 dans 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 facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

Ajoutez les propriétés suivantes dans 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 monolocataire, consultez Convertir une application monolocataire en application multilocataire sur Microsoft Entra ID.

Ajoutez l’attribut @RegisteredOAuth2AuthorizedClient dans votre code pour permettre l’accès au serveur de ressources associé, comme le montre l’exemple suivant :

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

Pour obtenir un exemple complet illustrant ce scénario, consultez l’exemple spring-cloud-azure-starter-active-directory : aad-resource-server-obo.

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

Ce scénario prend en charge l’accès à une application web et la protection d’un serveur de ressources/d’une API dans une même application.

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

Ajoutez les dépendances suivantes dans 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 facture de documents (BOM), consultez la section Prise en main du guide du développeur Azure Spring Cloud.

Mettez à jour votre fichier application.yml. Affectez à la propriété spring.cloud.azure.active-directory.application-type la valeur web_application_and_resource_server et 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 monolocataire, consultez Convertir une application monolocataire en application multilocataire sur Microsoft Entra ID.

Écrire du code Java pour configurer plusieurs instances HttpSecurity.

Dans l’exemple de code suivant, AadWebApplicationAndResourceServerConfig contient deux configurations de sécurité, une pour un serveur de ressources et une autre 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 basse priorité pour configurer l’adaptateur de sécurité de l’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 esource 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 cette 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 de type d’application Valeur par défaut
Oui No 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ée par le serveur de ressources pour valider l’audience dans le jeton d’accès. Le jeton d’accès n’est valide que 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 Mappage qui configure les API de ressources auxquelles l’application pourra accéder. Chaque élément correspond à une API de ressources à laquelle l’application pourra accéder. Dans votre code Spring, chaque élément correspond à un seul objet OAuth2AuthorizedClient.
spring.cloud.azure.active-directory.authorization-clients.<your-client-name.scopes> Autorisations d’API d’un serveur de ressources que l’application doit obtenir.
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 resource-server), 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 inscrit dans l’ID Microsoft Entra.
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 Permet v1.0/me/transitiveMemberOf d’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 du 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 se trouvent dans la réponse de l’appel d’API MemberOf Graph.
spring.cloud.azure.active-directory.user-name-attribute Indique quelle revendication sera le nom du principal.

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

Exemple de propriété 1 : Pour utiliser Azure China 21Vianet au lieu d’Azure Global, effectuez l’étape suivante.

  • Ajoutez les propriétés suivantes dans 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 national ou souverain Azure au lieu du cloud public Azure.

Exemple de propriété 2 : Pour utiliser un nom de groupe afin de protéger une méthode dans une application web, effectuez les étapes ci-après :

Ajoutez la propriété suivante dans 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.

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

Option 2 : Fournir une configuration autodéfinis. Pour fournir une configuration, étendez la classe AadWebSecurityConfigurerAdapter et appelez super.configure(http) dans la fonction configure(HttpSecurity http), comme indiqué 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 cet exemple :

@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’informations d’identification du client dans un serveur de ressources visitant des serveurs de ressources, procédez comme suit :

Ajoutez la propriété suivante dans 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, sur le modèle de 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 appRoles fonctionnalité de Microsoft Entra ID pour créer une revendication et implémenter le roles contrôle d’accès.

Remarque

La revendication roles générée à partir d’appRoles est décorée avec le préfixe APPROLE_.

Si vous utilisez appRoles comme revendication roles, ne configurez pas en même temps un attribut de groupe en tant que roles. 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 implémenter 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 Procédure : Ajouter des rôles d’application dans 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, sur le modèle de l’exemple suivant :

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

Dépannage

Activer la journalisation du client

Les Kits de développement logiciel (SDK) Azure pour Java offrent un article de journalisation cohérent pour vous aider à résoudre et résoudre les erreurs d’application. Les journaux générés capturent le flux d’une application avant le point terminal, facilitant ainsi la localisation de la cause racine d’une erreur. 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 de journalisation dans l’environnement Spring (par exemple, dans application.properties) en utilisant logging.level.<logger-name>=<level>, où « level » peut avoir l’une des valeurs suivantes : TRACE, DEBUG, INFO, WARN, ERROR, FATAL ou OFF. Vous pouvez configurer le journal racine avec logging.level.root.

L’exemple suivant montre des paramètres de journalisation possibles 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, poursuivez vers le centre de documentation Spring sur Azure.