Article original : How to Build a Dropbox-like Distributed File Storage System Using MinIO and gRPC

Dans ce tutoriel, je vais vous guider à travers la construction d'un système de stockage de fichiers distribué inspiré par Dropbox, en utilisant MinIO (un serveur de stockage d'objets open-source compatible S3) et gRPC. L'objectif est de créer un système capable de stocker, répliquer et gérer des fichiers sur plusieurs nœuds, assurant ainsi la disponibilité et la résilience des données.

Nous implémenterons des fonctionnalités principales telles que la réplication de fichiers, la gestion des métadonnées et la gestion des versions, tout en démontrant comment atteindre une cohérence éventuelle dans un environnement distribué. À la fin, vous aurez un système de stockage de fichiers distribué entièrement fonctionnel capable de gérer un trafic élevé, d'optimiser le stockage et d'assurer l'intégrité des données.

Ce que vous allez apprendre

  • Comment configurer MinIO pour le stockage d'objets distribué.

  • Comment utiliser gRPC pour une communication client-serveur efficace.

  • Comment implémenter la réplication de fichiers et la gestion des métadonnées.

  • Comment comprendre la cohérence des données dans un système distribué.

  • Comment utiliser Docker pour déployer une architecture distribuée et scalable.

Prérequis

Avant de commencer, assurez-vous d'avoir installé les éléments suivants :

  • Node.js (v14 ou supérieur)

  • MinIO

  • gRPC et gRPC-tools

  • Docker

Vous aurez également besoin d'une compréhension de base de Node.js, du stockage d'objets et des systèmes distribués.

Table des matières

Aperçu du projet

Nous allons construire un système de stockage de fichiers distribué où :

  1. Les utilisateurs peuvent télécharger et téléverser des fichiers.

  2. Les fichiers sont répliqués sur plusieurs nœuds de stockage pour assurer une haute disponibilité.

  3. Les métadonnées (comme les noms de fichiers, les heures de téléversement et les versions) sont gérées centralement.

  4. Le système gère la cohérence éventuelle en synchronisant les mises à jour de fichiers sur les nœuds.

Architecture du système

Notre système se composera de :

  1. Serveur gRPC : Gère les téléversements, téléchargements et métadonnées des fichiers.

  2. Nœuds de stockage distribué MinIO : Gère le stockage d'objets et la réplication.

  3. Interface client : Permet aux utilisateurs d'interagir avec le système via HTTP.

Étape 1 : Configuration du projet

Créez un nouveau répertoire pour le projet et initialisez une application Node.js :

mkdir stockage-fichiers-distribué
cd stockage-fichiers-distribué
npm init -y

Maintenant, installez les dépendances nécessaires :

npm install grpc @grpc/grpc-js @grpc/proto-loader express multer dotenv minio

  • grpc : Pour construire le serveur et le client gRPC.

  • @grpc/proto-loader : Charge les fichiers de protocole gRPC.

  • express : Pour le serveur HTTP côté client.

  • multer : Pour gérer les téléversements de fichiers.

  • dotenv : Pour gérer les variables d'environnement.

  • minio : Client MinIO pour interagir avec les nœuds de stockage.

Créez un fichier .env avec le contenu suivant :

MINIO_ENDPOINT_1=localhost:9001
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin
PORT=5000

Étape 2 : Configuration des nœuds de stockage distribué MinIO

Nous utiliserons Docker pour exécuter plusieurs instances MinIO, simulant un environnement distribué. Exécutez les commandes suivantes pour configurer trois conteneurs MinIO :

docker run -p 9001:9000 --name minio1 -e "MINIO_ACCESS_KEY=minioadmin" -e "MINIO_SECRET_KEY=minioadmin" -d minio/minio server /data
docker run -p 9002:9000 --name minio2 -e "MINIO_ACCESS_KEY=minioadmin" -e "MINIO_SECRET_KEY=minioadmin" -d minio/minio server /data
docker run -p 9003:9000 --name minio3 -e "MINIO_ACCESS_KEY=minioadmin" -e "MINIO_SECRET_KEY=minioadmin" -d minio/minio server /data

Ces commandes démarreront trois nœuds MinIO, chacun écoutant sur un port différent.

Étape 3 : Définition du protocole gRPC

Créez un nouveau dossier nommé protos et à l'intérieur, créez un fichier appelé storage.proto :

syntax = "proto3";

service FileStorage {
  rpc UploadFile(stream FileRequest) returns (UploadResponse);
  rpc DownloadFile(FileDownloadRequest) returns (stream FileResponse);
  rpc GetMetadata(FileMetadataRequest) returns (MetadataResponse);
}

message FileRequest {
  bytes fileData = 1;
  string fileName = 2;
}

message UploadResponse {
  string message = 1;
}

message FileDownloadRequest {
  string fileName = 1;
}

message FileResponse {
  bytes fileData = 1;
}

