Servidor HTTP de línea de comando simple

Tengo un script que genera un informe diario que quiero servir al llamado público en general. El problema es que no quiero agregar a mis dolores de cabeza el mantenimiento de un servidor HTTP (por ejemplo, Apache) con todas las configuraciones e implicaciones de seguridad.

¿Existe una solución simple para servir una página HTML pequeña sin el esfuerzo de configurar un servidor HTTP completo?

Sí nweb

Se puede encontrar aquí: nweb.c

(anteriormente en ibm.com )

Para compilar nweb.c:

gcc -O -DLINUX nweb.c -o nweb

Prueba SimpleHTTPServer :

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

Debería servir lo que sea que esté en el CWD (por ejemplo, index.html) en http://0.0.0.0:8000 .

Hay una gran lista de servidores http estáticos :

Para entrar en esta lista, una solución debe:

1. Servir archivos estáticos utilizando su directorio actual (o un directorio especificado) como raíz del servidor
2. poder ejecutarse con un solo comando de una línea (las dependencias están bien si son una sola vez)
3. sirve tipos de archivos básicos (html, css, js, imágenes) con los tipos mime adecuados, no requiere configuración (de archivos o de otro tipo) más allá del comando en sí (sin servidores específicos del marco, etc.)
4. debe ejecutarse, o tener un modo en el que pueda ejecutarse, en primer plano (es decir, sin demonios)

Por ejemplo:

• Trenzado (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
  

Uso node.js, rápido y ligero.

O

simplemente use el nccomando netcat simple para iniciar un servidor web rápido en un puerto y servir el contenido de un archivo, incluidos los encabezados de respuesta del servidor.

Referencia 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

Desde la versión 5.4.0 PHP también tiene un servidor web incorporado :

php -S localhost:8000

Puede especificar el directorio de documentos del servidor web con -t, por ejemplo:

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

Si desea poder acceder al servidor a través de la red, entonces:

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

Node tiene un módulo de servidor HTTP simple, rápido y ligero. Instalar:

sudo npm install http-server -g

(Suponiendo que tiene nodey npmya está instalado).

Para ejecutarlo, use el directorio actual como raíz del sitio web:

http-server

Esto crea un servidor encendido http://0.0.0.0:8080/.

Intenta usarlo 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()')

Las dos primeras líneas están configuradas para el servidor web. La última línea crea un servidor web simple, abierto en el puerto 8080, que solo sirve archivos ~/public_html. Si sólo hay un archivo está en ese directorio, entonces sólo se expone que: http://localhost:8080/output.txt.

Puedes llevar a cuestas a xinetd . Coloque el siguiente archivo de configuración en /etc/xinetd.d/ y vuelva a cargar service 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
}

Funciona para mis propósitos de redireccionamiento:

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

Servidor 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

Asegúrese de modificar el DocumentRootpara su configuración. Ver también esto .

Otra opción sería instalar lighttpd. Los siguientes son pasos sugeridos para instalar lighttpd en 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 es donde se ubicarán todos los archivos web accesibles. La ubicación es / var / wwww

El paso anterior instalará un servidor web lighttpd básico. Para más información consulte las siguientes referencias

Referencias

• Servidor web lighttpd en Ubuntu 12.04 (Preciso)
• Descripción de Lighttpd
• Lighttpd se inicia pero no funciona. lighttpd.pid Permiso denegado
• Comenzando - Linode
• Servidor web para pruebas en Linux
• Consejo técnico: Servidor HTTP realmente simple con Python
• ¿Qué servidor web ligero y de código abierto es adecuado para usted?
• 6 excelentes servidores web Linux / Open Source
• Configuración Lighttpd

Ruby one liner simple para servir un directorio:

ruby -run -e httpd . -p 8080

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

• -o abre url en el navegador
• -a para todas las interfaces
• -P usuario / pase de autenticación
• . servir archivos en el mismo directorio

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

Una solución / mejora simple para una respuesta votada un poco injusta (en mi humilde opinión) también podría funcionar. Primero configuremos el archivo html ...

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

Ahora puede servirlo con esta frase:

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

Esta idea básica se presta a otros trucos que podrían funcionar para usted a través de otras catideas o sub-shell como:

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

prueba caddie

curl https://getcaddy.com | bash

servir contenido de / var / www caddy -root /var/www "browse"

ahora encuentra el servidor en http: // localhost: 2015

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

Ejemplo simple de netcat para poner en script bash:

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

SFK vale la pena mencionar aquí

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

Una excelente herramienta multipropósito sin dependencias

disponible en sabores deb y rpm

sfk httpserv -port 1234

servirá directorio actual

sfk httpserv -port 1234 -rw

también permitirá subir archivos

Pure bash: un servidor web en un script de shell .

Además, necesitará xinetd (creo que está disponible en cualquier distribución) para escuchar el puerto y ejecutar el script cuando sea necesario, por lo que no tiene que codificar tcp stack, etc. en bash.

Usé estas instrucciones para instalar un servidor web en mi máquina CentOS sin tener que usar sudo o tocar ningún archivo del sistema:

Primer nodo de instalación:

$ 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

luego instale el servidor http:

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

luego ejecute http-server en el puerto 12321:

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

He mejorado ncun poco la solución para que:

• Agrega la filename=pista,
• Se ejecuta en un bucle hasta que Ctrl + C,
• Guarda un PID para /tmp/serveFile-$PORTque pueda matarlo más tarde fácilmente.

.

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

También se podría usar, nc -k -l ...pero de esta manera puedes

• realizar acciones personalizadas entre archivos servidos,
• hacer alternar varios archivos.