MongoDB Academy · 강의

쿼리 성능을 위한 S3 데이터 파티셔닝

학습자는 S3 경로에 파티션 속성을 정의해 Data Federation이 관련 없는 파일을 제외하고 빠른 분석 쿼리를 제공하도록 합니다.

쿼리 성능을 위한 S3 데이터 파티셔닝은(는) CoddyKit의 무료 MongoDB Academy 강의입니다. 이것은 4개 중 4번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 MongoDB Academy 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. MongoDB Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why Partitioning S3 Data Matters

In Atlas Data Federation, every query against an S3-backed virtual collection potentially reads many files. Without partitioning, even a query asking for a single day's data might scan an entire year of files. Partitioning organises S3 objects into a directory structure that encodes queryable metadata in the path, allowing the query engine to skip irrelevant files — a technique called partition pruning.

Partition Pruning: The Core Mechanism

Partition pruning works because Atlas Data Federation parses the S3 object key (path) and extracts the values defined as partition attributes in the storage configuration. When a query filter matches one of these attributes, the query engine only reads objects whose path values match — skipping all others without even issuing S3 GetObject requests for them.

// Path template with partition attributes
// /events/{year int}/{month int}/{day int}/data.parquet

// Query: fetch March 15, 2025 data
db.events.find({ year: 2025, month: 3, day: 15 })

// Data Federation issues S3 ListObjects only for:
// /events/2025/3/15/
// All other years/months/days are skipped

Designing Your Partition Structure

Choose partition attributes based on how your queries filter data. Common patterns: time-based (year/month/day) for time-series data, geo-based (region/country) for global data, entity-based (tenantId, userId) for multi-tenant SaaS. Put the most-frequently-filtered partition attribute highest in the hierarchy for the greatest pruning effect.

// Time-based partition hierarchy
// /events/{year int}/{month int}/{day int}/{hour int}/

// Entity + time partition (tenant queries prune all other tenants)
// /orders/{tenantId string}/{year int}/{month int}/

// Geo + time
// /events/{region string}/{year int}/{month int}/

Registering Partition Attributes in Storage Config

Partition attributes are declared in the storage configuration's path field using curly-brace syntax with the attribute name and type: {attrName type}. Supported types are string, int, and ISODate. The type determines how the attribute is parsed and compared against query filter values.

{
  'dataSources': [{
    'storeName': 's3Store',
    'path': '/events/{year int}/{month int}/{day int}/*.parquet'
  }]
}
// Partition attributes: year (int), month (int), day (int)
// Filters like { year: 2025, month: 3 } trigger pruning
// The '*.parquet' at the end matches any file in the day directory

File Size: Finding the Sweet Spot

Partition pruning works at the directory level, but file size also matters. Too many tiny files (thousands of 1 KB files) wastes time on per-file S3 API calls, even after pruning. Too few giant files (one 100 GB file per month) prevents pruning below the month level. Aim for file sizes of 64 MB to 256 MB (compressed), with enough files per partition to enable sub-partition pruning where needed.

// Ideal partition design for daily query patterns:
// /events/2025/03/15/part-001.parquet  (~128 MB each)
// /events/2025/03/15/part-002.parquet
// /events/2025/03/15/part-003.parquet
// Total: ~384 MB for a busy day, 3 files to manage

// Avoid:
// /events/2025/03/15/00001.json (1 KB each, thousands of files)
// /events/2025/march.parquet    (no day-level pruning possible)

Using ISODate Partition Attributes

For S3 paths that encode timestamps in ISO format (e.g., 2025-03-15), use the ISODate partition attribute type. This lets you filter with MongoDB date comparison operators ($gte, $lt, $lte) against the partition attribute, and Data Federation will correctly prune files outside the requested date range.

// Path: /events/{date ISODate}/data.parquet
// e.g.: /events/2025-03-15/data.parquet

// Query with ISODate range — triggers pruning
db.events.find({
  date: {
    $gte: ISODate('2025-03-01'),
    $lt:  ISODate('2025-04-01')
  }
})
// Only reads /events/2025-03-*/ directories

Compacting and Re-Partitioning Files

Over time, streaming data pipelines often produce many small files (the 'small files problem'). To maintain query performance, periodically compact files: read all files in a partition and write them back as fewer, larger files. This is typically done with Spark, AWS Glue, or a scheduled Atlas Function that reads and re-exports data.

// Compact using MongoDB Data Federation's own $out
// (Re-export a partition to a temporary location, then replace)
db.events_raw.aggregate([
  { $match: { year: 2024, month: 1 } },
  { $out: {
    s3: {
      bucket: 'mycompany-analytics-archive',
      region: 'us-east-1',
      filename: 'events/2024/1/compacted-{UUID()}.parquet',
      format: { name: 'parquet' }
    }
  }}
])

