Aggregation-Pipelines über mehrere Quellen ausführen
Sie schreiben Aggregation-Pipelines, die Daten aus Atlas-Collections in einer einzigen Abfrage mit in S3 gespeicherten JSON- oder Parquet-Dateien verknüpfen.
Aggregation-Pipelines über mehrere Quellen ausführen ist eine kostenlose MongoDB Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. 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 MongoDB Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist das Besondere an Pipelines über mehrere Quellen?
Eine Aggregation Pipeline über mehrere Quellen in Atlas Data Federation führt dieselben Aggregationsstufen aus, die Sie aus MongoDB kennen. Die Daten unter den einzelnen Stufen können jedoch aus verschiedenen physischen Systemen stammen – einem S3-Bucket, einem aktiven Atlas-Cluster oder beiden. Die föderierte Query Engine übernimmt Routing, Fan-out und das Zusammenführen der Ergebnisse transparent. Aus Sicht Ihrer Anwendung sieht dies wie eine Abfrage einer einzelnen MongoDB-Collection aus.
Einfache Abfrage über mehrere Quellen
Die einfachste Abfrage über mehrere Quellen ist ein find() für eine virtuelle Collection, die von S3-Dateien unterstützt wird. Die Query Engine liest und analysiert die Dateien und wendet den Filter an. Felder im Filter, die Partitionsattributen im Pfad entsprechen, führen automatisch zum Überspringen nicht relevanter Dateien. Felder, die keinen Partitionsattributen entsprechen, werden nach dem Lesen als Filter angewendet.
// Virtual collection 'events' backed by S3 JSON files
// Path: /data/events/{year int}/{month int}/*.json
// This query prunes to /data/events/2025/1/ only
const jan2025 = await db.collection('events').find({
year: 2025,
month: 1,
eventType: 'purchase' // post-read filter (not a partition attr)
}).toArray()S3-Daten wie eine aktive Collection aggregieren
Sie können jede Aggregationsstufe auf virtuelle Collections anwenden, die von S3 unterstützt werden: $match, $group, $project, $sort, $limit. Die Query Engine verlagert Stufen, sofern möglich, an die Datenquelle (insbesondere $match für Partition-Pruning und Spalten-Pruning in Parquet) und führt die übrigen Stufen nach dem Lesen der Daten in ihrer eigenen Compute-Schicht aus.
// Group S3-archived events by region and count
const summary = await db.collection('events_2024').aggregate([
{ $match: { year: 2024, month: { $in: [10, 11, 12] } } }, // pruning
{ $group: { _id: '$region', total: { $sum: 1 }, revenue: { $sum: '$amount' } } },
{ $sort: { revenue: -1 } },
{ $limit: 10 }
]).toArray()Atlas und S3 mit $lookup verknüpfen
Das leistungsfähigste Muster über mehrere Quellen hinweg ist die Verwendung von $lookup, um eine aktive Atlas-Collection mit einer in S3 archivierten Collection zu verknüpfen. Starten Sie die Pipeline mit der aktiven Collection (dem „Treiber“) und führen Sie die Suche in der virtuellen, von S3 unterstützten Collection aus. Platzieren Sie frühzeitig ein $match, um die Anzahl der ausgeführten Lookups zu minimieren.
// Join live customers (Atlas) with archived orders (S3)
const result = await db.collection('customers').aggregate([
{ $match: { tier: 'gold', region: 'EU' } }, // filter live data first
{ $lookup: {
from: 'orders_archive', // virtual S3-backed collection
let: { custId: '$_id' },
pipeline: [
{ $match: { $expr: { $eq: ['$customerId', '$$custId'] } } },
{ $project: { orderId: 1, amount: 1, date: 1 } }
],
as: 'orderHistory'
}},
{ $addFields: { totalSpend: { $sum: '$orderHistory.amount' } } },
{ $sort: { totalSpend: -1 } },
{ $limit: 50 }
]).toArray()Über mehrere Atlas-Cluster hinweg aggregieren
Wenn Ihre föderierte Instanz mehrere Atlas-Cluster-Stores enthält, können Sie Collections aus verschiedenen Atlas-Clustern in einer einzigen Pipeline verknüpfen. Das ist nützlich für mandantenfähige oder multiregionale Bereitstellungen, bei denen Daten auf separate Cluster verteilt sind und Sie clusterübergreifende Berichte benötigen, ohne Cluster zusammenzuführen oder eine separate Reporting-Datenbank aufzubauen.
// Virtual collections pointing to different Atlas clusters
// 'orders_us' -> Atlas cluster in US
// 'orders_eu' -> Atlas cluster in EU
// Union results from two clusters
db.orders_us.aggregate([
{ $match: { date: { $gte: ISODate('2025-01-01') } } },
{ $unionWith: {
coll: 'orders_eu',
pipeline: [{ $match: { date: { $gte: ISODate('2025-01-01') } } }]
}},
{ $group: { _id: '$status', count: { $sum: 1 } } }
])Ergebnisse mit $out / $merge in Atlas schreiben
Nach einer Aggregation über mehrere Quellen können Sie die Ergebnisse mit $out oder $merge zurück in eine aktive Atlas-Collection schreiben. Dies ist das ETL-Muster: historische Daten aus S3 lesen, mit aktiven Daten verknüpfen, Aggregate berechnen und die Ergebnisse in eine materialisierte View-Collection in Atlas schreiben, die Anwendungen anschließend kostengünstig und schnell abfragen können.
// ETL: aggregate S3 archive + Atlas, write result to Atlas
db.events_2024.aggregate([
{ $match: { year: 2024 } },
{ $group: {
_id: { region: '$region', month: '$month' },
sessions: { $sum: 1 },
revenue: { $sum: '$amount' }
}},
{ $merge: {
into: { db: 'reporting', coll: 'monthly_summary' },
whenMatched: 'replace',
whenNotMatched: 'insert'
}}
])Parquet-Spalten-Pruning: Nur benötigte Daten lesen
Bei Abfragen von Parquet-Dateien wendet Data Federation Spalten-Pruning an: Wenn Ihre $project-Stufe nur bestimmte Felder angibt, liest die Query Engine nur diese Spalten aus der Parquet-Datei, die Daten spaltenweise speichert. Dadurch kann sich die Anzahl der gelesenen Bytes gegenüber dem Lesen aller Spalten um mehr als 90 % verringern. Platzieren Sie $project so früh wie möglich in der Pipeline, um den größtmöglichen Nutzen aus dem Spalten-Pruning zu ziehen.
// Column pruning: only reads 'region', 'amount', 'date' columns from Parquet
db.events_2024.aggregate([
{ $project: { region: 1, amount: 1, date: 1, _id: 0 } }, // early project
{ $match: { region: 'EU' } },
{ $group: { _id: '$region', totalRevenue: { $sum: '$amount' } } }
])
// Other columns (userId, sessionId, metadata, etc.) are never read from diskLeistungsüberwachung föderierter Abfragen
Atlas Data Federation protokolliert Details zur Abfrageausführung in der Atlas UI auf der Registerkarte Query History. Für jede Abfrage werden die verarbeiteten Bytes, die Ausführungszeit und die Anzahl der gescannten Dateien bzw. Partitionen angezeigt. Eine hohe Anzahl verarbeiteter Bytes deutet meist darauf hin, dass Partitionsattribute fehlen oder die Abfrage keinem Partitionsschlüssel entspricht. Verwenden Sie dieses Protokoll, um Ihre Speicherkonfiguration und Abfragemuster zu optimieren.
// Get query stats via the admin DB on the federated instance
db.adminCommand({ currentOp: 1 })
// Shows active federated queries with bytes read, duration
// In Atlas UI: Data Federation > Query History
// Shows past queries, duration, data processed, and cost estimateSchemaunterschiede zwischen Quellen behandeln
S3-Dateien aus unterschiedlichen Zeiträumen oder Systemen können verschiedene Schemas aufweisen (Feldnamen, Typen, Struktur). Data Federation behandelt dies problemlos: Fehlende Felder geben null zurück, zusätzliche Felder werden einbezogen. Mit $ifNull, $cond und $convert können Sie unterschiedliche Schemas in Ihrer Pipeline normalisieren, bevor Sie gruppieren oder Verknüpfungen durchführen.
// Normalise schema variations across old and new S3 file formats
db.events.aggregate([
{ $addFields: {
// Old format: 'user_id', New format: 'userId'
userId: { $ifNull: ['$userId', '$user_id'] },
// Old format: string amount, New format: number
amount: { $convert: { input: '$amount', to: 'double', onError: 0 } }
}},
{ $group: { _id: '$userId', total: { $sum: '$amount' } } }
])Ergebnisse föderierter Abfragen zwischenspeichern
Data Federation speichert Ergebnisse zwischen Abfragen nicht im Cache – jede Abfrage liest die zugrunde liegenden Quellen erneut. Verwenden Sie für Dashboards, die denselben Bericht wiederholt ausführen, das ETL-Muster: Planen Sie eine Aggregation, die Ergebnisse über $merge in eine Atlas-Collection schreibt, und lassen Sie Ihr Dashboard anschließend die schnelle Atlas-Collection abfragen. Atlas Triggers können diese Aktualisierung in jedem Cron-Intervall planen.
Einschränkungen von Pipelines über mehrere Quellen
Beachten Sie die aktuellen Einschränkungen: 1) Transaktionen werden auf föderierten Instanzen nicht unterstützt. 2) Die Verwendung von Indizes gilt nur für von Atlas unterstützte Collections, nicht für S3-Dateien. 3) Sehr große Ergebnismengen können zu einem Timeout führen – verwenden Sie $out/$merge, um Ergebnisse zu schreiben, statt sie zurückzustreamen. 4) Die Latenz ist aufgrund der S3-E/A höher als bei einer aktiven Atlas-Abfrage; daher eignen sich solche Abfragen nicht für benutzerseitige Echtzeitabfragen.
Kurze Überprüfung
Testen Sie Ihr Verständnis der Konzepte aus dieser Lektion zu MongoDB & NoSQL Databases.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Aggregationspipelines über mehrere Quellen verwenden dieselben MongoDB-Stufen für virtuelle Collections, die von S3 oder Atlas-Clustern unterstützt werden; $lookup ermöglicht die Verknüpfung aktiver Atlas-Daten mit S3-Archiven in einer einzigen Pipeline; und ein früh platziertes $project ermöglicht Spalten-Pruning in Parquet-Dateien und reduziert die Anzahl der gelesenen Bytes erheblich. Als Nächstes untersuchen wir die S3-Datenpartitionierung zur Verbesserung der Abfrageleistung.
Lerne JavaScript 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
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Aggregation-Pipelines über mehrere Quellen ausführen“ kostenlos?
Ja — der vollständige Text von „Aggregation-Pipelines über mehrere Quellen ausführen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des MongoDB Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der MongoDB Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Aggregation-Pipelines über mehrere Quellen ausführen“?
Sie schreiben Aggregation-Pipelines, die Daten aus Atlas-Collections in einer einzigen Abfrage mit in S3 gespeicherten JSON- oder Parquet-Dateien verknüpfen. Du übst MongoDB Academy 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 MongoDB Academy zu starten?
Keine Vorkenntnisse erforderlich. MongoDB Academy 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 3 von 4.
Wie lange dauert die Lektion „Aggregation-Pipelines über mehrere Quellen ausführen“?
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 MongoDB Academy-Lektion Code schreiben und ausführen?
Ja. Jede MongoDB Academy-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
- Was ist Atlas Data Federation?
- S3- und Atlas-Quellen auf einen virtuellen Namensraum abbilden
- Aggregation-Pipelines über mehrere Quellen ausführen
- S3-Daten für bessere Abfrage-Performance partitionieren