Serveur HTTP simple en ligne de commande

J'ai un script qui génère un rapport quotidien que je veux servir au soi-disant grand public. Le problème est que je ne veux pas ajouter à mes maux de tête la maintenance d’un serveur HTTP (par exemple Apache) avec toutes les configurations et les implications en matière de sécurité.

Existe-t-il une solution simple et simple pour servir une petite page HTML sans avoir à configurer un serveur HTTP complet?

Oui, Nweb.

Peut être trouvé ici: nweb.c

(précédemment sur ibm.com )

Pour compiler nweb.c:

gcc -O -DLINUX nweb.c -o nweb

Essayez SimpleHTTPServer :

python -m SimpleHTTPServer
# or the Python 3 equivalent
python3 -m http.server

Il devrait servir tout ce qui est dans le CWD (par exemple, index.html) à http://0.0.0.0:8000 .

Il y a une grande liste de liners de serveur statique http :

Pour figurer sur cette liste, une solution doit:

1. servir des fichiers statiques en utilisant votre répertoire actuel (ou un répertoire spécifié) en tant que racine du serveur
2. pouvoir être exécuté avec une seule commande, une seule ligne (les dépendances sont acceptables si elles sont ponctuelles)
3. servir des types de fichiers de base (html, css, js, images) avec les types mime appropriés, ne nécessite aucune configuration (à partir de fichiers ou autre) au-delà de la commande elle-même (pas de serveurs spécifiques à la structure, etc.)
4. doit fonctionner, ou avoir un mode où il peut fonctionner, au premier plan (pas de démons)

Par exemple:

• Twisted (Python)

  twistd -n web -p 8000 --path . 
  

• Erlang :

  erl -s inets -eval 'inets:start(httpd,[{server_name,"NAME"},{document_root, "."},{server_root, "."},{port, 8000},{mime_types,[{"html","text/html"},{"htm","text/html"},{"js","text/javascript"},{"css","text/css"},{"gif","image/gif"},{"jpg","image/jpeg"},{"jpeg","image/jpeg"},{"png","image/png"}]}]).'
  

• Plack (Perl)

  cpan Plack
  plackup -MPlack::App::Directory -e 'Plack::App::Directory->new(root=>".");' -p 8000
  

• webfs

  webfsd -F -p 8000
  

• Ruby 1.9.2+

  ruby -run -ehttpd . -p8000
  

Utilisez node.js, rapide et léger.

Ou

utilisez simplement la nccommande netcat pour démarrer un serveur Web rapide sur un port et servir le contenu d'un fichier, y compris les en-têtes de réponse du serveur.

Référence de Wikipedia:

http://en.wikipedia.org/wiki/Netcat#Setting_up_a_one-shot_webserver_on_port_8080_to_present_the_content_of_a_file

{ echo -ne "HTTP/1.0 200 OK\r\n\r\n"; cat some.file; } | nc -l -p 8080
{ echo -ne "HTTP/1.0 200 OK\r\nContent-Length: $(wc -c <some.file)\r\n\r\n"; cat some.file; } | nc -l -p 8080

Depuis la version 5.4.0, PHP a également un serveur Web intégré :

php -S localhost:8000

Vous pouvez spécifier le répertoire de documents du serveur Web avec -t, par exemple:

php -S localhost:8000 -t /var/lib/www

Si vous voulez pouvoir accéder au serveur via le réseau, alors:

php -S 0.0.0.0:8000 -t /var/lib/www

Node a un module de serveur HTTP simple, rapide et léger. À installer:

sudo npm install http-server -g

(En supposant que vous avez nodeet npmdéjà installé.)

Pour l'exécuter, utilisez le répertoire actuel en tant que racine du site Web:

http-server

Cela crée un serveur http://0.0.0.0:8080/.

Essayez d'utiliser SimpleHTTPServeren Python.

mkdir ~/public_html
command_to_generate_output > ~/public_html/output.txt

(cd ~/public_html; python -c 'import SimpleHTTPServer,BaseHTTPServer; BaseHTTPServer.HTTPServer(("", 8080), SimpleHTTPServer.SimpleHTTPRequestHandler).serve_forever()')

Les deux premières lignes sont configurées pour le serveur Web. La dernière ligne crée un serveur Web simple, ouvert sur le port 8080, qui ne sert que les fichiers de ~/public_html. Si un seul fichier est dans ce répertoire, seul qui est exposé: http://localhost:8080/output.txt.

Vous pouvez utiliser Xinetd . Placez le fichier de configuration suivant dans /etc/xinetd.d/ et le service xinetd reload :

service http
{
  flags = REUSE IPv4
  protocol = tcp
  socket_type = stream
  port = 80
  wait = no
  user = nobody
  server = /bin/echo
  server_args = -e HTTP/1.0 301 Moved Permanently\nContent-Length: 0\nLocation: https://goo.gl/\n\n
  disable = no
}

Fonctionne pour mes besoins de redirection:

# wget 127.0.0.1
--2016-04-04 22:56:20--  http://127.0.0.1/
Connecting to 127.0.0.1:80... connected.
HTTP request sent, awaiting response... 301 Moved Permanently
Location: https://goo.gl/ [following]
...

Serveur HTTP Oldschool Ruby WEBrick :

#!/usr/bin/env ruby

