web-dev-qa-db-fra.com

Serveur de fichiers rapide Node.js (fichiers statiques via HTTP)

Existe-t-il un outil prêt à l'emploi Node.js (installé avec npm), qui m'aiderait à exposer le contenu du dossier en tant que serveur de fichiers via HTTP?.

Exemple, si j'ai

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

Puis à partir de D:\Folder\node node-file-server.js je pouvais accéder au fichier via

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

Pourquoi le serveur de fichiers statique de mon noeud supprime-t-il les demandes? référence un peu mystique

serveur de fichiers statique standard node.js

Si un tel outil n'existe pas, quel cadre dois-je utiliser?

Connexes: serveur de fichiers statique de base dans NodeJS

node.jshttpfileserver
555
Paul Verest

Un bon "outil prêt à l'emploi" pourrait être le serveur http:

npm install http-server -g

Pour l'utiliser:

cd D:\Folder
http-server

Ou comme ceci:

http-server D:\Folder

Découvrez-le: https://github.com/nodeapps/http-server

947
Matt Self

Si vous ne souhaitez pas utiliser l'outil ready, vous pouvez utiliser le code ci-dessous, comme je l'ai démontré à l'adresse https://developer.mozilla.org/en-US/docs/Node_server_without_framework :

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 Si vous devez accéder à votre serveur à partir d'un fichier/demande externe, vous devez vaincre le CORS, dans votre fichier node.js en écrivant le texte ci-dessous, comme je l'ai mentionné dans une réponse précédente ici

// 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);

UPDATE

