内容
# UWAS
**Unified Web Application Server**
One binary to serve them all.
Apache + Nginx + Varnish + Caddy + cPanel → UWAS
---
<p align="center">
<img src="assets/banner.jpeg" alt="UWAS Logo" width="100%">
</p>
> **Note:** UWAS is intended for production use; verify it against your own deployment, traffic, and security requirements.
[](https://go.dev)
[](LICENSE)
## What is UWAS?
UWAS replaces your entire web server stack and hosting control panel with a single Go binary. Auto HTTPS, built-in caching, PHP support, .htaccess compatibility, reverse proxy, WebSocket forwarding, WAF, multi-user access control, and a 42-page React dashboard backed by 254 explicit admin API route registrations.
One binary. Zero hassle.
## Current Snapshot (v0.11.34)
- **Dashboard pages:** 42 (`web/dashboard/src/pages`; `settingsSections.tsx` lives there too but is section definitions, not a page)
- **Admin API routes:** 254+ explicit route registrations in `internal/admin/routes.go` under `/api/v1` plus dashboard/static handlers
- **Go packages:** 71 (`go list ./...`) — 63 under `internal/`, 2 under `pkg/`; 57 carry tests
- **CLI commands:** 19
- **Test status:** all gates pass — `go build`, `go vet`, `staticcheck`, `go test`, `go test -race`, dashboard npm build; CI runs additional `govulncheck`, shellcheck, installer tests, Docker Compose validation, and docs/site builds
- **Security/stability fixes:** v0.11.29 hardens against request floods (async logging, rate-limited redirects, cache bypass fix) and moves to Go 1.26.9 for HTTP/2 DoS fixes
- **Security posture:** risk score 2.1/10 (Low) per July 2026 reassessment
**v0.11.34 highlights:**
- PHP update / uninstall from the dashboard, API and CLI; vulnerable versions get an "Update now" action
- Evidence-audit rounds 147–151: child-process env secrets filter, monitor proxy SSRF, firewall/deploy/autoblock ownership fixes
**v0.11.33 highlights:**
- PHP php2shell RCE (CVE-2026-109618/109619): Docker images on PHP 8.3.36; dashboard flags vulnerable and EOL PHP; PHP 8.2+ only
**v0.11.29 highlights:**
- Go 1.26.9 + x/net v0.60.0: HTTP/2 DoS vulnerabilities fixed
- Logging never blocks requests (flood no longer ends in an OOM kill)
- Canonical redirects and global 429s feed rate limiting / autoblock
- Cache: client no-cache ignored, origin max-age honoured, alias purge, rule cache_control on proxies
**v0.11.28 highlights:**
- Published binaries for the v0.11.27 product changes (that tag failed lint)
- Image conversions publish atomically under concurrency
- Domain backup fails closed if the database dump fails
- Dashboard tests drop `any` so release `npm run lint` stays green
**v0.11.27 highlights:**
- WAF blocks scanner probes (`phpinfo.php`, `secrets.json`, `.bak`) when WAF is on
- Alert titles spell out 5xx spikes instead of `error_spike`
- (tag only — binaries in v0.11.28)
**v0.11.26 highlights:**
- Round-robin uses configured backend weights; circuit probes recover
- SQL explorer refuses `EXPLAIN ANALYZE`; Docker short flags stay off the allowlist
- DNS record ids are escaped; nested zones match the longest name
**v0.11.25 highlights:**
- Published binaries for the v0.11.24 changes; dashboard lockfile clears
high `brace-expansion` and `undici` advisories
**v0.11.24 highlights:**
- File Manager: page through every file (50 per page); new uploads/saves
are mode 0600
- Cache keys are length-prefixed (one miss cycle); FastCGI responses cap
at 64 MiB
**v0.11.23 highlights:**
- Deploy: listen probe 45s (was 3s) — stops false rollbacks on slow Node boots;
Telegram notifications append `hostname · IP`
**v0.11.22 highlights:**
- Apps: Environment vars keep operator save order; full-width env editor;
deploy modal auto-closes on success
**v0.11.21 highlights:**
- Deploy: clear stale `.git/*.lock`, live SSE deploy logs, 5m UI timeout;
auto-build runs install/build as separate steps (no `&&`)
**v0.11.20 highlights:**
- Firewall: hide `# uwas-autoblock` rows from the rules table; enable opens
443/udp for HTTP/3 (QUIC)
**v0.11.19 highlights:**
- Firewall: heal missing IPv4 default DENY (v6-only orphan no longer blocks restore)
**v0.11.18 highlights:**
- Firewall: ↑↓ move no longer drops the bottom DENY; empty protocol shows as
`any`; panel/API reject blank port+source allow/deny
**v0.11.17 highlights:**
- Firewall: visible rule count matches the table (IPv6 hidden noted); empty port
= any; enable places a numbered default DENY at the bottom; re-enable no
longer duplicates rules
**v0.11.16 highlights:**
- WAF body scanning covers `application/json` and `multipart/form-data`
- Firewall source IP/CIDR, allow-above-deny insert, arrow reorder
- Database user Drop; remote MySQL firewall prompt for 3306
- Deploy-key Generate on app Edit
**v0.5.0 highlights (refactor + perf + observability sweep, 43 commits):**
- TLS handshake allowlist is now lock-free (atomic pointer instead of mutex + linear scan)
- IPACL / GeoIP / CORS / WAF middleware run as predicates on the hot path (no per-request wrapper allocation)
- API-key authentication is O(1) (secondary hash index alongside the username map)
- Cache LRU promotion debounced; per-host mutex on access-log writes; ACME renewal split from cert-map iteration
- New `internal/respond` package centralizes JSON responses with operator-visible 5xx logging
- Per-handler latency histogram (`uwas_handler_duration_seconds{handler,quantile}`)
- **Behavioural change:** plaintext `api_key` fallback is now opt-in (`global.users.allow_legacy_plaintext_api_key`, default `false`). Operators upgrading from v0.4.x with a plaintext key must set the flag or migrate to hashed credentials.
## Features
### Web Server
- **Auto HTTPS** — Let's Encrypt certificates with zero configuration
- **HTTP/3 (QUIC)** — Via quic-go with Alt-Svc header advertisement
- **Built-in Cache** — Varnish-level caching with grace mode, tag-based purge, ESI (Edge Side Includes)
- **PHP Ready** — FastCGI with connection pooling and .htaccess support
- **Per-domain PHP** — Multiple PHP versions per domain with auto-port assignment, crash auto-restart
- **Load Balancer** — 6 algorithms (round-robin, least-conn, ip-hash, uri-hash, random, sticky), health checks, circuit breaker, canary routing
- **WebSocket Proxy** — Transparent TCP tunnel with hijack + bidirectional pipe
- **URL Rewrite** — Apache mod_rewrite compatible engine
- **Brotli + Gzip** — Dual compression with Accept-Encoding negotiation
- **Image Optimization** — On-the-fly WebP/AVIF conversion
### Hosting Control Panel
- **42-page Dashboard** — React 19 admin panel with dark/light theme
- **Applications** — Deploy and supervise Node.js, Python, Ruby, Go, custom, and Docker apps
- **Web Terminal** — Browser-based shell via WebSocket-to-PTY bridge
- **Multi-user Auth** — Admin, reseller, user roles with TOTP 2FA
- **WordPress Management** — One-click install, plugin updates, debug mode, error log viewer
- **DNS Zone Editor** — Full CRUD for Cloudflare, Hetzner, DigitalOcean, Route53
- **File Manager** — Browse, edit, upload, delete files via dashboard
- **SFTP Server** — Built-in pure Go SFTP with chroot per domain + SSH key management
- **Database Management** — MySQL/MariaDB + Docker containers (MariaDB/MySQL/PostgreSQL)
- **Site Migration** — SSH wizard: rsync files + dump/import database
- **Clone/Staging** — One-click domain clone with DB duplication
- **Backup/Restore** — Local, S3, SFTP providers with scheduling + webhook notifications
- **Cron Jobs** — Per-domain cron management with execution monitoring and failure alerts
### Security & Monitoring
- **WAF** — SQL injection, XSS, shell, RCE detection
- **Per-domain Rate Limiting** — Sharded token bucket per domain
- **Bandwidth Limits** — Monthly/daily caps with throttle or block action
- **Webhook Events** — 12 event types plus a `test` event, HMAC-SHA256 signed, with retry
- **Uptime Monitoring** — Per-domain health checks with alerting
- **Analytics** — Per-domain traffic, referrer tracking, user agent breakdown
- **Prometheus Metrics** — p50/p95/p99 latency percentiles
- **Audit Logging** — Track all admin actions with timestamps and IPs
- **IP Access Control** — Per-domain whitelist/blacklist
- **Resource Limits** — Per-domain CPU/memory/PID limits via Linux cgroups v2
### DevOps
- **Git Deploy** — Git clone/pull + build + health check + restart with concurrent protection, env persistence, and cancellation support
- **AI-Native** — MCP server for LLM-driven management
- **Nginx/Apache Migration** — CLI config converter
- **Hot-Reload** — All per-domain chains rebuild on SIGHUP (zero downtime)
- **Self-Update** — Binary auto-update from GitHub releases
- **CI/CD** — GitHub Actions for build, test, release automation (manual or on `v*` release tags, not on every push — see [CONTRIBUTING.md](CONTRIBUTING.md#ci))
- **Single Binary** — ~16MB, no runtime dependencies, just download and run
## Install
```bash
# One-line install (Linux / macOS)
curl -fsSL https://raw.githubusercontent.com/uwaserver/uwas/main/install.sh | sh
```
### Update
```bash
# One-line update (detects current version, downloads latest, restarts service)
curl -fsSL https://raw.githubusercontent.com/uwaserver/uwas/main/update.sh | sh
```
Or download from [GitHub Releases](https://github.com/uwaserver/uwas/releases).
> **Upgrading?** Releases that change runtime behavior are documented in
> [UPGRADING.md](UPGRADING.md). v0.8.7 (security release) tightens several
> defaults — review it before upgrading multi-user or docker-compose deployments.
### Build from Source
```bash
git clone https://github.com/uwaserver/uwas.git && cd uwas
make build # Production binary → bin/uwas
make linux # Cross-compile for Linux amd64
```
## Quick Start
```bash
# Start server (auto-creates config on first run)
uwas
# Or with a specific config
uwas serve -c uwas.yaml
# Install as systemd service (auto-start on boot)
sudo uwas install
sudo systemctl start uwas
# Dashboard
# http://127.0.0.1:9443/_uwas/dashboard/
# CLI commands (API key auto-loaded from ~/.uwas/.env)
uwas status
uwas php list
uwas domain list
uwas doctor
```
## Configuration
UWAS uses a single YAML file. See [`uwas.example.yaml`](uwas.example.yaml) for a full reference.
### Static Site
```yaml
global:
http_listen: ":80"
https_listen: ":443"
acme:
email: you@example.com
domains:
- host: example.com
root: /var/www/html
type: static
ssl:
mode: auto
```
### WordPress / PHP
```yaml
domains:
- host: blog.example.com
root: /var/www/wordpress
type: php
ssl:
mode: auto
php:
fpm_address: "unix:/var/run/php/php8.3-fpm.sock"
htaccess:
mode: import
cache:
enabled: true
ttl: 1800
```
### Standalone App + Domain Route
Apps live outside the main domain YAML. Create them from the dashboard
Applications page or as files under `/etc/uwas/apps.d/`; then route a
domain to the app by using `apps://<name>` as a proxy upstream.
```yaml
# /etc/uwas/apps.d/my-api.yaml
name: my-api
runtime: node
work_dir: /var/lib/uwas/apps/my-api
port: 0
env:
NODE_ENV: production
# uwas.yaml or domains.d/api.example.com.yaml
domains:
- host: api.example.com
type: proxy
ssl:
mode: auto
proxy:
upstreams:
- address: "apps://my-api"
```
Native runtimes with an empty workdir get a small demo file on create
(`index.js`, `app.py`, `app.rb`, or `main.go`) so the app has something
runnable immediately. Existing files are never overwritten.
### Git Deploy + Private Repos + Webhooks
Applications can be deployed from a Git repo from the dashboard or by
persisting deploy settings in the app YAML. Private repositories can use
either a HTTPS token or an SSH deploy key. If `build_cmd` is empty, UWAS
auto-detects the build step from `package.json`, `requirements.txt`,
`Gemfile`, or `go.mod`; set `build_cmd: none` to skip builds. Set
`health_path` when deploys should require a 2xx/3xx HTTP response after
the process starts.
```yaml
# /etc/uwas/apps.d/my-api.yaml
name: my-api
runtime: node
work_dir: /var/lib/uwas/apps/my-api
port: 0
env:
NODE_ENV: production
deploy:
git_url: https://github.com/acme/private-api.git
git_branch: main
health_path: /health
git_token: ghp_xxx
webhook_secret: a-long-random-secret
branch_filter: main
```
For SSH repositories:
```yaml
deploy:
git_url: git@github.com:acme/private-api.git
git_branch: main
ssh_key_path: /home/uwas/.ssh/private-api-deploy-key
webhook_secret: a-long-random-secret
```
Add a GitHub webhook pointing at:
```text
https://your-admin-host/api/v1/apps/my-api/webhook
```
Use `application/json` and the same webhook secret. GitLab can use the
same URL with `X-Gitlab-Token`. Accepted webhook pushes run clone/fetch,
auto build if needed, restart the app, verify that it is listening, and
check `health_path` when configured. If build, restart, or health
verification fails after an existing repo moved to a new commit, UWAS
resets the workdir to the previous commit and restarts the previous
version.
### Reverse Proxy with WebSocket
```yaml
domains:
- host: api.example.com
type: proxy
ssl:
mode: auto
proxy:
upstreams:
- address: "http://127.0.0.1:3000"
weight: 3
- address: "http://127.0.0.1:3001"
weight: 1
algorithm: least_conn
websocket: true
health_check:
path: /health
interval: 10s
```
### Bandwidth Limits + Rate Limiting
```yaml
domains:
- host: example.com
root: /var/www/html
type: static
bandwidth:
enabled: true
monthly_limit: 100GB
daily_limit: 5GB
action: throttle # or "block"
security:
rate_limit:
requests: 100
window: 1m
```
## Requirements
| Component | Minimum | Recommended | Notes |
|-----------|---------|-------------|-------|
| Go | 1.26.10+ | 1.26.10+ | For building from source (1.26.10 carries the `crypto/x509` GO-2026-6809 fix) |
| PHP | 8.2+ (8.2.35 / 8.3.36 / 8.4.27 / 8.5.12 or newer) | 8.4+ / 8.5+ | Only needed for PHP sites. 8.1 and older are end-of-life and unsupported; older patch releases are vulnerable to CVE-2026-109618/109619 |
| Docker | 20.10+ | 24+ | Only for Docker apps and database containers |
**No PHP needed** for static sites, reverse proxy, or redirect domains.
## CLI
```
uwas Start server (auto-setup if no config)
uwas serve -c uwas.yaml Start with specific config
uwas serve -d Start as background daemon
uwas version Print version info
uwas config validate Validate config file
uwas domain list List domains
uwas cache stats Cache statistics
uwas cache purge Purge cache
uwas status Server status via admin API
uwas reload Hot-reload configuration
uwas stop Stop running server
uwas restart Restart running server
uwas migrate nginx <file> Convert Nginx config to UWAS
uwas migrate apache <file> Convert Apache config to UWAS
uwas backup Create config backup
uwas restore Restore from backup
uwas php list List detected PHP versions
uwas php start <ver> Start PHP-FPM for version
uwas install Install as systemd service
uwas uninstall Remove systemd service
uwas user list List admin users
uwas cert list List certificates + expiry
uwas doctor System diagnostics + auto-fix
uwas help Show help
```
## Architecture
```
Request Flow:
TCP → TLS (SNI routing)
→ HTTP Parse
→ Global Middleware Chain:
Recovery → Request ID → Real IP → Security Headers → Compress
→ Rate Limit → Security Guard (blocked paths) → Bot Guard
→ Access Log
→ Virtual Host Lookup
→ Per-domain (inline in handleRequest, not middleware):
IP ACL → GeoIP → BasicAuth → CORS → Header Transform → WAF
→ Bandwidth Check (throttle/block)
→ Rewrite Engine (mod_rewrite compatible)
→ Cache Lookup (L1 memory + L2 disk)
→ Handler:
├── Static File (ETag, Range, pre-compressed, SPA)
├── FastCGI/PHP (connection pool, CGI env)
├── Reverse Proxy (6 LB algorithms, sticky, circuit breaker, gRPC)
├── WebSocket (TCP tunnel, bidirectional pipe)
└── Redirect (301/302/307/308)
→ Cache Store
→ Bandwidth Record
→ Response
```
## Project Layout
```
cmd/uwas/ → CLI entry point (19 commands)
internal/
admin/ → REST API (253 route registrations) + dashboard embed + TOTP auth
apps/ authmw/ backup/ cloudflare/ database/ deploy/ domain/ files/
php/ settings/ wordpress/ → handler sub-packages (see docs/admin-subpackaging.md)
alerting/ → Alert thresholds + webhook/Slack/Telegram/email notifications
analytics/ → Per-domain traffic analytics
apps/ → Standalone Node/Python/Ruby/Go/custom/Docker app supervision
auth/ → Multi-user RBAC (admin/reseller/user) + session + TOTP 2FA
backup/ → Local/S3/SFTP backup + restore + scheduling
bandwidth/ → Per-domain bandwidth limits (throttle/block)
build/ → Build metadata (version, commit, date) via ldflags
cache/ → L1 memory (256-shard LRU) + L2 disk cache + ESI
cli/ → CLI framework and commands
cloudflare/ → Cloudflare Tunnel API + local cloudflared process
config/ → YAML parser, validation, defaults, ByteSize/Duration types
cronjob/ → Cron job management + execution monitoring
database/ → MySQL/MariaDB management + Docker container support
deploy/ → Git clone/pull + Docker-based application deployment
dnsmanager/ → Cloudflare, Route53, Hetzner, DigitalOcean DNS CRUD
dnschecker/ → DNS record verification (A/MX/NS/TXT)
doctor/ → System diagnostics + auto-fix
domainroot/ → Filesystem root resolution for a domain (apps:// aware)
domainutil/ → Pure hostname helpers shared by admin and admin/domain
filemanager/ → Web file manager (browse/edit/upload/delete)
firewall/ → UFW management via API
handler/
fastcgi/ → PHP handler, CGI environment builder
proxy/ → Reverse proxy, load balancing, WebSocket, circuit breaker
static/ → Static files, MIME, ETag, pre-compressed, SPA
install/ → System package installer task queue
logger/ → Structured logger (slog wrapper)
mcp/ → MCP server for AI management
metrics/ → Prometheus-compatible metrics
middleware/ → Chain, recovery, rate limit, gzip, CORS, WAF, bot guard
migrate/ → Nginx/Apache converter + SSH site migration + clone
monitor/ → Uptime monitoring per domain
notify/ → Webhook, Slack, Telegram, Email (SMTP) channels
pathsafe/ → Path traversal guard (symlink-resolving containment check)
phpmanager/ → PHP detect, install, start/stop, per-domain assign
respond/ → Centralized JSON response helpers (status + hardening headers + 5xx logging)
rewrite/ → URL rewrite engine (Apache mod_rewrite compatible)
rlimit/ → Per-domain resource limits via Linux cgroups v2
router/ → Virtual host routing, request context
selfupdate/ → Binary self-update from GitHub releases
server/ → HTTP/HTTPS/HTTP3 server + request dispatch + log rotation
serverip/ → Server IP detection (interfaces + public IP)
services/ → systemd service management (start/stop/restart)
sftpserver/ → Built-in SFTP server (pure Go, chroot per domain)
siteuser/ → SFTP user management (chroot jail + SSH keys)
terminal/ → WebSocket-to-PTY bridge for browser-based shell
tls/ → TLS manager, ACME client, auto-renewal, cert expiry alerts
acme/ → RFC 8555 ACME protocol, JWS signing
webhook/ → Event-driven webhook delivery (12 events + test, HMAC, retry)
wordpress/ → WordPress install, manage, debug, permissions
pkg/
fastcgi/ → FastCGI binary protocol, connection pool
htaccess/ → .htaccess parser and converter
web/dashboard/ → React 19 SPA (42 pages, Vite + TypeScript + Tailwind)
```
## Dashboard
UWAS includes a 42-page React 19 dashboard at `/_uwas/dashboard/` with dark/light theme:
**Sites:** Dashboard, Domains, Domain Detail, Topology, Certificates, DNS Zone Editor, Cloudflare, WordPress, Clone/Staging, Migration, File Manager
**Server:** PHP, PHP Config, Applications, Software Library, Database, DB Explorer, SFTP Users, Cron Jobs, Services, Packages, IP Management, Email Guide
**Performance:** Cache, Metrics, Analytics, Logs
**Security:** Security, Firewall, Unknown Domains, Audit Log, Admin Users
**System:** Setup Wizard, Config Editor, Webhooks, Backups, Terminal, Updates, Doctor, Settings, About
**Not in the sidebar:** Domain Detail, Login
**Auth:** Login (with 2FA/TOTP support)
## Comparison
| Feature | UWAS | Nginx | Caddy | Apache | cPanel |
|---------|------|-------|-------|--------|--------|
| Single binary | Yes | No | Yes | No | No |
| Auto HTTPS | Yes | No | Yes | No | Yes |
| Built-in cache | Yes | No | No | No | No |
| PHP FastCGI | Yes | Yes | Yes | Yes | Yes |
| .htaccess support | Yes | No | No | Yes | Yes |
| Load balancer | Yes | Yes | No | No | No |
| WebSocket proxy | Yes | Yes | No | No | No |
| WAF | Yes | No | No | Mod | Yes |
| Control panel | Yes (built-in) | No | No | No | Yes |
| Multi-user auth | Yes | No | No | No | Yes |
| Webhook events | Yes | No | No | No | No |
| DNS management | 4 providers | No | No | No | Yes |
| MCP / AI-native | Yes | No | No | No | No |
| Open source | AGPL-3.0 | BSD | Apache 2.0 | Apache 2.0 | Proprietary |
## Performance
Tested with [hey](https://github.com/rakyll/hey) on AMD Ryzen 9 9950X3D:
| Scenario | Requests/sec | Avg Latency |
|----------|-------------|-------------|
| Small static file (14B) | **7,000** | 7.1ms |
| 4KB static file | **7,100** | 7.0ms |
| 100K requests @ 200 concurrent | **7,254** | 27ms |
| 404 error page | **22,000** | 2.2ms |
| Cache L1 lookup (bench) | **75,000,000** | 31ns |
| VHost routing (bench) | **70,000,000** | 35ns |
## Deployment
### Systemd
```bash
sudo cp init/uwas.service /etc/systemd/system/
sudo systemctl enable uwas
sudo systemctl start uwas
# Live config reload (zero downtime)
sudo systemctl reload uwas
```
### Docker
The image runs as a non-root `uwas` user (with `CAP_NET_BIND_SERVICE` for ports
80/443), includes a healthcheck, and ships a baked default config that the
entrypoint seeds into a writable volume on first boot — so domain additions and
config edits made from the dashboard persist across restarts.
**docker compose (recommended):** includes MariaDB + PHP-FPM sidecars.
```bash
cp .env.example .env # set UWAS_ADMIN_KEY (required for the dashboard)
docker compose up -d
```
The admin API binds `:9443` inside the container but Compose publishes it only
on host loopback (`127.0.0.1:9443`) because the default admin listener is HTTP.
For remote access, use `ssh -L 9443:127.0.0.1:9443 user@server` and open
`http://127.0.0.1:9443/_uwas/dashboard/`. Set `UWAS_ADMIN_KEY` in `.env`
(generate one with `openssl rand -hex 24`). The config lives in a named volume
(`uwas_config`); edit it from the dashboard or drop a custom
`docker/uwas.yaml` before the first boot.
**docker run (standalone):**
```bash
docker build -t uwas .
docker run -d -p 80:80 -p 443:443 -p 127.0.0.1:9443:9443 \
-e UWAS_ADMIN_KEY=your-admin-key \
-v uwas_config:/etc/uwas \
uwas
```
See [`docker-compose.yml`](docker-compose.yml) and [`docker/uwas.yaml`](docker/uwas.yaml) for the full reference.
## Migration from Nginx/Apache
```bash
# Convert existing Nginx config
uwas migrate nginx /etc/nginx/sites-enabled/example.conf > uwas.yaml
# Convert Apache config
uwas migrate apache /etc/apache2/sites-enabled/example.conf > uwas.yaml
# Or use the dashboard Migration wizard for full site transfer (files + database)
```
## Development
```bash
make dev # Build development binary
make dashboard # Build the React dashboard (required before go:embed)
make build # Production binary (includes dashboard build)
make test # Run all Go tests
make lint # Run go vet + staticcheck
make check # Pre-push gate: lint + tsc + tests
make clean # Clean build artifacts
```
> **Dashboard changes** require `npm install` in `web/dashboard/`, then
> `make dashboard` to rebuild before the Go binary picks them up.
## Monitoring (Prometheus + Grafana)
UWAS exposes a Prometheus-compatible metrics endpoint at `/api/v1/metrics`.
Scrape it with Prometheus:
```yaml
scrape_configs:
- job_name: uwas
static_configs:
- targets: ["localhost:9443"]
bearer_token: "your-admin-key"
```
A ready-made Grafana dashboard is included at
[`docs/grafana/uwas-overview.json`](docs/grafana/uwas-overview.json) — import
it via Dashboards → Import → Upload JSON. It covers request rate, cache hit
ratio, latency (p50/p95/p99), handler distribution, bandwidth, and more.
## License
UWAS is dual-licensed:
- **AGPL-3.0** for open-source and community use — [full text](LICENSE)
- **Commercial license** for enterprise and proprietary use — [uwaserver.com/enterprise](https://uwaserver.com/enterprise)
## Contributing
1. Open an issue first to discuss
2. One feature/fix per PR
3. Tests required
4. `go vet` must pass
连接信息
猜你喜欢
暂无推荐服务器