Instale, configure e automatize Webship.

Visão geral do produto

Um servidor entre a rede e a sua aplicação.

Webship é um Rust de borda e servidor web estático auto-hospedado. Um runtime termina protocolos modernos, aplica políticas de borda, serve ficheiros e faz proxy de pedidos de aplicações.

Início rápido

Do binário de lançamento a um listener saudável.

Começa no loopback, valida tudo antes de ligar e verifica a resposta de saúde incorporada antes de adicionar tráfego público.

1. 1

   Preparar ficheiros

   Coloque o binário de lançamento, a sua configuração TOML, a raiz estática e quaisquer ficheiros de certificado e chave TLS configurados no host.

2. 2

   Validar e inspecionar

   Execute ambos os comandos de configuração. Corrija o primeiro erro e inspecione o resultado efectivo redigido antes da inicialização.

3. 3

   Inicie de forma privada

   Inicie Webship com o ficheiro TOML selecionado. Adicione um par de certificados completo ou TLS automático quando o site estiver pronto para tráfego público seguro.

4. 4

   Verifique o runtime

   Chame GET /health localmente. Depois teste caminhos estáticos, TLS, rotas proxy, regras de segurança e monitorização autenticada.

listen = "127.0.0.1:4433"
workers = 4
root = "./public"

/usr/local/bin/webship --check-config --config /etc/webship/production.toml
/usr/local/bin/webship --print-effective-config --config /etc/webship/production.toml

/usr/local/bin/webship --config /etc/webship/production.toml
curl --http3-only --insecure https://127.0.0.1:4433/health

Guia de Início Rápido para Agentes de IA

Ligue um agente de IA ao Webship em cinco linhas.

Ligue o Claude Code, OpenAI, DeepSeek ou qualquer cliente MCP compatível através de um túnel SSH privado. O agente recebe uma superfície de operações autenticada sem partilhar o ouvinte público ou expor credenciais de controlo ao tráfego da internet.

{
  "mcpServers": {
    "webship": { "url": "https://localhost:19443/mcp",
      "headers": { "Authorization": "Bearer <token>" } }
  } }

Entrega estática

Servir um directório com predefinições conscientes do protocolo.

Defina uma raiz globalmente ou por site. Sites TLS usam HTTP/3 por defeito; sites em texto claro usam HTTP/1.1 e H2C por defeito. Pode substituir HTTP/1.1, HTTP/2 e HTTP/3 independentemente para cada site.

[[sites]]
domain = "app.example.com"
root = "/srv/app"
listen = "0.0.0.0:443"

[sites.protocols]
h1 = true
h2 = true
h3 = true

O router integrado suporta GET e HEAD, intervalos de bytes, pedidos condicionais, validadores e sidecars .br, .zst e .gz. Caminhos de ficheiros começando por ponto são recusados por defeito; .well-known permanece disponível.

Tráfego de aplicações

Encaminhe os pedidos para um ou mais a montante.

Ativar o reverse proxy, combinar um host e um caminho, e depois definir uma política final incondicional. Webship suporta pools limitados, verificações de saúde, balanceamento de carga, disjuntores, tentativas seguras sem corpo, WebSockets e cache.

[reverse_proxy]
enabled = true

[[reverse_proxy.routes]]
domain = "app.example.com"
path_prefix = "/api"
strip_path_prefix = true
upstreams = ["127.0.0.1:8080", "127.0.0.1:8081"]

[[reverse_proxy.policies]]
name = "default"
hosts = []
path_prefixes = ["/"]
methods = []
max_body_bytes = 1048576
total_timeout_ms = 30000

TLS e HTTP/3

Use certificados manuais ou deixe Webship geri-los.

Webship aceita TLS 1.3. HTTP/3 corre sobre o ouvinte UDP correspondente; ative HTTP/1.1 ou HTTP/2 explicitamente quando um site TLS também necessitar de compatibilidade TCP.

listen = "0.0.0.0:443"

[automatic_tls]
enabled = true
directory_url = "https://acme-v02.api.letsencrypt.org/directory"
cache_dir = "/var/lib/webship/acme"
contacts = ["mailto:ops@example.com"]
accept_terms_of_service = true

[[sites]]
domain = "app.example.com"
root = "/srv/app"

Política de borda

Mantenha a linha de base segura intacta.

Webship ativa as suas principais camadas de proteção por defeito. Ajuste os limites para o seu fluxo de trabalho e valide após cada alteração de regra ou política de cabeçalho.

