node.js - subir - npm

¿Cuál es la forma más eficiente de enviar archivos entre servidores NodeJS?

Question

Introducción

Digamos que en la misma red local tenemos dos servidores Node JS configurados con Express: el Servidor A para la API y el Servidor F para la forma.

• El Servidor A es un servidor API donde toma la solicitud y la guarda en la base de datos MongoDB (los archivos se almacenan como Buffer y sus detalles como otros campos)
• El servidor F sirve un formulario, maneja la publicación del formulario y envía los datos del formulario al servidor A.

¿Cuál es la forma más eficiente de enviar archivos entre dos servidores NodeJS donde el servidor receptor es Express API? ¿Dónde importa el tamaño del archivo?

1. HTTP Way

Si los archivos que estoy enviando son archivos PDF (que no excederán 50mb) ¿es eficiente enviar todo el contenido como una cadena a través de HTTP?

Algoritmo es el siguiente:

• El servidor F maneja la solicitud de archivo usando https://www.npmjs.com/package/multer y guarda el archivo
• a continuación, el servidor F lee este archivo y realiza una solicitud HTTP a través de https://github.com/request/request junto con algunos detalles sobre el archivo
• El Servidor A recibe esta solicitud y convierte el contenido del archivo de cadena en Buffer y guarda un registro en MongoDB junto con los detalles del archivo.

En este algoritmo, tanto el Servidor A (cuando se almacenaba en MongoDB) como el Servidor F (cuando lo estaba enviando al Servidor A) leyeron el archivo en la memoria, y la solicitud entre los dos servidores era aproximadamente del mismo tamaño que el archivo . (¿Las solicitudes de 50Mb están bien?)

Sin embargo, una cosa a considerar es que, con este método, usaría el estilo de API ExpressJS para todo el proceso y sería coherente con el resto de la aplicación donde las solicitudes /list , /details también están definidas en el rutas Me gusta la coherencia.

2. Socket.IO Way

En contraste con este algoritmo, he explorado https://github.com/nkzawa/socket.io-stream manera que se separó de la consistencia de la API HTTP en el Servidor A (como el controlador para los eventos socket.io están definidos no en las rutas sino en el archivo que tiene var server = http.createServer(app); ).

El servidor F maneja los datos del formulario como tales en routes/some_route.js :

router.post(''/'', multer({dest: ''./uploads/''}).single(''file''), function (req, res) {
    var api_request = {};
    api_request.name = req.body.name;
    //add other fields to api_request ...

    var has_file = req.hasOwnProperty(''file'');

    var io = require(''socket.io-client'');

    var transaction_sent = false;
    var socket = io.connect(''http://localhost:3000'');
    socket.on(''connect'', function () {
        console.log("socket connected to 3000");

        if (transaction_sent === false) {
            var ss = require(''socket.io-stream'');
            var stream = ss.createStream();

            ss(socket).emit(''transaction new'', stream, api_request);

            if (has_file) {
                var fs = require(''fs'');
                var filename = req.file.destination + req.file.filename;

                console.log(''sending with file: '', filename);

                fs.createReadStream(filename).pipe(stream);
            }

            if (!has_file) {
                console.log(''sending without file.'');
            }
            transaction_sent = true;

            //get the response via socket
            socket.on(''transaction new sent'', function (data) {
                console.log(''response from 3000:'', data);
                //there might be a better way to close socket. But this works.
                socket.close();
                console.log(''Closed socket to 3000'');

            });

        }


    });


});

Dije que lidiaría con archivos PDF que son <50Mb. Sin embargo, si utilizo este programa para enviar archivos más grandes en el futuro, ¿es socket.io una mejor manera de manejar archivos de 1GB ya que está usando stream?

Este método envía el archivo y los detalles, pero soy nuevo en esta biblioteca y no sé si debería utilizarse para este fin o si hay una forma mejor de utilizarlo.

Pensamientos finales

¿Qué métodos alternativos debería explorar?

• ¿Debo enviar el archivo a través de SCP y hacer una solicitud HTTP con los detalles del archivo, incluido el lugar donde lo envié, separando así los protocolos de los archivos y las solicitudes de la API?
• ¿Debo usar siempre las transmisiones porque no almacenan todo el archivo en la memoria? (Así es como funcionan, ¿verdad?)
• Esto https://github.com/liamks/Delivery.js ?

Referencias

• Transferencia de archivos / datos entre dos servidores node.js. Esto me permitió probar socket-stream.
• transferir archivos entre dos servidores node.js en http para HTTP way

Answer 1

¡Hay muchas formas de lograr esto, pero no tanto para hacerlo bien!

socket io y wesockets son eficientes cuando los usa con un navegador, pero como no lo hace, no es necesario.

El primer método que puedes probar es usar el módulo de red incorporado de nodejs, básicamente hará una conexión de tcp entre los servidores y pasará los datos.

también debe tener en cuenta que debe enviar fragmentos de datos, no todo el archivo, el método socket.write del módulo de red parece ser una buena opción para su caso, socket.write : https://nodejs.org/api/ net.html

Pero dependiendo del tamaño de sus archivos y la concurrencia, el consumo de memoria puede ser bastante grande.

si está ejecutando Linux en ambos servidores, incluso podría enviar los archivos a la zona cero con un simple comando de Linux llamado scp

nohup scp -rpC /var/www/httpdocs/* remote_user@remote_domain.com:/var/www/httpdocs &

Incluso puede hacer esto con Windows para Linux o de otra manera.

http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

el cliente scp para windows es pscp.exe

Espero que esto ayude !