0Pricing
Kotlin Academy · Leçon

Modules d’authentification : JWT et session

Sécurisez les routes Ktor avec des jetons porteurs JWT et une authentification fondée sur les sessions.

Modules d’authentification : JWT et session est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Présentation de l’authentification Ktor

Le module Authentication de Ktor fournit une API unifiée pour protéger les routes. Vous configurez un ou plusieurs fournisseurs (JWT, session, authentification basique, OAuth, etc.), puis vous placez les routes dans un bloc authenticate("providerName") { }.

Ajout des dépendances d’authentification

Ajoutez les bibliothèques d’authentification et JWT à votre build :

dependencies {
    implementation("io.ktor:ktor-server-auth:2.3.12")
    implementation("io.ktor:ktor-server-auth-jwt:2.3.12")
    implementation("io.ktor:ktor-server-sessions:2.3.12")
}

Configuration de l’authentification JWT

Installez le module Authentication et configurez un fournisseur JWT. Le verifier valide la signature du jeton, tandis que validate extrait le principal de la charge utile :

install(Authentication) {
    jwt("auth-jwt") {
        realm = "ktor app"
        verifier(
            JWT.require(Algorithm.HMAC256(secret))
                .withAudience(audience)
                .withIssuer(issuer)
                .build()
        )
        validate { credential ->
            if (credential.payload.getClaim("username").asString() != null)
                JWTPrincipal(credential.payload)
            else null
        }
    }
}

Protection des routes avec JWT

Placez n’importe quel groupe de routes dans authenticate("auth-jwt") { }. Les requêtes non authentifiées reçoivent automatiquement une réponse 401 :

routing {
    authenticate("auth-jwt") {
        get("/protected") {
            val principal = call.principal<JWTPrincipal>()!!
            val username = principal.payload.getClaim("username").asString()
            call.respondText("Hello, $username")
        }
    }
}

Émission d’un jeton JWT

Générez et signez un JWT sur le point de terminaison de connexion à l’aide de la bibliothèque java-jwt :

post("/login") {
    val user = call.receive<LoginRequest>()
    // validate credentials ...
    val token = JWT.create()
        .withAudience(audience)
        .withIssuer(issuer)
        .withClaim("username", user.username)
        .withExpiresAt(Date(System.currentTimeMillis() + 3_600_000))
        .sign(Algorithm.HMAC256(secret))
    call.respond(mapOf("token" to token))
}

Authentification par session

Les sessions stockent l’état de l’utilisateur côté serveur (ou côté client sous forme de cookies signés). Installez le module Sessions et définissez une classe de données de session :

data class UserSession(val userId: Long, val username: String)

install(Sessions) {
    cookie<UserSession>("user_session") {
        cookie.path = "/"
        cookie.httpOnly = true
    }
}

Configuration du fournisseur d’authentification par session

Créez un fournisseur d’authentification par session qui lit la session et renvoie un principal :

install(Authentication) {
    session<UserSession>("auth-session") {
        validate { session -> session }
        challenge { call.respond(HttpStatusCode.Unauthorized) }
    }
}

Définition et suppression des sessions

Définissez une session après la connexion avec call.sessions.set() et supprimez-la lors de la déconnexion avec call.sessions.clear() :

post("/login") {
    val creds = call.receive<LoginRequest>()
    // validate ...
    call.sessions.set(UserSession(userId = 1L, username = creds.username))
    call.respond(HttpStatusCode.OK)
}

post("/logout") {
    call.sessions.clear<UserSession>()
    call.respond(HttpStatusCode.OK)
}

JWT ou session : quand utiliser chacun

JWT : sans état, adapté aux API consommées par des clients mobiles ou des clients SPA. Le jeton contient toutes les revendications ; le serveur n’a pas besoin de stocker les sessions. Sessions : avec état, adaptées aux applications web dont les pages sont rendues côté serveur. L’identifiant de session se trouve dans un cookie ; le serveur conserve les données (en mémoire, dans Redis ou dans une base de données).

Combinaison de plusieurs fournisseurs d’authentification

Vous pouvez définir plusieurs fournisseurs et exiger n’importe lequel d’entre eux avec authenticate("jwt", "session") { }. Ktor essaie chaque fournisseur dans l’ordre et accepte la requête si l’un d’eux la valide avec succès.

Réponses de défi personnalisées

Chaque fournisseur possède un bloc challenge qui définit le comportement à adopter lorsque l’authentification échoue. Renvoyez une réponse 401 contenant un corps d’erreur JSON au lieu de l’en-tête WWW-Authenticate par défaut :

jwt("auth-jwt") {
    // ...
    challenge { _, _ ->
        call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Token expired or invalid"))
    }
}

Vérification rapide

Que fait le bloc validate d’un fournisseur JWT Ktor ?

Récapitulatif : modules d’authentification — JWT et session

Points essentiels :

  • Installez Authentication et configurez les fournisseurs (JWT, session, authentification basique, OAuth)
  • Protégez les routes avec authenticate("providerName") { }
  • JWT : jetons sans état ; signez-les lors de la connexion, vérifiez-les avec verifier et lisez les revendications dans validate
  • Sessions : avec état ; utilisez call.sessions.set() lors de la connexion et clear() lors de la déconnexion
  • Utilisez challenge pour personnaliser le format de la réponse 401

Questions Fréquemment Posées

La leçon « Modules d’authentification : JWT et session » est-elle gratuite ?

Oui — le texte complet de « Modules d’authentification : JWT et session » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modules d’authentification : JWT et session » ?

Sécurisez les routes Ktor avec des jetons porteurs JWT et une authentification fondée sur les sessions. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Modules d’authentification : JWT et session » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Configuration d’un projet Ktor : embeddedServer et modules d’application
  2. Routage et paramètres typés
  3. Négociation de contenu et kotlinx.serialization
  4. Modules d’authentification : JWT et session
← Retour à Kotlin Academy