Server HTTP a riga di comando semplice

Ho una sceneggiatura che genera un rapporto giornaliero che voglio servire al cosiddetto pubblico in generale. Il problema è che non voglio aggiungere al mio mal di testa la manutenzione di un server HTTP (ad esempio Apache) con tutte le configurazioni e le implicazioni di sicurezza.

Esiste una soluzione semplice morta per servire una piccola pagina HTML senza lo sforzo di configurare un server HTTP completo?

Sì, nweb.

Può essere trovato qui: nweb.c

(precedentemente su ibm.com )

Per compilare nweb.c:

gcc -O -DLINUX nweb.c -o nweb

Prova SimpleHTTPServer :

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

Dovrebbe servire qualunque cosa sia nel CWD (es . Index.html ) a http://0.0.0.0:8000 .

C'è un grande elenco di one-line di server statici http :

Per accedere a questo elenco, una soluzione deve:

1. servire file statici usando la directory corrente (o una directory specificata) come root del server
2. essere in grado di essere eseguito con un singolo comando a una riga (le dipendenze vanno bene se sono una cosa singola)
3. servire tipi di file di base (html, css, js, images) con tipi di mime appropriati, non richiede alcuna configurazione (da file o altro) oltre al comando stesso (nessun server specifico del framework, ecc.)
4. deve essere eseguito o avere una modalità in cui può essere eseguito in primo piano (ovvero senza demoni)

Per esempio:

• 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
  

Usa node.js, veloce e leggero.

O

basta usare il semplice nccomando netcat per avviare un webserver veloce su una porta e servire il contenuto di un file comprese le intestazioni di risposta del server.

Riferimento da 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

Dalla versione 5.4.0 PHP ha anche un web server integrato :

php -S localhost:8000

È possibile specificare la directory dei documenti del server Web con -t, ad esempio:

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

Se si desidera poter accedere al server in rete, allora:

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

Il nodo ha un modulo server HTTP semplice, veloce e leggero. Installare:

sudo npm install http-server -g

(Supponendo di avere nodee npmgià installato.)

Per eseguirlo, utilizzando la directory corrente come root del sito Web:

http-server

Questo crea un server acceso http://0.0.0.0:8080/.

Prova a utilizzare SimpleHTTPServerin 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()')

Le prime due righe sono configurate per il server Web. L'ultima riga crea un semplice server Web, aperto sulla porta 8080, che serve solo file ~/public_html. Se solo un file è in quella directory, allora solo che è esposto: http://localhost:8080/output.txt.

Puoi tornare su xinetd . Inserisci il seguente file di configurazione in /etc/xinetd.d/ e ricarica il servizio xinetd :

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
}

Funziona per i miei scopi di reindirizzamento:

# 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]
...

Server HTTP Ruby WEBrick Oldschool :

#!/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

Assicurati di modificare il DocumentRootper la tua configurazione. Si veda anche questo .

Un'altra opzione sarebbe quella di installare lighttpd. Di seguito sono suggeriti i passaggi per installare lighttpd su 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"

Nota: Documentroot è il punto in cui verranno posizionati tutti i file accessibili dal Web. La posizione è / var / wwww

Il passaggio precedente installerà un web server lighttpd di base. Per ulteriori informazioni, consultare i seguenti riferimenti

Riferimenti:

• server Web lighttpd su Ubuntu 12.04 (preciso)
• Descrizione Lighttpd
• Lighttpd si avvia ma non funziona. lighttpd.pid Autorizzazione negata
• Per iniziare - Linode
• Server Web per test su Linux
• Suggerimento tecnico: Server HTTP davvero semplice con Python
• Quale server Web leggero e open source è giusto per te?
• 6 eccellenti server Web Linux / Open Source
• Configurazione Lighttpd

Ruby one liner semplice per servire una directory:

ruby -run -e httpd . -p 8080

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

• -o apre l'URL nel browser
• -a per tutte le interfacce
• -P autent utente / pass
• . servire i file nella stessa directory

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

Potrebbe anche funzionare una semplice correzione / miglioramento a una risposta leggermente ingiusta (imho) sotto votata. Configuriamo prima il file html ...

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

Ora puoi servirlo con questo 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

Questa idea di base si presta ad altri trucchi che potrebbero funzionare per te tramite catidee di altri o subshell come:

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

prova caddy

curl https://getcaddy.com | bash

servire contenuti da / var / www caddy -root /var/www "browse"

ora trovi il server su http: // localhost: 2015

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

Semplice esempio di netcat da inserire nello script bash:

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

Vale la pena menzionare SFK qui

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

un eccellente strumento multiuso senza dipendenze

disponibile in entrambe le versioni deb e rpm

sfk httpserv -port 1234

servirà la directory corrente

sfk httpserv -port 1234 -rw

consentirà anche il caricamento di file

Pure bash: un server Web in uno script di shell .

Inoltre, avrai bisogno di xinetd (credo disponibile in qualsiasi distro) per ascoltare la porta ed eseguire lo script quando necessario, quindi non devi codificare tcp stack ecc. In bash.

Ho usato queste istruzioni per installare un web server sul mio computer CentOS senza dover usare sudo o toccare alcun file di sistema:

Primo nodo di installazione:

$ 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

quindi installare http-server:

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

quindi eseguire http-server sulla porta 12321:

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

Ho migliorato ncun po ' la soluzione in modo che:

• Aggiunge il filename=suggerimento,
• Funziona in loop fino a quando Ctrl + C,
• Salva un PID in /tmp/serveFile-$PORTmodo da poterlo uccidere facilmente in seguito.

.

#!/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

Si potrebbe anche usare, nc -k -l ...ma in questo modo è possibile

• eseguire azioni personalizzate tra i file pubblicati,
• fare alternare più file.