Configuración y uso de variables de entorno en NestJS

Curso de NestJS: Programación Modular, Documentación con Swagger y Deploy

Contenido del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

17
Inyección de Dependencias en APIs con Heroku
01:04 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:009:19

Configuración y uso de variables de entorno en NestJS

Curso de NestJS: Programación Modular, Documentación con Swagger y Deploy

Clase 9 de 17

Clase 9 / 17

Comentarios (17)17 comentarios

Fernando Cordero

Hace 5 años

Hola chicos, les quiero he notado que en la comunidad utilizando mucho los console logs para debugear, cosa que no esta mal, pero existe el debuguer de vscode que es muy bueno y pueden aprovechar el uso de los breakpoints como la consola del debuguer. Aca les dejo un link para que puedan levantar sus procesos con el debuguer del vscode. Cualquier duda, avisenme https://code.visualstudio.com/docs/nodejs/nodejs-debugging#_auto-attach-feature

Rony Porraz Vargas

Hace 5 años

estoy intentando pero no me deja :(

Nicolas Erices Mendez

Hace 5 años

tienes que usar el modulo de Logger de NEST

Rogelio Samuel Moreno Corrales

Hace 5 años

Como dice el profesor, no es buena practica trackear el archivo .env, pero también es buena práctica tener un archivo .env.example que ese sí se trackea. El archivo .env.example sirve para informar qué variables de entorno el proyecto necesita (sin valores, sólo cuales son) para que personas que quieran bajarlo y correlo sepan cuales agregar.

Jecsham Castillo

Hace 5 años

Así es, por lo general se dejan en blanco variables delicadas como api keys, y los demás si se deja lleno

Ángel David Roque Ayala

Hace 5 años

Apuntes

Introducción

El valor de las variables de entorno (las variables de entorno son variables globales que se usan en toda la aplicación) depende de si la aplicación se ejecutara en el servidor de producción, en el de pruebas o en una versión local.

Instalación

Para manejar las variables de entorno instalaremos el modulo config propio de nest js.

npm i --save @nestjs/config

Declaración de variables entorno

Debemos listar todas las variables de entorno en un archivo llamado .env en la raíz del proyecto.

// .env
DATABASE_NAME=my_db
API_KEY='1234'

No olvides agregar este archivo en lista de los ignore de git // .gitignore *.env

Usar el paquete config

// src/app.module.ts
...
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({ // 👈 Implement ConfigModule
      envFilePath: '.env',
      isGlobal: true,
    }),
    ...
  ],
})
export class AppModule {}

Usar las variables de entorno

// src/users/services/users.service.ts
import { ConfigService } from '@nestjs/config';
...

@Injectable()
export class UsersService {
  constructor(
    private productsService: ProductsService,
    private configService: ConfigService, // 👈 inject ConfigService
  ) {}
  ...

  findAll() {
    const apiKey = this.configService.get('API_KEY'); // 👈 get API_KEY
    const dbName = this.configService.get('DATABASE_NAME');  // 👈 get DATABASE_NAME
    console.log(apiKey, dbName);
    return this.users;
  }

  ...
}

Esolutions SA

Hace 5 años

Disculpa , en algun lado tenes todos los apuntes del curso , si me podes pasar seria buenisimo . Gracias

Ángel David Roque Ayala

Hace 5 años

Claro, con mucho gusto te comparto mis apuntes. Los hice en notion. Apuntes nest modular.

Espero te sean útiles amigo.

Juan David Merchán Torres

Hace 5 años

Hola 👋 Ya que no se sube el archivo .env a nuestro repositorio ni se trackea, es importante dar una documentacion de que se tiene alli pero sin especificar sus valores. Para ellos cambiamos un poco la especificacion del .gitignore para no ignore todos los archivos terminados en .env sino solo .env

// .gitignore
# Enviroments
*.env
!.example.env

Y agregamos a la raiz un example.env donde iran las mismas variables pero sin su respectivo valor

API_KEY=
DATABASE_NAME=

Espero haberles aportado algo 🚀

Miguel Angel Reyes Moreno

Hace 3 años

Si como yo, están usando el repo del curso con Nest en versión 7, seguramente tendrán que hacer

npm i @nestjs/config@0.6.3 --legacy-peer-deps

Para que les funcione esta configuración

Daniel Parra

Hace 4 años

A quien le pueda servir, tuve un problema al instalar @nestjs/config, me aparecia que ConfigModule no existia en @nestjs/config. Lo solucioné reemplazando en el package.json.

