Almacene archivos grandes

Overview

En esta guía, puedes aprender cómo almacenar y recuperar archivos grandes en MongoDB usando GridFS. El sistema de almacenamiento GridFS divide los archivos en fragmentos al almacenarlos y vuelve a ensamblar esos archivos al recuperarlos. La implementación del driver de GridFS es una abstracción que gestiona las operaciones y la organización del almacenamiento de archivos.

Utilice GridFS si el tamaño de cualquiera de sus archivos supera el límite de tamaño del documento BSON de 16 MB. Para obtener información más detallada sobre si GridFS es adecuado para su caso de uso, consulte GridFS en el manual del MongoDB Server.

Cómo funciona GridFS

GridFS organiza los archivos en un bucket, un grupo de colecciones de MongoDB que contienen los fragmentos de archivos e información que los describe. El bucket contiene las siguientes colecciones:

• chunks: almacena los fragmentos de archivos binarios

• files:Almacena los metadatos del archivo

El controlador crea el bucket de GridFS, si aún no existe, la primera vez que se escriben datos en él. El bucket contiene las colecciones chunks y files, con el prefijo predeterminado fs, a menos que se especifique otro. Para garantizar una recuperación eficiente de los archivos y los metadatos relacionados, el controlador crea un índice en cada colección. El controlador se asegura de que estos índices existan antes de realizar operaciones de lectura y escritura en el bucket de GridFS.

Para obtener más información sobre los índices de GridFS, consulta Índices de GridFS en el manual del servidor MongoDB.

Cuando se utiliza GridFS para almacenar archivos, el driver divide los archivos en fragmentos más pequeños, cada uno representada por un documento independiente en la colección chunks. También crea un documento en la colección files que contiene un ID de archivo, el nombre del archivo y otros metadatos del archivo.

El siguiente diagrama muestra cómo GridFS divide los archivos cuando se cargan en un bucket.

Al recuperar archivos, GridFS obtiene los metadatos de la colección files en el bucket especificado y usa la información para reconstruir el archivo a partir de documentos en la colección chunks.

Crear un bucket de GridFS

Para comenzar a utilizar GridFS para almacenar o recuperar archivos, crea una nueva instancia de la clase GridFSBucket, pasando un objeto IMongoDatabase que represente tu base de datos. Este método accede a un bucket existente o crea uno nuevo si aún no existe.

El siguiente ejemplo crea una nueva instancia de la clase GridFSBucket para la base de datos db:

var client = new MongoClient("<connection string>");
var database = client.GetDatabase("db");
// Creates a GridFS bucket or references an existing one
var bucket = new GridFSBucket(database);

var options = new GridFSBucketOptions { BucketName = "myCustomBucket" };
var customBucket = new GridFSBucket(database, options);

Cargar archivos

Puede cargar archivos en un bucket de GridFS utilizando los siguientes métodos:

• OpenUploadStream() o OpenUploadStreamAsync(): abre un nuevo flujo de carga en el que puedes escribir el contenido del archivo

• UploadFromStream() o UploadFromStreamAsync(): Sube el contenido de una secuencia existente a un archivo GridFS

Las siguientes secciones describen cómo usar estos métodos.

using (var uploader = bucket.OpenUploadStream("my_file"))
{
    // ASCII for "HelloWorld"
    byte[] bytes = { 72, 101, 108, 108, 111, 87, 111, 114, 108, 100 };
    uploader.Write(bytes, 0, bytes.Length);
    uploader.Close();
}

using (var uploader = await bucket.OpenUploadStreamAsync("my_file", options))
{
    // ASCII for "HelloWorld"
    byte[] bytes = { 72, 101, 108, 108, 111, 87, 111, 114, 108, 100 };
    await uploader.WriteAsync(bytes, 0, bytes.Length);
    await uploader.CloseAsync();
}

