Production-ready lambdas with Node.js

Luciano Mammino (@loige)

loige.link/lambda-pirate

SailsConf 2023

👋 I'm Luciano (🇮🇹🍕🍝🤌)

👨‍💻 Senior Architect @ fourTheorem

nodejsdp.link

📔 Co-Author of Node.js Design Patterns  👉

Let's connect!

  loige.co (blog)

  @loige (twitter)

  mastodon.ie/@loige

  loige (twitch)

  lmammino (github)

loige.link/lambda-pirate

Grab the slides

$ ~ whoami

Always re-imagining

We are a pioneering technology consultancy focused on AWS and serverless

loige

✉️ Reach out to us at  hello@fourTheorem.com

😇 We are always looking for talent: fth.link/careers

We can help with:

Cloud Migrations

Training & Cloud enablement

Building high-performance serverless applications

Cutting cloud costs

We host a weekly podcast about AWS

awsbites.com

loige

Agenda

  • What is Serverless
  • What is Lambda and how it works
  • Our first Lambda in JavaScript
  • Many tips for making it production ready™️

loige

⚡️Serverless

loige

loige

*

loige

Serverless, in a nutshell 🥜

  • A way of running applications in the cloud

  • Of course, there are servers
    ... we just don't have to think about them

  • You pay for what you use

  • Small units of compute (functions), triggered by events

loige

Serverless... with benefits 🎁

  • More focus on the business logic (generally)

  • Increased team agility (mostly)

  • Automatic scalability (sorta)

  • Not a universal solution, but it can work well in many situations!

  • Opinion: We will definitely see MOAR SERVERLESS in the future!

loige

AWS Lambda

FaaS offering in AWS

Can be triggered by different kinds of events

  • HTTP Requests
  • New files in S3
  • Jobs in a Queue
  • Orchestrated by Step Functions
  • On a schedule
  • Manually invoked

loige

How Lambda
Works ⚙️

loige

Hello, I am the "Lambda Engine"

loige

Oh, a new event!

Event

loige

Is there a Lambda associated to it?

Event

loige

Yes, here's one! So let's trigger it!

Event

loige

But, we don't have any instance ready!

Event

loige

Let's create a new one!

Event

loige

Let's use the code stored in this bucket!

Event

loige

Let's use the code stored in this bucket!

Event

loige

Now we can let this instance process the event!

Event

loige

Now we can let this instance process the event!

Event

loige

It's working really hard!

Event

🥵 

loige

Nice! Another event!

Event

🥵 

Event

loige

Our only instance is busy... we need a new one!

Event

🥵 

Event

loige

Event

🥵 

Event

loige

Event

🥵 

Event

It can now take care of the event!

loige

Event

🥵 

Event

🥵 

loige

Event

🥳

Event

🥵 

Response

Nice! The first lambda has completed

loige

Event

🥵 

Response

Let's forward its response back!

loige

Event

🥵 

loige

Event

🥵 

The 1st instance has been idle for a while

😴

loige

Event

🥵 

We can destroy it

😴

loige

Event

🥵 

loige

Event

🥳

Response

Nice! The second lambda has completed

loige

Response

loige

Oh, a new event!

Event

loige

There's an instance ready for it!

Event

loige

Event

🥵 

loige

Event

🥳

Response

loige

Response

loige

loige

😴

loige

loige

Summary

  • Events trigger lambda executions
  • Lambda code is stored in an S3 bucket
  • Lambda instances are created and destroyed on demand
  • An instance can handle an event at the time

loige

In more detail 🧐

  • Lambda instances run as micro-vms thanks to Firecracker
  • When an instance is created, this is called cold start
  • Instances can be invoked synchronously (request/response)
  • Or asynchronously
  • An instance doesn't really know how it is invoked, it's just a function
  • It receives an input (the event) and returns an output (the response)

Response

Event

loige

The limits of Lambda 😰

  • 15 minutes execution time limits
  • 256 kb max event/response size (async invocation) *
  • 6 MB max event/response size (sync invocation) *
  • 1000 concurrent executions (soft quota)

  • Max code size: 250 MB

docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html

* With the new Response Streaming feature the response limit goes up to 20 MB (with some extra 💸)

loige

AWS Lambda Pricing 💸

Cost = Allocated Memory 𝒙 time

aws.amazon.com/lambda/pricing/

loige

AWS Lambda Pricing 💸

Cost = Allocated Memory 𝒙 time

aws.amazon.com/lambda/pricing/