Esto:

"@nestjs/config": "github:nestjs/config",

Por esto:

"@nestjs/config": "^2.0.0"

Alexandra Jimenez

Hace 3 años

Me paso esto, y creo que fue porque me equivoque instale npm i nestjs/config sin el @ , borre el paquete , hice npm i , y lo instale con el @ es decir: npm i @nestjs/config y se instalo correctamente .

Nicolas David Pastran Zamora

Hace 5 años

Por si alguien en algún momento debe de hacer un Testing con el configModule acá esta un ejemplo, lo pongo con un guardian porque es común usar las variables de entorno para validar que un usuario haga un request con un api key adecuado y para verificar puede sacar los apikeys de las variables de entorno. Espero que les sea útil.

Guard

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  UnauthorizedException,
} from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class XApiKeyGuard implements CanActivate {

  constructor(private configService: ConfigService) {  }

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const xApiKey = request.headers['x-api-key'];
    if (this.configService.get('API_KEY') !== xApiKey) {
      throw new UnauthorizedException({
        message: 'Required valid x-api-key in header',
      });
    }
    return true;
  }
}

Test

import { ConfigService } from '@nestjs/config';
import { XApiKeyGuard } from './x-api-key.guard';
const configServiceMock = {
  get: (key: string) => '1234,0000',
} as ConfigService;

describe('XApiKeyGuard', () => {
  it('should be pass guard', () => {
    const mockExecutionContext = createMock<ExecutionContext>({
      switchToHttp: () => ({
        getRequest: () => ({
          headers: { 'x-api-key': '0000' },
        }),
      }),
    });

    const guard = new XApiKeyGuard(configServiceMock);
    expect(guard.canActivate(mockExecutionContext)).toBe(true);
  });
});

Nicolas Javier Espinoza Dias

Hace 5 años

profe, con esto ya puedo ser google developer expert? :( jaja

Platzi Team

Hace 5 años

Creo que faltan dos clases mas

Marcelo Fernández

Hace 5 años

Hola chicos, pego las variables de entorno que tengo en un proyecto personal que estoy desarrollando, que se conecta a una base de datos y usa tokens JWT

DB_USER=...
DB_NAME=...
DB_PASS=...
DB_HOST=localhost
JWT_SECRET=hCGxxCWBpz-WhxxxumIdboco6xx...
JWT_EXPIRES_IN_SECONDS=999..

Alvaro H. Ruiz V.

Hace 6 meses

Esto está mejor que los módulos globales @Global(), creo? =D

Yeko Garcia

Hace un año

A mi no me carga la variable me dice que undefined

Jorge Andres Poveda Carvajal

Hace 5 años

vale si de esta forma podemos acceder a muchas variables sin tener que inject una a una, cual seria un verdadero caso de uso o como seria un correcto uso para el useValue? es que ya me confundi un poco en esto ya que pues este deniega o es mucho mas util, practico y hasta seguro que el useValue

Nicolas Molina

Profesor

Hace 5 años

Correcto no es buena práctica inyectar uno a uno, no es muy mantenible, en cuanto a useValue se puede usar de muchas formas según veas la necesidad, por ejemplo algunos casos:

Una instancia global de un servicio externo como Sentry, S3 de Amazon o hasta la instancia de una conexión a DB (esto lo usamos en el curso de TypeORM) etc.

Es muy útil a la hora de hacer testing, ya que puede remplazar cualquier valor con un mock.

Kevin Fiorentino

Hace 5 años

¿Sería lo mismo usar este ConfigService para obtener los environments que usar process.env.XXX?

Cesar Andrés Ramírez Vanegas

Hace 5 años

Hola, una pregunta: como se podria leer una variable (mongoDbConnection) en el module (en el caso de conexion a DB )

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true,
    }),
    MongooseModule.forRoot(
      mongoDbConnection
    ),
    MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }]),
  ],
  controllers: ConstantsConfig.controllerList,
  providers: ConstantsConfig.serviceList,
})
export class AppModule {}

Quedo atento

Kevin Fiorentino

Hace 5 años

Compañero! Para estos casos podrías utilizar variables de entorno. Te recomiendo que veas esta documentación de NestJS para saber cómo leer los archivos .env y utilizar process.env.XXX para leer variables de entorno en donde necesites. Saludos!

jimy huacho dolores

Hace 5 años

