Introduction

Deploying a NestJS application to a production environment requires careful consideration of several factors, including environment variables, logging, and performance optimization. This guide outlines best practices for configuring your NestJS application for optimal performance and stability in production.

Setting Up Environment Variables

Environment variables are crucial for storing sensitive information (API keys, database credentials) and configuring your application differently across various environments (development, staging, production).

Best Practices

• Never hardcode sensitive information directly into your code.
• Use a .env file for local development. NestJS integrates well with libraries like dotenv.
• In production, set environment variables directly on your server (e.g., using systemd, Docker, or a cloud provider's configuration).

Implementation

1. Install dotenv:

npm install --save dotenv
npm install --save-dev @types/dotenv

2. Create a .env file in the root of your project:

# .env
DATABASE_URL=your_database_url
API_KEY=your_api_key
PORT=3000
NODE_ENV=development # or 'production', 'staging'

3. Load environment variables in your main.ts file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as dotenv from 'dotenv';
import { join } from 'path';

async function bootstrap() {
  dotenv.config({ path: join(__dirname, '../.env') }); //load .env in the root folder
  const app = await NestFactory.create(AppModule);
  await app.listen(process.env.PORT || 3000);
}
bootstrap(); 

4. Access environment variables using process.env:

// In your service or controller
@Injectable()
export class MyService {
  constructor() {
    const databaseUrl = process.env.DATABASE_URL;
    console.log('Database URL:', databaseUrl);
  }
} 

Important: Don't commit your .env file to your version control system (add it to your .gitignore file).

Configuring Logging

Effective logging is essential for monitoring your application's health, debugging issues, and gathering insights into its behavior.

Best Practices

• Use a structured logging format (e.g., JSON) for easier parsing and analysis.
• Configure different log levels (e.g., debug, info, warn, error, fatal) based on severity.
• Integrate with a centralized logging service (e.g., ELK stack, Graylog, Datadog) for aggregation and analysis.
• Include context in your logs (e.g., request ID, user ID) to facilitate debugging.

Implementation

1. Use NestJS's built-in logger or integrate with a logging library like Winston or Morgan:

Using the Built-in Logger:

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

const logger = new Logger('MyService'); // Define a context

// In your service or controller
@Injectable()
export class MyService {
  async someOperation() {
    logger.log('Starting someOperation');
    try {
      // ... your code ...
      logger.debug('Debug information');
      logger.verbose('Verbose information - only visible with special flag');
      logger.warn('This is a warning message');
      logger.error('An error occurred', null, 'Context-specific error'); // 'null' for stack trace, 'Context-specific error' optional context
      return 'Success';
    } catch (error) {
      logger.error('An error occurred', error.stack, 'someOperation');
      throw error;
    }
  }
} 

2. Create a custom logger (Optional - for more advanced logging)

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

@Injectable({ scope: Scope.TRANSIENT }) // Scope.TRANSIENT creates a new logger instance for each request
export class MyCustomLogger implements LoggerService {
  log(message: any, context?: string) {
    //Implement your own logging logic here.
    //You can write to a file, database, or any other destination.
    console.log(`[LOG] ${context ? '[' + context + '] ' : ''}${message}`);
  }

  error(message: any, trace?: string, context?: string) {
    console.error(`[ERROR] ${context ? '[' + context + '] ' : ''}${message} ${trace}`);
  }

  warn(message: any, context?: string) {
    console.warn(`[WARN] ${context ? '[' + context + '] ' : ''}${message}`);
  }

  debug?(message: any, context?: string) {
    console.debug(`[DEBUG] ${context ? '[' + context + '] ' : ''}${message}`);
  }

  verbose?(message: any, context?: string) {
    console.log(`[VERBOSE] ${context ? '[' + context + '] ' : ''}${message}`);
  }
} 

Use your custom logger by injecting it into your services/controllers.

import { Injectable, Inject } from '@nestjs/common';
import { MyCustomLogger } from './my-custom-logger.service';

@Injectable()
export class MyService {
  constructor(
    @Inject(MyCustomLogger) private readonly logger: MyCustomLogger,
  ) {}

  async someOperation() {
    this.logger.log('Starting someOperation', MyService.name);
    // ...
  }
}

Optimizing NestJS Applications for Production

Optimizing your NestJS application involves several techniques to improve performance, reduce resource consumption, and enhance scalability.

Best Practices

• Enable production mode: This disables development-specific features like hot reloading and verbose logging.
• Use a process manager: Tools like PM2 or systemd provide process monitoring, auto-restart, and load balancing.
• Configure caching: Implement caching strategies (e.g., Redis, Memcached) to reduce database load and improve response times.
• Optimize database queries: Use indexes, efficient query design, and connection pooling to minimize database latency.
• Compress responses: Enable gzip or Brotli compression to reduce the size of HTTP responses.
• Bundle your code: Use a bundler like Webpack or esbuild to reduce the number of files and improve loading times.
• Use a CDN: Serve static assets (images, CSS, JavaScript) from a content delivery network (CDN) to reduce latency and improve performance.
• Monitor your application: Use monitoring tools (e.g., Prometheus, Grafana) to track performance metrics and identify bottlenecks.

Implementation

1. Enable Production Mode:

Set the NODE_ENV environment variable to production. NestJS automatically optimizes certain behaviors based on this variable.

2. Use PM2 (Example):

npm install -g pm2

Start your application with PM2:

pm2 start dist/main.js --name "my-nestjs-app" --watch

PM2 provides features like:

• Automatic restarts on crashes
• Load balancing
• Monitoring
• Log management

3. Caching (Example with Redis):

npm install --save @nestjs/cache-manager cache-manager redis ioredis
npm install --save-dev @types/cache-manager @types/redis

Configure the CacheModule in your AppModule:

import { Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import * as redisStore from 'cache-manager-redis-store';
import { MyController } from './my.controller';
import { MyService } from './my.service';
import type { RedisClientOptions } from 'redis';

@Module({
  imports: [
    CacheModule.register({
      store: redisStore,
      host: 'localhost',
      port: 6379,
      ttl: 5, // seconds,
      isGlobal: true, // Make the cache available in all modules
    }),
  ],
  controllers: [MyController],
  providers: [MyService],
})
export class AppModule {} 

Use the CacheInterceptor in your controller:

import { Controller, Get, UseInterceptors, CacheInterceptor, Inject } from '@nestjs/common';
import { CacheKey, CacheTTL } from '@nestjs/cache-manager';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';
import { MyService } from './my.service';

@Controller('my')
@UseInterceptors(CacheInterceptor)
export class MyController {
  constructor(
    private readonly myService: MyService,
  ) {}

  @Get()
  @CacheKey('custom_key') // Optional - Define a specific key
  @CacheTTL(30) // Optional - Override the default TTL
  async getData(): Promise<string> {
    return this.myService.getDataFromSlowSource();
  }

} 

4. Compression:

npm install --save compression
npm install --save-dev @types/compression

Enable compression in your main.ts:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as compression from 'compression';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(compression());
  await app.listen(3000);
}
bootstrap();