512 MB = $0.0000000083/ms

Executing a lambda for 15 mins...

0.0000000083 * 900000 = 0.007 $

loige

AWS Lambda... what about CPU? 🙄

You don't explicitly configure it:

CPU scales based on memory

loige.link/lambda-cpu

loige

AWS Lambda... what about CPU? 🙄

You don't explicitly configure it:

CPU scales based on memory

Memory vCPUs
128 - 3008 MB 2
3009 - 5307 MB 3
5308 - 7076 MB 4
7077 - 8845 MB 5
8846+ MB 6

loige.link/lambda-cpu

loige

Writing Lambdas

in Node.js

loige

export const handler = async(event, context) => {
  // ... get data from event
  // ... run business logic
  // ... return a result
}

loige

export const handler = async(event, context) => {
  // ... get data from event
  const { url } = event

  // ... run business logic
  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  // ... return a result  
  return res.status
}

loige

We have written our first lambda! 🎉

How do we make it production ready?

loige

1. Use IaC

(Infrastructure as Code 🤗)

loige

1. Why IaC

  • Stop creating resources manually on your AWS accounts, NOW!
  • IaC means that all your infrastructure is defined as code
  • ... which means you can keep it in git
  • ... and create pipelines to deploy changes
  • ... and make all your environments reproducible

loige

1. (some) IaC tools

loige

SAM

Serverless Application Model

loige

AWS SAM

  • YAML-based Infrastructure as code (IaC) tool focused on serverless apps
  • Great when you have to go beyond just one Lambda

aws.amazon.com/serverless/sam

loige

Some example use cases:

  • You need to provision multiple lambdas
  • You need to provision multiple pieces of infrastructure (e.g. S3 buckets, permissions, DynamoDB tables, etc)
  • It supports everything that is natively supported by CloudFormation, but with a slightly simpler syntax
  • Deploys through CloudFormation!

AWS SAM

loige

# template.yaml

AWSTemplateFormatVersion : '2010-09-09'
Transform:
  - AWS::Serverless-2016-10-31

Description: |
  A sample Serverless project triggered from S3 CreateObject events
Resources:
  ExampleFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      Events:
        S3CreateObject:
          Type: S3
          Properties:
            Bucket: !Ref MyPhotoBucket
            Events: s3:ObjectCreated:*

  MyPhotoBucket:
    Type: AWS::S3::Bucket

loige

2. Observability

Observe all the things 👀

loige

(good) Metrics +

2. Observability

Observability Nirvana!

(good) Logs +

(good) Tracing =

loige

Lambda Power Tools!

awslabs.github.io/aws-lambda-powertools-typescript

loige

npm install \
  @aws-lambda-powertools/logger \
  @aws-lambda-powertools/metrics \
  @aws-lambda-powertools/tracer

loige

export const handler = async(event, context) => {
  const { url } = event

  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'

export const handler = async(event, context) => {
  const { url } = event

  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  const { url } = event

  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  const { url } = event

  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  console.info(`Status of ${url} : ${res.status}`)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  return res.status
}

loige

# template.yaml

Type: AWS::Serverless::Function
  Properties:
    # ..
    Environment:
      Variables:
        LOG_LEVEL: DEBUG

loige

loige

loige

import { Logger } from '@aws-lambda-powertools/logger'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })
  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })
  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)

  return res.status
}

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })
  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()

  return res.status
}

loige

loige

loige

Tracing example

loige

Observability is hard!

Can I get something for free, plz? 😩

loige

SLIC Watch

github.com/fourTheorem/slic-watch

loige

  • SLIC Watch gives you Automatic, best-practice CloudWatch Dashboards and Alarms
  • It works with SAM, CloudFormation, CDK, and Serverless Framework applications.

IaC

SLIC Watch

Deploy to AWS

🤔

🔨🤗

Updated IaC

📈📊🚨

loige

How to use it (with SAM)

Step 1: deploy the CF Transform Macro

fth.link/slic-watch-sar

👇

loige

# template.yaml

AWSTemplateFormatVersion : '2010-09-09'
Transform:
  - AWS::Serverless-2016-10-31

Description: |
  A sample Serverless project triggered from S3 CreateObject events
Resources:
  ExampleFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      Events:
        S3CreateObject:
          Type: S3
          Properties:
            Bucket: !Ref MyPhotoBucket
            Events: s3:ObjectCreated:*

  MyPhotoBucket:
    Type: AWS::S3::Bucket

