sst

What is sst?

The SST (Serverless Stack Toolkit) npm package is a framework for building serverless applications. It provides a set of tools and abstractions to simplify the development, deployment, and management of serverless applications on AWS. SST supports various AWS services and allows developers to define their infrastructure as code using AWS CDK (Cloud Development Kit).

What are sst's main functionalities?

Define Infrastructure

This feature allows you to define your cloud infrastructure using SST. In this example, an S3 bucket is created within a stack.

const sst = require('@serverless-stack/resources');

class MyStack extends sst.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define an S3 bucket
    const bucket = new sst.Bucket(this, 'MyBucket');
  }
}

module.exports = function main(app) {
  new MyStack(app, 'my-stack');
};

Deploy Lambda Functions

This feature allows you to deploy AWS Lambda functions easily. In this example, a Lambda function is defined with a handler located at 'src/lambda.handler'.

const sst = require('@serverless-stack/resources');

class MyStack extends sst.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define a Lambda function
    const lambda = new sst.Function(this, 'MyFunction', {
      handler: 'src/lambda.handler',
    });
  }
}

module.exports = function main(app) {
  new MyStack(app, 'my-stack');
};

API Gateway Integration

This feature allows you to integrate API Gateway with your Lambda functions. In this example, an API Gateway is created with a route that triggers the Lambda function defined at 'src/lambda.handler'.

const sst = require('@serverless-stack/resources');

class MyStack extends sst.Stack {
  constructor(scope, id, props) {
    super(scope, id, props);

    // Define an API Gateway
    const api = new sst.Api(this, 'Api', {
      routes: {
        'GET /': 'src/lambda.handler',
      },
    });
  }
}

module.exports = function main(app) {
  new MyStack(app, 'my-stack');
};

Other packages similar to sst

serverless

The Serverless Framework is a popular open-source framework for building and deploying serverless applications. It supports multiple cloud providers, including AWS, Azure, and Google Cloud. Compared to SST, Serverless Framework offers a more extensive plugin ecosystem and broader cloud provider support, but SST provides tighter integration with AWS CDK.

aws-cdk

The AWS Cloud Development Kit (CDK) is a framework for defining cloud infrastructure using familiar programming languages. It allows developers to define their infrastructure as code and provides high-level constructs for AWS services. While SST uses AWS CDK under the hood, it adds additional abstractions and tools specifically for serverless applications, making it easier to work with serverless architectures.

pulumi

Pulumi is an infrastructure as code tool that allows developers to define cloud resources using general-purpose programming languages. It supports multiple cloud providers and offers a flexible and modern approach to infrastructure management. Compared to SST, Pulumi provides broader cloud provider support and language flexibility, but SST offers a more focused experience for AWS serverless applications.

README

serverless-http

Description

This module allows you to 'wrap' your API for serverless use. No HTTP server, no ports or sockets. Just your code in the same execution pipeline you are already familiar with.

Sponsors

Thank you to Upstash for reaching out to sponsor this project!

Upstash: Serverless Database for Redis Serverless Redis with global replication and durable storage Price scales to zero with per request pricing Built-in REST API designed for serverless and edge functions Start for free in 30 seconds!

Support

Supported Frameworks

(* Experimental)

• Node (http.createServer)
• Connect
• Express
• Koa
• Restana
• Sails *
• Hapi *
• Fastify *
• Restify *
• Polka *
• Loopback *

Supported Providers

• AWS
• Azure (Experimental, untested, probably outdated)

Examples

Please check the examples folder!

Usage example using the Koa framework

const serverless = require('serverless-http');
const Koa = require('koa'); // or any supported framework

const app = new Koa();

app.use(/* register your middleware as normal */);

// this is it!
module.exports.handler = serverless(app);

// or as a promise
const handler = serverless(app);
module.exports.handler = async (event, context) => {
  // you can do other things here
  const result = await handler(event, context);
  // and here
  return result;
};

Usage example using the Express framework with Azure

const serverless = require('serverless-http');
const express = require('express');

const app = express();

app.use(/* register your middleware as normal */);

const handler = serverless(app, { provider: 'azure' });
module.exports.funcName = async (context, req) => {
  context.res = await handler(context, req);
}

Other examples

json-server-less-λ - using serverless-http with json-server and serverless framework in AWS

Limitations

Your code is running in a serverless environment. You cannot rely on your server being 'up' in the sense that you can/should not use in-memory sessions, web sockets, etc. You are also subject to provider specific restrictions on request/response size, duration, etc.

Think of this as a familiar way of expressing your app logic, not trying to make serverless do something it cannot.

Contributing

Pull requests are welcome! Especially test scenarios for different situations and configurations.

Further Reading

Here are some more detailed examples and advanced configuration options as well as provider-specific documentation