De nombreuses applications impliquent la gestion de fichiers et le stockage de fichiers est une fonctionnalité importante pour améliorer le traitement des données. Le stockage de fichiers nécessite souvent un CDN (Content Delivery Network) tiers, comme les services Web Amazon, mais cela rend le processus de gestion un peu fastidieux. Il serait plus facile d'accéder à toutes vos ressources à partir d'un seul stockage cloud, plutôt que de plusieurs, car il peut y avoir un risque d'échec lors de la récupération.
Stocker des fichiers directement dans une base de données via un seul appel d'API n'était pas quelque chose de facile jusqu'à l'introduction de GridFS dans MongoDB.
Qu'est-ce que MongoDB GridFS
GridFs est une couche d'abstraction dans MongoDB utilisée dans le stockage et la récupération de fichiers volumineux tels que des vidéos, des audios et des images. Ce système de fichiers stocke des fichiers encore plus importants que 16 Mo dans les collections de données MongoDB. Les fichiers sont stockés en les divisant d'abord en petits morceaux de données, chaque morceau ayant une taille de 255 Ko.
GridFS utilise deux systèmes de collecte pour stocker les fichiers :
- Bloc :Il s'agit de la collection qui stocke les parties du document. Les morceaux sont limités à une taille de 255 Ko chacun et lorsque l'on fait une requête, le pilote GridFS réassemble tous les morceaux selon le stockage unique _id. Par exemple, vous pourriez vouloir récupérer un segment d'un fichier vidéo plutôt que le fichier entier, cela est possible en interrogeant simplement la plage correcte que vous voulez.
- Fichier :Cela stocke les métadonnées supplémentaires conséquentes pour le fichier.
Les collections sont placées dans un bucket commun, puis préfixées chacune avec le nom du bucket qui par défaut est fs et nous avons :
- fs.chunks
- fs.files
On peut choisir un nom de bucket différent mais le nom complet de la collection est soumis à :une limite d'espace de noms de 255 octets.
Collection de morceaux
Les documents de collection de blocs ont la forme :
{
"_id" : <ObjectId>,
"files_id" : <ObjectId>,
"n" : <num>,
"data" : <binary>
}Où :
- _id :est l'identifiant unique du bloc
- files_id :est le _id du document parent tel qu'il est stocké dans la collection de fichiers
- n :est le numéro de séquence du morceau commençant par 0.
- data :est la charge utile du morceau en tant que type binaire BSON.
Un index composé utilisant des champs files_id et n est utilisé pour permettre une récupération efficace des morceaux par exemple :
db.fs.chunks.find( { files_id: fileId } ).sort( { n: 1 } )Pour créer cet index s'il n'existe pas, vous pouvez exécuter la commande suivante sur un shell mongo :
db.fs.chunks.createIndex( { files_id: 1, n: 1 }, { unique: true } );Collection de fichiers
Les documents de cette collection prennent la forme
{
"_id" : <ObjectId>,
"length" : <num>,
"chunkSize" : <num>,
"uploadDate" : <timestamp>,
"filename" : <string>,
"metadata" : <any>,
}Où :
- _id :est l'identifiant unique du document qui est du type de données que l'on choisit pour le document d'origine et par défaut dans MongoDB est le BSON ObjectId.
- longueur :correspond à la taille du document en octets
- chunkSize :taille de chaque morceau qui est limitée à 255 Ko
- uploadDate :champ de type Date qui stocke la date à laquelle le document a été stocké pour la première fois.
- nom du fichier :il s'agit d'un champ facultatif qui est une identification lisible par l'homme pour le fichier.
- métadonnées :il s'agit d'un champ facultatif qui contient des informations supplémentaires que l'on souhaite stocker.
Un exemple de fichier fs est présenté ci-dessous.
{
"filename": "file.html",
"chunkSize": NumberInt(23980),
"uploadDate": ISODate("2020-08-11T10:02:15.237Z"),
"length": NumberInt(312)
}Comme la collection chunks, un index composé utilisant les champs filename et uploadDate est utilisé dans la collection files pour permettre une récupération efficace des fichiers, par exemple :
db.fs.files.find( { filename: fileName } ).sort( { uploadDate: 1 } )Pour créer cet index s'il n'existe pas, vous pouvez exécuter la commande suivante sur un shell mongo :
db.fs.file.createIndex( { filename: 1, uploadDate: 1 }, { unique: true } );Quand utiliser le système de stockage MongoDB GridFS
MongoDB GridFS n'est pas couramment utilisé, mais les conditions suivantes peuvent nécessiter l'utilisation de ce système de stockage GridFS :
- Lorsque le système de fichiers actuel limite le nombre de fichiers pouvant être stockés dans un répertoire donné.
- Lorsque l'on a l'intention d'accéder à une partie des informations stockées, GridFS permet de rappeler des parties du fichier sans accéder à l'ensemble du document.
- Lorsque l'on a l'intention de distribuer des fichiers et leurs métadonnées par le biais d'ensembles de réplicas répartis géographiquement, GridFS permet aux métadonnées de synchroniser et de déployer automatiquement les données sur plusieurs systèmes ciblés.
Quand ne pas utiliser le système de stockage MongoDB GridFS
Le système de stockage GridFS n'est cependant pas approprié pour être utilisé lorsqu'il sera nécessaire de mettre à jour le contenu de l'ensemble du fichier enregistré dans GridFS.
Comment ajouter des fichiers à GridFS
Lorsque vous stockez un fichier mp3 dans MongoDB à l'aide de GridFs, la bonne procédure à suivre est la suivante :
- Ouvrez le terminal (l'invite de commande)
- Naviguez jusqu'à mongofiles.exe (celui-ci se trouve dans le dossier bin)
- Utilisez la commande
>mongofiles.exe -d gridfs put song.mp3
Après la commande, le nom de la base de données à utiliser est le gridfs, si par hasard, le nom manque, MongoDB crée automatiquement un document qui stocke le fichier sur la base de données.
Pour afficher le fichier stocké dans GridFS, utilisez la commande de requête ci-dessous sur le shell mongo ;
>db.fs.files.find()La commande renvoie un document au format indiqué ci-dessous :
{
_id: ObjectId('526a922bf8b4aa4d33fdf84d'),
filename: "song.mp3",
chunkSize: 233390,
uploadDate: new Date(1397391643474), md5: "e4f53379c909f7bed2e9d631e15c1c41",
length: 10302960
}Le fichier contient les détails suivants :nom de fichier, longueur, date de téléchargement, taille de bloc et object_id. Les morceaux de la collection fs.chunks peuvent être visualisés à l'aide de l'identifiant renvoyé dans la requête initiale, comme indiqué ci-dessous.
>db.fs.chunks.find({files_id:ObjectId('526a922bf8b4aa4d33fdf84d')})Partage GridFS
Le partage est également une autre fonctionnalité applicable avec GridFS. Pour partitionner la collection de morceaux, on peut utiliser soit un index composé de { files_id :1, n :1 } ou { files_id :1 } comme clé de partition.
Harshed Sharding n'est possible que si les pilotes MongoDB n'exécutent pas filemd5.
Les collections de fichiers ne sont souvent pas partitionnées, car elles ne contiennent que des métadonnées et sont très petites. Les clés disponibles ne fournissent pas non plus une distribution égale dans un cluster fragmenté. Cependant, si l'on a besoin de partitionner une collection de fichiers, vous pouvez utiliser le champ _id en combinaison avec certains champs d'application.
Limites de GridFS
Le système de fichiers GridFS présente les limitations suivantes :
- Mise à jour atomique : GridFS n'a pas de mise à jour atomique. Cela facilite la mise à jour manuelle en sélectionnant la version requise des fichiers et en conservant plusieurs versions de fichiers en cours d'exécution
- Performances : le système a tendance à être lent avec le système de fichiers et le serveur Web.
- Ensemble de travail : on utilise un autre serveur lorsqu'on travaille sur un nouvel ensemble de travail. Ceci est fait afin d'éviter de perturber l'ensemble de travail en cours d'exécution.
Conclusion
GridFS est comme une solution miracle pour les développeurs qui ont l'intention de stocker des fichiers volumineux dans MongoDB. Le système de stockage GridFS donne aux développeurs la possibilité de stocker des fichiers volumineux et de récupérer des parties des fichiers nécessaires. GridFS est donc une excellente fonctionnalité MongoDB qui peut être utilisée avec diverses applications.
