Estrategia y Guardia de Autenticación con JWT en NestJS

Curso de NestJS: Autenticación con Passport y JWT

Contenido del curso

Introducción

Protección con guardianes

Autenticación con Passport

Autenticación con JSON Web Tokens

Deployment

Próximos pasos

22
Implementación de Autenticación y Autorización en NestJS
00:41 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:38

Estrategia y Guardia de Autenticación con JWT en NestJS

Curso de NestJS: Autenticación con Passport y JWT

Clase 13 de 22

Clase 13 / 22

Recursos

¿Cómo asegurar la comunicación entre APIs utilizando tokens de acceso?

Los tokens de acceso son una pieza clave para mantener la seguridad en la comunicación entre APIs y clientes. En este contexto, una de las técnicas utilizadas es la implementación de estrategias de autenticación basadas en JWT (JSON Web Token), permitiendo validar la identidad y los permisos de los usuarios.

¿Cómo crear una estrategia para validar JWT?

Para garantizar que cada request a nuestra API esté debidamente autentificado, creamos una strategy que se encargue de validar el JWT. Esta se asegurará de que el token no haya expirado y sea válido, utilizando la siguiente estructura:

Creación de la estrategia: Utilizamos una JWT strategy que verificará la integridad del token. Esto involucra configurar parámetros como desde dónde se tomará el token (habitualmente desde el header) y asegurarse de que el token sea un Bearer token.

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: configService.get<string>('JWT_SECRET'),
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, role: payload.role };
  }
}

Configurar el guardián: Al crear un guardián (guard), podemos proteger ciertos endpoints exigendo la presencia de un token válido. Esto asegura que solo requests autorizados accedan a los datos o servicios:
```
import { JwtAuthGuard } from 'src/auth/jwt-auth.guard';

@UseGuards(JwtAuthGuard)
@Get('protected')
getProtectedData() {
  return this.productService.getAll();
}
```

¿Cómo implementar la validación de tokens en los endpoints?

Una vez implementada la strategy, es inmediata la aplicación sobre los endpoints que requerimos proteger:

Proteger rutas específicas: Al estar una ruta protegida, requiere que el request venga acompañado de un token válido. Los clientes de la API deben asegurarse de enviar este token en cada solicitud.
Validar tokens en cada solicitud: Es fundamental que cada endpoint verifique el token, lo cual asegura que el acceso sea controlado y se restrinja solo a usuarios autorizados, limitando brechas de seguridad.

¿Qué ventajas ofrece la tokenización de requests en APIs?

El uso de tokens no solo eleva el nivel de seguridad, sino que también ofrece otras ventajas prácticas:

Autenticación centralizada: Facilita la gestión de roles y permisos desde un único punto, favoreciendo la escalabilidad.
Integración sencilla con múltiples plataformas: Clientes web, móviles, o incluso dispositivos IoT pueden incorporar fácilmente el token, garantizando autenticidad desde diversos entornos.
Control granular de acceso: Permite definir con precisión qué acciones puede llevar a cabo un usuario, mejorando la gestión de recursos y privilegios.

Adoptar estos mecanismos no solo robustece la seguridad de nuestras aplicaciones, sino que también mejora la confiabilidad del sistema, proporcionando un entorno seguro y eficiente para los usuarios. Este camino fomenta el aprendizaje continuo, instando a desarrolladores a explorar más a fondo las herramientas a su disposición para construir aplicaciones seguras y escalables.

Rony Porraz Vargas

Hace 5 años

SE TE COMPLICO?

DEJA TE HECHO UNA MANITA

1.- Primero creamos el archivo jwt.strategy.ts en el cual agregaremos lo siguiente

import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';
import { jwtConstants } from './constants';
import { TokenPayloadModel } from './models/token.model';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
    constructor() {
        super({
            jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
	    // OBTENDREMOS EL TOKEN LOS HEADERS COMO 'Bearer token'
            ignoreExpiration: false,
	    // IGNORA LA EXPIRACION, EN TU CASO EL TIEMPO QUE LE HAYAS PUESTO
	   // EJE.  signOptions: { expiresIn: '24h' }, YO LE PUSE 1 DIA 
            secretOrKey: jwtConstants.secret,
	    // LA LLAVE SECRETA CON LA QUE FIRMAMOS EL TOKEN AL HACER LOGIN
        });
    }
   
   // ESTA FUNCION LO QUE HARA SERA RECIBIR EL TOKEN DECODIFICADO 
   // CON LA CARGA DE DATOS QUE LE PUSIMOS AL HACER LOGIN
    async validate( payload: TokenPayloadModel ) {
        
        return payload;

    }
}

