Generated banner for Render Background Workers
Generated logo for Render Background Workers

Render Background Workers

RenderOfficialCreated by Render

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • Low risk

From the author

Sets up and configures background workers on Render for queue-based job processing. Use when the user needs to process async jobs, consume from a queue, run Celery/Sidekiq/BullMQ/Asynq/Oban workers, handle graceful shutdown with SIGTERM, wire a worker to Key Value, or choose between workers and cron jobs for background work. Trigger terms: background worker, async jobs, queue consumer, Celery, Sidekiq, BullMQ, Asynq, Oban, job processing, SIGTERM, graceful shutdown.
— the description by Render

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides guidance on setting up, configuring, and maintaining background worker services on Render. It covers the architectural requirements for long-running, non-HTTP processes that consume jobs from queues, including integration with Render Key Value, framework-specific setup for tools like Celery and Sidekiq, and critical implementation details for graceful shutdowns to prevent job loss.

What it does

  • Explains the architecture of Render background workers as non-HTTP, long-running processes.
  • Provides configuration patterns for connecting workers to Render Key Value as a job broker.
  • Details how to implement graceful shutdown handlers to ensure in-flight jobs complete during deploys.
  • Offers guidance on choosing between background workers, Cron Jobs, and Workflows.
  • Includes Blueprint configuration examples for defining worker services in render.yaml.

When to use it

  • When you need to process asynchronous jobs using frameworks like Celery, Sidekiq, BullMQ, Asynq, or Oban.
  • When you need to configure a worker to consume from a queue backend.
  • When you need to ensure your worker handles SIGTERM signals correctly to avoid data loss during deployments.
  • When you are deciding whether a background worker is the appropriate service type for your task compared to a Cron Job or Workflow.

Advantages

  • Prevents job loss and duplication by implementing proper graceful shutdown procedures.
  • Optimizes resource usage by correctly configuring queue brokers and eviction policies.
  • Provides clear architectural distinctions between different background processing models on Render.
  • Standardizes the integration of worker services within Render Blueprints.

Usage examples

“How do I configure a Celery worker on Render?”
The agent provides the necessary Blueprint configuration, including the worker service definition and the environment variable wiring for the Redis-compatible Key Value broker.
“How can I prevent my background jobs from failing during a deployment?”
The agent explains how to implement SIGTERM signal handling and configure maxShutdownDelaySeconds to allow in-flight jobs to finish before the process exits.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/render-oss/render-background-workers/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip render-background-workers.zip -d .agents/skills

Documentation by Render

Render Background Workers

This skill explains worker services on Render: processes that consume jobs from a queue instead of serving HTTP. Pair with render-blueprints, render-env-vars, and render-networking when wiring render.yaml and private connectivity.

When to Use

  • Designing or debugging queue-backed workers (Celery, Sidekiq, BullMQ, Asynq, etc.)

  • Choosing between a worker, Cron Job, or Workflow for background work

  • Configuring Render Key Value as a broker (not a cache) with correct eviction policy

  • Implementing graceful shutdown so in-flight jobs are not lost on deploy

Per-framework setup and signal-handling detail: references/queue-framework-setup.md, references/graceful-shutdown.md.

Before deploying, restarting, or changing shutdown behavior, read references/deployments.md. Before configuring or troubleshooting a worker's outbound private-network connection, read references/private-networking.md. When choosing between a worker, cron job, and Workflow, read references/service-types.md.

How Workers Work

  • Long-running services with no inbound (HTTP) traffic. Render does not expose a public URL or internal hostname for workers the way it does for web or private services—workers cannot receive private network traffic directed at them.

  • The typical pattern is a poll loop: the process connects to a queue backend (often Render Key Value, Redis-compatible Valkey 8) and pulls jobs.

  • Workers can initiate outbound connections on the private network—to PostgreSQL, Key Value, private services, web services (internal URLs), and the public internet—subject to your plan and firewall rules.

Queue Framework Overview

FrameworkLanguageQueue backendNotes
CeleryPythonKey ValueMost common Python task queue
SidekiqRubyKey ValueStandard for Rails
BullMQNode.jsKey ValueModern Node queue
AsynqGoKey ValueGo async task processing
ObanElixirPostgres (not a Key Value queue)Queue stored in the database

