Serverless

• AWS Lambda
• Zeit Now

Attention Readers:

The sample provided allows you to easily build serverless web applications/services and RESTful APIs using Fastify on top of AWS Lambda and Amazon API Gateway.

Note: Using aws-lambda-fastify is just one possible way.

app.js

When executed in your lambda function we don't need to listen to a specific port, so we just export the wrapper function in this case. The lambda.js file will use this export.

When you execute your Fastify application like always, i.e. node app.js (the detection for this could be require.main === module), you can normally listen to your port, so you can still run your Fastify function locally.

const awsLambdaFastify = require('aws-lambda-fastify')
const init = require('./app');
const proxy = awsLambdaFastify(init())
// or
// const proxy = awsLambdaFastify(init(), { binaryMimeTypes: ['application/octet-stream'] })
exports.handler = proxy;
// or
// exports.handler = (event, context, callback) => proxy(event, context, callback);
// or
// exports.handler = (event, context) => proxy(event, context);
// or
// exports.handler = async (event, context) => proxy(event, context);

Example

An example deployable with claudia.js can be found .

Considerations

• API Gateway has a timeout of 29 seconds, so it's important to provide a reply during this time.

Unlike AWS Lambda or Google Cloud Functions, Google Cloud Run is a serverless container environment. It's primary purpose is to provide an infrastructure-abstracted environment to run arbitrary containers. As a result, Fastify can be deployed to Google Cloud Run with little-to-no code changes from the way you would write your Fastify app normally.

Follow the steps below to deploy to Google Cloud Run if you are already familiar with gcloud or just follow their .

In order for Fastify to properly listen for requests within the container, be sure to set the correct port and address:

function build() {
  const fastify = Fastify({ trustProxy: true })
  return fastify
}
async function start() {
  // Google Cloud Run will set this environment variable for you, so
  const IS_GOOGLE_CLOUD_RUN = process.env.K_SERVICE !== undefined
  // You must listen on the port Cloud Run provides
  const port = process.env.PORT || 3000
  // You must listen on all IPV4 addresses in Cloud Run
  const address = IS_GOOGLE_CLOUD_RUN ? "0.0.0.0" : undefined
  try {
    const server = build()
    const address = await server.listen(port, address)
    console.log(`Listening on ${address}`)
  } catch (err) {
    console.error(err)
    process.exit(1)
  }
}
module.exports = build
if (require.main === module) {
  start()

Add a Dockerfile

You can add any valid Dockerfile that packages and runs a Node app. A basic Dockerfile can be found in the official .

Add a .dockerignore

Dockerfile
README.md
node_modules
npm-debug.log

Next, submit your app to be built into a Docker image by running the following command (replacing PROJECT-ID and with your GCP project id and an app name):

gcloud builds submit --tag gcr.io/PROJECT-ID/APP-NAME

Deploy Image

After your image has built, you can deploy it with the following command:

Your app will be accessible from the URL GCP provides.

now provides zero configuration deployment for Node.js applications. In order to use now, it is as simple as configuring your now.json file like the following:

{
  "version": 2,
  "builds": [
    {
      "src": "api/serverless.js",
      "use": "@now/node",
      "config": {
        "helpers": false
      }
    }
  ],
  "routes": [
    { "src": "/.*", "dest": "/api/serverless.js"}
  ]
}

Then, write a api/serverless.js like so:

'use strict'
const build = require('./index')
const app = build()
module.exports = async function (req, res) {
  await app.ready()
  app.server.emit('request', req, res)
}

Note that you'll need to use Node 10 by setting it in package.json:

  "engines": {
  },