> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Ce guide de démarrage rapide montre comment ajouter l’authentification Auth0 à une application Java Servlet. Vous créerez une application Web sécurisée avec des fonctionnalités d’ouverture de session, de fermeture de session et de profil utilisateur à l’aide du SDK Auth0 Java MVC Commons.

# Ajouter l’ouverture de session à votre application Java Servlet

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

<HowToSchema />

<Note>
  **Prérequis :** Avant de commencer, assurez-vous d’avoir installé les éléments suivants :

  * **Java Development Kit (JDK)** : version 8 ou ultérieure
  * **Outil de build** : [Maven](https://maven.apache.org/download.cgi) 3.6+ ou [Gradle](https://gradle.org/install/) 6.0+
  * **Serveur d’applications** : [Apache Tomcat](https://tomcat.apache.org/download-90.cgi) 9.0+ ou tout conteneur de servlets
  * **Compte Auth0** : [Inscrivez-vous gratuitement](https://auth0.com/signup) si vous n'en avez pas
</Note>

<Accordion title="Utiliser l’IA pour intégrer Auth0" icon="microchip-ai" iconType="solid" defaultOpen>
  Si vous utilisez un assistant de programmation IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide des [agent skills](https://agentskills.io/home).

  **Installer :**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0-quickstart --skill auth0-java-mvc-common
  ```

  **Ensuite, demandez à votre assistant IA :**

  ```text theme={null}
  Add Auth0 authentication to my Java servlet app
  ```

  Votre assistant IA créera automatiquement votre application Auth0, récupérera les identifiants, ajoutera la dépendance au SDK Auth0 Java MVC Commons, configurera votre `web.xml` et mettra en place les flux de connexion et de déconnexion avec des filtres de servlet. [Documentation complète sur les agent skills →](/fr-CA/docs/quickstart/agent-skills)
</Accordion>

<div id="get-started">
  ## Pour commencer
</div>

Ce guide de démarrage rapide explique comment ajouter l’authentification Auth0 à une application Java Servlet. Vous créerez une application Web sécurisée avec des fonctionnalités de connexion, de déconnexion et de profil utilisateur à l’aide du SDK Auth0 Java MVC Commons.

<Steps>
  <Step title="Créer un nouveau projet Web en Java" stepNumber={1}>
    Créez un nouveau projet d’application web Java pour ce guide de démarrage rapide.

    <Tabs>
      <Tab title="Maven">
        ```bash theme={null}
        mvn archetype:generate \
          -DgroupId=com.auth0.example \
          -DartifactId=auth0-servlet-app \
          -DarchetypeArtifactId=maven-archetype-webapp \
          -DinteractiveMode=false
        ```

        Accédez au répertoire du projet :

        ```bash theme={null}
        cd auth0-servlet-app
        ```
      </Tab>

      <Tab title="Gradle">
        Créez un nouveau répertoire et initialisez un projet Gradle :

        ```bash theme={null}
        mkdir auth0-servlet-app && cd auth0-servlet-app
        gradle init --type java-application
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Installer le SDK Java MVC Commons d’Auth0" stepNumber={2}>
    Ajoutez la dépendance Auth0 au fichier de build de votre projet.

    <Tabs>
      <Tab title="Maven">
        Ajoutez la dépendance suivante à votre `pom.xml` :

        ```xml theme={null}
        <dependencies>
            <dependency>
                <groupId>com.auth0</groupId>
                <artifactId>mvc-auth-commons</artifactId>
                <version>1.11.1</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jstl</artifactId>
                <version>1.2</version>
            </dependency>
        </dependencies>
        ```
      </Tab>

      <Tab title="Gradle">
        Ajoutez les dépendances suivantes à votre `build.gradle` :

        ```gradle theme={null}
        plugins {
            id 'java'
            id 'war'
        }

        dependencies {
            implementation 'com.auth0:mvc-auth-commons:1.11.1'
            implementation 'javax.servlet:javax.servlet-api:3.1.0'
            implementation 'javax.servlet:jstl:1.2'
        }
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurez votre application Auth0" stepNumber={3}>
    Ensuite, vous devez créer une nouvelle application dans votre locataire Auth0 et ajouter la configuration à votre projet.

    1. Accédez à l’[Auth0 Dashboard](https://manage.auth0.com/dashboard)
    2. Cliquez sur **Applications** > **Applications** > **Create Application**
    3. Dans la fenêtre contextuelle, saisissez un nom pour votre application, sélectionnez **Regular Web Application** comme type d’application, puis cliquez sur **Create**
    4. Ouvrez l’onglet **Settings** sur la page des détails de l’application
    5. Notez les valeurs **Domaine**, **ID client** et **Secret client** dans le tableau de bord
    6. Enfin, dans l’onglet **Settings** de la page des détails de votre application, configurez les URL suivantes :

    **Allowed Callback URLs:**

    ```
    http://localhost:8080/callback
    ```

    **URL de déconnexion autorisées :**

    ```
    http://localhost:8080/login
    ```

    **Origines Web autorisées :**

    ```
    http://localhost:8080
    ```

    <Note>
      * **Allowed Callback URLs** constituent une mesure de sécurité essentielle pour garantir que les utilisateurs sont redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera et les utilisateurs verront une page d’erreur Auth0 au lieu d’accéder à votre application.
      * **Allowed Logout URLs** sont essentielles pour offrir une expérience utilisateur fluide lors de la déconnexion. Sans URL correspondante, les utilisateurs ne seront pas redirigés vers votre application après la déconnexion et resteront plutôt sur une page Auth0 générique.
      * **Allowed Web Origins** est essentiel à l’authentification silencieuse. Sans cela, les utilisateurs seront déconnectés lorsqu’ils actualiseront la page ou reviendront plus tard dans votre application.
    </Note>
  </Step>

  <Step title="Configurer le SDK Auth0" stepNumber={4}>
    Configurez votre application servlet pour utiliser le SDK Auth0 en définissant la configuration de `web.xml` avec les identifiants Auth0 générés ci-dessus.

    Créez ou mettez à jour `src/main/webapp/WEB-INF/web.xml`, puis remplacez les valeurs d’espace réservé par les paramètres réels de votre application Auth0 :

    ```xml expandable theme={null}
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
             http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">

        <display-name>Auth0 Servlet Example</display-name>

        <!-- Configuration Auth0 -->
        <context-param>
            <param-name>com.auth0.domain</param-name>
            <param-value>YOUR_AUTH0_DOMAIN</param-value>
        </context-param>
        <context-param>
            <param-name>com.auth0.clientId</param-name>
            <param-value>YOUR_AUTH0_CLIENT_ID</param-value>
        </context-param>
        <context-param>
            <param-name>com.auth0.clientSecret</param-name>
            <param-value>YOUR_AUTH0_CLIENT_SECRET</param-value>
        </context-param>
    </web-app>
    ```

    **Important** : Remplacez `YOUR_AUTH0_DOMAIN`, `YOUR_AUTH0_CLIENT_ID` et `YOUR_AUTH0_CLIENT_SECRET` par les valeurs réelles figurant dans les paramètres de votre application Auth0.
  </Step>

  <Step title="Créer des composants d’authentification et un filtre" stepNumber={5}>
    Créez les classes Java nécessaires pour gérer les flux d'authentification et protéger les pages sécurisées.

    <AuthCodeGroup>
      ```java src/main/java/com/auth0/example/AuthenticationControllerProvider.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;
      import com.auth0.jwk.JwkProvider;
      import com.auth0.jwk.JwkProviderBuilder;

      import javax.servlet.ServletConfig;
      import java.io.UnsupportedEncodingException;

      /**
       * Gère une instance singleton d'AuthenticationController pour l'application.
       */
      public class AuthenticationControllerProvider {

          private AuthenticationControllerProvider() {}

          private static AuthenticationController INSTANCE;

          public static synchronized AuthenticationController getInstance(ServletConfig config)
                  throws UnsupportedEncodingException {
              if (INSTANCE == null) {
                  String domain = config.getServletContext().getInitParameter("com.auth0.domain");
                  String clientId = config.getServletContext().getInitParameter("com.auth0.clientId");
                  String clientSecret = config.getServletContext().getInitParameter("com.auth0.clientSecret");

                  if (domain == null || clientId == null || clientSecret == null) {
                      throw new IllegalArgumentException(
                          "Missing domain, clientId, or clientSecret. Check your web.xml configuration.");
                  }

                  // JwkProvider requis pour les jetons RS256
                  JwkProvider jwkProvider = new JwkProviderBuilder(domain).build();
                  INSTANCE = AuthenticationController.newBuilder(domain, clientId, clientSecret)
                          .withJwkProvider(jwkProvider)
                          .build();
              }
              return INSTANCE;
          }
      }
      ```

      ```java src/main/java/com/auth0/example/LoginServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;

      import javax.servlet.ServletConfig;
      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;
      import java.io.UnsupportedEncodingException;

      @WebServlet(urlPatterns = {"/login"})
      public class LoginServlet extends HttpServlet {

          private AuthenticationController authenticationController;

          @Override
          public void init(ServletConfig config) throws ServletException {
              super.init(config);
              try {
                  authenticationController = AuthenticationControllerProvider.getInstance(config);
              } catch (UnsupportedEncodingException e) {
                  throw new ServletException("Couldn't create the AuthenticationController instance. Check the configuration.", e);
              }
          }

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {
              // Construire l'URL de rappel
              String redirectUri = req.getScheme() + "://" + req.getServerName();
              if ((req.getScheme().equals("http") && req.getServerPort() != 80) ||
                  (req.getScheme().equals("https") && req.getServerPort() != 443)) {
                  redirectUri += ":" + req.getServerPort();
              }
              redirectUri += "/callback";

              // Générer l'URL d'autorisation Auth0
              String authorizeUrl = authenticationController.buildAuthorizeUrl(req, res, redirectUri)
                      .build();
              res.sendRedirect(authorizeUrl);
          }
      }
      ```

      ```java src/main/java/com/auth0/example/CallbackServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.AuthenticationController;
      import com.auth0.IdentityVerificationException;
      import com.auth0.SessionUtils;
      import com.auth0.Tokens;

      import javax.servlet.ServletConfig;
      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;
      import java.io.UnsupportedEncodingException;

      @WebServlet(urlPatterns = {"/callback"})
      public class CallbackServlet extends HttpServlet {

          private AuthenticationController authenticationController;

          @Override
          public void init(ServletConfig config) throws ServletException {
              super.init(config);
              try {
                  authenticationController = AuthenticationControllerProvider.getInstance(config);
              } catch (UnsupportedEncodingException e) {
                  throw new ServletException("Couldn't create the AuthenticationController instance. Check the configuration.", e);
              }
          }

          @Override
          public void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws IOException, ServletException {
              handleCallback(req, res);
          }

          @Override
          public void doPost(HttpServletRequest req, HttpServletResponse res)
                  throws IOException, ServletException {
              handleCallback(req, res);
          }

          private void handleCallback(HttpServletRequest req, HttpServletResponse res)
                  throws IOException {
              try {
                  // Traiter le rappel d'authentification
                  Tokens tokens = authenticationController.handle(req, res);

                  // Stocker les jetons en session
                  SessionUtils.set(req, "accessToken", tokens.getAccessToken());
                  SessionUtils.set(req, "idToken", tokens.getIdToken());

                  // Rediriger vers la zone sécurisée
                  res.sendRedirect("/profile");
              } catch (IdentityVerificationException e) {
                  // Échec de l'authentification
                  e.printStackTrace();
                  res.sendRedirect("/login?error=auth_failed");
              }
          }
      }
      ```

      ```java src/main/java/com/auth0/example/ProfileServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebServlet(urlPatterns = {"/profile"})
      public class ProfileServlet extends HttpServlet {

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {

              String accessToken = (String) SessionUtils.get(req, "accessToken");
              String idToken = (String) SessionUtils.get(req, "idToken");

              if (accessToken == null && idToken == null) {
                  res.sendRedirect("/login");
                  return;
              }

              // Transférer au JSP de profil
              req.setAttribute("accessToken", accessToken);
              req.setAttribute("idToken", idToken);
              req.getRequestDispatcher("/WEB-INF/jsp/profile.jsp").forward(req, res);
          }
      }
      ```

      ```java src/main/java/com/auth0/example/LogoutServlet.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.ServletException;
      import javax.servlet.annotation.WebServlet;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebServlet(urlPatterns = {"/logout"})
      public class LogoutServlet extends HttpServlet {

          @Override
          protected void doGet(HttpServletRequest req, HttpServletResponse res)
                  throws ServletException, IOException {

              // Effacer la session
              SessionUtils.set(req, "accessToken", null);
              SessionUtils.set(req, "idToken", null);
              req.getSession().invalidate();

              // Rediriger vers la connexion

              res.sendRedirect("/login");
          }
      }
      ```

      ```java src/main/java/com/auth0/example/AuthenticationFilter.java expandable lines theme={null}
      package com.auth0.example;

      import com.auth0.SessionUtils;

      import javax.servlet.*;
      import javax.servlet.annotation.WebFilter;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      import java.io.IOException;

      @WebFilter(urlPatterns = {"/profile"})
      public class AuthenticationFilter implements Filter {

          @Override
          public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                  throws IOException, ServletException {

              HttpServletRequest req = (HttpServletRequest) request;
              HttpServletResponse res = (HttpServletResponse) response;

              String accessToken = (String) SessionUtils.get(req, "accessToken");
              String idToken = (String) SessionUtils.get(req, "idToken");

              if (accessToken == null && idToken == null) {
                  res.sendRedirect("/login");
                  return;
              }

              chain.doFilter(request, response);
          }

          @Override
          public void init(FilterConfig filterConfig) throws ServletException {
              // Initialiser le filtre
          }

          @Override
          public void destroy() {
              // Libérer les ressources
          }
      }
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Créer des pages d’interface utilisateur" stepNumber={6}>
    Créez les pages JSP et les fichiers HTML de votre application.

    <AuthCodeGroup>
      ```jsp src/main/webapp/WEB-INF/jsp/profile.jsp expandable lines theme={null}
      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
      <!DOCTYPE html>
      <html>
      <head>
          <title>Profil - Exemple Auth0</title>
          <style>
              body { font-family: Arial, sans-serif; margin: 40px; }
              .profile-container { max-width: 600px; margin: 0 auto; }
              .token-section { margin: 20px 0; padding: 15px; background-color: #f5f5f5; border-radius: 5px; }
              .logout-btn {
                  background-color: #dc3545;
                  color: white;
                  padding: 10px 20px;
                  text-decoration: none;
                  border-radius: 5px;
                  display: inline-block;
                  margin-top: 20px;
              }
              .logout-btn:hover { background-color: #c82333; }
              code { background-color: #e9ecef; padding: 2px 4px; border-radius: 3px; }
          </style>
      </head>
      <body>
          <div class="profile-container">
              <h1>Bienvenue sur votre profil&nbsp;!</h1>
              <p>Vous vous êtes authentifié avec succès avec Auth0.</p>

              <div class="token-section">
                  <h3>Jeton d’accès</h3>
                  <p><code>${accessToken}</code></p>
              </div>

              <div class="token-section">
                  <h3>ID Token</h3>
                  <p><code>${idToken}</code></p>
              </div>

              <a href="/logout" class="logout-btn">Se déconnecter</a>
          </div>
      </body>
      </html>
      ```

      ```html src/main/webapp/index.html expandable lines theme={null}
      <!DOCTYPE html>
      <html>
        <head>
          <title>Exemple de servlet Java Auth0</title>
          <style>
            body {
              font-family: Arial, sans-serif;
              margin: 0;
              padding: 40px;
              background-color: #f8f9fa;
            }
            .container {
              max-width: 600px;
              margin: 0 auto;
              text-align: center;
              background-color: white;
              padding: 40px;
              border-radius: 8px;
              box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
            }
            .login-btn {
              background-color: #007bff;
              color: white;
              padding: 12px 30px;
              text-decoration: none;
              border-radius: 5px;
              display: inline-block;
              font-size: 16px;
              margin-top: 20px;
              transition: background-color 0.3s;
            }
            .login-btn:hover {
              background-color: #0056b3;
            }
            h1 {
              color: #333;
            }
            p {
              color: #666;
              line-height: 1.6;
            }
          </style>
        </head>
        <body>
          <div class="container">
            <h1>Exemple de servlet Java Auth0</h1>
            <p>
              Cet exemple montre comment ajouter l’authentification à une application
              de servlet Java à l’aide du SDK Auth0 Java MVC Commons.
            </p>
            <p>
              Cliquez sur le bouton ci-dessous pour vous authentifier avec Auth0 et accéder à votre
              profil.
            </p>

            <a href="/login" class="login-btn">Se connecter avec Auth0</a>
          </div>
        </body>
      </html>
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Compiler et exécuter votre application" stepNumber={7}>
    Vous êtes maintenant prêt à compiler et à exécuter votre application.

    <Tabs>
      <Tab title="Maven">
        Compilez l’application :

        ```bash theme={null}
        mvn clean compile war:war
        ```

        Déployez l’application dans Tomcat :

        ```bash theme={null}
        # Copiez le fichier WAR dans le répertoire webapps de Tomcat
        cp target/auth0-servlet-app.war $CATALINA_HOME/webapps/ROOT.war
        ```
      </Tab>

      <Tab title="Gradle">
        Compilez l’application :

        ```bash theme={null}
        gradle clean build
        ```

        Déployez l’application dans Tomcat :

        ```bash theme={null}
        # Copiez le fichier WAR dans le répertoire webapps de Tomcat
        cp build/libs/auth0-servlet-app.war $CATALINA_HOME/webapps/
        ```
      </Tab>
    </Tabs>

    Démarrez Tomcat (ou le conteneur de servlets de votre choix) :

    ```bash theme={null}
    $CATALINA_HOME/bin/startup.sh  # Sur Unix/Linux/Mac
    # ou
    $CATALINA_HOME/bin/startup.bat  # Sur Windows
    ```
  </Step>
</Steps>

<Check>
  **Point de contrôle**

  Vous devriez maintenant avoir une application servlet entièrement fonctionnelle intégrée à Auth0, qui s’exécute à l’adresse [http://localhost:8080/](http://localhost:8080/)

  **Testez votre implémentation :**

  1. Accédez à l’URL de votre application
  2. Cliquez sur « Se connecter avec Auth0 »
  3. Terminez le processus de connexion à Auth0
  4. Vous devriez être redirigé vers votre page de profil affichant les jetons
  5. Cliquez sur « Logout » pour effacer la session
</Check>

***

<div id="advanced-usage">
  ## Utilisation avancée
</div>

<Accordion title="Améliorez votre application">
  Maintenant que l’authentification de base fonctionne, pensez aux améliorations suivantes :

  * **Informations sur le profil utilisateur** : Décodez le jeton d’identité pour afficher les informations de l’utilisateur
  * **Appels d’API** : Utilisez le jeton d’accès pour appeler la Management API d’Auth0 ou vos propres API
  * **Contrôle d’accès basé sur les rôles** : Implémentez l’autorisation à l’aide des rôles et des permissions d’Auth0
  * **Authentification unique (SSO)** : Configurez le SSO entre plusieurs applications
</Accordion>

<Accordion title="Ressources supplémentaires">
  * [Documentation d’Auth0 Java MVC Commons
    ](https://github.com/auth0/auth0-java-mvc-common) - [Auth0
    Dashboard](https://manage.auth0.com/) - Gérez vos applications Auth0 -
    [Dépôt d’exemples de servlets Auth0
    ](https://github.com/auth0-samples/auth0-servlet-sample) - Exemples complets -
    [Documentation du SDK Java Auth0
    ](https://auth0.com/docs/libraries/auth0-java) - Utilisation avancée du SDK
</Accordion>

<Accordion title="Dépannage">
  **Problèmes courants**

  **L’authentification échoue avec « URL de rappel invalide »**

  * Vérifiez que l’URL de rappel dans les paramètres de votre application Auth0 correspond exactement à : `http://localhost:8080/callback`

  **Erreur « Missing domain, clientId, or clientSecret »**

  * Vérifiez que votre configuration `web.xml` contient les bonnes valeurs de l’application Auth0
  * Assurez-vous que les noms de paramètres correspondent exactement : `com.auth0.domain`, `com.auth0.clientId`, `com.auth0.clientSecret`

  **L’application ne démarre pas**

  * Vérifiez que toutes les dépendances requises se trouvent dans votre classpath
  * Vérifiez que votre conteneur de servlets prend en charge Servlet API 3.0+
  * Consultez les journaux du serveur pour obtenir des messages d’erreur précis

  **La session n’est pas conservée**

  * Assurez-vous que votre conteneur de servlets est configuré pour la gestion des sessions
  * Vérifiez que les témoins sont activés dans votre navigateur
  * Vérifiez que HTTPS est utilisé dans les environnements de production

  Pour obtenir de l’aide supplémentaire, visitez la [communauté Auth0](https://community.auth0.com/).
</Accordion>