Construir una arquitectura multiinquilino para la MongoDB Vector Search

Una colección para todos los inquilinos

Recomendamos almacenar todos los datos del inquilino en una única colección, así como en una única base de datos y clúster. Puede distinguir entre tenants incluyendo un campo de tenant_id dentro de cada documento. Este campo puede ser cualquier identificador único para el tenant, como un UUID o un nombre de tenant. Se puede usar este campo como un prefiltro en los índices y queries de MongoDB Vector Search.

Este enfoque centralizado ofrece los siguientes beneficios:

• Fácil de modelar y escalar.

• Simplifica las operaciones de mantenimiento.

• Enrutamiento eficiente de query mediante prefiltrado por tenant_id.

  Nota

  Este filtro ofrece garantías de que las query devuelvan datos solo para los inquilinos que coincidan con este filtro.

Una colección por inquilino u una base de datos por inquilino

No recomendamos almacenar cada inquilino en una colección o base de datos diferente por las siguientes razones:

• Impacto en el rendimiento: Este enfoque puede producir cargas de flujo de cambios variables según el número de colecciones, lo que podría afectar negativamente el rendimiento y las capacidades de supervisión.

• No hay aislamiento adicional: Las garantías de aislamiento de datos en Atlas se aplican a nivel de base de datos. El uso de colecciones separadas dentro de la misma base de datos no proporciona ningún beneficio adicional de aislamiento de datos. El uso de bases de datos separadas introduce una complejidad operativa sin ventajas significativas en materia de seguridad para la mayoría de los casos de uso.

En su lugar, utiliza una sola colección para todos los inquilinos. Para ver un ejemplo de cómo migrar de un modelo de colección por inquilino a un modelo de colección única, consulta Migrar de un modelo de colección por inquilino.

Discrepancias en el tamaño del inquilino

Si tiene muchos tenants con relativamente pocos documentos cada uno, o si experimenta problemas de rendimiento debido a una distribución desigual de los datos (algunos tenants grandes y muchos pequeños), considere las siguientes estrategias.

{
  "fields": [
    {
      "type": "autoEmbed",
      "modality": "text",
      "path": "<fieldToIndex>",
      "model": "<embeddingModel>",
      "indexingMethod": "flat"
    },
    {
      "type": "filter",
      "path": "tenant_id"
    }
  ]
}

{
  "fields": [
    {
      "type": "vector",
      "path": "<fieldToIndex>",
      "numDimensions": <numberOfDimensions>,
      "similarity": "euclidean | cosine | dotProduct",
      "indexingMethod": "flat"
    },
    {
      "type": "filter",
      "path": "tenant_id"
    }
  ]
}

db.createView(
  "<viewName>",
  "<collectionName>",
  [
    {
      "$match": {
        "tenant_id": "<largeTenantId>"
      }
    }
  ]
)

db.createView(
  "<viewName>",
  "<collectionName>",
  [
    {
      "$match": {
        "tenant_id": {
          "$nin": [ "<largeTenantId1>", "<largeTenantId2>", ... ]
        }
      }
    }
  ]
)

Muchos usuarios grandes

Si tiene muchos inquilinos, cada uno con una gran cantidad de documentos, considere la posibilidad de utilizar un sistema basado en particiones, distribuyendo los datos entre fragmentos.

Puedes usar el campo tenant_id como llave de partición para distribuir los datos a través de rangos específicos basados en el ID de arrendatario. Para más información, consulta Particionado clasificado por rango.

Migración desde un modelo de colección por inquilino

Para migrar de un modelo de colección por inquilino a un modelo de colección única, procesa cada colección de inquilinos e inserta los documentos en una nueva colección.

import { MongoClient } from 'mongodb';
const uri = "<connectionString>"; 
const sourceDbName = "<sourceDatabaseName>"; 
const targetDbName = "<targetDatabaseName>"; 
const targetCollectionName = "<targetCollectionName>";
async function migrateCollections() {
 const client = new MongoClient(uri);
 try {
     await client.connect();
     const sourceDb = client.db(sourceDbName);
     const targetDb = client.db(targetDbName);
     const targetCollection = targetDb.collection(targetCollectionName);
     const collections = await sourceDb.listCollections().toArray();
     console.log(`Found ${collections.length} collections.`);
     const BATCH_SIZE = 1000; // Define a suitable batch size based on your requirements
     let totalProcessed = 0;
     for (const collectionInfo of collections) {
         const collection = sourceDb.collection(collectionInfo.name);
         let documentsProcessed = 0;
         let batch = [];
         const tenantId = collectionInfo.name; // Uses the collection name as the tenant_id
         const cursor = collection.find({});
         for await (const doc of cursor) {
             doc.tenant_id = tenantId; // Adds a tenant_id field to each document
             batch.push(doc);
             if (batch.length >= BATCH_SIZE) {
                 await targetCollection.insertMany(batch);
                 totalProcessed += batch.length;
                 documentsProcessed += batch.length;
                 console.log(`Processed ${documentsProcessed} documents from ${collectionInfo.name}. Total processed: ${totalProcessed}`);
                 batch = [];
             }
         }
         if (batch.length > 0) {
             await targetCollection.insertMany(batch);
             totalProcessed += batch.length;
             documentsProcessed += batch.length;
             console.log(`Processed ${documentsProcessed} documents from ${collectionInfo.name}. Total processed: ${totalProcessed}`);
         }
     }
     console.log(`Migration completed. Total documents processed: ${totalProcessed}`);
 } catch (err) {
     console.error('An error occurred:', err);
 } finally {
     await client.close();
 }
}
await migrateCollections().catch(console.error);