Chargement d'un fichier dans le stockage de fichiers Azure à l'aide de node.js

je trouve le plus simple est d'utiliser pkgcloud qui simplifie les différences entre les fournisseurs de cloud et fournit également une interface propre pour le téléchargement et le téléchargement de fichiers. Il utilise des flux de sorte que la mise en œuvre est efficace de mémoire aussi bien.

var pkgcloud = require('pkgcloud')
var fs = require('fs')
var client = pkgcloud.storage.createClient({
  provider: 'azure',
  storageAccount: 'your-storage-account',
  storageAccessKey: 'your-access-key'
});

var readStream = fs.createReadStream('a-file.txt');
var writeStream = client.upload({
  container: 'your-storage-container',
  remote: 'remote-file-name.txt'
});

writeStream.on('error', function (err) {
  // handle your error case
});

writeStream.on('success', function (file) {
  // success, file will be a File model
});

readStream.pipe(writeStream);

nous pouvons tirer profit de cette réponse du thread sur SO comment envoyer une image D'un client Android à un noeud.js server via HttpUrlConnection? créer un middleware pour obtenir le téléchargement de fichiers contenu dans un tableau tampon, alors nous pouvons utiliser createFileFromText() pour stocker le fichier en Stockage Azure.

Voici l'extrait de code:

function rawBody(req, res, next) {
    var chunks = [];

    req.on('data', function (chunk) {
        chunks.push(chunk);
    });

    req.on('end', function () {
        var buffer = Buffer.concat(chunks);

        req.bodyLength = buffer.length;
        req.rawBody = buffer;
        next();
    });

    req.on('error', function (err) {
        console.log(err);
        res.status(500);
    });
}
router.post('/upload', rawBody,function (req, res){

    fileService.createShareIfNotExists('taskshare', function (error, result, response) {
        if (!error) {
            // if result = true, share was created.
            // if result = false, share already existed.
            fileService.createDirectoryIfNotExists('taskshare', 'taskdirectory', function (error, result, response) {
                if (!error) {
                    // if result = true, share was created.
                    // if result = false, share already existed.
                    try {
                        fileService.createFileFromText('taskshare', 'taskdirectory', 'test.txt', req.rawBody, function (error, result, resp) {
                            if (!error) {
                                // file uploaded
                                res.send(200, "File Uploaded");
                            } else {
                                res.send(200, "Error!");
                            }
                        });
                    } catch (ex) {
                        res.send(500, { error: ex.message });
                    }

                }
            });
        }
    });

})
router.get('/getfile', function (req, res){
    fileService.createReadStream('taskshare', 'taskdirectory', 'test.txt').pipe(res);
})

Lorsque la demande arrive à la fonction définie dans exports.post, l'ensemble de la demande est déjà là, donc vous n'avez pas besoin de tampon. Vous pouvez le simplifier en écrivant quelque chose dans le sens du code ci-dessous.

exports.post = function(request, response){
    var shareName = request.headers.sharename;
    var dirPath = request.headers.directorypath;
    var fileName = request.headers.filename;

    var body = request.body;
    var length = body.length;

    console.log(length);

    try {
        fileService.createFileFromText(shareName, dirPath, fileName, body, function(error, result, resp) {
            if (!error) {
                // file uploaded
                response.send(statusCodes.OK, "File Uploaded");
            } else {
                response.send(statusCodes.OK, "Error!");
            }
        });
    } catch (ex) {
        response.send(500, { error: ex.message });
    }
}

Il y a plusieurs choses:

1. createFileFromText peut fonctionner avec du texte simple. Mais il échouera pour ces contenus binaires, car il utilise l'encodage UTF-8.

Vous pourriez vouloir vous référer à la même question pour les blob: sauver blob (pourrait être data!) retourné par L'appel AJAX à Azure Blob Storage crée une image corrompue

2. createFileFromStream ou createWriteStreamToExistingFile\createWriteStreamToNewFile Azure storage API peut être la fonction peut aider.

veuillez noter que ces IPA sont ciblés par les flux. Vous devez convertir votre tampon / chaîne de caractères dans le corps de la requête en un flux. Vous pouvez vous référer à comment envelopper un tampon comme un flux lisible par stream2?

createFileFromStream:

fileService.createFileFromStream(req.headers.sharename, 
  req.headers.directorypath, 
  req.headers.filename, 
  requestStream, 
  data.length, 
  function (error, result, resp) {
    res.statusCode = error ? 500 : 200;
    res.end();
  }
);

createWriteStreamToNewFile:

var writeStream = fileService.createWriteStreamToNewFile(req.headers.sharename, 
  req.headers.directorypath, 
  req.headers.filename, 
  data.length);

requestStream.pipe(writeStream);

3. Il y a plusieurs problèmes dans votre code

console.log(body); // This giving the result as undefined

la raison est que vous définissez var body et c'est undefined. Le code body += chunk toujours body undefined.

fileService.createFileFromStream(shareName, dirPath, fileName, body, length, function(error, result, resp) {
  if (!error) {
    // file uploaded
    response.send(statusCodes.OK, "File Uploaded");
  }else{
    response.send(statusCodes.OK, "Error!");
  }
});

Quand l'erreur se produit dans createFileFromStream, cela pourrait aussi être une erreur dans le transfert réseau, vous pourriez aussi vouloir retourner le code d'erreur au lieu de statusCodes.OK.