Gatus

Gatus is a lightweight, self‑hosted status and uptime dashboard written in Go that exposes a RESTful API for configuring health checks, rendering real‑time dashboards, and delivering alerts. From the developer’s perspective it functions as a health‑check orchestrator: it periodically executes HTTP, ICMP, TCP, or DNS probes against user‑defined endpoints and evaluates the responses against a rich set of conditions. The results are stored in an embedded key‑value store (BoltDB or SQLite) and can be queried via its API, enabling seamless integration with CI/CD pipelines, monitoring stacks, or custom front‑ends.

Architecture

• Language & Runtime: Pure Go (≥1.20) leveraging the standard library for networking, TLS inspection, and concurrency primitives.
• Frameworks: Minimal dependencies; uses net/http for the web server, gorilla/mux for routing, and go-metrics for internal metrics. The templating engine is the built‑in html/template.
• Data Layer: Optional persistence backends – BoltDB (default) or SQLite for larger deployments. The schema is simple: a table of endpoints, conditions, and history logs.
• Alerting: Built‑in webhook dispatcher that supports Slack, Teams, PagerDuty, Discord, Twilio, email (SMTP/SES), and many others. Each alert type is implemented as a pluggable adapter, making it trivial to add new destinations.
• Containerization: A single static binary is exposed via Docker images on GHCR and Docker Hub. The image is scratch‑based, ensuring minimal attack surface and fast startup times.

Core Capabilities

• Endpoint Types: HTTP(S) with customizable headers, ICMP ping, TCP connect, DNS resolution (A/AAAA/CNAME), and custom scripts.
• Condition Language: Declarative YAML conditions that support status codes, response time thresholds, body regex matching, certificate expiry checks, JSON/YAML path extraction, and arithmetic comparisons.
• Dynamic Placeholders: Runtime variables ({{.Host}}, {{.Port}}) that allow templated URLs and headers.
• Alerting API: Exposes a /alerts webhook endpoint; developers can send custom payloads or trigger alerts programmatically.
• Metrics Export: Prometheus‑compatible metrics (gatus_http_requests_total, gatus_response_time_seconds) for integration with existing observability stacks.
• Extensibility: The condition engine is plugin‑friendly; developers can implement custom Condition types in Go and ship them as a separate binary that Gatus loads at runtime.

Deployment & Infrastructure

Gatus is designed for self‑hosting in varied environments:

• Kubernetes: Deploy as a Deployment/StatefulSet with ConfigMap or Secret for configuration. The stateless nature of the binary means multiple replicas can share a single persistent volume for BoltDB, or each replica can maintain its own store.
• Docker Compose: Single‑container setup with volume mapping for persistence and a reverse proxy (NGINX/Traefik) to expose the dashboard.
• Bare Metal / VMs: Run as a systemd service; the binary can be downloaded from GHCR and placed in /usr/local/bin.
• Scalability: Horizontal scaling is straightforward; health checks are idempotent and can be sharded across replicas by partitioning the endpoint list in configuration.

Integration & Extensibility

• Webhook API: External services can trigger health checks or receive status updates via POST requests to /api/health. This makes Gatus a natural fit for CI pipelines that need to expose build status.
• Plugins: The alerting adapters are implemented as Go interfaces; adding a new channel involves compiling a small plugin and placing it in the plugins/ directory.
• Custom Dashboards: The built‑in dashboard is minimal; developers can consume the API and build a bespoke UI in React, Vue, or even static sites using gh-pages.
• Auth & Security: Supports HTTP Basic Auth, JWT, and integration with OAuth providers via reverse proxies. TLS termination can be handled by the front‑end proxy, keeping Gatus HTTP only.

Developer Experience

The configuration is a single YAML file (config.yml) that is fully version‑controlled. The documentation is concise, with a README that covers every field and example use cases. Community support is active; issues are triaged quickly, and pull requests for new alert adapters or condition types are routinely merged. The project’s license is MIT, allowing unrestricted use in commercial and open‑source projects.

Use Cases

• Service Status Pages: Expose a public status page for microservices or APIs, integrating with Slack/Twitter alerts.
• CI/CD Pipelines: Trigger Gatus checks after deployments to validate endpoints before opening a PR.
• Infrastructure Monitoring: Monitor critical internal services (database, cache, message broker) without adding a full‑blown monitoring stack.
• Compliance Audits: Verify TLS certificate expiry and response time SLAs programmatically.

Advantages

• Zero‑Dependencies Go Binary: Fast startup, low memory footprint, and easy binary distribution.
• Rich Condition Language: No need for external scripting; conditions are declarative and testable.
• Extensive Alerting: Built‑in adapters for most modern communication platforms reduce the need for custom webhooks.
• Open Source & MIT: No