Servidor HTTP de linha de comando simples

Eu tenho um script que gera um relatório diário que quero servir ao chamado público em geral. O problema é que não quero adicionar à minha dor de cabeça a manutenção de um servidor HTTP (por exemplo, Apache) com todas as configurações e implicações de segurança.

Existe uma solução simples para servir uma pequena página HTML sem o esforço de configurar um servidor HTTP completo?

Sim, nweb.

Pode ser encontrado aqui: nweb.c

(anteriormente em ibm.com )

Para compilar o nweb.c:

gcc -O -DLINUX nweb.c -o nweb

Experimente o SimpleHTTPServer :

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

Ele deve servir o que estiver no CWD (por exemplo, index.html) em http://0.0.0.0:8000 .

Há uma grande lista de one-liners de servidor estático http :

Para entrar nessa lista, uma solução deve:

1. servir arquivos estáticos usando seu diretório atual (ou um diretório especificado) como raiz do servidor
2. poder ser executado com um único comando de uma linha (as dependências são boas se forem únicas)
3. serve tipos básicos de arquivo (html, css, js, imagens) com tipos mime adequados, não requer configuração (de arquivos ou outros) além do próprio comando (sem servidores específicos da estrutura, etc.)
4. deve ser executado ou ter um modo em que possa ser executado em primeiro plano (ou seja, sem daemons)

Por exemplo:

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

Use node.js, rápido e leve.

Ou

basta usar o nccomando netcat simples para iniciar um servidor da web rápido em uma porta e servir o conteúdo de um arquivo, incluindo os cabeçalhos de resposta do servidor.

Referência 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

Desde a versão 5.4.0, o PHP também possui um servidor da web embutido :

php -S localhost:8000

Você pode especificar o diretório de documentos do servidor da Web com -t, por exemplo:

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

Se você deseja acessar o servidor pela rede, então:

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

O nó possui um módulo de servidor HTTP simples, rápido e leve. Para instalar:

sudo npm install http-server -g

(Supondo que você tem nodee npmjá instalado.)

Para executá-lo, use o diretório atual como raiz do site:

http-server

Isso cria um servidor http://0.0.0.0:8080/.

Tente usar SimpleHTTPServerem 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()')

As duas primeiras linhas são configuradas para o servidor web. A última linha cria um servidor web simples, aberto na porta 8080, que serve apenas arquivos de ~/public_html. Se apenas um arquivo está no diretório, então, apenas que é exposta: http://localhost:8080/output.txt.

Você pode pegar o xinetd . Coloque o seguinte arquivo de configuração em /etc/xinetd.d/ e 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
}

Funciona para meus propósitos de redirecionamento:

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

Certifique-se de modificar o DocumentRootpara sua instalação. Veja também isso .

Outra opção seria instalar o lighttpd. A seguir, são sugeridas as etapas para instalar o lighttpd em um 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: O Documentroot é o local onde todos os arquivos acessíveis pela Web serão locais. O local é / var / wwww

A etapa acima instalará um servidor web lighttpd básico. Para mais informações, consulte as seguintes referências

Referências:

• Servidor Web lighttpd no Ubuntu 12.04 (Preciso)
• Descrição Lighttpd
• O Lighttpd inicia, mas não funciona. Permissão negada lighttpd.pid
• Introdução - Linode
• Servidor da Web para teste no Linux
• Dica técnica: Servidor HTTP realmente simples com Python
• Que servidor Web leve e de código aberto é ideal para você?
• 6 excelentes servidores Web Linux / código aberto
• Configuração Lighttpd

Simples liner Ruby para servir um diretório:

ruby -run -e httpd . -p 8080

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

• -o abre o URL no navegador
• -a para todas as interfaces
• -P usuário / senha de autenticação
• . servir arquivos no mesmo diretório

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

Uma correção / aprimoramento simples para uma resposta votada levemente injusta (imho) também pode funcionar. Vamos configurar o arquivo html primeiro ...

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

Agora você pode atendê-lo com esta linha única:

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

Essa ideia básica se presta a outros truques que podem funcionar para você por meio de outras catidéias ou subconjuntos, 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

tente caddy

curl https://getcaddy.com | bash

servir conteúdo de / var / www caddy -root /var/www "browse"

agora você encontra o servidor em http: // localhost: 2015

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

Exemplo simples de netcat para colocar no script bash:

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

Vale a pena mencionar aqui o SFK

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

uma excelente ferramenta multiuso sem dependências

disponível nos sabores deb e rpm

sfk httpserv -port 1234

servirá diretório atual

sfk httpserv -port 1234 -rw

também permitirá o upload de arquivos

Pure bash: um servidor web em um script de shell .

Além disso, você precisará do xinetd (acredito disponível em qualquer distribuição) para ouvir a porta e executar o script quando necessário, para que você não precise codificar a pilha tcp etc. no bash.

Usei estas instruções para instalar um servidor Web na minha máquina CentOS sem precisar usar o sudo ou tocar em nenhum arquivo de sistema:

Primeiro nó de instalação:

$ 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

instale o servidor http:

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

em seguida, execute o servidor http na porta 12321:

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

Melhorei ncum pouco a solução para que:

• Adiciona a filename=dica,
• É executado em um loop até Ctrl + C,
• Salva um PID para /tmp/serveFile-$PORTque você possa matá-lo mais tarde facilmente.

.

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

Pode-se também usar, nc -k -l ...mas desta maneira você pode

• faça ações personalizadas entre os arquivos veiculados,
• alterne vários arquivos.