Pairing with Key Value

  • Use Render Key Value as the job broker when your framework expects Redis.

  • Set maxmemory policy to noeviction. allkeys-lru and similar policies are for caches; evicting queue keys drops jobs.

  • Wire REDIS_URL (or your framework’s equivalent) via fromService with type: keyvalue and property: connectionString in the Blueprint.

  • Blueprints require ipAllowList on Key Value—include the CIDRs that should reach the instance (often [] for private-network-only access; see render-blueprints / Key Value field reference).

See references/queue-framework-setup.md for minimal app + YAML examples.

Worker vs Cron vs Workflow

NeedUseWhy
Always-on queue consumerBackground WorkerPolls continuously; long-lived process
Periodic scheduled taskCron JobRuns on a schedule, exits; 12h max per run
Distributed parallel computeWorkflowEach run gets its own instance; fan-out patterns
High-volume or bursty jobsWorkflowScales per run without a continuously running worker instance

Graceful Shutdown

  • Workers should: (1) stop accepting new jobs, (2) finish the current job or checkpoint progress, (3) close connections, (4) exit 0.

  • Follow references/deployments.md for Render's current drain, signal, and shutdown-delay behavior.

Language- and framework-specific handlers: references/graceful-shutdown.md.

Blueprint Configuration

Minimal pattern: type: worker, runtime, buildCommand, startCommand, and envVars wired from Key Value.

services:
  - type: keyvalue
    name: jobs
    plan: starter
    region: oregon
    maxmemoryPolicy: noeviction
    ipAllowList: []

  - type: worker
    name: task-worker
    runtime: python
    region: oregon
    plan: starter
    buildCommand: pip install -r requirements.txt
    startCommand: celery -A tasks worker --loglevel=info
    envVars:
      - key: REDIS_URL
        fromService:
          name: jobs
          type: keyvalue
          property: connectionString

Optional: maxShutdownDelaySeconds on the worker service for longer draining jobs.

References

TopicFile
Celery, Sidekiq, BullMQ, Asynq, Oban setup + YAMLreferences/queue-framework-setup.md
SIGTERM, maxShutdownDelaySeconds, per-language patternsreferences/graceful-shutdown.md
Deploy lifecycle, shutdown, restart, and verificationreferences/deployments.md
Private-network scope, internal addresses, and troubleshootingreferences/private-networking.md
Service-type selection and execution modelsreferences/service-types.md
  • render-deploy — First deploy, CLI, service creation

  • render-blueprints — Full render.yaml schema, fromService, projects

  • render-networking — Private URLs, what can call what

  • render-scaling — Worker plans, instance counts, limits

<!-- shared:documentation-retrieval -->

Current documentation retrieval

Whenever this skill directs you to consult current Render documentation:

  1. Retrieve the linked Markdown document directly with an available URL-fetching tool or HTTP client, such as curl. Do not substitute web-search summaries for the document.

  2. Confirm that retrieval succeeded and returned the expected document, then read its contents. Saving a file or printing its path is not sufficient.

  3. If the request fails or your tool cannot read the Markdown response, open and read the linked HTML version instead.

  4. If neither version can be retrieved, disclose that the current reference is unavailable and follow any topic-specific fallback in the skill. Use bundled guidance only for stable constraints, and do not guess at changeable platform details.

When a task requires multiple references, apply this workflow to each one and distinguish the documents you verified from those that remain unavailable.

<!-- /shared:documentation-retrieval -->

Files

references/queue-framework-setup.md

Queue framework setup on Render

Minimal patterns for running each stack as a type: worker service. Replace regions, plans, and commands to match your repo.

Shared Key Value wiring — add once, reference from every consumer that needs the broker:

services:
  - type: keyvalue
    name: jobs
    region: oregon
    plan: starter
    maxmemoryPolicy: noeviction
    ipAllowList: []

Env var (worker or web that enqueues):

envVars:
  - key: REDIS_URL
    fromService:
      name: jobs
      type: keyvalue
      property: connectionString

The Blueprint sets Key Value maxmemoryPolicy: noeviction so queue keys are never evicted like cache entries.


