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

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:0012:39

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

Curso de NestJS: Autenticación con Passport y JWT

Clase 14 de 22

Clase 14 / 22

Recursos

¿Cómo proteger los endpoints de un controlador con un JSON Web Token?

Proteger los endpoints de un controlador mediante un JSON Web Token (JWT) es una práctica esencial para garantizar la seguridad de una aplicación eCommerce o cualquier API. Los procesos de obtener, crear, actualizar y eliminar productos deben estar resguardados bajo un sistema de autorización que verifique la autenticidad y permisos del usuario.

NestJS facilita este proceso con la ayuda del paquete "passport" que permite implementar estrategias de autenticación, como JWT. Sin embargo, pese a que la mayoría de los endpoints deben estar protegidos, hay ocasiones, como en el caso del endpoint para obtener productos, que necesitamos que sea accesible públicamente.

Configuración de un guardián personalizado

Para implementar esta funcionalidad, creamos un guardián (también conocido como "guard") a través de NestJS que verifica JWT. Aquí explicamos cómo personalizarlo:

Creación del guardián: Iniciar con el siguiente comando en la terminal del proyecto NestJS:
```
nest generate guard auth/jwt-auth
```
Esto generará un archivo base para nuestro nuevo guardián.

Extender las funcionalidades de JWT: En lugar de reescribir la función canActivate, podemos expandirla.

import { Injectable, ExecutionContext } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  canActivate(context: ExecutionContext) {
    return super.canActivate(context);  // Mantiene la funcionalidad original
  }
}

Sin embargo, necesitamos verificar si el acceso debe ser público.

Lectura de metadata: Utilizamos el decorador @Public() para aquellos endpoints que deben ser accesibles sin autenticación.

// Incorporando Reflector para manejar metadata
import { Reflector } from '@nestjs/core';

constructor(private reflector: Reflector) {}

canActivate(context: ExecutionContext) {
  const isPublic = this.reflector.getAllAndOverride<boolean>('isPublic', [
    context.getHandler(),
    context.getClass(),
  ]);
  if (isPublic) {
    return true;  // Si el endpoint es público, permitir acceso
  }
  return super.canActivate(context); // De lo contrario, validar el JWT
}

Implementación del decorador @Public

Para que un endpoint sea accesible sin necesidad de un token, creamos un decorador personalizado:

import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC_KEY = 'isPublic';
export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);

Esto permite anotar métodos específicos del controlador para indicar que no requieren autenticación, como el siguiente ejemplo:

@ApiTags('products')
@Controller('products')
export class ProductsController {
  @Public()
  @Get()
  findAll(): string {
    return 'This action returns all products';
  }
}

Prueba del entorno

Con la implementación de este guardián personalizado, puedes verificar su efecto directamente en Insomnia o Postman. Intenta realizar una solicitud GET a tu endpoint público para obtener productos; debe ser accesible sin necesidad de autenticarlo con un token.

Ventajas y consejos prácticos

Flexibilidad: Esta aproximación permite seleccionar qué endpoints son públicos o privados mediante decoradores sencillos, manteniendo un código limpio y organizado.
Reutilización: Esta funcionalidad puede ser aplicable a otros proyectos gracias a la arquitectura modular de NestJS.
Seguridad: Asegúrate de usar tokens seguros y de realizar revisiones periódicas sobre los permisos de acceso de cada endpoint.

Mantener una API segura y eficiente es crucial para proteger los datos de usuario y la integridad de la aplicación. Estos métodos garantizan que los usuarios sólo accedan a los recursos para los cuales están autorizados, al mismo tiempo que permite un acceso público controlado cuando sea necesario. ¡Continúa explorando y aplicando estas prácticas en tus proyectos para sacar el máximo provecho de NestJS!

Andrés Esteban Rodríguez Jiménez

Hace 3 años

Extendiendo JWT Guard

Ya tenemos la funcionalidad del proteger los distintos Endpoints de nuestra aplicación en base a una estrategia de autenticación con JWT5, ahora, vamos a extender estas funcionalidades, por ejemplo, esta bien que proteja la parte de crear, actualizar y borrar un producto en base a un usuario administrador, pero deberíamos poder ver los productos independientemente de que tengamos una sesión o no.

Vamos a ver como realizar esta extensión:

Para esto, vamos a crear un nuevo guardián.

nest g gu auth/guards/jwt-auth --flat

Ahora vamos a empezar a crear la lógica de como queremos que actúe este guardian:

import { Injectable, ExecutionContext } from '@nestjs/common';

// importamos a reflector para obtener la metadata
import { Reflector } from '@nestjs/core';
// importamos a "UseGuards" y a "AuthGuard"
import { AuthGuard } from '@nestjs/passport';
// traemos la definición del decorador @IsPublic() que habíamos creado
import { IS_PUBLIC_KEY } from '../decorators/public.decorator';

// vamos a extender la funcionalidad del AuthGuard('jwt')
@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {
  // inyectamos al reflector como una dependencia
  constructor(private reflector: Reflector) {
    // como hacemos herencia, llamamos a "super()"
    super();
  }

  // creamos una funcionalidad para validar la activación
  // le enviamos el contexto de ejecución donde recibimos lametadata
  canActive(context: ExecutionContext) {
    // validamos si el Endpoint tiene en su metadata si es público
    const IsPublic = this.reflector.get(IS_PUBLIC_KEY, context.getHandler());

    // el Endpoint es público?
    if (IsPublic) {
      // retornamos el acceso sin necesidad de validar
      return true;
    }

    // si no
    // le decimos que realize la validación que hace desde su herencia
    return super.canActivate(context);
  }
}

Bien, ahora lo que vamos a hacer es decirle al product.controller que aplique el guardian que acabamos de crear:

**src/products/controllers/product.controller.ts**:

import { UseGuards } from '@nestjs/common';
// importamos el guardian
import { JwtAuthGuard } from 'src/auth/guards/jwt-auth.guard';
// traemos al decodador personalizado que hace un Endpoint público
import { Public } from 'src/auth/decorators/public.decorator';

// le decimos al controler que en vez, utilice nuestro guardian
@UseGuards(JwtAuthGuard)
@ApiTags('products')
@Controller('products')
export class ProductsController {
  constructor(private productsService: ProductsService) {}

	// lo usamos en los Endpoints que deseamos hacer públicos
  @Public()
  @Get()
  @ApiOperation({ summary: 'List of products' })
  getProducts(@Query() param: FilterProductsDto) {
    return this.productsService.findAll(param);
  }

	// este tambíen
  @Public()
  @Get(':productId')
  @HttpCode(HttpStatus.ACCEPTED)
  getOne(@Param('productId', MongoIdPipe) productId: string) {
    return this.productsService.findOne(productId);
  }

  // ...
}

Y listo, de esta forma estamos utilizando nuestro guardián personalizo que nos permite programar excepciones, así que ya logramos extender el controlador que ya teníamos y logramos tener una lógica reutilizable.

Mauricio Jourdan

Hace 3 años

Gracias por tus apuntes. Ojo, que hay un tipo en canActive. Saludos

Comentarios (11)11 comentarios

Jairo Campos Ruiz

Hace 4 años

Claudio Anibal Morales Pérez

Hace 5 años

Luis Abdel Rangel Castro

Andres Trujillo

Rony Porraz Vargas

yerson lasso

Nicolas Molina

Profesor

Naldo Duran

Jorge Andres Sanabria Camacho

Nicolas Javier Espinoza Dias

Juan David Merchán Torres

Brayhan Andres Jaramillo Castaño

Catalano Nicolas

Rubén Maier Enzler

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

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

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