var options = new GridFSUploadOptions
{
    ChunkSizeBytes = 1048576 // 1 MB
};
using (var uploader = bucket.OpenUploadStream("my_file", options))
{
    // ASCII for "HelloWorld"
    byte[] bytes = { 72, 101, 108, 108, 111, 87, 111, 114, 108, 100 };
    uploader.Write(bytes, 0, bytes.Length);
    uploader.Close();
}

var options = new GridFSUploadOptions
{
    ChunkSizeBytes = 1048576 // 1 MB
};
using (var uploader = await bucket.OpenUploadStreamAsync("my_file", options))
{
    // ASCII for "HelloWorld"
    byte[] bytes = { 72, 101, 108, 108, 111, 87, 111, 114, 108, 100 };
    await uploader.WriteAsync(bytes, 0, bytes.Length);
    await uploader.CloseAsync();
}

using (var fileStream = new FileStream("/path/to/input_file", FileMode.Open, FileAccess.Read))
{
    bucket.UploadFromStream("new_file", fileStream);
}

using (var fileStream = new FileStream("/path/to/input_file", FileMode.Open, FileAccess.Read))
{
    await bucket.UploadFromStreamAsync("new_file", fileStream);
}

Descargar archivos

Puede descargar archivos de un bucket GridFS utilizando los siguientes métodos:

• OpenDownloadStream() o OpenDownloadStreamAsync(): Puedes abrir un nuevo flujo de descargar desde el cual puedes leer el contenido del archivo

• DownloadToStream() o DownloadToStreamAsync(): Escribe el contenido de un archivo GridFS en un flujo existente