Si la variables de entorno no las subes al repositorio ¿Cómo haces para que los demás miembros de tu equipo sepan que variables existen? ¿Solo se informa a través de correos?

Francisco Ponce

Hace 5 años

Hola Jimmy

Sé que no es la respuesta que esperas pero se comparten de otras formas.

¿Cuáles? Bueno eso dependerá del departamento o área de seguridad informática de tu empresa y si no la hay, dependerá del área TI. Los canales de donde fluye la información interna en las empresas son vigilados (o deberían), quizás tengan un hub donde te pasen alguna clave semanalmente o quizás te las proporcionen mediante una app que encripte esa información. Eso ya depende de quien defina las medidas de seguridad del proyecto.

Luis Hernando Sendoya Serrato

Hace 4 años

documentación de nestjs sobre module config

Jose Angel Morales Gonzalez

Hace 4 años

Si necesitas las variables de entorno en el app.module puedes crear una instancia, del configService, y usarlo donde necesites

const configService = new ConfigService();

Ricardo Enrique Vargas Peraza

Hace 5 años

Pueden ser trackeados por git, más por buenas practicas nunca deben ir al repositorio.

Recursos

A medida que tu aplicación crezca, puedes llegar a necesitar decenas de variables de entorno. Variables que cambian de valor dependiendo si estás en un entorno de desarrollo, de pruebas o de producción.

Variables de entorno en NestJS

El manejo de variables de entorno en NestJS se realiza de una forma muy sencilla. Instala la dependencia @nestjs/config e importa el módulo ConfigModule en el módulo principal de tu aplicación.

import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true
    }),
  ],
})
export class AppModule {}

El archivo que almacena las variables de entorno suele llamarse .env. Créalo en la raíz de tu proyecto con las variables que necesitas.

API_KEY=1324567890
API_SECRET=ABCDEFGHI

De esta manera, las variables de entorno estarán disponibles en tu aplicación y utilizando el objeto global de NodeJS llamado process puedes acceder a estos valores de la siguiente manera:

process.env.API_KEY
process.env.API_SECRET

Consejos sobre las variables de entorno

Es muy importante NO VERSIONAR el archivo .env en el repositorio de tu proyecto. No guardes las claves secretas de tu aplicación en GIT.

Para asegurar esto, agrega el archivo .env a la configuración del archivo .gitignore para que no sea reconocido por Git y este no lo guarde en el repositorio.

Lo que puedes hacer es crear un archivo llamado .env.example que contendrá un modelo de las variables de entorno que tu aplicación necesita, pero no sus valores.

API_KEY=
API_SECRET=

De este modo, cuidas tu aplicación y guardas un archivo para que cualquier desarrollador que tome el proyecto, sepa qué variables necesita configurar para el funcionamiento de la misma.

Cuadro de código para usar el módulo de configuración

npm i --save @nestjs/config

// .gitignore
*.env

// .env
DATABASE_NAME=my_db
API_KEY='1234'

// src/app.module.ts
...
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({ // 👈 Implement ConfigModule
      envFilePath: '.env',
      isGlobal: true,
    }),
    ...
  ],
})
export class AppModule {}

// src/users/services/users.service.ts
import { ConfigService } from '@nestjs/config';
...

@Injectable()
export class UsersService {
  constructor(
    private productsService: ProductsService,
    private configService: ConfigService, // 👈 inject ConfigService
  ) {}
  ...

  findAll() {
    const apiKey = this.configService.get('API_KEY'); // 👈 get API_KEY
    const dbName = this.configService.get('DATABASE_NAME');  // 👈 get DATABASE_NAME
    console.log(apiKey, dbName);
    return this.users;
  }

  ...
}

Contribución creada por: Kevin Fiorentino.

// src/app.module.ts
...
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({ // 👈 Implement ConfigModule
      envFilePath: '.env',
      isGlobal: true,
    }),
    ...
  ],
})
export class AppModule {}

// src/users/services/users.service.ts
import { ConfigService } from '@nestjs/config';
...

@Injectable()
export class UsersService {
  constructor(
    private productsService: ProductsService,
    private configService: ConfigService, // 👈 inject ConfigService
  ) {}
  ...

  findAll() {
    const apiKey = this.configService.get('API_KEY'); // 👈 get API_KEY
    const dbName = this.configService.get('DATABASE_NAME');  // 👈 get DATABASE_NAME
    console.log(apiKey, dbName);
    return this.users;
  }

