Verwenden Sie MongoDB als Dateispeicher in PHP

Wenn es darum geht, skalierbaren Speicher für große Dateien zu erstellen, sind MongoDB und sein GridFS (geschrieben in MongoDB Query Language – MQL) eine der besten Dateispeicherlösungen auf dem Markt. In diesem Tutorial erfahren Sie, wie Sie MongoDB als Dateispeicher in PHP verwenden.

Es vereinfacht den Abfrageprozess für jeden Teil der Dateien-Sammlung und führt zu demselben Prozess wie für jede andere Abfrage, indem die benötigten Daten in Ihr Arbeitsset geladen werden (das Arbeitsset stellt einen Satz von Daten oder geladenen Daten dar zu diesem bestimmten Zeitpunkt), die von MongoDB innerhalb eines bestimmten Zeitrahmens benötigt werden, um die optimale Leistung zu verbessern oder aufrechtzuerhalten. Darüber hinaus führt es die Abfrage (Speicherung, Übertragung, Manipulation von Daten/Dateien) durch, indem es sie in den RAM auslagert.

Seine Leseleistung variiert, da er für kleine Dateien direkt aus dem RAM hervorragend sein kann und andererseits für große Dateien besser sein könnte. Es wird erwartet, dass die meisten Computer nicht über 600+ GB RAM verfügen und problemlos 600+ GB Partition einer einzelnen Datei auf einer einzelnen mongod-Instanz verarbeiten können.

Eine wichtige Sache, die hier zu berücksichtigen ist, ist, dass die Standard- oder durchschnittliche Größe von chunks 256 KB beträgt, was eine riesige Menge an Dokumenten für eine 600-GB-Dateisammlung ergibt; Sie können diese Einstellung jedoch in den meisten Treibern ändern. GridFS verwendet die Standardsperren (Datenbankebene 2.2+ oder globale Ebene vor 2.2) wie bei jeder anderen Sammlung.

Datenbankebene 2.2+ und globale Ebene vor 2.2 stören sich gegenseitig, und mit einem gründlichen Verständnis können Sie ein konsistentes Lesen eines Dokuments sicherstellen, das geschrieben wird.

Der implementierte Servertreiber bedeutet, dass er keine Ahnung von GridFS hat, und es gibt keine spezielle Auflösung von GridFS-Daten auf der Serverseite. Sie lernen, wie Sie das GridFS mit MongoDB in Ihrem PHP-Projekt implementieren, und es besteht die Möglichkeit für Konflikte basierend auf Ihren Szenariospezifikationen, dem Datenverkehr, der Anzahl gleichzeitiger Schreib-/Lesevorgänge und vielen anderen, sodass es möglicherweise eine Sperre für Lese-/Lesevorgänge gibt. Schreiboperationen in einigen Fällen.

Verwenden Sie GridFS von MongoDB als Dateispeicher

Dateien, deren Größe zunimmt (über die 16-MB-Standardgrenze der BSON-Datei hinaus), erfordern ein robusteres Speichersystem, und GridFS ist in der Lage, große Dateien zu verarbeiten, da es die Dateien in Chunks aufteilt, um jeden Chunk als separate Datei/Dokument zu speichern/handhaben anstatt die Datei als einzelnes Dokument zu speichern. Seine Standard-Chunk-Größe beträgt 255 KB und speichert sie in einer Sammlung und die Dateimetadaten in einer anderen.

Das Dateisystem auf Systemebene kann keine großen Dateien verarbeiten, und das Speichern in einer MongoDB-Datenbank ist effizienter. GridFS ist eine perfekte Lösung für den Zugriff auf Informationen aus Teilen großer Dateien, ohne das gesamte Dokument in den Speicher zu laden, und es ist eine leistungsoptimale Lösung, um das Daten-/Speicherlimit in einem Verzeichnis zu erhöhen.

