Gibt es das gebrauchsfertige Tool Node.j (installiert mit npm), mit dem ich Ordnerinhalte als Dateiserver über HTTP verfügbar machen kann?

Beispiel, wenn ich habe

D:\Folder\file.zip
D:\Folder\file2.html
D:\Folder\folder\file-in-folder.jpg

Ab D:\Folder\ node node-file-server.js dann konnte ich über auf die Datei zugreifen

http://hostname/file.zip
http://hostname/file2.html
http://hostname/folder/file-in-folder.jpg

Warum löscht der statische Dateiserver meines Knotens Anforderungen? Verweisen Sie auf einige mystische

Standardknoten.js statischer Dateiserver

Welches Framework sollte ich verwenden, wenn es kein solches Tool gibt?

Verwandte: Grundlegender statischer Dateiserver in NodeJS

Eine gute "gebrauchsfertige Tool" -Option könnte http-server sein:

npm install http-server -g

Um es zu benutzen:

cd D:\Folder
http-server

Oder so:

http-server D:\Folder

Probieren Sie es aus: https://github.com/nodeapps/http-server

Wenn Sie kein fertiges Tool verwenden möchten, können Sie den folgenden Code verwenden, wie von mir unter https://developer.mozilla.org/en-US/docs/Node_server_without_framework gezeigt :

var http = require('http');
var fs = require('fs');
var path = require('path');

http.createServer(function (request, response) {
    console.log('request starting...');

    var filePath = '.' + request.url;
    if (filePath == './')
        filePath = './index.html';

    var extname = path.extname(filePath);
    var contentType = 'text/html';
    switch (extname) {
        case '.js':
            contentType = 'text/javascript';
            break;
        case '.css':
            contentType = 'text/css';
            break;
        case '.json':
            contentType = 'application/json';
            break;
        case '.png':
            contentType = 'image/png';
            break;      
        case '.jpg':
            contentType = 'image/jpg';
            break;
        case '.wav':
            contentType = 'audio/wav';
            break;
    }

    fs.readFile(filePath, function(error, content) {
        if (error) {
            if(error.code == 'ENOENT'){
                fs.readFile('./404.html', function(error, content) {
                    response.writeHead(200, { 'Content-Type': contentType });
                    response.end(content, 'utf-8');
                });
            }
            else {
                response.writeHead(500);
                response.end('Sorry, check with the site admin for error: '+error.code+' ..\n');
                response.end(); 
            }
        }
        else {
            response.writeHead(200, { 'Content-Type': contentType });
            response.end(content, 'utf-8');
        }
    });

}).listen(8125);
console.log('Server running at http://127.0.0.1:8125/');

UPDATE Wenn Sie von einer externen Anforderung / Datei auf Ihren Server zugreifen müssen, müssen Sie das CORS in Ihrer node.js-Datei überwinden, indem Sie Folgendes schreiben, wie in einer vorherigen Antwort hier erwähnt

// Website you wish to allow to connect
response.setHeader('Access-Control-Allow-Origin', '*');

// Request methods you wish to allow
response.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');

// Request headers you wish to allow
response.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');

// Set to true if you need the website to include cookies in the requests sent
// to the API (e.g. in case you use sessions)
response.setHeader('Access-Control-Allow-Credentials', true);

AKTUALISIEREN

Wie Adrian erwähnt, in den Kommentaren, schrieb er einen ES6 Code mit einer umfassenden Erläuterung hier , ich erneut veröffentlichen nur seinen Code unten, von der ursprünglichen Website aus irgendeinem Grund den Code im Falle gegangen:

const http = require('http');
const url = require('url');
const fs = require('fs');
const path = require('path');
const port = process.argv[2] || 9000;