Las siguientes secciones describen estos métodos con más detalle.

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var doc = bucket.Find(filter).FirstOrDefault();
if (doc != null)
{
    using (var downloader = bucket.OpenDownloadStream(doc.Id))
    {
        var buffer = new byte[downloader.Length];
        downloader.Read(buffer, 0, buffer.Length);
        // Process the buffer as needed
    }
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var cursor = await bucket.FindAsync(filter);
var fileInfoList = await cursor.ToListAsync();
var doc = fileInfoList.FirstOrDefault();
if (doc != null)
{
    using (var downloader = await bucket.OpenDownloadStreamAsync(doc.Id))
    {
        var buffer = new byte[downloader.Length];
        await downloader.ReadAsync(buffer, 0, buffer.Length);
        // Process the buffer as needed
    }
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var doc = bucket.Find(filter).FirstOrDefault();
if (doc != null)
{
    var options = new GridFSDownloadOptions
    {
        Seekable = true
    };
    using (var downloader = bucket.OpenDownloadStream(id, options))
    {
        var buffer = new byte[downloader.Length];
        downloader.Read(buffer, 0, buffer.Length);
        // Process the buffer as needed
    }
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var cursor = await bucket.FindAsync(filter);
var fileInfoList = await cursor.ToListAsync();
var doc = fileInfoList.FirstOrDefault();
if (doc != null)
{
    var options = new GridFSDownloadOptions
    {
        Seekable = true
    };
    using (var downloader = await bucket.OpenDownloadStreamAsync(doc.Id, options))
    {
        var buffer = new byte[downloader.Length];
        await downloader.ReadAsync(buffer, 0, buffer.Length);
        // Process the buffer as needed
    }
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var doc = bucket.Find(filter).FirstOrDefault();
if (doc != null)
{
    using (var outputFile = new FileStream("/path/to/output_file", FileMode.Create, FileAccess.Write))
    {
        bucket.DownloadToStream(doc.Id, outputFile);
    }
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var cursor = await bucket.FindAsync(filter);
var fileInfoList = await cursor.ToListAsync();
var doc = fileInfoList.FirstOrDefault();
if (doc != null)
{
    using (var outputFile = new FileStream("/path/to/output_file", FileMode.Create, FileAccess.Write))
    {
        await bucket.DownloadToStreamAsync(doc.Id, outputFile);
    }
}

Buscar archivos

Para encontrar archivos en un bucket GridFS, llame al método Find() o FindAsync() en su instancia GridFSBucket. Estos métodos aceptan los siguientes parámetros:

El siguiente ejemplo de código muestra cómo recuperar e imprimir metadatos de archivos en un bucket de GridFS. El Find() método devuelve una IAsyncCursor<GridFSFileInfo> instancia desde la que se puede acceder a los resultados. Utiliza un foreach bucle para iterar sobre el cursor devuelto y mostrar el contenido de los archivos cargados en los ejemplos de carga de archivos.

Selecciona la pestaña Synchronous o Asynchronous para ver el código correspondiente.

var filter = Builders<GridFSFileInfo>.Filter.Empty;
var files = bucket.Find(filter);
foreach (var file in files.ToEnumerable())
{
    Console.WriteLine(file.ToJson());
}

{ "_id" : { "$oid" : "..." }, "length" : 13, "chunkSize" : 261120, "uploadDate" :
{ "$date" : ... }, "filename" : "new_file" }
{ "_id" : { "$oid" : "..." }, "length" : 50, "chunkSize" : 1048576, "uploadDate" :
{ "$date" : ... }, "filename" : "my_file" }

var filter = Builders<GridFSFileInfo>.Filter.Empty;
var files = await bucket.FindAsync(filter);
await files.ForEachAsync(file => Console.Out.WriteLineAsync(file.ToJson()))

{ "_id" : { "$oid" : "..." }, "length" : 13, "chunkSize" : 261120, "uploadDate" :
{ "$date" : ... }, "filename" : "new_file" }
{ "_id" : { "$oid" : "..." }, "length" : 50, "chunkSize" : 1048576, "uploadDate" :
{ "$date" : ... }, "filename" : "my_file" }

Para personalizar la operación de búsqueda, pasa una instancia de la clase GridFSFindOptions al método Find() o FindAsync(). La clase GridFSFindOptions contiene las siguientes propiedades:

Borrar archivos

Para borrar archivos de un bucket GridFS, llama al método Delete() o DeleteAsync() en tu instancia de GridFSBucket. Este método remueve la colección de metadatos de un archivo y sus fragmentos asociados de tu bucket.

Los métodos Delete y DeleteAsync() aceptan los siguientes parámetros:

El siguiente ejemplo de código muestra cómo borrar un archivo llamado "my_file" pasando su valor _id a delete_file():

• Utiliza la clase Builders para crear un filtro que coincida con el archivo llamado "my_file"

• Utiliza el método Find() para buscar el archivo llamado "my_file"

• Pasa el valor _id del archivo al método Delete() para eliminar el archivo

Selecciona la pestaña Synchronous o Asynchronous para ver el código correspondiente.

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var doc = bucket.Find(filter).FirstOrDefault();
if (doc != null)
{
    bucket.Delete(doc.Id);
}

var filter = Builders<GridFSFileInfo>.Filter.Eq(x => x.Filename, "new_file");
var cursor = await bucket.FindAsync(filter);
var fileInfoList = await cursor.ToListAsync();
var doc = fileInfoList.FirstOrDefault();
if (doc != null)
{
    await bucket.DeleteAsync(doc.Id);
}

Documentación de la API

Para obtener más información sobre las clases utilizadas en esta página, consulta la siguiente documentación de la API:

• GridFSBucket

• Opciones de GridFSBucket

• GridFSDownloadOptions

• GridFSFindOptions

• GridFSUploadOptions

• GridFSFileInfo

Para conocer más sobre los métodos de la *clase* GridFSBucket utilizados en esta página, consulta la siguiente documentación de la API:

• OpenUploadStream()

• OpenUploadStreamAsync()

• UploadFromStream()

• UploadFromStreamAsync()

• OpenDownloadStream()

• OpenDownloadStreamAsync()

• DownloadToStream()

• DownloadToStreamAsync()

• find()

• FindAsync()

• borrar()

• DeleteAsync()