Step 2:
Add the SLIC Watch
transform

loige

# template.yaml

AWSTemplateFormatVersion : '2010-09-09'
Transform:
  - AWS::Serverless-2016-10-31
  - SlicWatch-v2

Description: |
  A sample Serverless project triggered from S3 CreateObject events
Resources:
  ExampleFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      Events:
        S3CreateObject:
          Type: S3
          Properties:
            Bucket: !Ref MyPhotoBucket
            Events: s3:ObjectCreated:*

  MyPhotoBucket:
    Type: AWS::S3::Bucket

loige

Step 2:
Add the SLIC Watch
transform

# template.yaml

AWSTemplateFormatVersion : '2010-09-09'
Transform:
  - AWS::Serverless-2016-10-31
  - SlicWatch-v2
  
Metadata:
  slicWatch:
    enabled: true
    topicArn: !Ref MonitoringTopic

Description: |
  A sample Serverless project triggered from S3 CreateObject events
Resources:
  ExampleFunction:
    Type: AWS::Serverless::Function
    Properties:
      Runtime: nodejs18.x
      Handler: index.handler
      Events:
        S3CreateObject:
          Type: S3
          Properties:
            Bucket: !Ref MyPhotoBucket
            Events: s3:ObjectCreated:*

  MyPhotoBucket:
    Type: AWS::S3::Bucket

Step 3: (optional)
add your config

loige

Step 4: deploy!

$ sam deploy

🥳

loige

Without SLIC watch!

loige

With SLIC watch!

loige

With SLIC watch!

loige

With SLIC watch!

loige

With SLIC watch!

loige

With SLIC watch!

loige

3. Avoid code duplication

🛵

loige

Real World™️  lambda

export const handler = (event, context) => {
  // BOILERPLATE!
  // E.g. decrypt environment variables with KMS
  // deserialize the content of the event
  // validate input, authentication, authorization
  
  // REAL BUSINESS LOGIC
  const response = doSomethingUsefulWith(event)
  
  // MORE BOILERPLATE
  // E.g. validate output
  // serialize response
  // handle errors
  return response
}

loige

Real World™️  lambda

export const handler = (event, context) => {
  // BOILERPLATE!
  // E.g. decrypt environment variables with KMS
  // deserialize the content of the event
  // validate input, authentication, authorization
  
  // REAL BUSINESS LOGIC
  const response = doSomethingUsefulWith(event)
  
  // MORE BOILERPLATE
  // E.g. validate output
  // serialize response
  // handle errors
  return response
}

Lots of boilerplate! 🤷‍♀️

loige

🙇‍♀️

In a real project with many lambdas,
we might end up with a lot of code duplication!

loige

🤔

Can we avoid this clutter by separating
"pure business logic" from the "boilerplate"?

loige

npm install @middy/core

Give it moar love, plz 😍

loige

loige

export const handler = (event, context) => {
  // BOILERPLATE!
  // E.g. decrypt environment variables with KMS
  // deserialize the content of the event
  // validate input, authentication, authorization
  
  // REAL BUSINESS LOGIC
  const response = doSomethingUsefulWith(event)
  
  // MORE BOILERPLATE
  // E.g. validate output
  // serialize response
  // handle errors
  return response
}

loige

import middy from '@middy/core'

export const handler = (event, context) => {
  // BOILERPLATE!
  // E.g. decrypt environment variables with KMS
  // deserialize the content of the event
  // validate input, authentication, authorization
  
  // REAL BUSINESS LOGIC
  const response = doSomethingUsefulWith(event)
  
  // MORE BOILERPLATE
  // E.g. validate output
  // serialize response
  // handle errors
  return response
}

loige

import middy from '@middy/core'

const lambdaHandler = (event, context) => {
  // REAL BUSINESS LOGIC
  return doSomethingUsefulWith(event)
}

export const handler = (event, context) => {
  // BOILERPLATE!
  // E.g. decrypt environment variables with KMS
  // deserialize the content of the event
  // validate input, authentication, authorization
  
  // MORE BOILERPLATE
  // E.g. validate output
  // serialize response
  // handle errors
}

loige

import middy from '@middy/core'

const lambdaHandler = (event, context) => {
  // REAL BUSINESS LOGIC
  return doSomethingUsefulWith(event)
}

export const handler = middy(lambdaHandler)
  .use(/* KMS stuff */)
  .use(/* input deserializer */)
  .use(/* validation */)
  .use(/* auth */)
  .use(/* output serialization */)
  .use(/* error handling */)