Darüber hinaus hilft es bei der Synchronisation von Dokumenten, Dateien und Metadaten und beim Deployment der Daten über viele Systeme hinweg, um Dateien und ihre Metadaten effizient und automatisch zu verteilen, wenn geografisch verteilte Replikatsätze verwendet werden (Datenverteilung auf mehrere mongod-Instanzen). GridFS erleichtert Programmierern das Speichern und Verteilen von Daten auf zwei Arten, einschließlich der Verwendung eines MongoDB-Treibers oder des Befehlszeilentools mongofiles.

Es gibt zwei Arten von Sammlungen, mit denen GridFS arbeitet, einschließlich der Sammlungen chunks und files. Darüber hinaus repräsentiert es die chunks-Sammlung von fs.chunks und die files-Sammlung von fs.files für einen Buck namens fs.

/*
prerequisites

i) MongoDB 3.0 or higher
ii) PHP Driver

[Remember| install both on the same server]

This example will store a >1GB video on a MongoDB server.

the source code `mkdir src` must be stored in a directory so create one
to create a successful connection and understanding between your files and storage, create a settings file
your new directory will contain a `Settings.php` file with the following PHP contents:
*/

<?php
    # Remember| PHP 7.0 allows you to have one `define` using an array
    define("USERNAME_MONGODB", "[your_username]");
    define("PASSWORD_MONGODB", "[your_password]");
    define("DATABASE_MONGODB", "[your_databaseName]");
    define("SERVERIP_MONGODB", "[your_serverIP or your_hostname]");

    // the following script will enable file storage so you can store a file
    require_once(__DIR__ . '/Settings.php');

    if (!isset($argv[1]))
    {
        die("Please mention/pass the filepath to the file you want to store in MongoDB Server.");
    }

    $storage_filepath = $argv[1];

    if (!file_exists($storage_filepath) || is_dir($storage_filepath))
    {
        die("Invalid! Please, re-check your filepath.");
    }


    function mongo_Connect($your_username, $your_password, $your_database, $your_host_serverIP)
    {
        $con_MongoDB = new Mongo("mongodb://{$your_username}:{$your_password}@{$your_host_serverIP}"); // Connect to Mongo Server
        $con_database = $con_MongoDB -> selectDB($your_database); // Connect to Database
        return $con_database;
    }

    $con_database = mongo_Connect(
        USERNAME_MONGODB,
        PASSWORD_MONGODB,
        DATABASE_MONGODB,
        SERVERIP_MONGODB
    );

    $grid_FS = $con_database -> getGridFS();

    # you can stick any metadata here, e.g., upload the owner's ID, date of execution, etc.
    $add_metadata = array("date" => new MongoDate());
    $storage_filepath = $storage_filepath;
    $grid_FS -> storeFile($storage_filepath, array("metadata" => $add_metadata));

    // You can execute the script using the php `StoreFile.php` "filename.com.avi"
    // list files with the file size
    require_once(__DIR__ . '/Settings.php');

    function _mongoConnect($your_username, $your_password, $your_database, $your_host_serverIP)
    {
        $con_MongoDB = new Mongo("mongodb://{$your_username}:{$your_password}@{$your_host_serverIP}"); // Connect to Mongo Server
        $con_database = $con_MongoDB -> selectDB($your_database); // Connect to Database
        return $con_database;
    }

    $con_database = _mongoConnect(
        USERNAME_MONGODB,
        PASSWORD_MONGODB,
        DATABASE_MONGODB,
        SERVERIP_MONGODB
    );

    $grid_FS = $con_database -> getGridFS();

    # Loop over the files and output their names and file sizes
    $storage_files = $grid_FS -> find();

    while (($your_file = $storage_files -> getNext()) != null)
    {
        print $your_file -> getFilename() . "\t" . $your_file -> getSize() . PHP_EOL;
    }

    // retrieve files
    require_once(__DIR__ . '/Settings.php');

    if (!isset($argv[1]))
    {
        die("Please mention/pass the filepath to the file you want to store in MongoDB Server.");
    }

    $storage_filepath = $argv[1];

    if (!file_exists($storage_filepath) || is_dir($storage_filepath))
    {
        die("Invalid! Please, re-check your filepath.");
    }

    function mongoConnect($your_username, $your_password, $your_database, $your_host_serverIP)
    {
        $con_MongoDB = new Mongo("mongodb://{$your_username}:{$your_password}@{$your_host_serverIP}"); // Connect to Mongo Server
        $con_database = $con_MongoDB -> selectDB($your_database); // Connect to Database
        return $con_database;
    }

    $con_database = mongoConnect(
        USERNAME_MONGODB,
        PASSWORD_MONGODB,
        DATABASE_MONGODB,
        SERVERIP_MONGODB
    );

    $grid_FS = $con_database -> getGridFS();

    # in the following code, you can search for the filepath passed in as the first argument
    $search_fileParams = array("filename" => $storage_filepath);

    if (false)
    {
        # If you used absolute paths when storing files, then you could use the following to download a folder's contents.
        $folder = '/path/to/folder';

        # Refer to https://secure.php.net/manual/en/class.mongoregex.php
        $file_get_filename = new MongoRegex("/^$folder");

        $search_fileParams = array(
            'filename' => $file_get_filename
        );
    }

    # Alternatively, use findOne($search_fileParams) if you expect only one file with the provided name.
    $storage_files = $grid_FS -> find($search_fileParams);

    while (($your_file = $storage_files -> getNext()) != null)
    {
        # Use a random string in case there is a file with the same name in the current directory.
        $random_string = substr(str_shuffle(MD5(microtime())), 0, 10);
        $outputFile_path = __DIR__ . '/' . $random_string . "_" . basename($your_file -> getFilename());
        $your_file -> write($outputFile_path);
        print "Retrieved: " . $outputFile_path . PHP_EOL;
    }

    // use the script like
    // php RetrieveFiles.php "my_filename.mp4"
