MongoDB 8: Novità e Miglioramenti Performance

MongoDB 8.0 è stato rilasciato nell'estate 2024 portando Queryable Encryption in GA, performance delle query raddoppiate, time series collections ottimizzate, sharding automatico migliorato e Atlas Search potenziato. Questa release consolida MongoDB come database NoSQL leader.

🎯 Novità Principali

Queryable Encryption (GA)

Encryption in-use per dati sensibili:

// ✅ MongoDB 8 - Queryable Encryption

const { MongoClient } = require("mongodb");

// Setup encryption
const encryptedClient = new MongoClient(uri, {
  autoEncryption: {
    keyVaultNamespace: "encryption.__keyVault",
    kmsProviders: {
      local: {
        key: Buffer.from(localMasterKey, "base64"),
      },
    },
    encryptedFieldsMap: {
      "mydb.users": {
        fields: [
          {
            path: "ssn",
            bsonType: "string",
            queries: { queryType: "equality" },
          },
          {
            path: "creditCard",
            bsonType: "string",
            queries: { queryType: "equality" },
          },
          {
            path: "salary",
            bsonType: "int",
            queries: { queryType: "range" },
          },
        ],
      },
    },
  },
});

// Insert encrypted data
await users.insertOne({
  name: "Mario Rossi",
  ssn: "123-45-6789", // Encrypted
  creditCard: "1234-5678", // Encrypted
  salary: 75000, // Encrypted
});

// Query encrypted fields - works transparently!
const user = await users.findOne({ ssn: "123-45-6789" });
console.log(user.name); // Mario Rossi

// Range queries on encrypted data
const highEarners = await users
  .find({
    salary: { $gt: 100000 },
  })
  .toArray();

// Security benefits:
// - Data encrypted at rest, in transit, and in-use
// - Zero trust architecture
// - Compliance ready (GDPR, HIPAA)
// - Query without decryption

Performance Improvements 2x

// ✅ MongoDB 8 - Query performance doubled

// Complex aggregation pipeline
const pipeline = [
  {
    $match: {
      status: "active",
      createdAt: { $gte: new Date("2024-01-01") },
    },
  },
  {
    $lookup: {
      from: "orders",
      localField: "_id",
      foreignField: "userId",
      as: "orders",
    },
  },
  {
    $unwind: "$orders",
  },
  {
    $group: {
      _id: "$_id",
      totalSpent: { $sum: "$orders.total" },
      orderCount: { $sum: 1 },
    },
  },
  {
    $sort: { totalSpent: -1 },
  },
  {
    $limit: 100,
  },
];

const results = await users.aggregate(pipeline).toArray();

// Performance comparison:
// MongoDB 7: 2.5s
// MongoDB 8: 1.1s (-56%)

// Index intersection improved
await collection.createIndex({ status: 1 });
await collection.createIndex({ category: 1 });

// Query uses both indexes efficiently
const results = await collection
  .find({
    status: "active",
    category: "electronics",
  })
  .toArray();

// MongoDB 7: 850ms
// MongoDB 8: 320ms (-62%)

// Sort optimization
const sorted = await collection
  .find({ status: "active" })
  .sort({ createdAt: -1 })
  .limit(100)
  .toArray();

// MongoDB 7: 1.2s
// MongoDB 8: 450ms (-62%)

Time Series Collections Enhanced

// ✅ MongoDB 8 - Time series optimizations

// Create time series collection
await db.createCollection("metrics", {
  timeseries: {
    timeField: "timestamp",
    metaField: "metadata",
    granularity: "seconds",
    // New in MongoDB 8: compression improvements
    bucketMaxSpanSeconds: 3600,
  },
});

// Insert time series data
await metrics.insertMany([
  {
    timestamp: new Date(),
    metadata: {
      sensor: "temp_01",
      location: "warehouse_a",
    },
    temperature: 23.5,
    humidity: 45.2,
  },
  {
    timestamp: new Date(),
    metadata: {
      sensor: "temp_02",
      location: "warehouse_a",
    },
    temperature: 24.1,
    humidity: 47.8,
  },
]);

