InfraEye

website

Observing the Unseen • Healing the Broken

InfraEye is an enterprise-grade, agentless observability platform designed for modern DevOps teams. It provides a unified "Command Center" for your entire infrastructure—from bare-metal Linux servers to complex Kubernetes clusters—featuring real-time telemetry, AI-driven diagnostics, and a proactive self-healing engine.

Explore Documentation • Report Bug • Request Feature

---

Vision

In an era of microservices and ephemeral infrastructure, observability shouldn't be expensive or complex. InfraEye bridges the gap between raw metrics and actionable intelligence by providing a high-fidelity, real-time cockpit that doesn't just tell you what's wrong, but helps you fix it—automatically.

Key Modules

Module	Description	status
Infrastructure Navigator	Unified view of Linux servers with real-time CPU, Mem, Disk & Network telemetry.	Production
Kubernetes 'Lens'	Advanced resource explorer for Pods, Deployments, and Events with 1-click diagnostics.	Production
Netra AI Assistant	LLM-powered infrastructure consulting and log analysis.	Beta
Self-Healing Engine	XML-defined alert rules that trigger automated SSH remediation commands.	Production
OIDC/SSO Authentication	Keycloak, Auth0, Okta, Azure AD integration for enterprise single sign-on.	Production
MCP Sidecar	Model Context Protocol integration for AI-driven cluster troubleshooting.	Experimental
SSH Terminal	Full browser-based xterm.js terminal over secure SSH tunnels.	Production
Desktop App	Native macOS (Apple Silicon)/Linux app (Wails) — SQLite-backed, single binary, no Docker required.	Beta
Infrastructure-as-Code Sync	Sync server lists and alert rules from a Git repo — non-destructive, credentials never read from Git.	Beta

---

Architecture

InfraEye uses a Distributed Bridge architecture. Instead of installing heavy agents on every node, our Go-backend establishes secure, lightweight SSH connections to gather metrics and stream logs.

graph TD
    User((DevOps Engineer)) -->|HTTPS/WSS| Web[React Frontend]
    Web -->|API/RPC| API[Go Backend]
    API -->|Port 22/SSH| DB[Target Servers]
    API -->|Port 6443/API| K8s[Kubernetes Clusters]
    API -->|JSON-RPC/SSE| MCP[MCP Sidecar]
    API -->|GORM| DB_PG[(PostgreSQL)]
    API -->|Pub/Sub| REDIS[(Redis)]
    MCP -->|Tools| K8s

---

Quick Start Deployment (Production)

InfraEye can be deployed fully containerized. We deliver automated installer scripts for both native Kubernetes (recommended) and Docker Compose. Images are pulled directly from ghcr.io/mnshchtri/infra-eye.

Option A: Kubernetes (Recommended)

This deploys InfraEye, Postgres, Redis, and the MCP sidecar into the infra-eye namespace via Kustomize. It bypasses Docker networking conflicts by using a direct NodePort.

# Ensure KUBECONFIG is set (e.g., export KUBECONFIG=/etc/rancher/k3s/k3s.yaml)
curl -fsSL https://raw.githubusercontent.com/mnshchtri/infra-eye/main/install-k8s.sh | bash

Option B: Docker Compose

If you prefer a pure Docker setup, this isolates the stack and manages the reverse proxy bindings.

curl -fsSL https://raw.githubusercontent.com/mnshchtri/infra-eye/main/install.sh | bash

Option C: Desktop App (macOS / Linux)

A fully self-contained native app — no Docker, no Postgres, no Redis. The same backend and frontend run embedded inside a Wails shell, backed by a local SQLite database. Intended for single-user local use. Currently built for macOS (Apple Silicon) and Linux (amd64).

macOS, via Homebrew:

brew tap mnshchtri/infra-eye
brew install --cask infra-eye

Or download directly from the GitHub Releases page — InfraEye-macOS-arm64.dmg or InfraEye-Linux.deb — or build it yourself:

# Requires Go 1.25+, Node.js 20+, and the Wails v2 CLI
go install github.com/wailsapp/wails/v2/cmd/wails@latest

git clone https://github.com/mnshchtri/infra-eye && cd infra-eye
make desktop-build

This builds the frontend, embeds it into the Go binary, and packages a native .dmg/.deb via Wails, landing in backend/cmd/desktop/build/bin/. On Linux, libgtk-3-dev and libwebkit2gtk-4.1-dev (or 4.0-dev on older distros) must be installed first.

The app creates its own SQLite database and a random JWT secret on first launch, stored under your OS's standard app-data directory (~/Library/Application Support/InfraEye on macOS, ~/.config/InfraEye on Linux). Kubernetes cluster management works if kubernetes-mcp-server is installed and on your PATH; Linux-server (SSH) monitoring works regardless. See documentation.md for details.

Hot Reloading (Updates & Configurations)

If you pull new updates from the GitHub repository or edit your .env configuration file, you can apply these changes instantaneously using our automated hot-reload script.

# Must be executed from the infra-eye directory
./reload.sh

This automatically fetches the latest code, evaluates updated .env credentials, forces container recreations, and sanitizes dangling Docker images to keep your server clean.

Accessing the Platform

After installation, the scripts will output the exact URL you need to access (e.g., http://<node-ip>:30080 for K8s or http://<node-ip>:8080 for Docker).

Default Login:

• Username: admin
• Password: infra123

(⚠ Change this password immediately after the first login!)

---

Developer Setup (Hybrid Mode)

For active development, we recommend running databases in Docker and the app natively.

# 1. Start core infrastructure
make infra

# 2. Install dependencies
make backend-install
make frontend-install

# 3. Run Development Servers
# Terminal 1: Backend
make backend

# Terminal 2: Frontend
make frontend

---

Upcoming Features (Roadmap)

We are constantly evolving. Here's what's currently in the pipeline:

• OIDC / SSO Integration: Support for Keycloak, Google, GitHub, Okta, and Azure AD authentication. See OIDC Integration Guide.
• Desktop App: Native macOS (Apple Silicon)/Linux build via Wails — SQLite-backed, single binary, no Docker required.
• Infrastructure-as-Code Sync: Sync your server list and alert rules directly from a Git repo — non-destructive (never touches manually-created entries), credentials never read from Git. See documentation.md.
• Terraform Bridge: Visualize and drift-detect Terraform-managed resources.
• Metric Persistence: Long-term data retention using Prometheus/VictoriaMetrics.
• Mobile Command Center: A dedicated PWA optimized for "on-call" emergency status checks.
• Dynamic Alert Builder: A visual drag-and-drop builder for "Self-Healing" conditions.

---

Contributing

We ❤️ contributions! Whether you're fixing a bug, adding a new feature, or improving documentation, your help is appreciated.

1. Fork the repository.
2. Create a feature branch (git checkout -b feature/amazing-feature).
3. Commit your changes (git commit -m 'Add amazing feature').
4. Push to the branch (git push origin feature/amazing-feature).
5. Open a Pull Request.

How you can help right now:

• Help us improve the Kubernetes Resource Explorer with more resource types (CRDs, NetworkPolicies).
• Add support for different OS collectors (BSD, Windows).
• Improve the AI Assistant's prompt engineering for better infrastructure diagnostics.

---