  ...
}

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  UnauthorizedException,
} from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class XApiKeyGuard implements CanActivate {

  constructor(private configService: ConfigService) {  }

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const xApiKey = request.headers['x-api-key'];
    if (this.configService.get('API_KEY') !== xApiKey) {
      throw new UnauthorizedException({
        message: 'Required valid x-api-key in header',
      });
    }
    return true;
  }
}

import { ConfigService } from '@nestjs/config';
import { XApiKeyGuard } from './x-api-key.guard';
const configServiceMock = {
  get: (key: string) => '1234,0000',
} as ConfigService;

describe('XApiKeyGuard', () => {
  it('should be pass guard', () => {
    const mockExecutionContext = createMock<ExecutionContext>({
      switchToHttp: () => ({
        getRequest: () => ({
          headers: { 'x-api-key': '0000' },
        }),
      }),
    });

    const guard = new XApiKeyGuard(configServiceMock);
    expect(guard.canActivate(mockExecutionContext)).toBe(true);
  });
});

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true,
    }),
    MongooseModule.forRoot(
      mongoDbConnection
    ),
    MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }]),
  ],
  controllers: ConstantsConfig.controllerList,
  providers: ConstantsConfig.serviceList,
})
export class AppModule {}

Resumen

Variables de entorno en NestJS

import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true
    }),
  ],
})
export class AppModule {}

El archivo que almacena las variables de entorno suele llamarse .env. Créalo en la raíz de tu proyecto con las variables que necesitas.

API_KEY=1324567890
API_SECRET=ABCDEFGHI

De esta manera, las variables de entorno estarán disponibles en tu aplicación y utilizando el objeto global de NodeJS llamado process puedes acceder a estos valores de la siguiente manera:

process.env.API_KEY
process.env.API_SECRET

Consejos sobre las variables de entorno

Es muy importante NO VERSIONAR el archivo .env en el repositorio de tu proyecto. No guardes las claves secretas de tu aplicación en GIT.

Para asegurar esto, agrega el archivo .env a la configuración del archivo .gitignore para que no sea reconocido por Git y este no lo guarde en el repositorio.

Lo que puedes hacer es crear un archivo llamado .env.example que contendrá un modelo de las variables de entorno que tu aplicación necesita, pero no sus valores.

API_KEY=
API_SECRET=

De este modo, cuidas tu aplicación y guardas un archivo para que cualquier desarrollador que tome el proyecto, sepa qué variables necesita configurar para el funcionamiento de la misma.

Cuadro de código para usar el módulo de configuración

npm i --save @nestjs/config

// .gitignore
*.env

// .env
DATABASE_NAME=my_db
API_KEY='1234'

// src/app.module.ts
...
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot({ // 👈 Implement ConfigModule
      envFilePath: '.env',
      isGlobal: true,
    }),
    ...
  ],
})
export class AppModule {}

// src/users/services/users.service.ts
import { ConfigService } from '@nestjs/config';
...

@Injectable()
export class UsersService {
  constructor(
    private productsService: ProductsService,
    private configService: ConfigService, // 👈 inject ConfigService
  ) {}
  ...

  findAll() {
    const apiKey = this.configService.get('API_KEY'); // 👈 get API_KEY
    const dbName = this.configService.get('DATABASE_NAME');  // 👈 get DATABASE_NAME
    console.log(apiKey, dbName);
    return this.users;
  }

  ...
}

Contribución creada por: Kevin Fiorentino.

Módulos de NestJS

Programación Modular y Deployment en Nest GS

Encapsulación de Lógica en Módulos con NestJS

Programación Modular en NestJS: Controladores y Entidades

Interacción entre Módulos en NestJS: Servicios y Controladores

Inyección de Dependencias en Arquitectura de Software

Tipos de Providers en NestJS: Use Class y Use Value

useFactory

Uso de Módulos Globales en NestJS para Inyecciones Compartidas

Configuración de entornos

Configuración y uso de variables de entorno en NestJS

Configuración de Ambientes con Archivos .env en Node.js

Tipado seguro en TypeScript para configuración de aplicaciones

Validación de Variables de Entorno con Joi en Node.js

Documentación

Documentación automática de APIs con NestJS y Swagger

Documentación de API con NestJS y Swagger

Deploy

Deployment de Aplicaciones Node.js en Heroku

Deployment de Aplicaciones en Heroku: Configuración y Solución de Errores

Próximos pasos

Inyección de Dependencias en APIs con Heroku

Configuración y uso de variables de entorno en NestJS

Progreso del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

Recursos

Recursos