http.createServer(function (req, res) {
  console.log(`${req.method} ${req.url}`);

  // parse URL
  const parsedUrl = url.parse(req.url);
  // extract URL path
  let pathname = `.${parsedUrl.pathname}`;
  // based on the URL path, extract the file extention. e.g. .js, .doc, ...
  const ext = path.parse(pathname).ext;
  // maps file extention to MIME typere
  const map = {
    '.ico': 'image/x-icon',
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.json': 'application/json',
    '.css': 'text/css',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.wav': 'audio/wav',
    '.mp3': 'audio/mpeg',
    '.svg': 'image/svg+xml',
    '.pdf': 'application/pdf',
    '.doc': 'application/msword'
  };

  fs.exists(pathname, function (exist) {
    if(!exist) {
      // if the file is not found, return 404
      res.statusCode = 404;
      res.end(`File ${pathname} not found!`);
      return;
    }

    // if is a directory search for index file matching the extention
    if (fs.statSync(pathname).isDirectory()) pathname += '/index' + ext;

    // read file from file system
    fs.readFile(pathname, function(err, data){
      if(err){
        res.statusCode = 500;
        res.end(`Error getting the file: ${err}.`);
      } else {
        // if the file is found, set Content-type and send data
        res.setHeader('Content-type', map[ext] || 'text/plain' );
        res.end(data);
      }
    });
  });


}).listen(parseInt(port));

console.log(`Server listening on port ${port}`);

Für Benutzer, die einen Server wünschen, der über das NodeJS-Skript ausgeführt werden kann:

Sie können expressjs / serve-static verwenden, das ersetzt connect.static(das ab Connect 3 nicht mehr verfügbar ist):

myapp.js:

var http = require('http');

var finalhandler = require('finalhandler');
var serveStatic = require('serve-static');

var serve = serveStatic("./");

var server = http.createServer(function(req, res) {
  var done = finalhandler(req, res);
  serve(req, res, done);
});

server.listen(8000);

und dann von der Kommandozeile:

• $ npm install finalhandler serve-static
• $ node myapp.js

Ich weiß, dass es kein Knoten ist, aber ich habe Pythons SimpleHTTPServer verwendet:

python -m SimpleHTTPServer [port]

Es funktioniert gut und kommt mit Python.

connect könnte das sein, wonach Sie suchen.

Einfach zu installieren mit:

npm install connect

Dann könnte der grundlegendste statische Dateiserver wie folgt geschrieben werden:

var connect = require('connect'),
    directory = '/path/to/Folder';

connect()
    .use(connect.static(directory))
    .listen(80);

console.log('Listening on port 80.');

Installieren Sie Express mit npm: https://expressjs.com/en/starter/installing.html

Erstellen Sie eine Datei mit dem Namen server.js auf derselben Ebene wie index.html mit folgendem Inhalt:

var express = require('express');
var server = express();
server.use('/', express.static(__dirname + '/'));
server.listen(8080);

Wenn Sie es an einem anderen Ort ablegen möchten, legen Sie den Pfad in der dritten Zeile fest:

server.use('/', express.static(__dirname + '/public'));

CD in den Ordner mit Ihrer Datei und führen Sie den Knoten mit diesem Befehl von der Konsole aus aus:

node server.js

Navigieren Sie zu localhost: 8080

One-line ™ Proofs statt Versprechen

Der erste ist http-server, hs- Link

npm i -g http-server   // install
hs C:\repos            // run with one line?? FTW!!

Der zweite ist servevon ZEIT.co - Link

npm i -g serve         // install
serve C:\repos         // run with one line?? FTW!!

Im Folgenden finden Sie verfügbare Optionen, wenn dies Ihnen bei der Entscheidung hilft.

C: \ Users \ Qwerty> http-server --help
Verwendung: http-Server [Pfad] [Optionen]

Optionen:
  -p Port zur Verwendung [8080]
  -eine zu verwendende Adresse [0.0.0.0]
  -d Verzeichnislisten anzeigen [true]
  -i AutoIndex anzeigen [true]
  -g --gzip Wenn möglich gzip-Dateien bereitstellen [false]
  -e --ext Standarddateierweiterung, falls keine angegeben [keine]
  -s --silent Unterdrückt Protokollnachrichten von der Ausgabe
  --cors [= Header] Aktivieren Sie CORS über den Header "Access-Control-Allow-Origin"
                     Geben Sie optional eine durch Kommas getrennte CORS-Headerliste an
  -o [Pfad] Öffnet das Browserfenster nach dem Start des Servers
  -c Cache-Zeit (maximales Alter) in Sekunden [3600], z. B. -c10 für 10 Sekunden.
               Verwenden Sie -c-1, um das Caching zu deaktivieren.
  -U --utc Verwenden Sie das UTC-Zeitformat in Protokollnachrichten.

  -P --proxy Fallback-Proxy, wenn die Anforderung nicht gelöst werden kann. zB: http://someurl.com

  -S --ssl https aktivieren.
  -C --cert Pfad zur SSL-Zertifikatsdatei (Standard: cert.pem).
  -K --key Pfad zur SSL-Schlüsseldatei (Standard: key.pem).

  -r --robots Antworte auf /robots.txt [User-Agent: * \ nDisallow: /]
  -h --help Diese Liste drucken und beenden.

