Flux de téléchargement de fichier sur S3 Node.js à l'aide formidable et (knox ou aws sdk)

Je suis en train de flux de télécharger un fichier transmis via un formulaire directement à un compartiment Amazon S3, à l'aide de aws sdk ou knox. La gestion des formulaires est fait avec formidable.

Ma question est: comment puis-je utiliser correctement formidable avec aws sdk (ou knox) à l'aide de chacune de ces bibliothèques dernières fonctionnalités de manipulation de flux?

Je suis conscient que ce sujet a déjà été posée ici en différentes saveurs, c'est à dire:

Comment recevoir un fichier téléchargé à l'aide de node.js formidable de la bibliothèque et de l'enregistrer sur Amazon S3 en utilisant knox?
le nœud de l'application de flux de téléchargement de fichiers directement à amazon s3
Accéder au fichier raw flux à partir d'un nœud-formidable téléchargement de fichier (et de son très utile accepté de répondre à overiding forme.onpart ne())

Cependant, je crois que les réponses sont un peu obsolètes et/ou hors sujet (c'est à dire. Le soutien de la SCRO, dont je ne souhaite pas utiliser pour l'instant pour des raisons différentes) et/ou, surtout, de ne pas faire référence à des fonctionnalités les plus récentes soit à partir d'aws sdk (voir: https://github.com/aws/aws-sdk-js/issues/13#issuecomment-16085442) ou knox (notamment putStream() ou de ses readableStream.pipe(req) variante, les deux expliqué dans la doc).