// Optimized aggregation
const hourlyAvg = await metrics
  .aggregate([
    {
      $match: {
        timestamp: {
          $gte: new Date(Date.now() - 24 * 60 * 60 * 1000),
        },
        "metadata.location": "warehouse_a",
      },
    },
    {
      $group: {
        _id: {
          $dateTrunc: {
            date: "$timestamp",
            unit: "hour",
          },
        },
        avgTemp: { $avg: "$temperature" },
        avgHumidity: { $avg: "$humidity" },
      },
    },
    {
      $sort: { _id: 1 },
    },
  ])
  .toArray();

// Performance improvements:
// Storage: -40% vs MongoDB 7
// Query: 3x faster for time-range queries
// Compression: 60% better

// Window functions for time series
const movingAvg = await metrics
  .aggregate([
    {
      $setWindowFields: {
        partitionBy: "$metadata.sensor",
        sortBy: { timestamp: 1 },
        output: {
          movingAvg: {
            $avg: "$temperature",
            window: {
              documents: [-4, 0], // 5-point moving average
            },
          },
        },
      },
    },
  ])
  .toArray();

Sharding Improvements

// ✅ MongoDB 8 - Auto-balancing enhanced

// Enable sharding
sh.enableSharding("mydb");

// Shard collection with hashed key
sh.shardCollection("mydb.users", {
  userId: "hashed",
});

// New: Automatic zone sharding
sh.addShardToZone("shard0000", "EU");
sh.addShardToZone("shard0001", "US");
sh.addShardToZone("shard0002", "ASIA");

// Associate data ranges with zones
sh.updateZoneKeyRange(
  "mydb.users",
  { country: "IT" },
  { country: "IT\uffff" },
  "EU",
);

sh.updateZoneKeyRange(
  "mydb.users",
  { country: "US" },
  { country: "US\uffff" },
  "US",
);

// Automatic data placement based on zones
// MongoDB 8: intelligent balancing
// - Fewer chunk migrations (-60%)
// - Better latency distribution
// - Automatic rebalancing

// Compound shard key
sh.shardCollection("mydb.orders", {
  customerId: 1,
  orderDate: 1,
});

// Query routing optimized
const orders = await db.orders
  .find({
    customerId: "user123",
    orderDate: { $gte: new Date("2024-01-01") },
  })
  .toArray();

// MongoDB 8: targeted query routing
// Only queries relevant shards

🚀 Aggregation Framework Enhanced

New Operators

// ✅ MongoDB 8 - New aggregation operators

// $vectorSearch for AI/ML
const similarDocs = await collection
  .aggregate([
    {
      $vectorSearch: {
        queryVector: [0.1, 0.2, 0.3 /* ... */],
        path: "embedding",
        numCandidates: 100,
        limit: 10,
        index: "vector_index",
      },
    },
    {
      $project: {
        title: 1,
        content: 1,
        score: { $meta: "vectorSearchScore" },
      },
    },
  ])
  .toArray();

// $densify - fill gaps in time series
const filledData = await metrics
  .aggregate([
    {
      $densify: {
        field: "timestamp",
        range: {
          step: 1,
          unit: "hour",
          bounds: [new Date("2024-01-01"), new Date("2024-01-31")],
        },
      },
    },
    {
      $fill: {
        output: {
          temperature: { method: "linear" },
        },
      },
    },
  ])
  .toArray();

// $median and $percentile
const stats = await sales
  .aggregate([
    {
      $group: {
        _id: "$category",
        medianPrice: { $median: { input: "$price", method: "approximate" } },
        p95Price: {
          $percentile: {
            input: "$price",
            p: [0.95],
            method: "approximate",
          },
        },
      },
    },
  ])
  .toArray();

// $bottom and $top - get extremes
const topSellers = await products
  .aggregate([
    {
      $group: {
        _id: "$category",
        topProducts: {
          $top: {
            output: ["$name", "$sales"],
            sortBy: { sales: -1 },
            n: 5,
          },
        },
      },
    },
  ])
  .toArray();

Pipeline Optimization

// ✅ MongoDB 8 - Smarter query planning