Exporting Data to S3 With $out

Data Federation supports an extended form of $out that writes aggregation results directly to S3 instead of an Atlas collection. This is used for ETL pipelines: read raw data from Atlas, transform it, and export the result to S3 in an optimised format (Parquet, BSON) for future federated queries or downstream analytics tools.

// Export to S3 in Parquet format from Atlas
db.orders.aggregate([
  { $match: { year: 2025, month: 3 } },
  { $project: { customerId: 1, amount: 1, region: 1, status: 1 } },
  { $out: {
    s3: {
      bucket: 'mycompany-analytics-archive',
      region: 'us-east-1',
      filename: 'orders/2025/3/data.parquet',
      format: { name: 'parquet', maxFileSize: '128MB' }
    }
  }}
])

Combining Partition Pruning and Column Pruning

Maximum performance comes from combining both pruning strategies: partition pruning (time/entity attributes in the path skips whole files) and column pruning (early $project skips unneeded Parquet columns within each file). Together they can reduce I/O by 99%+ compared to a naive full-scan query on an unpartitioned, uncompressed dataset.

// Combined: partition pruning + column pruning
db.events.aggregate([
  // Partition pruning: only reads March 2025 S3 files
  { $match: { year: 2025, month: 3, eventType: 'purchase' } },
  // Column pruning: only reads userId, amount columns from Parquet
  { $project: { userId: 1, amount: 1, _id: 0 } },
  { $group: { _id: '$userId', total: { $sum: '$amount' } } },
  { $sort: { total: -1 } },
  { $limit: 100 }
])

Monitoring Partition Pruning Effectiveness

In the Atlas Data Federation query history, each query shows the number of files matched versus the number of files actually read. If matched >> read, partition pruning is working well. If matched ≈ read, your partition structure does not align with your query patterns and you should redesign the partition layout or add more partition attributes.

// Check execution stats to verify pruning
db.events.explain().aggregate([
  { $match: { year: 2025, month: 3 } },
  { $group: { _id: '$eventType', count: { $sum: 1 } } }
])
// In the explain output, look for:
// 'partitionsProcessed': 31   (one per day in March)
// 'partitionsTotal': 365      (total days in the year)
// Effective pruning: 31/365 files scanned

Partition Design: A Practical Checklist

When designing your S3 partition structure: 1) Identify the fields your queries filter most frequently — those become partition attributes. 2) Put the highest-cardinality, most-frequently-filtered field at the top of the path hierarchy. 3) Target 64–256 MB per file. 4) Use Parquet format for analytical workloads to also benefit from column pruning. 5) Include a date-based partition (year/month/day) for time-series data.

// Example: well-designed partition hierarchy for event data
// Prioritises: region (high selectivity), then year, month, day
// Path: /events/{region string}/{year int}/{month int}/{day int}/

// Query: EU events in March 2025
// Reads ONLY: /events/EU/2025/3/
// Skips: all other regions and all other months/years
db.events.find({ region: 'EU', year: 2025, month: 3, eventType: 'purchase' })

Quick Check

Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.

Lesson Recap

In this lesson you learned: partition attributes encode metadata in S3 paths so the query engine can skip non-matching files (partition pruning), combining partition pruning with column pruning in Parquet delivers the greatest I/O reduction, and aim for 64-256 MB file sizes to balance per-file API overhead with pruning granularity. Next up we explore Atlas Triggers for reacting to database events.

자주 묻는 질문

“쿼리 성능을 위한 S3 데이터 파티셔닝” 강의는 무료인가요?

네 — “쿼리 성능을 위한 S3 데이터 파티셔닝” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 MongoDB Academy 강의 전체를 잠금 해제할 수 있습니다. MongoDB Academy 강의에는 총 4개의 강의가 포함되어 있습니다.

“쿼리 성능을 위한 S3 데이터 파티셔닝”에서 뭘 배우나요?

학습자는 S3 경로에 파티션 속성을 정의해 Data Federation이 관련 없는 파일을 제외하고 빠른 분석 쿼리를 제공하도록 합니다. 브라우저에서 직접 실행하는 실습 코드로 MongoDB Academy을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

MongoDB Academy을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 MongoDB Academy은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 4번째 강의입니다.

“쿼리 성능을 위한 S3 데이터 파티셔닝” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 MongoDB Academy 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 MongoDB Academy 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

← MongoDB Academy(으)로 돌아가기