Faast.js

Serverless batch computing made simple.

Serverless
faastjs/faast.jsfaastjs.orgfaastjs

README

faast.js


License CircleCI codecov semantic-release FOSSA Status

Faast.js makes regular functions callable as serverless functions on AWS Lambda and Google Cloud. It handles the details of uploading your code, creating cloud infrastructure, and cleaning up. Scale up your functions to a thousand cores in seconds :rocket:

Faast.js is a pure library with no service dependencies, operational overhead, or unnecessary complexity.

Installation


Faast.js requires node version 8+.

  1. ```shell
  2. $ npm install faastjs
  3. ```

Example


First write the functions you want to run in a serverless function. Make sure to export them:

  1. ```typescript
  2. // functions.ts
  3. export function hello(name: string) {
  4.     return "hello " + name;
  5. }
  6. ```

Use faast.js to turn this into a serverless function:

  1. ```typescript
  2. // main.ts
  3. import { faast } from "faastjs";
  4. import * as funcs from "./functions";

  6. (async () => {
  7.     const m = await faast("aws", funcs);
  8.     const { hello } = m.functions;
  9.     const result = await hello("world!");
  10.     console.log(result);
  11.     await m.cleanup();
  12. })();
  13. ```

Make 1000 concurrent calls if you like:

  1. ```typescript
  2. const promises: string[] = [];
  3. for (let i = 0; i < 1000; i++) {
  4.     promises.push(hello(`world ${i}!`));
  5. }
  6. await Promise.all(promises);
  7. ```

How much did that cost...?

  1. ```typescript
  2. const cost = await m.costSnapshot();
  3. console.log(`$${cost.total()}`);
  4. ```

Relax. It's just half a penny:

  1. ```
  2. $0.00420858
  3. ```

Features


-   Frictionless. Faast.js takes care of packaging your code, setting up IAM roles, and other infrastructure complexity. Run your code on a thousand cores in seconds. All you need is an AWS or GCP account.
-   Scalable. Use serverless functions to scale your batch jobs up to thousands of cores.
-   Cost-effective. Understand and optimize your workload costs in real time. Pay only for compute time actually used.
-   Ephemeral. No clusters or services to manage. Faast.js creates the infrastructure it uses on the fly and cleans up when it's done.
-   Productive. First class support for TypeScript and JavaScript. Type safety, documentation, and extensive testing are part of our DNA.
-   Multi-cloud: Built-in support for AWS Lambda and Google Cloud Functions, as well as local processing mode when you don't have network access. Switch with one line of code.

Ready to learn more?


Check out our getting started documentation.

Work through some examples

Review the detailed API documentation.

Join our discord channel.

Follow us on twitter.

Contributing


See contributing.