Comme Adrian l'a mentionné, dans les commentaires, il a écrit un code ES6 avec une explication complète ici , je viens de republier son code ci-dessous, au cas où le code aurait disparu du site d'origine raison:

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}`);
167
Hasan A Yousef

Pour les personnes souhaitant un serveur exécutable à partir du script NodeJS:

Vous pouvez utiliser expressjs/serve-static qui remplace connect.static (qui n'est plus disponible à partir de connect 3):

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);

puis en ligne de commande:

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

Je sais que ce n'est pas Node, mais j'ai utilisé SimpleHTTPServer de Python:

python -m SimpleHTTPServer [port]

Cela fonctionne bien et vient avec Python.

54
Matt Sergeant

connect pourrait être ce que vous cherchez.

Installé facilement avec:

npm install connect

Ensuite, le serveur de fichiers statique le plus élémentaire pourrait être écrit comme suit:

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

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

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

Installez Express en utilisant npm: https://expressjs.com/fr/starter/installing.html

Créez un fichier nommé server.js au même niveau que votre index.html avec ce contenu:

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

Si vous souhaitez le placer dans un emplacement différent, définissez le chemin sur la troisième ligne:

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

CD dans le dossier contenant votre fichier et exécutez le noeud à partir de la console avec cette commande:

node server.js

Recherchez localhost: 8080

15
pasx

DEMO/PROTO SERVER UNIQUEMENT

Si c'est tout ce dont vous avez besoin, essayez ceci:

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);

note: vous devez utiliser "/index.html" dans votre adresse, par exemple " http: // localhost: 3000/index.html "

13
Jacksonkr

Preuves One-line ™ au lieu de promesses

enter image description here

Le premier est http-server, hs - link

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

La seconde est serve par ZEIT.co - link

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

Voici les options disponibles, si c’est ce qui vous aide à décider.

 C:\Utilisateurs\Qwerty> serveur http --help 
 Utilisation: serveur http [chemin] [options] 
 
 Options: 
 -p Port à utiliser [8080] 
 -a Adresse à utiliser [0.0.0.0] 
 -d Afficher les listes de répertoire [true] 
 -i Afficher autoIndex [true] 
 -g --gzip Servir les fichiers gzip lorsque cela est possible [false] 
 -e --ext Extension de fichier par défaut si aucun fourni [none] 
 -s --silent Supprimer les messages du journal sortie 
 --cors [= en-têtes] Activer CORS via l'en-tête "Access-Control-Allow-Origin" 
 Fournir éventuellement une liste d'en-têtes CORS séparés par des virgules 
 -o [chemin] Ouvrez la fenêtre du navigateur après avoir démarré le serveur 
 -C Durée du cache (max-âge) en secondes [3600], p.ex. -c10 pendant 10 secondes. 
 Pour désactiver la mise en cache, utilisez -c-1. 
 -U --utc Utilisez le format d’heure UTC dans les messages de journal. 
 
 - P - proxy proxy de secours si la demande ne peut pas être résolue. Exemple: http://someurl.com 
 
 -S --ssl Activer https. 
 -C --cert Chemin d'accès au fichier de certificat SSL (par défaut: cert.pem). 
 -K --key Chemin d'accès au fichier de clé ssl (par défaut: key.pem). 
 
 -R --robots Répondre à /robots.txt [User-agent: *\nDisallow: /]
 -h --help Affiche cette liste et quitte. 

 C:\Utilisateurs\Qwerty> serve --help 
 
 Utilisation: serve.js [options] [commande] 
 
 Commandes: 
 
 aide Afficher l’aide 
 
 Options: 
 
 -a, --auth Servir derrière l’authentification de base 
 - c, --cache Temps en millisecondes pour la mise en cache des fichiers dans le navigateur 
 -n, --clipless Ne pas copier l'adresse dans le Presse-papiers (désactivé par défaut) 
 -C, --cors Configuration * En-têtes CORS permettant aux demandes de n'importe quelle origine (désactivé par défaut) 
 -H, --help Informations d'utilisation en sortie 
 -I, --ignore Fichiers et répertoires à ignorer 
 -O , --open Ouvre l'adresse locale dans le navigateur (désactivé par défaut) 
 -p, --port Port sur lequel écouter (par défaut 5000) 
 -S, --silent Ne rien enregistrer sur la console 
 -s, --single Servir des applications à une seule page (définit `-c` sur 1 jour) 
 -t, --treeless N'affiche pas d'arborescence statique (désactivé par défaut) 
 -u, --unzipped Désactiver la compression GZIP 
 -V, --version Indiquer le numéro de version

Si vous devez surveiller les modifications, voir hostr , crédit réponse de Henry Tseng

10
Qwerty

Il y a un autre serveur web statique qui est assez gentil: la synchronisation du navigateur.

Il peut être téléchargé à l'aide du gestionnaire de paquets de noeud:

npm install -g browser-sync

Après l’installation, accédez au dossier du projet dans l’invite cmd et exécutez ce qui suit:

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

Il commencera à traiter tous les fichiers du dossier actuel du navigateur.

Plus d'informations peuvent être trouvées à partir de BrowserSync

Merci.

8
Samrat Debroy

Ici est mon seul fichier/léger node.js. Mon projet de serveur Web pour animaux domestiques sans dépendance, ce qui, à mon avis, est un outil rapide et riche dont l'utilisation est aussi simple que d'exécuter cette commande sur votre ordinateur. Terminal Linux/Unix/macOS (ou termux sur Android) lorsque node.js (ou nodejs-legacy sur Debian/Ubuntu) est installé:

curl pad.js.org | node

(différentes commandes existent pour les utilisateurs Windows dans la documentation)

Il soutient différentes choses que je crois pouvoir trouver utiles,

  • Création/desserte d’index de répertoire hiérarchique
    • Avec une capacité de tri sur les différents critères
    • Télécharger depuis un navigateur par [multi-fichier] glisser-déposer et copier/coller un fichier/texte uniquement et une copie d'écran avec une copie d'écran du presse-papiers système sous Chrome, Firefox et d'autres navigateurs, avec certaines limitations (pouvant être désactivées en ligne de commande les options qu'il fournit)
    • Bouton Dossier/création de note/téléchargement
  • Traitement des MIME corrects pour les types de fichiers connus (avec possibilité de le désactiver)
  • Possibilité d'installation en tant que package npm et outil local ou, installation linéaire sur un service permanent avec Docker
  • Serveur de fichiers HTTP 206 (transfert de fichiers en plusieurs parties) pour des transferts plus rapides
  • Chargements depuis la console du terminal et du navigateur (en fait, il s’agissait en fait d’un proxy de système de fichiers pour la console JS des navigateurs sur d’autres pages/domaines)
  • Téléchargement/téléchargement CORS (qui peut également être désactivé)
  • Intégration HTTPS facile
  • Options de ligne de commande allégées pour obtenir un meilleur service sécurisé:
    • Avec mon correctif sur node.js 8 , vous pouvez accéder aux options sans installation préalable: curl pad.js.org | node - -h
    • Ou bien installez-le d'abord comme un paquet npm global du système par [Sudo] npm install -g pad.js puis utilisez sa version installée pour avoir accès à ses options: pad -h
    • Ou utilisez l'image Docker fournie, qui utilise des options relativement sécurisées par défaut. [Sudo] docker run --restart=always -v /files:/files --name pad.js -d -p 9090:9090 quay.io/ebraminio/pad.js

Screenshot of a folder index using the tool

Les fonctionnalités décrites ci-dessus sont principalement documentées sur la page principale de l'outil http://pad.js.org qui, par une astuce intéressante, est aussi l'endroit où l'outil lui-même est également fourni!

La source de l'outil est sur GitHub , ce qui accueille vos commentaires, demandes de fonctionnalités et s!

6
Ebrahim Byagowi

Je n'ai pas eu beaucoup de chance avec aucune des réponses sur cette page, cependant, ci-dessous semblait faire l'affaire.

Ajoutez un fichier server.js avec le contenu suivant:

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)

Assurez-vous également que vous avez besoin de express. Exécutez yarn add express --save ou npm install express --save en fonction de votre configuration (je peux recommander yarn c'est assez rapide).

Vous pouvez remplacer dist par le dossier dans lequel vous diffusez votre contenu. Pour mon projet simple, je ne servais dans aucun dossier. J'ai donc simplement supprimé le nom de fichier dist.

Ensuite, vous pouvez exécuter node server.js. Comme je devais télécharger mon projet sur un serveur Heroku, je devais ajouter ce qui suit dans mon fichier package.json:

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

Si vous utilisez le cadre Express , cette fonctionnalité est prête à fonctionner.

Pour configurer une application de service de fichiers simple, procédez comme suit:

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

Pour une augmentation saine des performances en utilisant noeud pour servir des ressources statiques, je recommande d'utiliser Buffet . Il fonctionne comme un accélérateur d’application Web, également appelé proxy inverse HTTP en cache, mais il charge simplement le répertoire choisi en mémoire.

Buffet adopte une approche totalement tamponnée: tous les fichiers sont entièrement chargés en mémoire au démarrage de votre application, vous ne sentirez donc jamais la gravure du système de fichiers. En pratique, cela est extrêmement efficace. Si bien que mettre Varnish devant votre application pourrait même le ralentir!

Nous l’utilisons sur le site codePile et avons constaté une augmentation d’environ 700 demandes/seconde à plus de 4 000 requêtes par seconde sur une page téléchargeant 25 ressources sous une charge de connexion utilisateur simultanée de 1k.

Exemple:

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');

});
4
user742030

Jetez un coup d'œil à cela lien .

Vous devez seulement installer le module express de node js.

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

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

Vous pouvez accéder à votre fichier comme http: //hostname/Folder/file.Zip

4
Syed Ali hassan

Voici un autre serveur Web simple.

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

Installer

npm install -g hostr

Changer de directeur de travail

cd myprojectfolder/

Et commencer

hostr
3
Henry Tseng

Vous pouvez essayer serve-moi

Utiliser c'est si simple:

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

C'est tout.

PD: Le dossier servi par défaut est "public".

3
muit

Installez d’abord le serveur noeud-statique via npm install node-static -g -g consiste à l’installer globalement sur votre système, puis accédez au répertoire où se trouvent vos fichiers, démarrez le serveur avec static qu’il écoute sur le port 8080, naviaget dans le navigateur et tapez localhost: 8080/yourhtmlfilename.

2
samba

Pour le bénéfice des chercheurs, j’ai aimé la réponse de Jakub g, mais je voulais un peu de gestion des erreurs. Évidemment, il est préférable de gérer les erreurs correctement , mais cela devrait aider à empêcher un site de s’arrêter si une erreur se produit. Code ci-dessous:

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
});
2
HockeyJ
const http = require('http');
const fs = require('fs');
const url = require('url');
const path = require('path');


let mimeTypes = {
  '.html': 'text/html',
  '.css': 'text/css',
  '.js': 'text/javascript',
  '.jpg': 'image/jpeg',
  '.png': 'image/png',
  '.ico': 'image/x-icon',
  '.svg': 'image/svg+xml',
  '.eot': 'appliaction/vnd.ms-fontobject',
  '.ttf': 'aplication/font-sfnt'
};



http.createServer(function (request, response) {
  let pathName = url.parse(request.url).path;
  if(pathName === '/'){
    pathName = '/index.html';
  }
  pathName = pathName.substring(1, pathName.length);
  let extName = path.extName(pathName);
  let staticFiles = `${__dirname}/template/${pathName}`;

      if(extName =='.jpg' || extName == '.png' || extName == '.ico' || extName == '.eot' || extName == '.ttf' || extName == '.svg')
      {
          let file = fr.readFileSync(staticFiles);
          res.writeHead(200, {'Content-Type': mimeTypes[extname]});
          res.write(file, 'binary');
          res.end();
      }else {
        fs.readFile(staticFiles, 'utf8', function (err, data) {
          if(!err){
            res.writeHead(200, {'Content-Type': mimeTypes[extname]});
            res.end(data);
          }else {
            res.writeHead(404, {'Content-Type': 'text/html;charset=utf8'});
            res.write(`<strong>${staticFiles}</strong>File is not found.`);
          }
          res.end();
        });
      }
}).listen(8081);
2
Slava Nazaryan

Ce n'est pas encore sur NPM, mais j'ai construit un serveur statique simple sur Express qui vous permet également d'accepter l'envoi de formulaires et de les envoyer par courrier électronique via un service de messagerie transactionnelle (Sendgrid pour le moment, Mandrill à venir).

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

2
jdr0dn3y

Si vous êtes intéressé par un serveur http ultra-léger sans conditions préalables, vous devriez jeter un coup d'œil à: mangouste

1
yossico

Pour le travail de développement, vous pouvez utiliser (express 4) https://github.com/appsmatics/simple-httpserver.git

1
appsmatics

Vous pouvez utiliser le package NPM serve pour cela. Si vous n’avez pas besoin du logiciel NodeJS, c’est un outil rapide et facile à utiliser:

1 - Installez le paquet sur votre PC:

npm install -g serve

2 - Servez votre dossier statique avec serve <path>:

d:> serve d:\StaticSite

Il vous montrera quel port votre dossier statique est servi, naviguez simplement vers l'hôte de la manière suivante:

http://localhost:3000
1
Diego Mendes

Recherche dans le registre NPM https://npmjs.org/search?q=server , j'ai trouvé static-server https://github.com/maelstrom/static-server =

Vous avez déjà eu besoin d'envoyer un fichier à un collègue, mais vous ne pouvez pas vous ennuyer en envoyant un courriel à la bête de 100 Mo? Vous souhaitez exécuter un exemple d'application JavaScript simple, mais vous rencontrez des problèmes pour l'exécuter via le protocole file: ///? Vous souhaitez partager votre répertoire multimédia sur un réseau local sans configurer Samba, FTP ou quoi que ce soit qui vous oblige à modifier des fichiers de configuration? Ensuite, ce serveur de fichiers vous facilitera la vie.

Pour installer le serveur de fichiers statique simple, utilisez npm:

npm install -g static-server

Ensuite, pour servir un fichier ou un répertoire, lancez simplement

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

Cela pourrait même lister le contenu du dossier.

Malheureusement, il ne pouvait pas servir de fichiers :)

1
Paul Verest

Un simple serveur statique utilisant 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);

Voir aussi tilisation de node.js en tant que serveur Web simple

1
dreampulse

Vous avez également demandé pourquoi les demandes échouaient - vous ne savez pas quelle est la raison spécifique de votre cas, mais dans l'ensemble, vous optimisez le contenu statique du serveur à l'aide d'un middleware dédié (nginx, S3, CDN) car Node n'est vraiment pas optimisé pour cela. modèle de réseau. Voir plus d'explications ici (point 13): http://goldbergyoni.com/checklist-best-practice-of-node-js-in-production/

0
Yonatan

Ci-dessous a travaillé pour moi:

Créez un fichier app.js avec le contenu ci-dessous:

// 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);

Lancer une ligne de commande:

cmd

Exécuter ci-dessous dans cmd:

node app.js

Créer un index.html avec le contenu ci-dessous

Hi

Aller à l'URL ci-dessous, en chrome:

http://localhost:8080/index.html

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

J'espère que ça t'as aidé.

0
Manohar Reddy Poreddy

J'utilise Houston au travail et pour des projets personnels, cela fonctionne bien pour moi.

https://github.com/alejandro/Houston

0
matthewtole