Batching

Batch-Verarbeitung ermöglicht es, mehrere Items gleichzeitig zu verarbeiten, anstatt jeden Datensatz einzeln zu behandeln. Dies verbessert die Effizienz, reduziert API-Calls und hilft dabei, Rate Limits einzuhalten.

Was ist Batching?

Batching bedeutet, mehrere Items zu Gruppen zusammenzufassen und diese gemeinsam zu verarbeiten. Dies ist besonders nützlich bei:

Großen Datenmengen
API-Calls mit Rate Limits
Kostenoptimierung (weniger API-Calls)
Verbesserter Performance

Ohne Batching

Sequenzielle Verarbeitung:

Item 1 → API Call → Process
Item 2 → API Call → Process
Item 3 → API Call → Process

Zeit: 3 × API-Zeit

Mit Batching

Batch-Verarbeitung:

[Item 1, Item 2, Item 3] → Batch API Call → Process

Zeit: 1 × API-Zeit

Split In Batches Node

Der Split In Batches Node teilt Items in kleinere Gruppen auf:

Grundkonfiguration

Split In Batches konfigurieren:

{
  "batchSize": 10,
  "options": {}
}

Batch-Größe bestimmen

Optimale Batch-Größe wählen:Faktoren:

API-Rate Limits (z.B. 100 Requests/Minute)
Maximale Batch-Größe der API (z.B. 50 Items)
Verarbeitungszeit pro Batch
Memory-Limits

Empfehlungen:

Kleine Batches (5-10): Für schnelle APIs, niedrige Rate Limits
Mittlere Batches (10-50): Standard für die meisten APIs
Große Batches (50-100): Für APIs mit hohen Limits, wenn Memory ausreicht

Beginnen Sie mit Batch-Größe 10-20 und passen Sie basierend auf Performance und Rate Limits an.

Workflow-Struktur

Typischer Batch-Workflow:

Trigger → Split In Batches → Process Batch → Merge Results

// Schritt 1: Items erhalten (z.B. 100 Items)
Trigger → 100 Items

// Schritt 2: In Batches aufteilen
Split In Batches (batchSize: 20) → 5 Batches

// Schritt 3: Jeden Batch verarbeiten
Process Batch → API Call mit 20 Items

// Schritt 4: Ergebnisse zusammenführen
Merge → Alle verarbeiteten Items

Batch-API-Calls

HTTP Request mit Batch-Daten

Senden Sie mehrere Items in einem API-Call:

Batch POST Request

Mehrere Items in einem Request:

{
  "method": "POST",
  "url": "https://api.example.com/batch",
  "body": {
    "items": "={{ $json.all() }}"
  }
}

Batch GET Request

Mehrere IDs in einem Request:

{
  "method": "GET",
  "url": "https://api.example.com/items",
  "qs": {
    "ids": "={{ $json.all().map(item => item.json.id).join(',') }}"
  }
}

Function Node für Batch-Verarbeitung

Komplexe Batch-Logik mit Function Node:

// Alle Items aus Batch abrufen
const items = $input.all();

// Batch-Request vorbereiten
const batchData = {
  items: items.map(item => ({
    id: item.json.id,
    name: item.json.name,
    status: item.json.status
  }))
};

// API-Call (wird in nächstem Node gemacht)
return [{
  json: {
    batch: batchData,
    batchSize: items.length,
    timestamp: new Date().toISOString()
  }
}];

Rate Limit Management

Rate Limits einhalten

Batching hilft dabei, Rate Limits einzuhalten:

Rate Limit berechnen

Batch-Größe basierend auf Rate Limits:

// API erlaubt 100 Requests pro Minute
// Workflow verarbeitet 1000 Items

// Ohne Batching: 1000 Requests (10 Minuten)
// Mit Batching (10 Items/Batch): 100 Requests (1 Minute)

const rateLimit = 100; // Requests pro Minute
const itemsPerRequest = 10;
const totalItems = 1000;

const batchesNeeded = Math.ceil(totalItems / itemsPerRequest);
const timeNeeded = Math.ceil(batchesNeeded / rateLimit);

// Ergebnis: 100 Batches, 1 Minute

Rate Limit Node verwenden

Rate Limit Node für kontrollierte Verarbeitung:

Split In Batches → Rate Limit → Process Batch

{
  "maxRequests": 100,
  "interval": 60,
  "intervalUnit": "seconds"
}

Parallele Batch-Verarbeitung

Mehrere Batches parallel verarbeiten

Verarbeiten Sie mehrere Batches gleichzeitig:

Parallele Verarbeitung

Workflow-Struktur:

Split In Batches → [Branch 1] → Process Batch 1 ┐
                → [Branch 2] → Process Batch 2 ├→ Merge
                → [Branch 3] → Process Batch 3 ┘

Achten Sie auf Rate Limits! Parallele Verarbeitung kann Rate Limits schneller erreichen.

Limitierte Parallelität

Kontrollierte parallele Verarbeitung:

const batches = $input.all();
const maxParallel = 3; // Maximal 3 Batches gleichzeitig

// Batches in Gruppen aufteilen
const groups = [];
for (let i = 0; i < batches.length; i += maxParallel) {
  groups.push(batches.slice(i, i + maxParallel));
}

return groups.map(group => ({
  json: {
    batches: group,
    groupIndex: groups.indexOf(group)
  }
}));

Batch-Fehlerbehandlung

Fehler in Batches behandeln

Robuste Fehlerbehandlung für Batches:

Partielle Fehler

Wenn einige Items in einem Batch fehlschlagen:

const batchResponse = $json.batchResponse;
const results = [];
const errors = [];

