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. Puedes distinguir entre inquilinos al incluir un tenant_id campo dentro de cada documento. Este campo puede ser cualquier identificador único para el inquilino, como un UUID o un nombre de inquilino. Puede utilizar este campo como un Prefiltra en tus í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 query mediante prefiltrado por tenant_id.

  Nota

  Tienes la garantía de no servir tenants 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 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 tienes muchos tenants con relativamente pocos vectores cada uno, o si experimentas problemas de rendimiento debido a la distribución desigual de datos (algunos tenants grandes y muchos pequeños), considera las siguientes estrategias.

{
  "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 tienes muchos tenants (arrendatarios) que cada uno tiene un gran número de vectores, considera usar un sistema basado en particiones distribuyendo los datos entre los 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);