LA FUNCION VALIDATE ES IMPORTANTE YA QUE SI EL TOKEN ES VALIDO POR NUESTRO SERVIDOR, ESTE RETURN DE LA FUNCION MISMA DEVOLVERA EL PAYLOAD AL REQUEST DE NUESTRA RUTA A LA QUE VAYAMOS A PROTEGER, ESTO TE PUEDE SERVIR PARA A BUSCAR EN TU BD AL USUARIO O ALGUN PROCESO QUE REQUIERAS

2.- Lo siguiente es importar nuestra estrategia en nuestro modulo de autenticación en los providers

"auth.module.ts"

import { JwtStrategy } from './jwt.strategy';

@Module({
    imports: [
        ...Tus imports
    ],
    controllers: [Tus Controllers...],
    providers: [Tus demas providers..., JwtStrategy]
})
export class AuthModule {}

3.- Ya casi acabamos!, solo falta crear el guardián que protegerá nuestrs rutas, creamos un archivo llamado "jwt.auth.guard.ts" dentro de nuestor modulo de autenticacion

import { HttpException, HttpStatus, Injectable, UnauthorizedException } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
    
    // CON ESTA FUNCION DE PODEMOS PERSONALIZAR SI  
    //  QUEREMOS LANZAR ERRORES PERZONALIZADOS 
    handleRequest(err, user, info) {
        if (err || !user) {
            
            throw new HttpException({
                status: HttpStatus.UNAUTHORIZED,
                error: 'Usuario no autorizado',
            }, HttpStatus.UNAUTHORIZED);

        }
        
        return user;

    }

}

4.- Por ultimo solo importamos nuestro guardián en nuestro controlador que queramos proteger

Yo usare mi controlador llamado Pages

y listo, nuestra ruta quedo protegida, para acceder a ella abría que enviar por los headers nuestro token

import { AuthGuard } from '@nestjs/passport';
import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';

@ApiTags('pages')
@UseGuards(JwtAuthGuard) // colocamos nuestro guardián
@Controller('pages')
export class PagesController {
  constructor(private pageService: PageService) { }

  )
  @Get()
  getPages() {
   
    return this.pageService.getAllPages();

  }
 
}

Christian Guevara

Hace 4 años

Muy buena explicación y tips para controlar excepciones personalizadas.

Catalano Nicolas

Hace 3 años

Buenisimo, gracias por la explicación!

Introducción

Autenticación de Usuarios en APIs con Nest.js y JWT

Configuración de Autenticación en Proyectos Mongo y TimeORM

Implementación de Autentificación y Autorización en API Node.js

Protección con guardianes

Creación y Uso de Guardianes en NestJS para Autorización de Endpoints

Decoradores para Control de Acceso en Controladores NETJS

Gestión de Variables de Entorno en Aplicaciones Node.js

Autenticación con Passport

Hashing de Contraseñas en Bases de Datos con Node.js

Implementación de Hashing en Proyecto Mongo con Node.js

Autenticación con Passport.js en Nest.js: Estrategias Locales

Implementación de Controlador de Login con NestJS y Estrategia Local

Autenticación con JSON Web Tokens

Implementación de JSON Web Tokens en APIs para Autenticación Segura

Implementación de JWT en Módulo de Autenticación con Variables de Entorno

Estrategia y Guardia de Autenticación con JWT en NestJS

Extensión de Guardianes JWT en NestJS para Endpoints Públicos

Control de Roles y Permisos con JSON Web Tokens en TypeScript

Creación de Endpoints Seguros con JWT en NestJS

Deployment

Configuración y Despliegue de MongoDB Atlas en Heroku

Configuración de Variables de Entorno en Heroku para MongoDB

Configuración de PostgreSQL en Heroku para Node.js

Configuración de Conexiones a Base de Datos en Heroku y Entorno Local

Migraciones con TimeORM en Producción: Configuración y Ejecución

Próximos pasos

Implementación de Autenticación y Autorización en NestJS

Estrategia y Guardia de Autenticación con JWT en NestJS

Progreso del curso

Introducción

Protección con guardianes

Autenticación con Passport

Autenticación con JSON Web Tokens

Deployment

Próximos pasos

Recursos

Recursos