0Pricing
Kotlin Academy · Lección

Plugins de autenticación: JWT y sesión

Proteja las rutas de Ktor mediante tokens bearer JWT y autenticación basada en sesiones.

Plugins de autenticación: JWT y sesión es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Descripción general de la autenticación de Ktor

El plugin Authentication de Ktor proporciona una API unificada para proteger rutas. Configure uno o varios proveedores (JWT, Session, Basic, OAuth, etc.) y, a continuación, incluya las rutas en un bloque authenticate("providerName") { }.

Añadir dependencias de autenticación

Añada las bibliotecas de autenticación y JWT a su compilación:

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

Configuración de la autenticación JWT

Instale el plugin Authentication y configure un proveedor JWT. verifier valida la firma del token; validate extrae el principal del 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
        }
    }
}

Protección de rutas con JWT

Encapsule cualquier grupo de rutas en authenticate("auth-jwt") { }. Las solicitudes no autenticadas reciben automáticamente un 401:

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

Emisión de un token JWT

Genere y firme un JWT en el endpoint de inicio de sesión usando la biblioteca 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))
}

Autenticación mediante sesiones

Las sesiones almacenan el estado del usuario en el servidor (o en el cliente como cookies firmadas). Instale el plugin Sessions y defina una clase de datos para la sesión:

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

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

Configuración del proveedor de autenticación de sesiones

Cree un proveedor de autenticación de sesiones que lea la sesión y devuelva un principal:

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

Establecimiento y eliminación de sesiones

Establezca una sesión después de iniciar sesión con call.sessions.set() y elimínela al cerrar sesión 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 frente a sesiones: cuándo usar cada uno

JWT: sin estado, adecuado para API consumidas por clientes móviles o SPA. El token contiene todas las claims; el servidor no necesita un almacén de sesiones. Sessions: con estado, adecuadas para aplicaciones web renderizadas en el servidor. El ID de sesión se almacena en una cookie; el servidor conserva los datos (en memoria, Redis o una base de datos).

Combinación de varios proveedores de autenticación

Puede definir varios proveedores y exigir cualquiera de ellos usando authenticate("jwt", "session") { }. Ktor prueba cada uno en orden y acepta la solicitud si alguno la valida correctamente.

Respuestas de desafío personalizadas

Cada proveedor tiene un bloque challenge que define qué hacer cuando falla la autenticación. Devuelva un 401 con un cuerpo de error JSON en lugar del encabezado WWW-Authenticate predeterminado:

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

Comprobación rápida

¿Qué hace el bloque validate en un proveedor JWT de Ktor?

Resumen: plugins de autenticación — JWT y Session

Puntos clave:

  • Instale Authentication y configure proveedores (jwt, session, basic, oauth)
  • Proteja las rutas con authenticate("providerName") { }
  • JWT: tokens sin estado; fírmelo al iniciar sesión, verifíquelo con verifier y lea las claims en validate
  • Sessions: con estado; use call.sessions.set() al iniciar sesión y clear() al cerrar sesión
  • Use challenge para personalizar el formato de la respuesta 401

Preguntas frecuentes

¿La lección «Plugins de autenticación: JWT y sesión» es gratis?

Sí — el texto completo de «Plugins de autenticación: JWT y sesión» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Plugins de autenticación: JWT y sesión»?

Proteja las rutas de Ktor mediante tokens bearer JWT y autenticación basada en sesiones. Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Plugins de autenticación: JWT y sesión»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Configuración de un proyecto Ktor: embeddedServer y módulos de aplicación
  2. Enrutamiento y parámetros tipados
  3. Negociación de contenido y kotlinx.serialization
  4. Plugins de autenticación: JWT y sesión
← Volver a Kotlin Academy