Run NestJS Application in Serverless Framework on AWS

In this article, we’re going to learn how we can run a NestJS application as a Lamda function using the Serverless framework on the AWS platform.

NestJS application in Serverless framework on AWS

Hands-on Steps:

Create NestJS application:

First, we need to install Nest CLI globally to create a NestJS application.

npm i -g @nestjs/cli
nest new nest-sls && cd nest-sls

Install node dependencies for Serverless:

These are the node packages that we need to install first before we proceed.

npm install aws-lambda aws-serverless-express express --save

Map NestJS with ExpressJS:

Here we map our NestJS application into the ExpressJS application so that we can use this during AWS Lamda function implementation.

// src/app.ts
import { NestFactory } from '@nestjs/core';
import { ExpressAdapter } from '@nestjs/platform-express';
import { INestApplication } from '@nestjs/common';
import { AppModule } from './app.module';
import { Express } from 'express';
export async function createApp(
  expressApp: Express,
): Promise<INestApplication> {
  const app = await NestFactory.create(
    AppModule,
    new ExpressAdapter(expressApp),
  );
  return app;
}

Convert ExpressJS to AWS Lamda:

Now we convert our ExpressJS application into AWS Lamda function so that it can use our application as a function.

// src/serverless.ts
import { Server } from 'http';
import { Context } from 'aws-lambda';
import { createServer, proxy, Response } from 'aws-serverless-express';
import * as express from 'express';
import { createApp } from './app';
let cachedServer: Server;
async function bootstrap(): Promise<Server> {
  const expressApp = express();
  const app = await createApp(expressApp);
  await app.init();
  return createServer(expressApp);
}
export async function handler(event: any, context: Context): Promise<Response> {
  if (!cachedServer) {
    const server = await bootstrap();
    cachedServer = server;
  }
  return proxy(cachedServer, event, context, 'PROMISE').promise;
}

Create a configuration file:

Here we mentioned all the configurations for the Serverless application.

// serverless.yml
service: serverless-nestjs
frameworkVersion: '2'
useDotenv: true
provider:
  name: aws
  runtime: nodejs12.x
  stage: ${opt:stage, 'dev'}
  region: ${opt:region, 'ap-southeast-1'}
  apiGateway:
    shouldStartNameWithService: true
  environment:
    NODE_ENV: ${env:NODE_ENV}
functions:
  app:
    handler: dist/serverless.handler
    events:
      - http:
        method: any
        path: /{any+}

Build and deploy the Serverless application:

Make sure, we always build our application before deploying to AWS. Because all the changes will reflect after the build process is successful as we upload the files from the dist directory into AWS S3.

npm run build && sls deploy

Serverless Offline:

To speed up our development cycles, we can run and test our application on our local machine. Therefore, we can use this serverless-offline plugin to run our Serverless application on our local machine.

Install node dependencies:

Install this npm package before we proceed.

npm install serverless-offline --save-dev

Update configuration file:

We need to add this serverless-offline plugin in our Serverless configuration file. [NB: serverless-offline should always be the last plugin]

// serverless.yml
...
plugins:
  - serverless-offline
...

Build and run the Serverless application:

Same as before, we always build our application before running the application. Because all the changes will reflect after the build process is successful as our AWS Lamda function points to the dist directory.

npm run build && sls offline start