require 'webrick'
server = WEBrick::HTTPServer.new(:Port => 8000,
                                 :DocumentRoot => '~/webrickroot')

# stop server with Ctrl-C
trap('INT') { server.stop }
server.start

Assurez-vous de modifier le DocumentRootpour votre configuration. Voir aussi ceci .

Une autre option serait d'installer lighttpd. Voici les étapes suggérées pour installer lighttpd sur un Unbuntu 12.04 LTS.

apt-get update
apt-get upgrade --show-upgraded
apt-get install lighttpd
ifconfig
http://[your-ip-address]:80
/etc/lighttpd/lighttpd.conf (Edit to add server.port)
server.port = "8080"

Remarque: Documentroot est l'endroit où tous les fichiers accessibles sur le Web seront des endroits. L'emplacement est / var / wwww

L'étape ci-dessus va installer un serveur Web lighttpd de base. Pour plus d'informations, reportez-vous aux références suivantes

Références:

• Serveur Web lighttpd sur Ubuntu 12.04 (Précis)
• Description de Lighttpd
• Lighttpd démarre mais ne fonctionne pas. lighttpd.pid Autorisation refusée
• Mise en route - Linode
• Serveur Web pour tester sur Linux
• Conseil technique: serveur HTTP vraiment simple avec Python
• Quel serveur Web Open Source léger vous convient le mieux?
• 6 excellents serveurs Web Linux / Open Source
• Configuration Lighttpd

Simple Ruby un liner pour servir un répertoire:

ruby -run -e httpd . -p 8080

./devd -o -a -P devd:devd .

• -o ouvre l'URL dans le navigateur
• -a pour toutes les interfaces
• -P authentification utilisateur / passe
• . servir des fichiers dans le même répertoire

https://github.com/cortesi/devd/releases

Une simple correction / amélioration d'une réponse légèrement votée légèrement injustement (à mon humble avis) pourrait également fonctionner. Configurons d'abord le fichier html ...

echo '<html><head><title>My Test File</title></head><body><hi>OK!</h1></body></html>' > my_file.html

Maintenant, vous pouvez le servir avec ce one-liner:

while true; do echo -e "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n" | cat - my_file.html  | nc -l -p 8080; done

Cette idée de base se prête à d'autres astuces qui pourraient vous convenir via d'autres catidées ou sous-shell, telles que:

while true; do echo -e "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nI think the date is $(date), Have a good day!" | nc -l -p 8080; done

essayez caddie

curl https://getcaddy.com | bash

servir le contenu de / var / www caddy -root /var/www "browse"

maintenant vous trouvez le serveur sur http: // localhost: 2015

• https://caddyserver.com/
• https://nwgat.ninja/quick-easy-caddy-a-http-2-web-server-with-a-twist/

Exemple Netcat simple à mettre en script bash:

while true ; do nc -l 80 <index.html ; done 

SFK mérite d'être mentionné ici

http://stahlworks.com/dev/swiss-file-knife.html

un excellent outil polyvalent sans dépendances

disponible dans les saveurs deb et rpm

sfk httpserv -port 1234

servira le répertoire courant

sfk httpserv -port 1234 -rw

permettra également le téléchargement de fichiers

Pure bash: Un serveur Web dans un script shell .

En outre, vous aurez besoin de xinetd (disponible dans n’importe quelle distribution) pour écouter le port et exécuter le script si nécessaire, vous évitant ainsi de coder tcp stack etc en bash.

J'ai utilisé ces instructions pour installer un serveur Web sur ma machine CentOS sans avoir à utiliser sudo ou à toucher aucun fichier système:

Premier noeud d'installation:

$ cd ~
$ wget https://nodejs.org/download/release/latest/node-v8.6.0-linux-x64.tar.gz
$ tar node-v8.6.0-linux-x64.tar.gz

puis installez le serveur http:

$ export PATH=~/node-v8.6.0-linux-x64/bin:$PATH
$ npm install http-server

puis exécutez le serveur http sur le port 12321:

$ ~/node-v8.6.0-linux-x64/bin/node_modules/http-server/bin/http-server -p 12321

J'ai ncun peu amélioré la solution pour qu'elle:

• Ajoute un filename=indice
• Tourne en boucle jusqu'à ce que Ctrl + C,
• Enregistre un PID dans /tmp/serveFile-$PORTafin que vous puissiez le tuer facilement plus tard.

.

#!/bin/bash

FILE=$1;
if [ "$FILE" == "" ] ; then echo "Usage: $0 <file-to-serve> [<port:7979>]"; exit; fi
PORT=${2:-7979}
echo Serving $FILE at $PORT, PID: $$
echo $$ > /tmp/serveFilePID-$PORT

while true; do 
    { echo -ne "HTTP/1.0 200 OK\r\nContent-Length: $(wc -c <$FILE)\r\nContent-Disposition: inline; filename=\"$(basename $FILE)\"\r\n\r\n"; cat $FILE; } | nc -l $PORT
    CODE=$?
    #echo "Code: $CODE";
    if [ $CODE -gt 128 ] ; then break; fi;
done;

rm /tmp/serveFilePID-$PORT

On pourrait aussi utiliser nc -k -l ...mais de cette façon vous pouvez

• faire des actions personnalisées entre les fichiers servis,
• faire alterner plusieurs fichiers.