AutoGineer
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
Download ZIP

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://mp-staging.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

Related Skills

  • 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/service-types.md

<!-- shared:service-types -->

Render service types

Use this guidance when selecting or comparing Render service types, or when a task's architecture depends on the distinction between them. A task that is already unambiguously scoped to one service type does not need this entire overview.

On Render, a service represents code deployed for a particular execution model. Render runs that service on one or more instances, and the service's compute plan determines the CPU and memory available to each instance.

Before choosing a service type, fetch the current service-types reference:

Using the documentation-retrieval workflow in the root SKILL.md, retrieve and read the Markdown reference or its HTML version.

If neither version can be retrieved, use the bundled overview below only for basic service-type selection. State that current platform details could not be verified, and do not guess about changeable capabilities such as supported runtimes, plans, scaling, networking, disks, health checks, deployment behavior, availability, or limits.

Render provides six public service types for running code:

  • Web service: A continuously running server that receives public HTTP traffic and also has an internal hostname for private-network traffic. Use it for dynamic websites, APIs, and other internet-facing server applications.

  • Static site: Built HTML, CSS, JavaScript, and other static assets served publicly from Render's global CDN. Use it only when the deployed application does not require server-side runtime logic.

  • Private service: A continuously running server that receives traffic only over Render's private network. Use it for internal HTTP, TCP, gRPC, or other server processes that need an internal hostname but no public URL.

  • Background worker: A continuously running process that does not receive incoming traffic or expose a public or internal hostname. Use it for queue consumers and other processes that pull or poll for work.

  • Cron job: A command or process that starts on a schedule, performs a bounded unit of work, and exits. Use it for straightforward recurring tasks rather than an always-running process.

  • Workflow: A collection of on-demand tasks executed across distributed compute, with Render handling task queuing, orchestration, and provisioning. Use it when the workload benefits from independently invoked tasks, retries, composition, or parallel execution instead of a continuously running worker process.

Choose based on how the code executes and receives work:

  • Public incoming traffic that requires server-side logic belongs on a web service. Public static assets with no runtime server belong on a static site.

  • An application that needs both public and private ingress remains a web service; use its internal hostname for traffic from other Render services.

  • A process that receives private-network requests belongs on a private service. A process that only initiates connections and pulls work belongs on a background worker.

  • A simple scheduled command that exits belongs on a cron job. An always-running queue consumer belongs on a background worker. On-demand or distributed tasks for which Render should manage queuing and per-run compute belong in a workflow.

Cron jobs and Workflows use invocation-based execution models. The ordinary instance-count and autoscaling model used by continuously running services does not apply to them.

Render Postgres and Render Key Value are fully managed datastores, not general-purpose compute service types for running application code. Use Render Postgres for relational data and Render Key Value for use cases such as shared caching and job queues. An attached persistent disk is a storage feature of certain compute services, not a service type of its own.

After selecting a type, fetch the product article linked from the service-types reference before relying on details such as supported runtimes and sources, plans, scaling, networking, disks, health checks, deployment behavior, scheduling semantics, availability, or limits. These capabilities are not uniform across service types and can change independently.

Human-facing service names do not always map directly to configuration identifiers or structure. When creating or editing a Blueprint, fetch the current Blueprint specification and use its service-type schema instead of inferring fields or values from this overview. In particular, do not assume that every Dashboard service type has a same-named Blueprint type or that managed datastores are declared like compute services.

<!-- /shared:service-types -->

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.

Download ZIP

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