Celery (Python)

Install

pip install "celery[redis]"

Minimal app (tasks.py / package root):

import os
from celery import Celery

app = Celery("tasks", broker=os.environ["REDIS_URL"])

@app.task
def add(x, y):
    return x + y

Start command (adjust module path):

celery -A tasks worker --loglevel=info

Blueprint (worker)

  - type: worker
    name: celery-worker
    runtime: python
    region: oregon
    plan: starter
    buildCommand: pip install -r requirements.txt
    startCommand: celery -A tasks worker --loglevel=info
    envVars:
      - key: REDIS_URL
        fromService:
          name: jobs
          type: keyvalue
          property: connectionString

Sidekiq (Ruby)

Gemfile

gem "sidekiq"

Initializer (config/initializers/sidekiq.rb or equivalent):

Sidekiq.configure_server do |config|
  config.redis = { url: ENV.fetch("REDIS_URL") }
end

Sidekiq.configure_client do |config|
  config.redis = { url: ENV.fetch("REDIS_URL") }
end

Start command

bundle exec sidekiq

Blueprint (worker)

  - type: worker
    name: sidekiq
    runtime: ruby
    region: oregon
    plan: starter
    buildCommand: bundle install
    startCommand: bundle exec sidekiq
    envVars:
      - key: REDIS_URL
        fromService:
          name: jobs
          type: keyvalue
          property: connectionString

BullMQ (Node.js)

Install

npm install bullmq ioredis

Minimal worker (worker.js):

const { Worker } = require("bullmq");
const IORedis = require("ioredis");

const connection = new IORedis(process.env.REDIS_URL, {
  maxRetriesPerRequest: null,
});

const worker = new Worker("myqueue", async (job) => job.data, { connection });

Start command

node worker.js

Blueprint (worker)

  - type: worker
    name: bullmq-worker
    runtime: node
    region: oregon
    plan: starter
    buildCommand: npm ci
    startCommand: node worker.js
    envVars:
      - key: REDIS_URL
        fromService:
          name: jobs
          type: keyvalue
          property: connectionString

Asynq (Go)

Module

go get github.com/hibiken/asynq

Minimal worker (simplified):

package main

import (
    "log"
    "os"

    "github.com/hibiken/asynq"
)

func main() {
    redisOpt, err := asynq.ParseRedisURI(os.Getenv("REDIS_URL"))
    if err != nil {
        log.Fatal(err)
    }
    srv := asynq.NewServer(redisOpt, asynq.Config{Concurrency: 10})
    mux := asynq.NewServeMux()
    // mux.HandleFunc("task:type", handler)
    if err := srv.Run(mux); err != nil {
        log.Fatal(err)
    }
}

Start command (after go build in buildCommand or run go run):

./worker

Blueprint (worker)

  - type: worker
    name: asynq-worker
    runtime: go
    region: oregon
    plan: starter
    buildCommand: go build -o worker ./cmd/worker
    startCommand: ./worker
    envVars:
      - key: REDIS_URL
        fromService:
          name: jobs
          type: keyvalue
          property: connectionString

Oban (Elixir)

Oban uses PostgreSQL as its queue store—not a Key Value queue. Provision a Render PostgreSQL database and wire DATABASE_URL.

Config (config/runtime.exs or config/prod.exs pattern):

config :my_app, Oban,
  repo: MyApp.Repo,
  queues: [default: 10]

Start command (typical Release):

_build/prod/rel/my_app/bin/my_app start

Blueprint (worker) — fromDatabase for DATABASE_URL:

databases:
  - name: app-db
    plan: basic-256mb
    region: oregon

services:
  - type: worker
    name: oban-worker
    runtime: elixir
    region: oregon
    plan: starter
    buildCommand: mix deps.get && mix release
    startCommand: _build/prod/rel/my_app/bin/my_app start
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: app-db
          property: connectionString

Do not point Oban at Key Value unless you are using an experimental or custom backend; default Oban is Postgres-only.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

The author says: Render background worker services

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Render
Publisher
Render (Official)
Source
render-oss/skills · skills/render-background-workers · commit b985a63
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Render or Render.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download render-background-workers.zip