[ddos]
enabled = true
mode = "normal"
requests_per_minute = 600
burst = 100
block_seconds = 300

[security.response_headers]
enabled = true
nosniff = true
frame_deny = true
referrer_no_referrer = true
hsts = "max-age=31536000; includeSubDomains"
content_security_policy = "default-src 'self'; frame-ancestors 'none'"

Use o modo normal para tráfego regular, under_attack para um tratamento mais rigoroso de ataques ativos, e lockdown quando apenas sondagens e caminhos explicitamente permitidos devem permanecer disponíveis.

Diagnósticos privados

Inspecione a borda sem expor o plano de controlo.

Estatísticas e métricas do Prometheus correm num ouvinte autenticado separado. A instrumentação deve ser ativada sempre que qualquer um dos endpoints esteja ativo.

[observability]
instrumentation = true
stats = true
metrics = true
listen = "127.0.0.1:9090"
token = "replace-with-at-least-32-random-printable-ascii-characters"

Operações seguras

Recarregue deliberadamente. Mantenha o rollback próximo.

kill -HUP "$(pidof webship)"
/usr/local/bin/webship update --config /etc/webship/production.toml
sudo systemctl daemon-reload
sudo systemctl enable --now webship
sudo systemctl status webship

Otimização guiada por perfil

Colete perfis nativos do alvo sem confundir treino e produção.

Cada alvo Webship 1.1 tem uma CLI instrumentada separada para recolher dados de perfil LLVM nativos do alvo sob o seu tráfego representativo. Use a versão exata e o triplo do alvo, exercite as rotas e protocolos relevantes, e pare o processo de forma controlada para que possa descarregar cada ficheiro .profraw.

1. 1

   Selecione o alvo exato

   Transferir a CLI de treino PGO cuja versão de lançamento e triplo de alvo Rust correspondam exatamente ao runtime que pretende otimizar. Verificar primeiro o seu SHA-256 publicado.

2. 2

   Capturar tráfego representativo

   Defina LLVM_PROFILE_FILE para um diretório gravável, inicie a CLI de treino com uma cópia validada da configuração real, reproduza o tráfego representativo direto e através do proxy inverso, e depois pare o Webship de forma controlada.

3. 3

   Mesclar perfis brutos

   Usar llvm-profdata da compilação registrada para a versão final. Mesclar cada ficheiro .profraw emitido num único ficheiro sparse webship.profdata.

4. 4

   Reconstruir e verificar

   Aplicar o perfil mesclado apenas ao código-fonte, compilador, fornecedor de criptografia, conjunto de funcionalidades e alvo que o geraram. Executar verificações de correção e desempenho antes da promoção.

mkdir -p ./profiles
export LLVM_PROFILE_FILE="$PWD/profiles/webship-%p-%m.profraw"
./webship-pgo-training-1.2.0-<target> --config ./webship.toml

New-Item -ItemType Directory -Force ./profiles
$env:LLVM_PROFILE_FILE = "$PWD/profiles/webship-%p-%m.profraw"
.\webship-pgo-training-1.2.0-<target>.exe --config .\webship.toml

llvm-profdata merge -sparse ./profiles/*.profraw -o ./webship.profdata

Referência de linha de comando

Superfície pequena, arranque explícito.

webship [OPTIONS] | webship update [OPTIONS]

-c, --config PATH

Selecione o ficheiro TOML. Se não existir, Webship cria-o com uma identidade TLS privada para localhost.

--check-config

Valide a configuração completa e saia sem iniciar ouvintes.

--print-effective-config

Imprimir a configuração efetiva mesclada com os segredos removidos.

atualizar

Verificar o manifesto da comunidade assinado, selecionar este alvo de plataforma exato e instalar uma versão mais recente quando existir.

--help / --version

Imprimir a ajuda do comando ou a versão instalada do Webship.

Modos de falha comuns

Comece pela configuração e depois avance para o exterior.

1. Execute --check-config e corrija o primeiro erro reportado; campos TOML desconhecidos são rejeitados.
2. Confirme que as portas TCP e UDP configuradas estão disponíveis e permitidas pelo firewall.
3. Confirme que o certificado e a chave existem, são legíveis pela conta de serviço e formam um par correspondente.
4. Para TLS automático, confirme que cada domínio configurado resolve para o host Webship.
5. Chame /health no ouvinte da aplicação local antes de testar via DNS ou através de um caminho de carga externo.
6. Ativar a observabilidade autenticada temporariamente quando forem necessárias evidências em tempo de execução.