C: \ Users \ Qwerty> serve --help

  Verwendung: serve.js [Optionen] [Befehl]

  Befehle:

    Hilfe Hilfe anzeigen

  Optionen:

    -a, --auth Hinter der Basisauthentifizierung dienen
    -c, --cache Zeit in Millisekunden zum Zwischenspeichern von Dateien im Browser
    -n, --clipless Adresse nicht in Zwischenablage kopieren (standardmäßig deaktiviert)
    -C, --cors Setup * CORS-Header, um Anforderungen von jedem Ursprung zuzulassen (standardmäßig deaktiviert)
    -h, --help Verwendungsinformationen ausgeben
    -i, --ignore Dateien und Verzeichnisse, die ignoriert werden sollen
    -o, --open Lokale Adresse im Browser öffnen (standardmäßig deaktiviert)
    -p, --port Port zum Abhören (standardmäßig 5000)
    -S, --silent Protokollieren Sie nichts in der Konsole
    -s, --single Serve Einzelseitenanwendungen (setzt `-c` auf 1 Tag)
    -t, --treeless Zeigt keinen Statikbaum an (standardmäßig deaktiviert)
    -u, --unzipped Deaktiviert die GZIP-Komprimierung
    -v, --version Gibt die Versionsnummer aus

Wenn Sie auf Änderungen achten müssen hostr, schreiben Sie die Antwort von Henry Tseng gut

NUR DEMO / PROTO SERVER

Wenn das alles ist, was Sie brauchen, versuchen Sie Folgendes:

const http = require('http');
const fs = require('fs');
const port = 3000;
const app = http.createServer((req,res) => {
    res.writeHead(200);
    if (req.url === '/') req.url = '/index.html'; // courtesy of @JosephCho
    res.end(fs.readFileSync(__dirname + req.url));
});

app.listen(port);

Hinweis: Sie müssen "/index.html" als Teil Ihrer Adresse verwenden, dh " http: // localhost: 3000 / index.html ".

Es gibt einen anderen statischen Webserver, der ganz nett ist: die Browsersynchronisation.

Es kann mit dem Node Package Manager heruntergeladen werden:

npm install -g browser-sync

Navigieren Sie nach der Installation in der cmd-Eingabeaufforderung zum Projektordner und führen Sie einfach Folgendes aus:

browser-sync start --server --port 3001 --files="./*"

Es werden alle Dateien im aktuellen Ordner des Browsers bereitgestellt.

Weitere Informationen finden Sie in BrowserSync

Vielen Dank.

Ich hatte mit keiner der Antworten auf dieser Seite viel Glück, aber unten schien es den Trick zu tun.

Fügen Sie eine server.jsDatei mit folgendem Inhalt hinzu:

const express = require('express')
const path = require('path')
const port = process.env.PORT || 3000
const app = express()

// serve static assets normally
app.use(express.static(__dirname + '/dist'))

// handle every other route with index.html, which will contain
// a script tag to your application's JavaScript file(s).
app.get('*', function (request, response){
  response.sendFile(path.resolve(__dirname, 'dist', 'index.html'))
})

app.listen(port)
console.log("server started on port " + port)

Stellen Sie außerdem sicher, dass Sie benötigen express. Führen Sie yarn add express --saveoder npm install express --saveabhängig von Ihrem Setup (ich kann empfehlen, yarnes ist ziemlich schnell).

Sie können distin den Ordner wechseln, in dem Sie Ihren Inhalt bereitstellen. Für mein einfaches Projekt habe ich keinen Ordner bereitgestellt, daher habe ich einfach den distDateinamen entfernt.

Dann kannst du rennen node server.js. Da ich mein Projekt auf einen Heroku-Server hochladen musste, musste ich meiner package.jsonDatei Folgendes hinzufügen :

  "scripts": {
    "start": "node server.js"
  }

