Supabase Backend as a Service · Lektion

Aufgabenwarteschlangen mit Supabase und Workern

Erkunden Sie Strategien zur Implementierung der Verarbeitung von Hintergrundaufgaben und Nachrichtenwarteschlangen mit Supabase und externen Worker-Diensten

Lektion 2 von 311 Schritte

Aufgabenwarteschlangen mit Supabase und Workern ist eine kostenlose Supabase Backend as a Service-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Supabase Backend as a Service-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Supabase Backend as a Service-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Tasks: Background vs. Foreground

Imagine your app needs to send a welcome email, process a large image, or generate a report. If your user has to wait for these long tasks to finish, their experience suffers.

These are background tasks: operations that don't need immediate user interaction and can run independently without blocking the user interface.

Introducing Task Queues

A task queue (or message queue) is a system that allows different parts of your application to communicate asynchronously. It acts like a temporary holding area for tasks.

Producers: Add tasks to the queue.
Consumers (Workers): Pick up tasks from the queue and process them.

This decouples the task creation from its execution.

Why Use a Task Queue?

Task queues bring several key benefits to your application architecture:

Improved Responsiveness: Users don't wait for long operations.
Scalability: You can add more workers to handle increased load.
Reliability: Tasks can be retried if they fail.
Decoupling: Separates task submission from task execution.

Supabase as a Simple Queue

While Supabase isn't a dedicated message queue, its powerful PostgreSQL database can serve as a simple task queue for many use cases. We can create a dedicated table to store tasks.

A typical tasks table might have columns like:

id (Primary Key)
payload (JSONB, for task data)
status (e.g., 'pending', 'processing', 'completed', 'failed')
created_at (Timestamp)
processed_at (Timestamp, nullable)

Enqueueing Tasks (Producer)

To enqueue a task, your client-side application or API endpoint simply inserts a new row into the tasks table with a 'pending' status. The payload column holds all the necessary data for the worker to process.

For example, to send a welcome email after user signup:

import { createClient } from '@supabase/supabase-js';

const supabaseUrl = 'YOUR_SUPABASE_URL';
const supabaseKey = 'YOUR_SUPABASE_ANON_KEY';
const supabase = createClient(supabaseUrl, supabaseKey);

async function enqueueWelcomeEmail(userId, email) {
  const { data, error } = await supabase
    .from('tasks')
    .insert({
      type: 'send_welcome_email',
      payload: { userId, email },
      status: 'pending'
    });

  if (error) {
    console.error('Error enqueueing task:', error.message);
  } else {
    console.log('Welcome email task enqueued!');
  }
}

// Example usage (not runnable directly without Supabase setup)
// enqueueWelcomeEmail('user123', 'test@example.com');

Introducing External Workers

An external worker is a separate application or service that continuously monitors the task queue for new jobs. When it finds a 'pending' task, it picks it up, processes it, and updates its status.

Workers can be written in any language (Node.js, Python, Go) and run on various platforms (servers, serverless functions, containers). They connect to your Supabase database to read and update task records.

Dequeueing Tasks (Consumer/Worker)

A worker needs to:

Fetch 'pending' tasks.
Mark a task as 'processing' to prevent other workers from picking it up.
Execute the task logic using the payload.
Update the task status to 'completed' or 'failed'.

Workers can either poll (periodically check) or use Supabase's Realtime feature to listen for new task insertions.

Code: Simple Worker Logic (Polling)

Here's a simplified Node.js worker logic that polls the Supabase tasks table every few seconds. Remember to replace placeholder values.

// worker.js
const { createClient } = require('@supabase/supabase-js');

const SUPABASE_URL = 'YOUR_SUPABASE_URL';
const SUPABASE_KEY = 'YOUR_SUPABASE_SERVICE_ROLE_KEY'; // Use service key for workers
const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);

async function processTask(task) {
  console.log(`Processing task ${task.id}: ${task.type}`);
  // Simulate work (e.g., sending email, processing image)
  await new Promise(resolve => setTimeout(resolve, 2000));
  console.log(`Task ${task.id} processed.`);
  // In a real app, this would involve calling an email API etc.
}

async function runWorker() {
  console.log('Worker started, looking for tasks...');
  setInterval(async () => {
    try {
      // Fetch one pending task and lock it by updating status
      const { data: tasks, error } = await supabase
        .from('tasks')
        .select('*')
        .eq('status', 'pending')
        .order('created_at', { ascending: true })
        .limit(1);

      if (error) throw error;

      if (tasks.length > 0) {
        const task = tasks[0];
        // Atomically update status to 'processing'
        const { error: updateError } = await supabase
          .from('tasks')
          .update({ status: 'processing', processed_at: new Date().toISOString() })
          .eq('id', task.id)
          .eq('status', 'pending'); // Ensure no other worker picked it up

        if (updateError) {
          if (updateError.code === '40600') { // Row already updated by another process
            console.log(`Task ${task.id} already picked up.`);
            return; 
          }
          throw updateError;
        }

        await processTask(task);

        // Update status to 'completed'
        await supabase
          .from('tasks')
          .update({ status: 'completed' })
          .eq('id', task.id);

      } else {
        // console.log('No pending tasks.');
      }
    } catch (err) {
      console.error('Worker error:', err.message);
      // Implement error handling, e.g., update task status to 'failed'
    }
  }, 5000); // Poll every 5 seconds
}

// To run this: node worker.js
// (Requires 'npm install @supabase/supabase-js' and a Supabase project)
runWorker();

Task States & Reliability

Properly managing task states is crucial for reliability:

Pending: Task is waiting to be processed.
Processing: Worker has picked up the task.
Completed: Task finished successfully.
Failed: Task encountered an error.

For failed tasks, you might implement retries (e.g., after a delay) and ensure tasks are idempotent (running them multiple times has the same effect as running once) to prevent unintended side effects.

Queueing Question

You've learned about using Supabase and external workers for task queues. Consider a scenario where a user uploads a large video file that needs transcoding.

Beantworte es in der interaktiven Lektion

Recap: Task Queues & Workers

We've explored how task queues enable efficient background processing in your applications. By using Supabase as a simple queue and external workers, you can:

Offload long-running operations.
Improve user experience by keeping your app responsive.
Build more scalable and robust systems.

This pattern is fundamental for building complex, high-performance web and mobile applications.

Kostenlos starten

Lerne Supabase Backend as a Service mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 11
Lektionen: 40

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Aufgabenwarteschlangen mit Supabase und Workern“ kostenlos?

Ja — der vollständige Text von „Aufgabenwarteschlangen mit Supabase und Workern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Supabase Backend as a Service-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Supabase Backend as a Service-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Aufgabenwarteschlangen mit Supabase und Workern“?

Erkunden Sie Strategien zur Implementierung der Verarbeitung von Hintergrundaufgaben und Nachrichtenwarteschlangen mit Supabase und externen Worker-Diensten Du übst Supabase Backend as a Service mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Supabase Backend as a Service zu starten?

Keine Vorkenntnisse erforderlich. Supabase Backend as a Service auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Aufgabenwarteschlangen mit Supabase und Workern“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Supabase Backend as a Service-Lektion Code schreiben und ausführen?

Ja. Jede Supabase Backend as a Service-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Externe Dienste integrieren
Aufgabenwarteschlangen mit Supabase und Workern
Wiederkehrende Aufgaben mit pg_cron planen

← Zurück zu Supabase Backend as a Service