Job Queues with Arctickey

Redis-based job queues are the standard for background processing. Arctickey supports all major queue libraries.

Why Redis for Queues?#

Reliable — jobs persist even if workers crash
Fast — enqueue thousands of jobs per second
Scalable — add workers as needed
Visible — monitor queue depth and job status

BullMQ (Node.js)#

The most popular Node.js queue library:

Terminal

npm install bullmq

TypeScript

import { Queue, Worker } from 'bullmq';

const connection = {
  host: 'YOUR_INSTANCE.eu.arctickey.com',
  port: 6379,
  password: 'YOUR_PASSWORD',
  tls: {},
};

// Create a queue
const emailQueue = new Queue('emails', { connection });

// Add a job
await emailQueue.add('welcome', {
  to: 'user@example.com',
  subject: 'Welcome!',
  template: 'welcome',
});

// Add with options
await emailQueue.add('reminder', 
  { userId: '123' },
  {
    delay: 60000,        // 1 minute delay
    attempts: 3,         // Retry 3 times
    backoff: {
      type: 'exponential',
      delay: 1000,
    },
  }
);

Processing Jobs#

TypeScript

const worker = new Worker('emails', async (job) => {
  console.log(`Processing ${job.name} job ${job.id}`);
  
  switch (job.name) {
    case 'welcome':
      await sendWelcomeEmail(job.data);
      break;
    case 'reminder':
      await sendReminder(job.data);
      break;
  }
}, { connection });

worker.on('completed', (job) => {
  console.log(`Job ${job.id} completed`);
});

worker.on('failed', (job, err) => {
  console.error(`Job ${job?.id} failed:`, err);
});

Scheduled Jobs (Cron)#

TypeScript

// Run every day at 9 AM
await emailQueue.add(
  'daily-digest',
  {},
  {
    repeat: {
      pattern: '0 9 * * *',
      tz: 'Europe/Stockholm',
    },
  }
);

Sidekiq (Ruby)#

Configure Sidekiq to use Arctickey:

Ruby

# config/initializers/sidekiq.rb
Sidekiq.configure_server do |config|
  config.redis = {
    url: 'rediss://:YOUR_PASSWORD@YOUR_INSTANCE.eu.arctickey.com:6379',
    ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
  }
end

Sidekiq.configure_client do |config|
  config.redis = {
    url: 'rediss://:YOUR_PASSWORD@YOUR_INSTANCE.eu.arctickey.com:6379',
    ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
  }
end

Creating Workers#

Ruby

# app/workers/email_worker.rb
class EmailWorker
  include Sidekiq::Worker
  sidekiq_options retry: 3, queue: 'default'

  def perform(user_id, template)
    user = User.find(user_id)
    UserMailer.send(template, user).deliver_now
  end
end

# Enqueue a job
EmailWorker.perform_async(user.id, 'welcome')

# Schedule for later
EmailWorker.perform_in(1.hour, user.id, 'reminder')

Laravel Queues#

Configure Redis queues in Laravel:

PHP

// config/database.php
'redis' => [
    'client' => 'predis',
    'default' => [
        'url' => env('REDIS_URL'),
        'scheme' => 'tls',
    ],
    'queue' => [
        'url' => env('REDIS_URL'),
        'scheme' => 'tls',
    ],
],

Environment

REDIS_URL=rediss://:YOUR_PASSWORD@YOUR_INSTANCE.eu.arctickey.com:6379
QUEUE_CONNECTION=redis

Dispatching Jobs#

PHP

// Create a job
php artisan make:job ProcessPayment

// app/Jobs/ProcessPayment.php
class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public function __construct(public Order $order) {}

    public function handle()
    {
        // Process the payment
        PaymentGateway::charge($this->order);
    }
}

// Dispatch the job
ProcessPayment::dispatch($order);

// Delay dispatch
ProcessPayment::dispatch($order)->delay(now()->addMinutes(10));

Python (RQ / Celery)#

Redis Queue (RQ)#

Python

from redis import Redis
from rq import Queue

redis_conn = Redis(
    host='YOUR_INSTANCE.eu.arctickey.com',
    port=6379,
    password='YOUR_PASSWORD',
    ssl=True
)

q = Queue(connection=redis_conn)

# Enqueue a job
job = q.enqueue(send_email, 'user@example.com', 'Welcome!')

# Check job status
print(job.get_status())  # queued, started, finished, failed

Celery#

Python

# celery.py
from celery import Celery

app = Celery(
    'tasks',
    broker='rediss://:YOUR_PASSWORD@YOUR_INSTANCE.eu.arctickey.com:6379/0',
    backend='rediss://:YOUR_PASSWORD@YOUR_INSTANCE.eu.arctickey.com:6379/0',
    broker_use_ssl={'ssl_cert_reqs': 'CERT_NONE'},
    redis_backend_use_ssl={'ssl_cert_reqs': 'CERT_NONE'}
)

@app.task
def send_email(to, subject):
    # Send the email
    pass

# Call the task
send_email.delay('user@example.com', 'Hello!')

Best Practices#

Use separate queues for different priority jobs
Set reasonable retries — don't retry forever
Make jobs idempotent — safe to run twice
Monitor queue depth — alert if it grows too large
Use dead letter queues for failed jobs