> ## 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 Quickstart montre 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.

# Ajouter la connexion à 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 codage IA comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification Auth0 en quelques minutes à l’aide d’[Agent Skills](https://agentskills.io/home).

  **Installer :**

  ```bash theme={null}
  npx skills add auth0/agent-skills --skill auth0
  ```

  **Demandez ensuite à 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 du 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 d’Agent Skills →](/docs/fr-ca/quickstart/agent-skills)
</Accordion>

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

Ce Quickstart montre comment ajouter l’authentification Auth0 à une application Java Servlet. Vous créerez une application web sécurisée offrant 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 projet Web Java" stepNumber={1}>
    Créez un nouveau projet d’application Web Java pour ce Quickstart.

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

        Allez dans le répertoire de votre 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="Installez le SDK Auth0 Java MVC Commons" stepNumber={2}>
    Ajoutez la dépendance Auth0 au fichier de compilation 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 tenant Auth0 et ajouter la configuration à votre projet.

    1. Accédez au [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** dans la page Application Details
    5. Prenez en note les valeurs **Domain**, **Client ID** et **Client Secret** dans le dashboard
    6. Enfin, dans l’onglet **Settings** de votre page Application Details, configurez les URL suivantes :

    **Allowed Callback URLs:**

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

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

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

    **Origines Web autorisées :**

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

    <Note>
      * Les **Allowed Callback URLs** constituent une mesure de sécurité essentielle pour garantir que les utilisateurs sont redirigés en toute sécurité 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.
      * Les **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 pour 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 l’Auth0 SDK en configurant `web.xml` avec les informations d’authentification Auth0 générées ci-dessus.

    Créez ou mettez à jour `src/main/webapp/WEB-INF/web.xml` et remplacez les valeurs de l’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 callback 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;
              }

              // Transmettre 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="Pages de l’interface utilisateur Create User" 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 auprès d’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">Logout</a>
          </div>
      </body>
      </html>
      ```

      ```html src/main/webapp/index.html expandable lines theme={null}
      <!DOCTYPE html>
      <html>
        <head>
          <title>Exemple Auth0 Java Servlet</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 Auth0 Java Servlet</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 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 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>
  **Vérification**

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

  **Testez votre mise en œuvre :**

  1. Accédez à l’URL de votre application
  2. Cliquez sur « connexion with Auth0 »
  3. Terminez le processus de connexion à Auth0
  4. Vous devriez être redirigé vers votre page de profil, où s’affichent les jetons
  5. Cliquez sur « déconnexion » 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 à ces améliorations :

  * **Renseignements du profil utilisateur** : décodez le ID token pour afficher les renseignements de l’utilisateur
  * **Appels d’API** : utilisez le jeton d’accès pour appeler la Management API d’Auth0 ou vos propres API
  * **Accès basé sur les rôles** : mettez en place l’autorisation à l’aide des rôles et des permissions d’Auth0
  * **Single Sign-On** : configurez le SSO pour plusieurs applications
</Accordion>

<Accordion title="Ressources supplémentaires">
  * [Documentation d’Auth0 Java MVC Commons](https://github.com/auth0/auth0-java-mvc-common) - [Dashboard Auth0](https://manage.auth0.com/) - Gérez vos applications Auth0 -
    [Dépôt de l’exemple de servlet
    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 « Invalid callback URL »**

  * Vérifiez que l’URL de callback 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 pour l’application Auth0
  * Assurez-vous que les noms des 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 l’API Servlet 3.0+
  * Consultez les logs 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 cookies sont activés dans votre navigateur
  * Vérifiez que HTTPS est utilisé dans les environnements de production

  Pour obtenir du soutien supplémentaire, consultez l’[Auth0 Community](https://community.auth0.com/).
</Accordion>