loige

A more realistic example
(since Power Tools support Middy...)

loige

import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

loige

import middy from '@middy/core'
import { Logger } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

export const handler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {
  logger.debug('Received event', { event })
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {
  logger.debug('Received event', { event }) // ❌
  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))

loige

Type: AWS::Serverless::Function
  Properties:
    # ..
    Environment:
      Variables:
        LOG_LEVEL: DEBUG
        POWERTOOLS_LOGGER_LOG_EVENT: "true"

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits, logMetrics } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits, logMetrics } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics()
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))
  .use(logMetrics(metrics))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits, logMetrics } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  metrics.publishStoredMetrics() // ❌
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))
  .use(logMetrics(metrics))

loige

import middy from '@middy/core'
import { Logger, injectLambdaContext } from '@aws-lambda-powertools/logger'
import { Metrics, MetricUnits, logMetrics } from '@aws-lambda-powertools/metrics'

const logger = new Logger({ serviceName: 'httpCheck' })
const metrics = new Metrics({ namespace: 'utils', serviceName: 'httpCheck' })

const lambdaHandler = async(event, context) => {  
  const { url } = event
  logger.debug('Checking url', { url })

  const res = await fetch(url)
  logger.info('Url status', { url, status: res.status })

  const successMetric = metrics.singleMetric()
  successMetric.addDimension('status', String(res.status))
  successMetric.addMetric('successfulRequests', MetricUnits.Count, 1)
  metrics.addMetric(`successfulRequests${String(res.status)[0]}xx`, MetricUnits.Count, 1)
  return res.status
}

export const handler = middy(lambdaHandler)
  .use(injectLambdaContext(logger))
  .use(logMetrics(metrics))

loige

Middy comes with a built-in collection
of useful middleware

And it's very easy to create your own custom middleware!

loige

Why Middy?

  • Simplify your code
  • Reusability
    • input parsing
    • input & output validation
    • output serialization
    • error handling...
  • Focus (even) MORE on business logic
  • Testability

loige

Let's support Middy development! ❤️ 

💰 Sponsor Will on GitHub

🛵 Contribute to Middy

loige

4. Performance

⚡️

loige

🔧Fine Tuning

Your lambdas

loige

Fine tuning your Lambdas

  • If you give your lambdas more memory you get more CPU
  • Sometimes having more memory (hence more CPU) can make your executions faster and you can save money
  • So how can we find the sweet spot?!

loige

Lambda Power Tuning

A step function that can test different configurations of your Lambda

github.com/alexcasalboni/aws-lambda-power-tuning

loige

5. Other suggestions

🤫

loige

moar tips 🙀

  • use the AWS SDK v3 (more modular, easier to test)
  • use a module bundler (e.g. ESBuild with SAM)
  • use TypeScript (typed events and responses)
  • Re-use objects across invocations (keeping db connections and other shared objects outside the handler)
  • Config through Env Variables
  • Sensitive config through SSM & Secrets Manager

loige

Summary

  • Serverless is great because it let us focus more on what's important for the business!
  • Lambda is a great tool when it comes to writing serverless code
  • We should strive to use IaC to make our deployments versioned & reproducible
  • We can use Power Tools and SLIC Watch to make our apps more observable
  • We can use Middy to improve our code structure
  • We can use Lambda Power Tuning to optimise our Lambda configuration

loige

Cover photo by Vidar Nordli-Mathisen on Unsplash
Pirate GIFs by PiratesParley

Thanks to Stella Samuel, Eoin Shanaghy, Will Farrell, and Guilherme Dalla Rosa for the awesome suggestions!

nodejsdp.link

loige.link/lambda-pirate

Grab these slides!

github.com/lmammino/http-check

loige

Production-ready lambdas with Node.js - SailsConf 2023

By Luciano Mammino

Production-ready lambdas with Node.js - SailsConf 2023

A few tips that I learned along the way on how to build production-grade lambdas using AWS: testing, logging, metrics, tracing, infrastructure as code, code reuse, frameworks, and more! Writing Lambdas is quite easy, at the end of the day it is just a function, right?! But writing GOOD production-grade lambdas, well that is an entirely another story. In this talk, I will share some of the tips and tricks that I learned in building Lambda functions in Node.js during the last 6 years. We will talk about code organization and code reuse, logging, metrics, tracing, infrastructure as code, and more.

  • 1,952

More from Luciano Mammino