Long running jobs

We launched a new construct that makes it easy to run functions longer than 15 minutes — `Job]

These are useful for cases where you are running async tasks like video processing, ETL, and ML. A Job can run for up to 8 hours.

Job is made up of:

1. Job — a construct that creates the necessary infrastructure.
2. JobHandler — a handler function that wraps around your function code in a typesafe way.
3. Job.run — a helper function to invoke the job.

Launch event

We hosted a launch livestream where we demoed the new construct, did a deep dive, and answered some questions.

The video is timestamped and here’s roughly what we covered.

1. Intro
2. Demo
3. Deep Dive
   • Deep dive into the construct
   • Granting permissions for running the job
   • Typesafety
   • Defining the job handler
   • Running the job
   • Live debugging the job
4. Q&A
   • Q: When should I use Job vs Function?
   • Q: Is Job a good fit for batch jobs?
   • Q: Why CodeBuild instead of Fargate?

Get started

Here’s how you use the new Job construct. Start by creating a new job.

import { Job } from "@serverless-stack/resources";

const job = new Job(stack, "MyJob", {
  srcPath: "services",
  handler: "functions/myJob.handler",
});

Add the job handler.

import { JobHandler } from "@serverless-stack/node/job";

declare module "@serverless-stack/node/job" {
  export interface JobTypes {
    MyJob: {
      foo: string;
    };
  }
}

export const handler = JobHandler("MyJob", async (payload) => {
  // Do the job
});

Finally invoke the job.

import { Job } from "@serverless-stack/node/job";

function someFunction() {
  await Job.run("MyJob", {
    payload: {
      foo: "Hello World",
    },
  });
}

Note that the payload and job name MyJob here are typesafe.

For a full tutorial check out the Quick Start in the docs.