message FileMetadataRequest {
  string fileName = 1;
}

message MetadataResponse {
  string fileName = 1;
  string uploadTime = 2;
  string version = 3;
}

  • UploadFile : Transmet les données de fichier du client au serveur.

  • DownloadFile : Transmet les données de fichier du serveur au client.

  • GetMetadata : Récupère les métadonnées comme le nom de fichier, l'heure de téléversement et la version.

Étape 4 : Implémentation du serveur gRPC

Créez un fichier appelé server.js :

require('dotenv').config();
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const Minio = require('minio');
const fs = require('fs');
const path = require('path');

const packageDefinition = protoLoader.loadSync('protos/storage.proto');
const storageProto = grpc.loadPackageDefinition(packageDefinition).FileStorage;

// Configuration des clients MinIO pour chaque nœud
const minioClients = [
  new Minio.Client({
    endPoint: process.env.MINIO_ENDPOINT_1.split(':')[0],
    port: parseInt(process.env.MINIO_ENDPOINT_1.split(':')[1]),
    accessKey: process.env.MINIO_ACCESS_KEY,
    secretKey: process.env.MINIO_SECRET_KEY,
    useSSL: false,
  })
];

// Télécharger le fichier vers MinIO
async function uploadFile(call, callback) {
  const chunks = [];
  call.on('data', (chunk) => chunks.push(chunk.fileData));
  call.on('end', async () => {
    const buffer = Buffer.concat(chunks);
    const fileName = call.metadata.get('fileName')[0];

    // Stocker le fichier dans MinIO
    const client = minioClients[0];
    await client.putObject('files', fileName, buffer);
    callback(null, { message: `Fichier ${fileName} téléversé avec succès` });
  });
}

// Télécharger le fichier depuis MinIO
function downloadFile(call) {
  const { fileName } = call.request;
  const client = minioClients[0];

  client.getObject('files', fileName, (err, stream) => {
    if (err) return call.emit('error', err);
    stream.on('data', (chunk) => call.write({ fileData: chunk }));
    stream.on('end', () => call.end());
  });
}

function main() {
  const server = new grpc.Server();
  server.addService(storageProto.FileStorage.service, { uploadFile, downloadFile });
  server.bindAsync('0.0.0.0:5000', grpc.ServerCredentials.createInsecure(), () => {
    console.log('Serveur gRPC en cours d\'exécution sur le port 5000');
    server.start();
  });
}

main();

Voici ce qui se passe dans ce code :

  1. uploadFile : Gère les téléversements de fichiers en transmettant les données au serveur et en les stockant dans MinIO.

  2. downloadFile : Transmet le fichier demandé depuis MinIO vers le client.

  3. Clients MinIO : Nous configurons plusieurs clients MinIO pour gérer le stockage distribué.

Étape 5 : Création du client

Créez un fichier nommé client.js :

const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');
const fs = require('fs');

const packageDefinition = protoLoader.loadSync('protos/storage.proto');
const storageProto = grpc.loadPackageDefinition(packageDefinition).FileStorage;
const client = new storageProto('localhost:5000', grpc.credentials.createInsecure());

function uploadFile(filePath) {
  const call = client.uploadFile();
  const fileName = filePath.split('/').pop();
  const stream = fs.createReadStream(filePath);

  stream.on('data', (chunk) => call.write({ fileData: chunk }));
  stream.on('end', () => call.end());
  call.on('data', (response) => console.log(response.message));
}

function downloadFile(fileName) {
  const call = client.downloadFile({ fileName });
  const writeStream = fs.createWriteStream(`downloaded_${fileName}`);

  call.on('data', (chunk) => writeStream.write(chunk.fileData));
  call.on('end', () => console.log(`Fichier ${fileName} téléchargé`));
}

uploadFile('test.txt');  // Exemple d'utilisation

Étape 6 : Exécution du système

  1. Démarrez le serveur gRPC :

    node server.js

  2. Exécutez le client :

    node client.js

Conclusion : Ce que vous avez appris

Félicitations ! Vous avez construit un système de stockage de fichiers distribué en utilisant MinIO et gRPC. Dans ce tutoriel, vous avez appris à :

  1. Configurer un système de stockage d'objets distribué en utilisant MinIO.

  2. Utiliser gRPC pour gérer les téléversements, téléchargements et la gestion des métadonnées de fichiers.

  3. Implémenter la réplication de fichiers et la cohérence éventuelle sur plusieurs nœuds.

  4. Utiliser Docker pour simuler un environnement distribué scalable.

Prochaines étapes :

  1. Ajouter la gestion des versions de fichiers : Stockez plusieurs versions de fichiers pour permettre un retour en arrière.

  2. Implémenter l'authentification : Sécurisez vos endpoints gRPC avec JWT.

  3. Déployer avec Kubernetes : Scalez votre système sur plusieurs nœuds pour une haute disponibilité.

Bon codage !