0Pricing
Kotlin Academy · Lezione

Plugin di autenticazione: JWT e sessione

Metta in sicurezza le route Ktor usando bearer token JWT e autenticazione basata su sessione.

Plugin di autenticazione: JWT e sessione è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Panoramica dell'autenticazione Ktor

Il plugin Authentication di Ktor fornisce un'API unificata per proteggere le route. Configuri uno o più provider (JWT, Session, Basic, OAuth ecc.) e racchiuda quindi le route in un blocco authenticate("providerName") { }.

Aggiunta delle dipendenze per l'autenticazione

Aggiunga le librerie per l'autenticazione e JWT alla configurazione di 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")
}

Configurazione dell'autenticazione JWT

Installi il plugin Authentication e configuri un provider JWT. Il verifier convalida la firma del token; validate estrae il principal dal payload:

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
        }
    }
}

Protezione delle route con JWT

Racchiuda qualsiasi gruppo di route in authenticate("auth-jwt") { }. Le richieste non autenticate ricevono automaticamente una risposta 401:

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

Emissione di un token JWT

Generi e firmi un JWT nell'endpoint di login utilizzando la libreria 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))
}

Autenticazione tramite sessione

Le sessioni memorizzano lo stato dell'utente lato server (o lato client sotto forma di cookie firmati). Installi il plugin Sessions e definisca una classe per i dati della sessione:

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

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

Configurazione del provider di autenticazione tramite sessione

Crei un provider di autenticazione basato sulla sessione che legga la sessione e restituisca un principal:

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

Impostazione e cancellazione delle sessioni

Imposti una sessione dopo il login con call.sessions.set() e la cancelli al logout con 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 o sessione: quando usare ciascuno

JWT: stateless, indicato per le API utilizzate da client mobili o SPA. Il token contiene tutti i claim; il server non necessita di un session store. Sessioni: stateful, indicate per le applicazioni web renderizzate dal server. L'ID della sessione è contenuto in un cookie; il server conserva i dati (in memoria, Redis o un DB).

Combinazione di più provider di autenticazione

Può definire più provider e richiederne uno qualsiasi utilizzando authenticate("jwt", "session") { }. Ktor prova ciascun provider nell'ordine indicato e accetta la richiesta se uno di essi esegue correttamente la convalida.

Risposte di challenge personalizzate

Ogni provider dispone di un blocco challenge che definisce cosa fare quando l'autenticazione non riesce. Restituisca un 401 con un corpo JSON contenente l'errore invece dell'intestazione WWW-Authenticate predefinita:

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

Verifica rapida

Che cosa fa il blocco validate in un provider JWT di Ktor?

Riepilogo: plugin di autenticazione — JWT e sessione

Punti chiave:

  • Installi Authentication e configuri i provider (jwt, session, basic, oauth)
  • Protegga le route con authenticate("providerName") { }
  • JWT: token stateless; lo firmi al login, lo verifichi con verifier e legga i claim in validate
  • Sessioni: stateful; utilizzi call.sessions.set() al login e clear() al logout
  • Utilizzi challenge per personalizzare il formato della risposta 401

Domande Frequenti

La lezione «Plugin di autenticazione: JWT e sessione» è gratuita?

Sì — il testo completo di «Plugin di autenticazione: JWT e sessione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Plugin di autenticazione: JWT e sessione»?

Metta in sicurezza le route Ktor usando bearer token JWT e autenticazione basata su sessione. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Plugin di autenticazione: JWT e sessione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di un progetto Ktor: embeddedServer e moduli Application
  2. Routing e parametri tipizzati
  3. Content negotiation e kotlinx.serialization
  4. Plugin di autenticazione: JWT e sessione
← Torna a Kotlin Academy