Wenn Sie das Express-Framework verwenden , ist diese Funktionalität sofort einsatzbereit.

Gehen Sie folgendermaßen vor, um eine einfache Datei-Serving-App einzurichten:

mkdir yourapp
cd yourapp
npm install express
node_modules/express/bin/express

Hier ist mein statisches Datei-Web-Server-Haustierprojekt für eine Datei / ein leichtes node.js ohne Abhängigkeit, von dem ich glaube, dass es ein schnelles und umfangreiches Tool ist, dessen Verwendung so einfach ist wie die Ausgabe dieses Befehls auf Ihrem Linux / Unix / macOS-Terminal ( oder termux unter Android), wenn node.js (oder nodejs-legacyunter Debian / Ubuntu) installiert ist:

curl pad.js.org | node 

(In der Dokumentation sind verschiedene Befehle für Windows-Benutzer vorhanden.)

Es unterstützt verschiedene Dinge, von denen ich glaube, dass sie nützlich sind.

• Hierarchische Verzeichnisindexerstellung / -bereitstellung
  • Mit Sortierfähigkeit nach den verschiedenen Kriterien
  • Das Hochladen aus dem Browser durch [Multi-File] Drag & Drop und Nur-Datei / Text-Copy-Paste und Screenshot-Einfügen in die System-Zwischenablage in Chrome, Firefox und anderen Browsern kann mit einigen Einschränkungen verbunden sein (die über die Befehlszeile deaktiviert werden können Optionen, die es bietet)
  • Schaltfläche zum Erstellen von Ordnern / Notizen / Hochladen
