Construya una arquitectura multiinquilino para MongoDB Vector Search

Una colección para todos los inquilinos

Recomendamos almacenar todos los datos de los inquilinos en una sola colección, así como en una única base de datos y clúster. Puede distinguir entre inquilinos incluyendo un tenant_id Campo dentro de cada documento. Este campo puede ser cualquier identificador único del inquilino, como un UUID o el nombre del inquilino. Puede usarlo como prefiltro en sus índices y consultas 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 consultas mediante filtrado previo por tenant_id.

  Nota

  Se le garantiza que no atenderá a inquilinos que no 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 generar diferentes cambiar las cargas de transmisión en función de la cantidad de recopilaciones, lo que podría afectar negativamente el rendimiento y las capacidades de monitoreo.

• Sin 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 ofrece ningún beneficio adicional de aislamiento de datos. El uso de bases de datos independientes introduce complejidad operativa sin ventajas significativas de seguridad en la mayoría de los casos de uso.

En su lugar, utilice 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 uno de colección única, consulte Migración desde un modelo de colección por inquilino.

Discrepancias en el tamaño del inquilino

Si experimentas problemas de rendimiento por la distribución desigual de datos (algunos inquilinos grandes y muchos inquilinos pequeños), utiliza las vistas de MongoDB para separar los inquilinos grandes de los inquilinos más pequeños:

• Grandes inquilinos (Top 1%):

  • Cree una vista para cada inquilino grande.

  • Crea un índice para cada vista.

  • Mantenga un registro de inquilinos grandes que verifique en el momento de la consulta para dirigir las consultas en consecuencia.

• Pequeños inquilinos (inquilinos restantes):

  • Cree una vista única para todos los pequeños inquilinos.

  • Construya un índice único para esta vista.

  • Utilice el campo tenant_id como prefiltro para enrutar las consultas en consecuencia.

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

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

Muchos inquilinos grandes

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

Puede usar el tenant_id campo como clave de fragmentación para distribuir los datos en rangos específicos según el ID del inquilino. Para obtener más información, consulte Fragmentación por rangos.

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, procese cada colección de inquilino e inserte 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);