batchResponse.results.forEach((result, index) => {
  if (result.success) {
    results.push({
      json: {
        ...result.data,
        processed: true
      }
    });
  } else {
    errors.push({
      json: {
        originalItem: $input.all()[index].json,
        error: result.error,
        retry: true
      }
    });
  }
});

// Erfolgreiche Items zurückgeben
return results;

// Fehlerhafte Items separat behandeln (Error Trigger)

Retry-Logik für Batches

Fehlgeschlagene Batches erneut versuchen:

Process Batch → Error Trigger → Retry Logic → Process Batch

const maxRetries = 3;
const retryCount = $workflow.staticData.retryCount || 0;

if (retryCount < maxRetries) {
  const delay = Math.pow(2, retryCount) * 1000; // 1s, 2s, 4s
  
  // Wartezeit einbauen
  await new Promise(resolve => setTimeout(resolve, delay));
  
  $workflow.staticData.retryCount = retryCount + 1;
  
  // Batch erneut verarbeiten
  return $input.all();
} else {
  // Max Retries erreicht, Fehler loggen
  throw new Error('Batch processing failed after retries');
}

Best Practices

Optimale Batch-Größe

Wählen Sie Batch-Größe basierend auf:

API-Limits
Verarbeitungszeit
Memory-Verfügbarkeit
Rate Limits

Fehlerbehandlung

Implementieren Sie robuste Fehlerbehandlung:

Partielle Fehler behandeln
Retry-Logik für fehlgeschlagene Batches
Fehler-Logging

Rate Limits

Respektieren Sie API-Rate Limits:

Verwenden Sie Rate Limit Node
Implementieren Sie Backoff
Überwachen Sie Request-Rate

Monitoring

Überwachen Sie Batch-Performance:

Batch-Größe tracken
Verarbeitungszeit messen
Fehlerrate überwachen

Memory-Management

Achten Sie auf Memory:

Nicht zu große Batches
Ergebnisse früh ausgeben
Unnötige Daten entfernen

Testing

Testen Sie Batching:

Mit verschiedenen Batch-Größen
Mit Edge Cases (leere Batches, sehr große Batches)
Fehler-Szenarien

Praktisches Beispiel

E-Mail-Versand in Batches

Versenden Sie E-Mails effizient in Batches:

Items vorbereiten

// 100 E-Mails zu versenden
[
  { "to": "user1@example.com", "subject": "Newsletter", "body": "..." },
  { "to": "user2@example.com", "subject": "Newsletter", "body": "..." },
  ...
]

In Batches aufteilen

Split In Batches (batchSize: 20)
→ 5 Batches mit je 20 E-Mails

Batch verarbeiten

// HTTP Request an E-Mail-API
{
  "method": "POST",
  "url": "https://api.email-service.com/batch",
  "body": {
    "emails": "={{ $json.all() }}"
  }
}

Ergebnisse zusammenführen

Merge → Alle versendeten E-Mails
→ Success/Error Tracking

Checkliste

Batch-Größe ist optimiert für API-Limits
Rate Limits werden eingehalten
Fehlerbehandlung ist implementiert
Retry-Logik für fehlgeschlagene Batches
Memory-Verbrauch ist akzeptabel
Performance wird überwacht
Edge Cases wurden getestet

Nächste Schritte

Retry Logic

Erfahren Sie, wie Sie Retry-Logik für fehlgeschlagene Batches implementieren.

Performance

Optimieren Sie die Batch-Verarbeitung für bessere Performance.

Item Management

Lernen Sie, wie Sie Items effektiv verwalten.

Testing

Testen Sie Ihre Batch-Workflows gründlich.

Tipp: Beginnen Sie mit kleineren Batch-Größen und erhöhen Sie diese schrittweise, während Sie die Performance überwachen.

Grundlagen

Workflows

Erweitert

Betrieb

Batching

Batching

Was ist Batching?

Ohne Batching

Mit Batching

Split In Batches Node

Batch-API-Calls

HTTP Request mit Batch-Daten

Function Node für Batch-Verarbeitung

Rate Limit Management

Rate Limits einhalten

Parallele Batch-Verarbeitung

Mehrere Batches parallel verarbeiten

Batch-Fehlerbehandlung

Fehler in Batches behandeln

Best Practices

Optimale Batch-Größe

Fehlerbehandlung

Rate Limits

Monitoring

Memory-Management

Testing

Praktisches Beispiel

E-Mail-Versand in Batches

Checkliste

Nächste Schritte

Retry Logic

Performance

Item Management

Testing

Grundlagen

Workflows

Erweitert

Betrieb

​Batching

​Was ist Batching?

Ohne Batching

Mit Batching

​Split In Batches Node

​Batch-API-Calls

​HTTP Request mit Batch-Daten

​Function Node für Batch-Verarbeitung

​Rate Limit Management

​Rate Limits einhalten

​Parallele Batch-Verarbeitung

​Mehrere Batches parallel verarbeiten

​Batch-Fehlerbehandlung

​Fehler in Batches behandeln

​Best Practices

Optimale Batch-Größe

Fehlerbehandlung

Rate Limits

Monitoring

Memory-Management

Testing

​Praktisches Beispiel

​E-Mail-Versand in Batches

​Checkliste

​Nächste Schritte

Retry Logic

Performance

Item Management

Testing

Batching

Was ist Batching?

Split In Batches Node

Batch-API-Calls

HTTP Request mit Batch-Daten

Function Node für Batch-Verarbeitung

Rate Limit Management

Rate Limits einhalten

Parallele Batch-Verarbeitung

Mehrere Batches parallel verarbeiten

Batch-Fehlerbehandlung

Fehler in Batches behandeln

Best Practices

Praktisches Beispiel

E-Mail-Versand in Batches

Checkliste

Nächste Schritte