// Complex pipeline - auto-optimized
const optimized = await orders
  .aggregate([
    { $match: { status: "completed" } }, // Pushed to beginning
    { $sort: { total: -1 } }, // Uses index
    { $limit: 100 }, // Early limit
    {
      $lookup: {
        // Optimized join
        from: "customers",
        localField: "customerId",
        foreignField: "_id",
        as: "customer",
      },
    },
    { $unwind: "$customer" },
    { $match: { "customer.vip": true } }, // Secondary filter
  ])
  .toArray();

// Query planner improvements:
// - Better predicate pushdown
// - Index selection improved
// - Join optimization
// - Early filtering

// Explain plan
const explain = await orders.aggregate(pipeline).explain("executionStats");

console.log(explain.executionStats);
// Shows optimized execution path

🔒 Security Enhancements

LDAP Authentication

// ✅ MongoDB 8 - Enterprise security

// LDAP configuration
// mongod.conf
security: authorization: enabled;
ldap: servers: "ldap.example.com";
bind: queryUser: "cn=admin,dc=example,dc=com";
queryPassword: "password";
userToDNMapping: '[{match: "(.+)", substitution: "cn={0},ou=users,dc=example,dc=com"}]';

// Connection with LDAP
const client = new MongoClient(uri, {
  authMechanism: "PLAIN",
  authSource: "$external",
  username: "mario@example.com",
  password: "userpassword",
});

Field-Level Encryption

// ✅ Client-side field level encryption

const encryptionOptions = {
  keyVaultNamespace: "encryption.__keyVault",
  kmsProviders: {
    aws: {
      accessKeyId: process.env.AWS_ACCESS_KEY,
      secretAccessKey: process.env.AWS_SECRET_KEY,
    },
  },
};

const encryptedClient = new MongoClient(uri, {
  autoEncryption: encryptionOptions,
});

// Automatic encryption/decryption
const db = encryptedClient.db("mydb");
const users = db.collection("users");

// Insert - automatically encrypted
await users.insertOne({
  name: "Mario",
  ssn: "123-45-6789", // Encrypted
  email: "mario@test.com", // Encrypted
});

// Query - transparent decryption
const user = await users.findOne({ name: "Mario" });
console.log(user.ssn); // '123-45-6789' (decrypted)

📊 Atlas Search Enhanced

Vector Search

// ✅ MongoDB 8 - Vector search for AI

// Create vector index
await collection.createSearchIndex({
  name: "vector_index",
  type: "vectorSearch",
  definition: {
    fields: [
      {
        type: "vector",
        path: "embedding",
        numDimensions: 1536,
        similarity: "cosine",
      },
    ],
  },
});

// Insert documents with embeddings
await collection.insertOne({
  title: "MongoDB Tutorial",
  content: "Learn MongoDB...",
  embedding: await getEmbedding("Learn MongoDB..."), // OpenAI, etc.
});

// Semantic search
const queryEmbedding = await getEmbedding("database tutorial");

const results = await collection
  .aggregate([
    {
      $vectorSearch: {
        index: "vector_index",
        path: "embedding",
        queryVector: queryEmbedding,
        numCandidates: 100,
        limit: 10,
      },
    },
    {
      $project: {
        title: 1,
        content: 1,
        score: { $meta: "vectorSearchScore" },
      },
    },
  ])
  .toArray();

// Hybrid search (vector + text)
const hybridResults = await collection
  .aggregate([
    {
      $vectorSearch: {
        index: "vector_index",
        path: "embedding",
        queryVector: queryEmbedding,
        numCandidates: 100,
        limit: 50,
      },
    },
    {
      $match: {
        $text: { $search: "mongodb tutorial" },
      },
    },
    {
      $limit: 10,
    },
  ])
  .toArray();

Full-Text Search

// ✅ Atlas Search improvements

// Create text index
await collection.createSearchIndex({
  name: "text_index",
  definition: {
    mappings: {
      dynamic: false,
      fields: {
        title: {
          type: "string",
          analyzer: "lucene.standard",
        },
        content: {
          type: "string",
          analyzer: "lucene.english",
        },
        tags: {
          type: "string",
        },
      },
    },
  },
});

