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

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:0010:47

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

Curso de NestJS: Autenticación con Passport y JWT

Clase 4 de 22

Clase 4 / 22

Recursos

¿Qué son los guardianes en NestJS y cómo funcionan?

Los guardianes son uno de los componentes más importantes en el framework NestJS, junto con los controladores, proveedores y pipes. Estos elementos son cruciales para asegurar que cada endpoint de un controlador tenga o no la autorización necesaria. En esencia, los guardianes permiten validar cualquier tipo de información que venga en los headers, como tokens de API, o cualquier otro estado requerido, antes de conceder acceso a un recurso solicitado.

¿Cómo crear y estructurar un guardián?

Para crear un guardián, primero se debe crear un módulo específico para manejar la autenticación dentro de la aplicación. Independientemente del proyecto en el que te encuentres, ya sea Mongo o cualquier otro, el proceso inicia con la generación de un nuevo módulo que administrará la autenticación. Dentro de este módulo, utilizaremos el generador de NestJS para crear un guardián.

nest generate guard guardianes/apk --skipTests

Aquí estamos indicando al generador que cree un guardián llamado apk dentro de una carpeta específica llamada guardianes.

Explorando el guardián generado

El guardián generado por defecto incluye un método que se encarga de decidir si se concede el acceso o no. Este método puede regresar un valor booleano, una promesa que regrese un booleano, o un observable, dependiendo de la implementación:

canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
  return true; // true para permitir acceso, false para denegarlo
}

Configurando el guardián en un controlador

Para proteger un endpoint, primero importamos el guardián en el controlador correspondiente:

import { UseGuards } from '@nestjs/common';
import { Apkguarian } from './guardianes/apk.guard';

@Controller('api')
export class AppController {
  @Get('nuevo')
  @UseGuards(Apkgurar)
  nuevo() {
    return 'Acceso concedido';
  }
}

Ahora, el endpoint nuevo está protegido por el guardián, el cual por defecto no permite el acceso, simulando un valor false.

Validación dinámica con headers

Supongamos que queremos otorgar acceso solo si un header específico está presente en la solicitud. Para esto, implementamos la lógica necesaria en el método canActivate:

canActivate(context: ExecutionContext): boolean {
  const request = context.switchToHttp().getRequest();
  const authHeader = request.headers['authorization'];

  if (authHeader === '1234') {
    return true;
  } else {
    throw new UnauthorizedException('No estás autorizado');
  }
}

Este código revisa si el header authorization tiene el valor 1234 antes de permitir el acceso.

Probando en Insomnia

Si probamos con Insomnia o cualquier cliente REST, observa que cuando el header authorization tiene el valor correcto, se concede el acceso. De lo contrario, se lanza una excepción indicando que el acceso no está autorizado.

::tip:: Consejo: Personaliza los mensajes de error para que sean más claros y comprensibles. Usar excepciones específicas como UnauthorizedException en NestJS facilita esta tarea.

Aprender sobre los guardianes y cómo aplicarlos en tus proyectos es fundamental para tener una aplicación NestJS segura y robusta. Experimenta con diferentes condiciones y mecanismos de validación, y sigue aprendiendo sobre cómo mejorar la seguridad en tus aplicaciones. ¡Sigue adelante y no te detengas!

Andrés Esteban Rodríguez Jiménez

Hace 3 años

Introducción a Guards

Los guards (guardianes) son artefactos proporcionados por Nest.js que nos permiten proteger nuestros Endpoints en los controladores, verificando si un usuario tiene los permisos necesarios para acceder a un Endpoint en función de una condición.

Esto se puede lograr validando datos en los encabezados (headers), el estado, un token, etc., y determinando si el usuario tiene los permisos necesarios o no.

Creando la capa de autenticación

Primero lo que vamos a hacer es crear un nuevo guardián que se va a encargar de la autenticación en nuestra aplicación.

nest g gu auth/guards/api-key --flat

La estructura que nos debería crear es la siguiente:

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

@Injectable()
export class ApiKeyGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // Si retornamos true, se permite el acceso al Endpoint
    return false;
  }
}

Ahora, veamos cómo podemos implementar este guardián. Vamos a seleccionar un controlador y un Endpoint específico, y lo protegeremos con nuestro guardián:

**src/app-controller.ts**:

// Importamos el guardián y el decorador para usarlo
import { UseGuards } from '@nestjs/common';
import { ApiKeyGuard } from './auth/guards/api-key.guard';

@Controller()
export class AppController {
  // ...

  // Pasamos el guardián al decorador
  @UseGuards(ApiKeyGuard)
  @Get('nuevo')
  newEndpoint() {
    return 'Yo soy nuevo';
  }
}

De esta manera, no será posible acceder al Endpoint, ya que en el guardián estamos retornando false, lo cual deniega el acceso.

Podemos permitir el acceso si se envía un encabezado específico. Veamos cómo hacerlo en nuestro guardián:

// Importamos el tipo 'Request'
import { Request } from 'express';

@Injectable()
export class ApiKeyGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    // Obtenemos la información del request HTTP
    const request = context.switchToHttp().getRequest<Request>();
    // Obtenemos el encabezado 'Auth' de ese request
    const authHeader = request.header('Auth');

    // Si no se envía ninguna autenticación, se rechaza el acceso
    if (!authHeader) {
      return false;
    }
    
    // Verificamos si el encabezado 'Auth' es igual a 'contraseña ultra secreta'
    // Si es así, se permite el acceso; de lo contrario, se deniega el acceso
    return authHeader === 'contraseña ultra secreta';
  }
}

Si enviamos la clave correcta en el encabezado 'Auth', se nos permitirá el acceso; de lo contrario, recibiremos un código 403, que indica que no estamos autorizados.

De esta manera, podemos utilizar los guardián en Nest.js. Como has visto, los guardián se basan en un contexto que nos permite acceder a la información necesaria y podemos programar la condición que debe cumplir esta información obtenida a través del contexto.

Comentarios (10)10 comentarios

Gabriel Rodriguez

Hace 5 años

Rony Porraz Vargas

Arnold Kevin Guzman Campos

Ángel David Roque Ayala

Fernando Sanchez

Hace 4 años

Mauricio Jourdan

Andres Trujillo

Renato Renzo Luna Herrera

Hanier Morales

Juan Francisco Maldonado De Régules

Hace un año

yerson lasso

Nicolas Molina

Profesor

Luis Berenguer

Jeremi Airon Enock Ocando

Felipe de Jesús Ramirez Rodriguez

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

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

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