Après des heures de galère, j'en suis venu à la conclusion que j'avais besoin d'un peu d'aide (disclaimer: je suis un newbie avec le cours d'eau).

Formulaire HTML:

<form action="/uploadPicture" method="post" enctype="multipart/form-data">
  <input name="picture" type="file" accept="image/*">
  <input type="submit">
</form>

Express bodyParser middleware est configuré de cette manière:

app.use(express.bodyParser({defer: true}))

POSTE de gestionnaire des demandes:

uploadPicture = (req, res, next) ->
  form = new formidable.IncomingForm()
  form.parse(req)

  form.onPart = (part) ->
    if not part.filename
      # Let formidable handle all non-file parts (fields)
      form.handlePart(part)
    else
      handlePart(part, form.bytesExpected)

  handlePart = (part, fileSize) ->
    # aws-sdk version
    params =
      Bucket: "mybucket"
      Key: part.filename
      ContentLength: fileSize
      Body: part # passing stream object as body parameter

    awsS3client.putObject(params, (err, data) ->
      if err
        console.log err
      else
        console.log data
    )

Cependant, j'obtiens l'erreur suivante:

{ [RequestTimeout: Votre prise de connexion au serveur n'a pas été lu ou écrit dans le délai imparti. Les connexions inactives seront fermés.]

message: "Votre prise de connexion au serveur n'a pas été lu ou écrit dans le délai imparti. Les connexions inactives sera fermé.',
code: 'RequestTimeout',
nom: RequestTimeout',
statusCode: 400,
renouvelable: false }

Un knox version de handlePart() la fonction adaptée de cette façon aussi qui échoue lamentablement:

handlePart = (part, fileSize) ->
  headers =
    "Content-Length": fileSize
    "Content-Type": part.mime
  knoxS3client.putStream(part, part.filename, headers, (err, res) ->
    if err
      console.log err
    else
      console.log res
  )

J'ai aussi une grosse res objet avec un 400 statusCode quelque part.

Région est configuré pour eu-west-1 dans les deux cas.

Remarques supplémentaires:

nœud 0.10.12

dernière formidable de mnp (1.0.14)

dernière aws sdk de mnp (1.3.1)

dernière knox de mnp (0.8.3)

InformationsquelleAutor jbmusso | 2013-06-26

9

Bien, selon le créateur de Formidable, streaming direct vers Amazon S3 est impossible :

Le S3 API exige de vous fournir la taille des fichiers lors de la création d'eux. Cette information n'est pas disponible pour multipart/form-data fichiers jusqu'à ce qu'elles ont été reçues. Cela signifie que le streaming est impossible.

En effet, forme.bytesExpected se réfère à la taille de l'ensemble de la forme, et non pas la taille du fichier unique.

Les données doivent donc frapper la mémoire ou le disque sur le serveur avant d'être téléchargés sur S3.
- C'est juste qu'il m'a sauvé beaucoup de temps. Merci.
- Ce n'est pas réellement le cas. Il est possible de tuyau/flux s3! vous avez juste besoin de connaître la taille de l'upload. Si votre client peut fournir cela, alors vous pouvez en effet utiliser le tuyau pour télécharger s3 sans un méchant disque dur à écrire. Je suis en train d'écrire un cli et serveur intermédiaire qui va télécharger à s3. Parce que je contrôle à la fois le client et le serveur, je peux déterminer la taille du fichier avant de le télécharger. Je pense qu'il y a peut-être d'autres cas comme le mien qui ne devrait pas être rejetée. Je utiliser knox de flux de s3 avec une demande.
- C'est un très valable commentaire, je ne pense qu'à l'époque je pensais à un serveur-côté de la seule solution. N'hésitez pas à poster une réponse si vous parvenez à obtenir quelque chose de travail, je vais heureux de voter pour votre solution. Vous pouvez également modifier cette réponse. Merci!
- Va faire. Cheerio.
- comment en êtes-vous sur? Pouvez-vous s'il vous plaît poster la solution - il pourrait me sauver de 30 minutes. Des acclamations.
- href="http://stackoverflow.com/questions/7497404/get-file-size-before-uploading" title="obtenir la taille du fichier avant de le télécharger">stackoverflow.com/questions/7497404/... devrait aider. Vous pourriez commencer par la fixation d'un <input type="hidden" name="taille_fichier"> avec la valeur de taille de fichier.
- merci pour vos commentaires. Pour ma situation, j'ai été intéressé par le streaming à partir de mongodb par nœud de l'application (pas de navigateur). Trouvé la solution à l'aide de "s3-téléchargement-stream" NPM module. Il utilise S3 multipart API et ne nécessite donc PAS l'ensemble de la taille à l'avant. Il fonctionne en morceaux et passe sa taille automatiquement. N'a pris que quelques minutes pour copier l'exemple de code de fermer le fichier readme et le plugin pour mon application. Vous allez aimer le confort de NodeJS modules de la communauté. Il y a assez peu de vieux SOF postes toujours là à essayer de faire cela en utilisant des solutions sur mesure qui ne sont pas idéales. Encore merci pour la suggestion.
- J'ai fini par avoir à stocker localement parce que nous avions besoin de compresser le contenu lorsque nous avons téléchargé. Puis décompresser sur le serveur avant de le pousser à s3.
InformationsquelleAutor jbmusso

À l'aide d'AWS S3 multipartUpload (s3-téléchargement-stream comme module de travail) et le noeud-formidable de lisible flux, vous pouvez diriger le flux à télécharger comme cette:

var formidable = require('formidable');
var http = require('http');
var util = require('util');
var AWS      = require('aws-sdk');
var config = require('./config');
var s3 = new AWS.S3({
accessKeyId: config.get('S3_ACCESS_KEY'),
secretAccessKey: config.get('S3_SECRET_KEY'),
apiVersion: '2006-03-01'
});
var s3Stream = require('s3-upload-stream')(s3);
var bucket = 'bucket-name';
var key = 'abcdefgh';
http.createServer(function(req, res) {
if (req.url == '/upload' && req.method.toLowerCase() == 'post') {
var form = new formidable.IncomingForm();
form.on('progress', function(bytesReceived, bytesExpected) {
//console.log('onprogress', parseInt( 100 * bytesReceived /bytesExpected ), '%');
});
form.on('error', function(err) {
console.log('err',err);
});
//This 'end' is for the client to finish uploading
//upload.on('uploaded') is when the uploading is
//done on AWS S3
form.on('end', function() {
console.log('ended!!!!', arguments);
});
form.on('aborted', function() {
console.log('aborted', arguments);
});
form.onPart = function(part) {
console.log('part',part);
//part looks like this
//   {
//       readable: true,
//       headers:
//       {
//           'content-disposition': 'form-data; name="upload"; filename="00video38.mp4"',
//           'content-type': 'video/mp4'
//       },
//       name: 'upload',
//           filename: '00video38.mp4',
//       mime: 'video/mp4',
//       transferEncoding: 'binary',
//       transferBuffer: ''
//   }
var start = new Date().getTime();
var upload = s3Stream.upload({
"Bucket": bucket,
"Key": part.filename
});
//Optional configuration
//upload.maxPartSize(20971520); //20 MB
upload.concurrentParts(5);
//Handle errors.
upload.on('error', function (error) {
console.log('errr',error);
});
upload.on('part', function (details) {
console.log('part',details);
});
upload.on('uploaded', function (details) {
var end = new Date().getTime();
console.log('it took',end-start);
console.log('uploaded',details);
});
//Maybe you could add compress like
//part.pipe(compress).pipe(upload)
part.pipe(upload);
};
form.parse(req, function(err, fields, files) {
res.writeHead(200, {'content-type': 'text/plain'});
res.write('received upload:\n\n');
res.end(util.inspect({fields: fields, files: files}));
});
return;
}
//show a file upload form
res.writeHead(200, {'content-type': 'text/html'});
res.end(
'<form action="/upload" enctype="multipart/form-data" method="post">'+
'<input type="text" name="title"><br>'+
'<input type="file" name="upload" multiple="multiple"><br>'+
'<input type="submit" value="Upload">'+
'</form>'
);
}).listen(8080);

J'ai utilisé cela avec le multipartisme

InformationsquelleAutor tsuz

3

Depuis ce post est vieux et je crois en streaming directement est maintenant pris en charge, j'ai passé beaucoup de temps à la lecture de la date de réponses sur ce sujet...

Si ça aide quelqu'un, j'ai été en mesure de diffuser à partir du client s3 directement, sans la nécessité d'installer des paquets:

https://gist.github.com/mattlockyer/532291b6194f6d9ca40cb82564db9d2a

Le serveur suppose req est un objet de flux de données, dans mon cas, un Fichier objet a été utilisé dans xhr(envoyer), qui permettra d'envoyer des données binaires dans les navigateurs modernes.
```
const fileUploadStream = (req, res) => {
//get "body" args from header
const { id, fn } = JSON.parse(req.get('body'));
const Key = id + '/' + fn; //upload to s3 folder "id" with filename === fn
const params = {
Key,
Bucket: bucketName, //set somewhere
Body: req, //req is a stream
};
s3.upload(params, (err, data) => {
if (err) {
res.send('Error Uploading Data: ' + JSON.stringify(err) + '\n' + JSON.stringify(err.stack));
} else {
res.send(Key);
}
});
};
```
Oui il rompt la convention, mais si vous regardez l'essentiel c'est beaucoup plus propre que tout autre chose, j'ai trouvé s'appuyant sur d'autres paquets.

+1 pour le pragmatisme et grâce à @SalehenRahman pour son aide.
- Dans mon cas, le téléchargement a fonctionné, mais le fichier image n'a pas pu être ouvert correctement.
- Avez-vous vérifier vos extensions? Ouvert correctement sur AWS ou de télécharger un autre? Vérifiez que vous recevez la bonne quantité d'octets en trop.
InformationsquelleAutor mattdlockyer

Essayez d'ajouter le 'ContentType' pour le Télécharger params (https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#upload-property)

...
const params = {
Key,
Bucket: bucketName,
Body: req,
ContentType: 'image/jpg'
};
s3.upload(params, (err, data) => {
if (err) return err;
console.log(data);
});
...

InformationsquelleAutor panduroab

Vous devez vous connecter pour publier un commentaire.