// Advanced search query
const searchResults = await collection
  .aggregate([
    {
      $search: {
        index: "text_index",
        compound: {
          must: [
            {
              text: {
                query: "mongodb database",
                path: "content",
                fuzzy: { maxEdits: 2 },
              },
            },
          ],
          should: [
            {
              text: {
                query: "tutorial",
                path: "title",
                score: { boost: { value: 2 } },
              },
            },
          ],
          filter: [
            {
              text: {
                query: "beginner",
                path: "tags",
              },
            },
          ],
        },
      },
    },
    {
      $project: {
        title: 1,
        content: 1,
        score: { $meta: "searchScore" },
      },
    },
    {
      $limit: 20,
    },
  ])
  .toArray();

// Faceted search
const facets = await collection
  .aggregate([
    {
      $searchMeta: {
        index: "text_index",
        facet: {
          operator: {
            text: {
              query: "mongodb",
              path: "content",
            },
          },
          facets: {
            categoryFacet: {
              type: "string",
              path: "category",
            },
            yearFacet: {
              type: "number",
              path: "year",
              boundaries: [2020, 2021, 2022, 2023, 2024],
            },
          },
        },
      },
    },
  ])
  .toArray();

🔄 Change Streams Enhanced

// ✅ MongoDB 8 - Change streams improvements

// Watch for changes
const changeStream = collection.watch(
  [
    {
      $match: {
        "fullDocument.status": "active",
        operationType: { $in: ["insert", "update"] },
      },
    },
  ],
  {
    fullDocument: "updateLookup",
    // New in MongoDB 8: expanded events
    fullDocumentBeforeChange: "whenAvailable",
  },
);

changeStream.on("change", (change) => {
  console.log("Change detected:", change);

  // Access both before and after state
  console.log("Before:", change.fullDocumentBeforeChange);
  console.log("After:", change.fullDocument);

  // React to change
  if (change.operationType === "insert") {
    sendWelcomeEmail(change.fullDocument);
  }
});

// Resume tokens improved
// More reliable resumability after restart
const resumeToken = changeStream.resumeToken;

// Later, resume from token
const resumedStream = collection.watch([], {
  resumeAfter: resumeToken,
});

// Performance:
// MongoDB 7: 15ms latency
// MongoDB 8: 5ms latency (-67%)

🎓 Best Practices

1. Use Queryable Encryption

// ✅ For sensitive data
autoEncryption: {
  encryptedFieldsMap: {
    'db.collection': {
      fields: [{ path: 'ssn', queries: { queryType: 'equality' } }]
    }
  }
}

2. Optimize Indexes

// ✅ Compound indexes strategically
await collection.createIndex({
  status: 1,
  createdAt: -1,
});

3. Time Series for Metrics

// ✅ Use time series collections
await db.createCollection("metrics", {
  timeseries: { timeField: "timestamp" },
});

4. Vector Search for AI

// ✅ Semantic search capabilities
$vectorSearch: {
  queryVector: embedding,
  path: 'embedding'
}

📊 Performance Comparison

Operation	MongoDB 7	MongoDB 8	Miglioramento
Complex query	2.5s	1.1s	-56%
Index intersect	850ms	320ms	-62%
Time series query	1.8s	600ms	-67%
Change stream	15ms	5ms	-67%
Storage (TS)	100GB	60GB	-40%

🔗 Risorse Utili

💡 Conclusioni

MongoDB 8 porta miglioramenti significativi:

✅ Queryable Encryption in GA ✅ Performance 2x migliorate ✅ Time series ottimizzate ✅ Vector search per AI ✅ Security rafforzata

Quando aggiornare:

✅ Smooth upgrade da MongoDB 7
✅ Performance boost immediato
🚀 New features production-ready

MongoDB 8 consolida la leadership nel NoSQL!

Contenuto redatto con l'assistenza di strumenti di intelligenza artificiale e rivisto dalla redazione di Codegrind, che ne è responsabile. Hai trovato un errore? Scrivici.