Leveraging NestJS with Serverless Framework for Scalable Applications

In today’s cloud-native world, serverless architectures are becoming increasingly popular due to their cost-efficiency and ease of scaling. If you’re a TypeScript enthusiast, combining the power of NestJS with the Serverless Framework can lead to robust and scalable applications. In this article, we will explore how to set up and use NestJS with the Serverless Framework.

Why NestJS and Serverless?

• NestJS: A progressive Node.js framework for building efficient, reliable, and scalable server-side applications. Built with TypeScript, it offers a highly modularized structure that encourages code reuse and maintainability.
• Serverless Framework: Simplifies the process of deploying and managing functions on cloud platforms like AWS Lambda, Azure Functions, and Google Cloud Functions. With serverless architecture, you focus on writing code rather than managing infrastructure.

Setting Up the Project

Prerequisites

• Node.js (12.x or later)
• NPM or Yarn
• Serverless Framework CLI
• AWS CLI (configured with your credentials)

Step 1: Create a New NestJS Project

First, let’s create a new NestJS project using the Nest CLI:

npm i -g @nestjs/cli
nest new nest-serverless
cd nest-serverless

Step 2: Install Serverless Framework and Dependencies

Next, we need to install the Serverless Framework and some essential dependencies.

npm install -g serverless
npm install serverless-offline serverless-plugin-typescript aws-lambda @types/aws-lambda

Step 3: Configuring Serverless Framework

Create a serverless.yml file in the root directory of your project. This YAML file will define the configuration for deploying your application.

Here is a basic example for AWS Lambda:

service: nest-serverless

provider:
  name: aws
  runtime: nodejs14.x
  region: us-east-1

plugins:
  - serverless-offline
  - serverless-plugin-typescript

functions:
  api:
    handler: dist/lambda.handler
    events:
      - http:
          path: /
          method: get

Step 4: Create the Lambda Handler

To handle AWS Lambda events, we’ll create a lambda.ts file. This file will act as the entry point for AWS Lambda to invoke our NestJS application.

Create lambda.ts in your source directory src:

import { Handler } from 'aws-lambda';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Server } from 'http';

let cachedServer: Server;

const bootstrapServer = async (): Promise<Server> => {
  if (!cachedServer) {
    const app = await NestFactory.create(AppModule);
    await app.init();
    cachedServer = app.getHttpServer();
  }
  return cachedServer;
};

export const handler: Handler = async (event, context) => {
  context.callbackWaitsForEmptyEventLoop = false;
  const server = await bootstrapServer();
  return server(event, context);
};

Step 5: Update tsconfig.json

Ensure your tsconfig.json includes the necessary settings for modules and decorators:

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "es2017",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "sourceMap": true,
    "outDir": "./dist",
    "baseUrl": "./",
    "incremental": true
  }
}

Step 6: Build and Deploy

Build your project using the NestJS CLI:

nest build

Finally, you can deploy your application using the Serverless Framework:

serverless deploy

Step 7: Testing Locally

To test your service locally, you can use the serverless-offline plugin:

serverless offline

Conclusion

Combining the power of NestJS with the Serverless framework opens up possibilities for building highly scalable and maintainable applications. The modular architecture of NestJS aligns well with the event-driven nature of serverless environments, making it a perfect fit for modern cloud-native applications.

Deploy your first serverless application today and experience the seamless integration of these powerful tools!

If you have any questions or run into issues, feel free to leave a comment below. Happy coding!