?>

Ausgang:

Retrieved: my_filename.mp4

Verwenden Sie die Methode StoreUpload(), wenn Sie anstelle eines CLI-Tools eine PHP-Website entwickeln (anstatt die Methode StoreFile() zu verwenden). Verwenden Sie relative oder vollständige Pfade, um eine Datei im System zu speichern, und der in MongoDB gespeicherte Dateiname ist genau die Zeichenfolge, die übergeben wurde, wenn Sie den vollständigen Pfad übergeben, z. B. /path/to/file.mp4 und den Dateinamen wird dasselbe sein.

Denken Sie daran, dass das mehrmalige Aufrufen des Skripts für dieselbe Datei nicht fehlschlägt. Dies kann jedoch wertvolle Speicherressourcen verschwenden, indem dieselbe Datei mehrmals gespeichert wird. Das PHP-Codebeispiel zeigt Ihnen, wie Sie MongoDB als Standardspeicher für Ihre PHP-Website oder -Projekte verwenden.

Hadoop und sein HDFS sind eine großartige Alternative zu MongoDB, aber es ist extrem kompliziert; Im Vergleich zu MongoDB unterstützt es jedoch Map/Reduce-Jobs. Am wichtigsten ist, dass GridFS eine erstklassige Option ist, da seine Implementierung clientseitig innerhalb des Treibers selbst erfolgt (ohne spezielles Laden oder Verständnis des Dateikontexts).

MongoDB und sein GridFS sind treiberimplementiert, und die Spezifikation kann variieren, da Treiber es Ihnen ermöglichen, eine Sammlung von Dokumenten aus der Sammlung Dateien abzufragen und es Programmierern ermöglichen, später die Datei selbst aus der Sammlung chunks mit einer einzigen Abfrage bereitzustellen . Es erleichtert das Laden der Dateien-Sammlung und der nachfolgenden chunks-Sammlung in Ihr Arbeitsset.