Crie uma arquitetura multilocatário para a Vector Search do MongoDB

Uma coleção para todos os locatários

Recomendamos armazenar todos os dados do locatário em uma única coleção, e em um único banco de dados e cluster. Você pode distinguir entre locatários incluindo um campo tenant_id em cada documento. Este campo pode ser qualquer identificador único para o locatário, como um UUID ou um nome de locatário. Você pode usar este campo como um pré-filtro em seus índices de pesquisa do MongoDB Vector Search e consultas.

Essa abordagem centralizada oferece os seguintes benefícios:

• Simples de modelar e dimensionar.

• Simplifica as operações de manutenção.

• Roteamento eficiente de query por meio de pré-filtragem por tenant_id.

  Observação

  Este filtro garante que as query retornem dados apenas para locatários que correspondem a este filtro.

Uma coleção por locatário ou um banco de dados por locatário

Não recomendamos armazenar cada locatário em uma coleção ou banco de dados separado pelos seguintes motivos:

• Impacto no desempenho: essa abordagem pode levar à variação das cargas de fluxo de alterações, dependendo do número de coleções, o que pode impactar negativamente o desempenho e os recursos de monitoramento.

• Sem isolamento adicional: As garantias de isolamento de dados no Atlas se aplicam no nível do banco de dados. O uso de coleções separadas dentro do mesmo banco de dados não oferece nenhum benefício adicional de isolamento de dados. O uso de bancos de dados separados introduz complexidade operacional sem vantagens de segurança significativas para a maioria dos casos de uso.

Em vez disso, use uma coleção para todos os locatários. Para um exemplo de como migrar de um modelo de coleção por locatário para um modelo de coleção única, veja Migrando de um modelo de coleção por locatário.

Discrepâncias de tamanho do locatário

Se você tiver muitos locatários com relativamente poucos documentos cada, ou se tiver problemas de desempenho devido à distribuição desigual de dados (alguns locatários grandes e muitos locatários pequenos), considere as estratégias a seguir.

{
  "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>", ... ]
        }
      }
    }
  ]
)

Muitos locatários grandes

If you have many tenants that each have a large number of documents, consider using a partition-based system by distributing data across shards.

Você pode usar o campo tenant_id como uma chave de fragmento para distribuir os dados em faixas específicas com base no ID do locatário. Para obter mais informações, consulte Fragmentação à distância.

Migrando de um modelo de coleção por locatário

Para migrar de um modelo de coleção por locatário para um modelo de coleção única, processe cada coleção de locatário e insira os documentos em uma nova coleção.

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);