• Bereitstellung korrekter MIMEs für bekannte Dateitypen (mit der Möglichkeit, diese zu deaktivieren)
• Möglichkeit der Installation als npm-Paket und lokales Tool oder einlineare Installation als permanenter Service mit Docker
• HTTP 206-Dateiserving (mehrteilige Dateiübertragung) für schnellere Übertragungen
• Uploads von Terminal und Browserkonsole (ursprünglich sollte es ein Dateisystem-Proxy für die JS-Konsole von Browsern auf anderen Seiten / Domänen sein)
• CORS-Download / Uploads (die auch deaktiviert werden können)
• Einfache HTTPS-Integration
• Leichte Befehlszeilenoptionen für eine bessere sichere Bereitstellung:
  • Mit meinem Patch auf node.js 8 können Sie ohne vorherige Installation auf die Optionen zugreifen:curl pad.js.org | node - -h
  • Oder installieren Sie es zuerst als system-globales npm-Paket von [sudo] npm install -g pad.jsund verwenden Sie dann die installierte Version, um Zugriff auf die folgenden Optionen zu erhalten:pad -h
  • Oder verwenden Sie das bereitgestellte Docker-Image, das standardmäßig relativ sichere Optionen verwendet. [sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Die oben beschriebenen Funktionen sind größtenteils auf der Hauptseite des Tools http://pad.js.org dokumentiert, das nach einem netten Trick auch der Ort ist, von dem aus die Tool-Quelle selbst bereitgestellt wird!

Die Tool-Quelle befindet sich auf GitHub und freut sich über Ihr Feedback, Ihre Feature-Anfragen und Ihre Fragen!

Ab [email protected] wurde npmneben der üblichen npm eine neue Binärdatei installiert npx. Nun also ein Liner zum Erstellen eines statischen http-Servers aus dem aktuellen Verzeichnis:

npx serve

oder

npx http-server

Für eine gesunde Leistungssteigerung mit Node zur Bereitstellung statischer Ressourcen empfehle ich die Verwendung von Buffet . Es funktioniert ähnlich wie ein Webanwendungsbeschleuniger, der auch als Cache-HTTP-Reverse-Proxy bezeichnet wird, lädt jedoch nur das ausgewählte Verzeichnis in den Speicher.

Buffet verfolgt einen vollständig gepufferten Ansatz - alle Dateien werden beim Booten Ihrer App vollständig in den Speicher geladen, sodass Sie das Brennen des Dateisystems nie spüren werden. In der Praxis ist dies immens effizient. So sehr, dass das Platzieren von Varnish vor Ihrer App diese möglicherweise sogar verlangsamt! 

Wir verwenden es auf der codePile-Site und haben auf einer Seite, die 25 Ressourcen unter einer Last von 1k gleichzeitiger Benutzerverbindung herunterlädt, einen Anstieg von ~ 700 Anfragen / Sek. Auf> 4k Anfragen / Sek. Festgestellt.

Beispiel:

var server = require('http').createServer();

var buffet = require('buffet')(root: './file'); 

 

server.on('request', function (req, res) {

  buffet(req, res, function () {

    buffet.notFound(req, res);

  });

});

 

server.listen(3000, function () {

  console.log('test server running on port 3000');

});

Schauen Sie sich diesen Link an .

Sie müssen nur das Express-Modul von installieren node js.

var express = require('express');
var app = express();

app.use('/Folder', express.static(__dirname + '/Folder'));

Sie können auf Ihre Datei wie http: //hostname/Folder/file.zip zugreifen

Unten hat bei mir funktioniert:

Erstellen Sie eine Datei app.jsmit folgendem Inhalt:

// app.js

var fs = require('fs'),
    http = require('http');

http.createServer(function (req, res) {
  fs.readFile(__dirname + req.url, function (err,data) {
    if (err) {
      res.writeHead(404);
      res.end(JSON.stringify(err));
      return;
    }
    res.writeHead(200);
    res.end(data);
  });
}).listen(8080);

Erstellen Sie eine Datei index.htmlmit folgendem Inhalt:

Hi

Starten Sie eine Befehlszeile:

cmd

Laufen Sie unten in cmd:

node app.js

Gehe unter die URL in Chrom:

http://localhost:8080/index.html

Das ist alles. Ich hoffe, das hilft.

Quelle: https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/

Sie können versuchen , mir zu dienen

Die Verwendung ist so einfach:

ServeMe = require('serve-me')();
ServeMe.start(3000);

Das ist alles.

PD: Der standardmäßig bereitgestellte Ordner ist "public".

Hier ist ein weiterer einfacher Webserver.

https://www.npmjs.com/package/hostr

Installieren

npm install -g hostr

Arbeitsdirektor wechseln

cd myprojectfolder/

Und Start

hostr

In plain node.js:

const http = require('http')
const fs = require('fs')
const path = require('path')

process.on('uncaughtException', err => console.error('uncaughtException', err))
process.on('unhandledRejection', err => console.error('unhandledRejection', err))

const publicFolder = process.argv.length > 2 ? process.argv[2] : '.'
const port = process.argv.length > 3 ? process.argv[3] : 8080

const mediaTypes = {
  zip: 'application/zip',
  jpg: 'image/jpeg',
  html: 'text/html',
  /* add more media types */
}

const server = http.createServer(function(request, response) {
  console.log(request.method + ' ' + request.url)

  const filepath = path.join(publicFolder, request.url)
  fs.readFile(filepath, function(err, data) {
    if (err) {
      response.statusCode = 404
      return response.end('File not found or you made an invalid request.')
    }

    let mediaType = 'text/html'
    const ext = path.extname(filepath)
    if (ext.length > 0 && mediaTypes.hasOwnProperty(ext.slice(1))) {
      mediaType = mediaTypes[ext.slice(1)]
    }

    response.setHeader('Content-Type', mediaType)
    response.end(data)
  })
})

server.on('clientError', function onClientError(err, socket) {
  console.log('clientError', err)
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})

server.listen(port, '127.0.0.1', function() {
  console.log('👨‍🔧 Development server is online.')
})

Dies ist ein einfacher node.js-Server, der nur angeforderte Dateien in einem bestimmten Verzeichnis bereitstellt.

Verwendungszweck:

node server.js folder port

folderkann je nach server.jsStandort absolut oder relativ sein . Der Standardwert .ist das Verzeichnis, in dem Sie den node server.jsBefehl ausführen .

port ist standardmäßig 8080, Sie können jedoch jeden in Ihrem Betriebssystem verfügbaren Port angeben.

In Ihrem Fall würde ich tun:

cd D:\Folder
node server.js

Sie können die Dateien unter D:\Foldervon einem Browser aus durch Eingabe durchsuchenhttp://127.0.0.1:8080/somefolder/somefile.html

Es ist noch nicht auf NPM, aber ich habe einen einfachen statischen Server auf Express erstellt, mit dem Sie auch Formularübermittlungen akzeptieren und über einen Transaktions-E-Mail-Dienst per E-Mail versenden können (Sendgrid für jetzt, Mandrill kommt).

https://github.com/jdr0dn3y/nodejs-StatServe

Zum Wohle der Suchenden gefiel mir die Antwort von Jakub g, aber ich wollte ein wenig Fehler behandeln. Natürlich ist es am besten, Fehler richtig zu behandeln , aber dies sollte verhindern, dass eine Site angehalten wird, wenn ein Fehler auftritt. Code unten:

var http = require('http');
var express = require('express');

process.on('uncaughtException', function(err) {
  console.log(err);
});

var server = express();

server.use(express.static(__dirname));

var port = 10001;
server.listen(port, function() { 
    console.log('listening on port ' + port);     
    //var err = new Error('This error won't break the application...')
    //throw err
});

Installieren Sie zuerst den Node-Static-Server über npm install node-static -g -g, um ihn global auf Ihrem System zu installieren. Navigieren Sie dann zu dem Verzeichnis, in dem sich Ihre Dateien befinden, starten Sie den Server static , indem Sie Port 8080 abhören, navigieren Sie zum Browser und geben Sie localhost: 8080 / yourhtmlfilename ein .

Sie können hierfür das NPM- Serve- Paket verwenden. Wenn Sie das NodeJS-Material nicht benötigen, ist es ein schnelles und einfach zu verwendendes Tool:

1 - Installieren Sie das Paket auf Ihrem PC:

npm install -g serve

2 - Servieren Sie Ihren statischen Ordner mit serve <path>:

d:> serve d:\StaticSite

Es zeigt Ihnen, an welchem ​​Port Ihr statischer Ordner bereitgestellt wird. Navigieren Sie einfach zum Host wie folgt:

http://localhost:3000

Bei der Suche in der NPM-Registrierung https://npmjs.org/search?q=server habe ich den statischen Server https://github.com/maelstrom/static-server gefunden

Mussten Sie schon einmal einem Kollegen eine Datei senden, können sich aber nicht die Mühe machen, dem 100-MB-Biest eine E-Mail zu senden? Wollten Sie eine einfache JavaScript-Beispielanwendung ausführen, hatten jedoch Probleme beim Ausführen über das Protokoll file: ///? Wollten Sie Ihr Medienverzeichnis in einem LAN freigeben, ohne Samba oder FTP einzurichten, oder etwas anderes, bei dem Sie Konfigurationsdateien bearbeiten müssen? Dann wird dieser Dateiserver Ihr Leben ein bisschen einfacher machen.

Verwenden Sie npm, um den einfachen statischen Stuff-Server zu installieren:

npm install -g static-server

Führen Sie dann einfach eine Datei oder ein Verzeichnis aus, um sie bereitzustellen

$ serve path/to/stuff
Serving path/to/stuff on port 8001

Das könnte sogar Ordnerinhalte auflisten.

Leider konnten keine Dateien bereitgestellt werden :)

Ein einfacher statischer Server mit connect

var connect = require('connect'),
  directory = __dirname,
  port = 3000;

connect()
  .use(connect.logger('dev'))
  .use(connect.static(directory))
  .listen(port);

console.log('Listening on port ' + port);

Siehe auch Verwenden von node.js als einfacher Webserver

Für Entwicklungsarbeiten können Sie (Express 4) https://github.com/appsmatics/simple-httpserver.git verwenden

Wenn Sie sich für ultraleichte http-Server ohne Voraussetzungen interessieren, sollten Sie sich Folgendes ansehen: Mungo

Ich benutze Houston bei der Arbeit und für persönliche Projekte funktioniert es gut für mich.

https://github.com/alejandro/Houston

Sie haben auch gefragt, warum Anfragen fallen - nicht sicher, was der spezifische Grund für Ihren Fall ist, aber insgesamt sollten Sie statische Inhalte mit dedizierter Middleware (nginx, S3, CDN) besser serverisieren, da Node für dieses Netzwerkmuster wirklich nicht optimiert ist. Weitere Erläuterungen finden Sie hier (Punkt 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/