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

# Java Spring Boot

> Ajoutez la connexion Auth0 à une application Web Spring Boot à l’aide du Okta Spring Boot Starter.

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

  * JDK 17+ ([télécharger](https://adoptium.net/))
  * Maven 3.6+ ou Gradle 7+ ([Maven](https://maven.apache.org/download.cgi) | [Gradle](https://gradle.org/install/))
  * Un IDE (IntelliJ IDEA, Eclipse ou VS Code recommandés)

  **Compatibilité des versions de Java :** Spring Boot 3.x+ et le Okta Spring Boot Starter 3.x nécessitent Java 17 ou une version ultérieure.
</Note>

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

Ce Quickstart montre comment ajouter la connexion Auth0 à une application Web Spring Boot. Vous créerez une application Web sécurisée avec login, logout et une page de profil protégée à l’aide d’Okta Spring Boot Starter, qui configure automatiquement la prise en charge de OAuth2 login dans Spring Security.

<Steps>
  <Step title="Créer un nouveau projet" stepNumber={1}>
    Créez un projet Spring Boot avec les dépendances requises.

    <Tabs>
      <Tab title="Avec Spring Initializr">
        ```bash theme={null}
        curl -L https://start.spring.io/starter.zip \
            -d dependencies=web,security,thymeleaf \
            -d javaVersion=17 \
            -d name=auth0-webapp \
            -d artifactId=auth0-webapp \
            -d packageName=com.auth0.example \
            -o auth0-webapp.zip

        mkdir auth0-webapp && unzip auth0-webapp.zip -d auth0-webapp && cd auth0-webapp
        ```
      </Tab>

      <Tab title="Ou créez-le manuellement avec Maven">
        ```bash theme={null}
        mvn archetype:generate \
            -DgroupId=com.auth0 \
            -DartifactId=auth0-webapp \
            -DarchetypeArtifactId=maven-archetype-quickstart \
            -DinteractiveMode=false

        cd auth0-webapp
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Ajouter le module Okta Spring Boot Starter" stepNumber={2}>
    Ajoutez la dépendance Okta Spring Boot Starter à votre projet. Cette dépendance ajoute la prise en charge de l’authentification OAuth2 de Spring Security avec l’autoconfiguration propre à Auth0/Okta.

    <Tabs>
      <Tab title="Maven (pom.xml)">
        ```xml theme={null}
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity6</artifactId>
        </dependency>
        <dependency>
            <groupId>com.okta.spring</groupId>
            <artifactId>okta-spring-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>
        ```
      </Tab>

      <Tab title="Gradle (build.gradle)">
        ```gradle theme={null}
        dependencies {
            implementation 'org.springframework.boot:spring-boot-starter-security'
            implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
            implementation 'org.springframework.boot:spring-boot-starter-web'
            implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
            implementation 'com.okta.spring:okta-spring-boot-starter:3.1.0'
            testImplementation 'org.springframework.boot:spring-boot-starter-test'
            testImplementation 'org.springframework.security:spring-security-test'
            testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
        }
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurer Auth0" stepNumber={3}>
    Créez une Regular Web Application dans votre tenant Auth0 et ajoutez la configuration à votre projet.

    Vous pouvez choisir de configurer automatiquement votre application Auth0 en exécutant une commande CLI, ou de le faire manuellement par le biais du Dashboard :

    <Tabs>
      <Tab title="CLI">
        Exécutez la commande shell suivante à la racine de votre projet pour créer une application Auth0 et mettre à jour votre fichier `src/main/resources/application.yml` :

        <CodeGroup>
          ```shellscript Mac theme={null}
          # Installez Auth0 CLI (s’il n’est pas déjà installé)
          brew tap auth0/auth0-cli && brew install auth0

          # Configurez l’application Auth0 et générez application.yml
          auth0 qs setup --app --type regular --framework spring-boot --build-tool maven --port 3000 --name "My Spring Boot App"
          ```

          ```powershell Windows theme={null}
          # Installez Auth0 CLI (s’il n’est pas déjà installé)
          scoop bucket add auth0 https://github.com/auth0/scoop-auth0-cli.git
          scoop install auth0

          # Configurez l’application Auth0 et générez application.yml
          auth0 qs setup --app --type regular --framework spring-boot --build-tool maven --port 3000 --name "My Spring Boot App"
          ```
        </CodeGroup>

        <Note>
          Cette commande :

          1. Vérifie si vous êtes authentifié (et vous invite à vous connecter au besoin)
          2. Crée une Regular Web Application Auth0 configurée pour `http://localhost:3000`
          3. Génère `src/main/resources/application.yml` avec `okta.oauth2.issuer`, `okta.oauth2.client-id` et `okta.oauth2.client-secret`

          Les utilisateurs de Gradle doivent remplacer `--build-tool maven` par `--build-tool gradle`.
        </Note>
      </Tab>

      <Tab title="Dashboard">
        Avant de commencer, ajoutez la configuration d’Auth0 à votre fichier `src/main/resources/application.yml` :

        ```yaml src/main/resources/application.yml expandable theme={null}
        server:
          port: 3000

        okta:
          oauth2:
            issuer: "https://YOUR_AUTH0_DOMAIN/"
            client-id: "YOUR_CLIENT_ID"
            client-secret: "YOUR_CLIENT_SECRET"
        ```

        1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) → **Applications** → **Applications**.
        2. Sélectionnez **Create Application**.
        3. Entrez un nom (p. ex., "My Spring Boot Webapp") et sélectionnez **Regular Web Applications**.
        4. Sélectionnez **Create**.
        5. Accédez à l’onglet **Application Settings** et configurez :
           * **Allowed Callback URLs** : `http://localhost:3000/login/oauth2/code/okta`
           * **Allowed Logout URLs** : `http://localhost:3000/`
        6. Copiez le **Domain**, le **Client ID** et le **Client Secret** dans l’onglet **Application Settings**.
        7. Remplacez les valeurs de l’espace réservé dans `application.yml`.

        <Info>
          L’**URL de rappel** doit correspondre exactement. La connexion OAuth2 de Spring Security utilise le chemin `/login/oauth2/code/okta` par défaut.

          L’**Issuer** doit inclure `https://` et un `/` à la fin. Utilisez uniquement le domaine et la région. Par exemple : `https://dev-abc123.us.auth0.com/`.
        </Info>
      </Tab>
    </Tabs>
  </Step>

  <Step title="Configurer l’authentification" stepNumber={4}>
    Créez une configuration de sécurité qui active la connexion OAuth2 et gère la déconnexion d’Auth0. Les utilisateurs non authentifiés sont automatiquement redirigés vers la page de connexion Auth0.

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

    package com.auth0.example;

    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.web.SecurityFilterChain;
    import org.springframework.security.web.authentication.logout.LogoutHandler;
    import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

    import java.io.IOException;

    import static org.springframework.security.config.Customizer.withDefaults;

    @Configuration
    public class SecurityConfig {

        @Value("${okta.oauth2.issuer}")
        private String issuer;
        @Value("${okta.oauth2.client-id}")
        private String clientId;

        @Bean
        public SecurityFilterChain configure(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .requestMatchers("/", "/images/**").permitAll()
                    .anyRequest().authenticated()
                )
                .oauth2Login(withDefaults())
                .logout(logout -> logout
                    .addLogoutHandler(logoutHandler()));
            return http.build();
        }

        private LogoutHandler logoutHandler() {
            return (request, response, authentication) -> {
                try {
                    String baseUrl = ServletUriComponentsBuilder.fromCurrentContextPath().build().toUriString();
                    response.sendRedirect(issuer + "v2/logout?client_id=" + clientId + "&returnTo=" + baseUrl);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            };
        }
    }
    ```
  </Step>

  <Step title="Créer des contrôleurs et des vues" stepNumber={5}>
    Créez les contrôleurs et les modèles Thymeleaf pour les pages d’accueil et de profil.

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

      import org.springframework.security.core.annotation.AuthenticationPrincipal;
      import org.springframework.security.oauth2.core.oidc.user.OidcUser;
      import org.springframework.stereotype.Controller;
      import org.springframework.ui.Model;
      import org.springframework.web.bind.annotation.GetMapping;

      @Controller
      public class HomeController {

          @GetMapping("/")
          public String home(Model model, @AuthenticationPrincipal OidcUser principal) {
              if (principal != null) {
                  model.addAttribute("profile", principal.getClaims());
              }
              return "index";
          }
      }
      ```

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

      import com.fasterxml.jackson.core.JsonProcessingException;
      import com.fasterxml.jackson.databind.ObjectMapper;
      import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
      import org.springframework.security.core.annotation.AuthenticationPrincipal;
      import org.springframework.security.oauth2.core.oidc.user.OidcUser;
      import org.springframework.stereotype.Controller;
      import org.springframework.ui.Model;
      import org.springframework.web.bind.annotation.GetMapping;

      import java.util.Map;

      @Controller
      public class ProfileController {

          private final static ObjectMapper mapper = new ObjectMapper().registerModule(new JavaTimeModule());

          @GetMapping("/profile")
          public String profile(Model model, @AuthenticationPrincipal OidcUser oidcUser) {
              model.addAttribute("profile", oidcUser.getClaims());
              model.addAttribute("profileJson", claimsToJson(oidcUser.getClaims()));
              return "profile";
          }

          private String claimsToJson(Map<String, Object> claims) {
              try {
                  return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(claims);
              } catch (JsonProcessingException jpe) {
                  return "Erreur lors de l’analyse des claims en JSON.";
              }
          }
      }
      ```

      ```html src/main/resources/templates/index.html expandable lines theme={null}
      <!DOCTYPE html>
      <html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
      <head>
          <meta charset="UTF-8">
          <title>Connexion Auth0 avec Spring Boot</title>
      </head>
      <body>
          <h1>Exemple de connexion Auth0 avec Spring Boot</h1>

          <div sec:authorize="!isAuthenticated()">
              <p>Vous n’êtes pas connecté.</p>
              <a href="/oauth2/authorization/okta">Se connecter</a>
          </div>

          <div sec:authorize="isAuthenticated()">
              <p>Bienvenue, <span sec:authentication="name">User</span>!</p>
              <ul>
                  <li><a href="/profile">Voir le profil</a></li>
                  <li>
                      <form th:action="@{/logout}" method="post" style="display:inline;">
                          <button type="submit">Se déconnecter</button>
                      </form>
                  </li>
              </ul>
          </div>
      </body>
      </html>
      ```

      ```html src/main/resources/templates/profile.html expandable lines theme={null}
      <!DOCTYPE html>
      <html lang="en" xmlns:th="http://www.thymeleaf.org">
      <head>
          <meta charset="UTF-8">
          <title>Profil utilisateur</title>
      </head>
      <body>
          <h1>Profil utilisateur</h1>
          <a href="/">Accueil</a>

          <div th:if="${profile}">
              <img th:if="${profile['picture']}" th:src="${profile['picture']}" width="64" height="64" alt="Photo de profil" />
              <h2 th:text="${profile['name']}">Nom</h2>
              <p th:text="${profile['email']}">Courriel</p>
          </div>

          <h3>Tous les claims</h3>
          <pre th:text="${profileJson}">JSON des claims</pre>

          <form th:action="@{/logout}" method="post">
              <button type="submit">Se déconnecter</button>
          </form>
      </body>
      </html>
      ```
    </AuthCodeGroup>
  </Step>

  <Step title="Exécutez votre application" stepNumber={6}>
    Lancez l’application à l’aide du wrapper Maven ou Gradle.

    <Tabs>
      <Tab title="Maven">
        ```bash theme={null}
        ./mvnw spring-boot:run
        ```
      </Tab>

      <Tab title="Gradle">
        ```bash theme={null}
        ./gradlew bootRun
        ```
      </Tab>
    </Tabs>

    Votre application est maintenant accessible à l’adresse `http://localhost:3000`. Accédez à `http://localhost:3000/profile` pour lancer le flux de connexion Auth0.
  </Step>
</Steps>

<Check>
  Vous devriez maintenant avoir une application Web Spring Boot entièrement fonctionnelle avec la connexion Auth0 sur votre [localhost](http://localhost:3000/). La page d’accueil est publique, et si vous accédez à `/profile`, les utilisateurs non authentifiés sont redirigés vers la page de connexion Auth0.
</Check>

***

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

<Accordion title="Accéder aux claims du profil utilisateur">
  Le paramètre `@AuthenticationPrincipal OidcUser` vous donne accès à tous les claims de l’ID token. Utilisez `getClaims()` pour récupérer l’ensemble complet des claims, ou des méthodes getter individuelles pour des claims précis.

  ```java theme={null}
  @GetMapping("/profile")
  public String profile(Model model, @AuthenticationPrincipal OidcUser oidcUser) {
      model.addAttribute("name", oidcUser.getFullName());
      model.addAttribute("email", oidcUser.getEmail());
      model.addAttribute("picture", oidcUser.getPicture());
      model.addAttribute("sub", oidcUser.getSubject());
      model.addAttribute("allClaims", oidcUser.getClaims());
      return "profile";
  }
  ```
</Accordion>

<Accordion title="Contrôle d’accès basé sur les rôles">
  Vous pouvez restreindre l’accès aux pages en fonction des rôles Auth0. Commencez par ajouter les rôles à l’ID token à l’aide d’une Action Auth0, puis utilisez `hasAuthority()` dans votre configuration de sécurité.

  ### Ajouter des rôles aux jetons

  1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) → **Actions** → **Flows** → **Login**.
  2. Créez une Action personnalisée qui ajoute les rôles sous forme de custom claim à l’ID token :

  ```javascript theme={null}
  exports.onExecutePostLogin = async (event, api) => {
    const namespace = "https://my-app.example.com";
    if (event.authorization) {
      api.idToken.setCustomClaim(`${namespace}/roles`, event.authorization.roles);
    }
  };
  ```

  ### Configurer l’autorisation

  Mettez à jour votre `SecurityConfig` pour exiger des rôles précis sur les endpoints :

  ```java expandable theme={null}
  @Bean
  public SecurityFilterChain configure(HttpSecurity http) throws Exception {
      http
          .authorizeHttpRequests(authorize -> authorize
              .requestMatchers("/", "/images/**").permitAll()
              .requestMatchers("/admin/**").hasAuthority("ROLE_admin")
              .anyRequest().authenticated()
          )
          .oauth2Login(withDefaults())
          .logout(logout -> logout
              .addLogoutHandler(logoutHandler()));
      return http.build();
  }
  ```
</Accordion>

<Accordion title="Mappage personnalisé des autorités">
  Le starter Okta prend en charge le mappage personnalisé des autorités au moyen de l’interface `AuthoritiesProvider`. Enregistrez un bean pour ajouter des objets `GrantedAuthority` personnalisés en fonction des attributs de l’utilisateur ou de sources de données externes.

  ```java expandable theme={null}
  package com.auth0.example;

  import com.okta.spring.boot.oauth.AuthoritiesProvider;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.core.GrantedAuthority;
  import org.springframework.security.core.authority.SimpleGrantedAuthority;

  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;

  @Configuration
  public class AuthoritiesConfig {

      @Bean
      AuthoritiesProvider customAuthoritiesProvider() {
          return (user, userRequest) -> {
              Set<GrantedAuthority> authorities = new HashSet<>();

              // Mapper le claim personnalisé des rôles vers les autorités Spring Security
              Object roles = user.getAttribute("https://my-app.example.com/roles");
              if (roles instanceof List<?> roleList) {
                  roleList.forEach(role ->
                      authorities.add(new SimpleGrantedAuthority("ROLE_" + role))
                  );
              }

              return authorities;
          };
      }
  }
  ```
</Accordion>

***

<div id="common-issues">
  ## Problèmes courants
</div>

<AccordionGroup>
  <Accordion title="Échec de la redirection vers la page de connexion - URL de rappel invalide">
    Après avoir sélectionné login, Auth0 affiche une erreur indiquant que l’URL de rappel ne correspond pas.

    Les **Allowed Callback URLs** de votre application Auth0 doivent correspondre exactement à l’URL de rappel utilisée par Spring Security. La valeur par défaut est `http://localhost:3000/login/oauth2/code/okta`.

    1. Accédez à [Auth0 Dashboard](https://manage.auth0.com) → **Applications** → Votre application → **Settings**.
    2. Sous **Allowed Callback URLs**, ajoutez : `http://localhost:3000/login/oauth2/code/okta`.
    3. Sélectionnez **Save Changes**.
  </Accordion>

  <Accordion title="Issuer invalide au démarrage">
    L’application ne démarre pas, ou login échoue en raison d’une incompatibilité de l’issuer.

    Le `okta.oauth2.issuer` doit être l’URL complète du tenant Auth0, y compris `https://` et un `/` à la fin.

    ```yaml theme={null}
    # ❌ INCORRECT - https:// ou la barre oblique finale est manquant
    okta:
      oauth2:
        issuer: "dev-abc123.us.auth0.com"

    # ✅ CORRECT - URL complète avec barre oblique finale
    okta:
      oauth2:
        issuer: "https://dev-abc123.us.auth0.com/"
    ```
  </Accordion>

  <Accordion title="Échec de la découverte OIDC au démarrage">
    L’application ne démarre pas en raison d’une erreur de connexion lors de la récupération de `/.well-known/openid-configuration`.

    Le Okta Spring Boot Starter récupère le document de découverte OpenID Connect à partir de votre issuer URL au démarrage. Vérifiez que l’issuer URL est correcte et accessible depuis votre réseau. Si vous êtes derrière un firewall d’entreprise, configurez le proxy :

    ```yaml theme={null}
    okta:
      oauth2:
        issuer: "https://dev-abc123.us.auth0.com/"
        proxy:
          host: "proxy.example.com"
          port: 8080
    ```
  </Accordion>

  <Accordion title="Valeurs de configuration introuvables">
    L’application démarre, mais login échoue parce que les propriétés de configuration ne sont pas lues.

    Assurez-vous que votre `application.yml` utilise la bonne indentation YAML sous l’espace de noms `okta.oauth2` :

    ```yaml theme={null}
    # ❌ INCORRECT - structure plate, non imbriquée
    okta.oauth2.issuer: "https://dev-abc123.us.auth0.com/"

    # ✅ CORRECT - YAML correctement imbriqué
    okta:
      oauth2:
        issuer: "https://dev-abc123.us.auth0.com/"
        client-id: "YOUR_CLIENT_ID"
        client-secret: "YOUR_CLIENT_SECRET"
    ```
  </Accordion>

  <Accordion title="Logout n’efface pas la session Auth0">
    Après avoir sélectionné logout, l’utilisateur est immédiatement reconnecté sans voir la page de connexion Auth0.

    Assurez-vous que votre `SecurityConfig` inclut le `LogoutHandler` personnalisé qui redirige vers le endpoint Auth0 `/v2/logout`. Vérifiez aussi que les **Allowed Logout URLs** dans les paramètres de votre application Auth0 incluent `http://localhost:3000/`.
  </Accordion>
</AccordionGroup>

***

<div id="additional-resources">
  ## Ressources supplémentaires
</div>

<CardGroup cols={3}>
  <Card title="Documentation du SDK" icon="book" href="https://github.com/okta/okta-spring-boot">
    Documentation complète du SDK, code source et notes de version
  </Card>

  <Card title="Documentation Auth0" icon="file-lines" href="https://auth0.com/docs">
    Documentation officielle d’Auth0 pour les applications Spring Boot
  </Card>

  <Card title="Référence de Spring Security" icon="shield" href="https://docs.spring.io/spring-security/reference/servlet/oauth2/login.html">
    Documentation sur OAuth2 login de Spring Security
  </Card>

  <Card title="Référence de configuration" icon="gear" href="https://github.com/okta/okta-spring-boot#configuration-reference">
    Toutes les propriétés de configuration okta.oauth2.\* offertes
  </Card>

  <Card title="Auth0 Dashboard" icon="browser" href="https://manage.auth0.com/">
    Gérez vos API et vos applications Auth0
  </Card>

  <Card title="Forum de la communauté" icon="comments" href="https://community.auth0.com/">
    Obtenez de l’aide auprès de la communauté Auth0
  </Card>
</CardGroup>

***

<div id="sample-application">
  ## Application d’exemple
</div>

Une application d’exemple complète qui montre le login, l’affichage du profil et le logout avec Auth0 est disponible dans le dépôt d’exemples Auth0.

<Card title="Exemple MVC de login" icon="github" href="https://github.com/auth0-samples/auth0-spring-boot-login-samples/tree/master/mvc-login">
  Comprend le login, le logout et une page de profil avec l’intégration OAuth2 d’Auth0
</Card>

Clonez et exécutez :

```bash theme={null}
git clone https://github.com/auth0-samples/auth0-spring-boot-login-samples.git
cd auth0-spring-boot-login-samples/mvc-login

# Mettez à jour src/main/resources/application.yml avec votre configuration Auth0
# Puis exécutez :
./gradlew bootRun
```

Ouvrez `http://localhost:3000` dans votre navigateur et sélectionnez le lien **Login** pour tester le processus de connexion avec Auth0.