Deploy Background Workers

Perfect For

How It Works

1. 1

   Write your worker

   A normal Node.js, Python, or Go process. Loop forever, await your queue, do the work.

2. 2

   Push to Tokay

   git push tokay we detect it as a background worker.

3. 3

   It just runs

   No URL, no schedule. Your process stays alive in the background, and we give you logs and a way to stop and start it.

4. 4

   It stays up

   If your process crashes, we restart it. If you push a new version, we swap it in cleanly.

When to Pick a Background Worker

The four service types each fit a different shape of work. Here's the quick test:

Just Write Your Worker

No framework to learn. Loop, do work, log. We keep the process alive.

Node.js Queue Consumer

// worker.js - Pulls jobs off SQS forever
const { SQSClient, ReceiveMessageCommand, DeleteMessageCommand } = require('@aws-sdk/client-sqs');

const sqs = new SQSClient({ region: 'us-east-1' });
const QueueUrl = process.env.QUEUE_URL;

async function processJob(body) {
  console.log('Processing', body.id);
  // ... do the work
}

async function run() {
  console.log('Worker started');
  while (true) {
    const { Messages = [] } = await sqs.send(new ReceiveMessageCommand({
      QueueUrl,
      WaitTimeSeconds: 20,
      MaxNumberOfMessages: 10,
    }));

    for (const m of Messages) {
      await processJob(JSON.parse(m.Body));
      await sqs.send(new DeleteMessageCommand({ QueueUrl, ReceiptHandle: m.ReceiptHandle }));
    }
  }
}

run().catch((err) => {
  console.error('Worker crashed:', err);
  process.exit(1);
});

Python Poller

# poller.py - Sync an external API every 30 seconds, forever
import os, time, requests

API = os.environ['UPSTREAM_URL']
TOKEN = os.environ['UPSTREAM_TOKEN']

def sync_once():
    res = requests.get(API, headers={'Authorization': f'Bearer {TOKEN}'})
    res.raise_for_status()
    for item in res.json():
        # ... write to your database
        print('synced', item['id'])

def run():
    print('Poller started')
    while True:
        try:
            sync_once()
        except Exception as e:
            print('sync failed:', e)
        time.sleep(30)

if __name__ == '__main__':
    run()

Go Stream Processor

// main.go - Consume a Kafka topic forever
package main

import (
    "context"
    "log"
    "os"

    "github.com/segmentio/kafka-go"
)

func main() {
    r := kafka.NewReader(kafka.ReaderConfig{
        Brokers: []string{os.Getenv("KAFKA_BROKERS")},
        Topic:   "events",
        GroupID: "tokay-worker",
    })
    defer r.Close()

    log.Println("Worker started")
    for {
        msg, err := r.ReadMessage(context.Background())
        if err != nil {
            log.Fatalf("read failed: %v", err)
        }
        log.Printf("event %s: %s", msg.Key, msg.Value)
        // ... process the event
    }
}

Push it. We detect it as a background worker, keep it running, and stream you the logs.

What We Handle For You