VynOps
v0.3.0  ·  Open Source  ·  MIT License

VynOps — AI-Powered Kubernetes Operations Platform

Real-time visibility, intelligent incident management, and autonomous remediation — in a single open-source platform your team owns.

Built on Next.js 15 · Groq Llama-4 · Prometheus · Loki · Jaeger · Alertmanager

Get Started Free View SourcePricing
Real-time visibility
AI root cause analysis
Smart alert management
Auto remediation
SLA & on-call mgmt
Cloud & cost analytics
Multi-cluster
Secure by design
Team collaboration
Live pod exec

Features

Everything, documented

Real-Time Cluster Visibility

Live pod, node, and namespace monitoring across every connected cluster. Drill from cluster health score down to individual container metrics in two clicks. Supports multi-cluster views with per-cluster and aggregate dashboards.

  • Health scoring (0–100) based on pod restarts, resource pressure, and alert severity
  • Real-time pod status: Running, Pending, CrashLoopBackOff, OOMKilled, Evicted
  • Node resource utilisation: CPU, memory, storage per node
  • Namespace-level breakdown: workload counts, resource quotas, cost estimates
  • Live kubectl exec and log streaming via WebSocket

AI Copilot & Root Cause Analysis

Powered by Groq Llama-4-Scout-17b — the fastest available LLM inference. The AI Copilot correlates Prometheus metrics, Loki logs, Kubernetes events, and alert history to surface the most likely root cause. Bring your own Groq API key.

  • Natural language queries: "What's broken in production right now?"
  • Automatic event correlation across metrics, logs, and alerts
  • Blast radius estimation before any remediation is applied
  • Confidence scoring on all AI suggestions (0–100%)
  • Persistent incident memory — learns from past incidents over time
  • Sub-second inference via Groq ultra-fast LLM runtime (meta-llama/llama-4-scout-17b-16e-instruct)

Intelligent Alert Management

Ingests alerts from Prometheus Alertmanager via webhook. Automatically deduplicates, groups, and suppresses noise. Shows you the 3 alerts that actually need attention, not the 300 that are firing.

  • Alertmanager webhook receiver — no agent installation needed
  • Automatic deduplication and grouping by namespace, severity, and workload
  • Suppression rules: silence by label, time window, or alert name
  • Alert history and firing frequency analytics
  • Escalation to Slack with configurable routing rules

Autonomous Remediation

The AI generates step-by-step remediation plans with kubectl and Helm commands. Each plan includes a dry-run preview, blast radius estimate, and risk rating. Nothing runs without explicit confirmation.

  • Full kubectl command generation: patch, scale, delete, rollout restart
  • Helm chart upgrade suggestions with diff preview
  • Risk rating per remediation step: LOW / MEDIUM / HIGH
  • Dry-run mode: see what will change before applying
  • Full audit trail: who approved what, when, and what the outcome was
  • Rollback instructions included in every remediation plan

SLA & On-Call Management

Built-in SLA tracking with configurable thresholds and automatic escalation policies. Manage on-call rotations, schedule overrides, and escalation tiers directly in VynOps.

  • SLA definition by severity: Critical (<30 min), High (<2h), Medium (<8h), Low (<48h)
  • Automatic escalation when SLA breach is imminent
  • On-call schedule editor with rotation and override support
  • Slack integration: alert notifications, @-mentions, and escalation messages
  • SLA compliance reporting: breach rate, MTTR, MTTA by team and service

Cloud & Cost Analytics

Unified cost and infrastructure visibility across Kubernetes clusters and cloud nodes. Track compute spend, storage costs, and efficiency scores at namespace and workload level — with AI-generated optimisation recommendations.

  • Node inventory: CPU cores, memory, pod count, uptime, instance type, OS, and arch
  • Custom cost rate editor: USD/vCPU/hour, USD/GiB-hour, USD/GiB-month
  • Namespace and workload cost breakdown with efficiency scores
  • Over-provisioning detection: CPU/memory requests vs actual usage delta
  • PVC storage inventory: capacity, usage %, storage class, and per-PVC cost
  • Optimisation recommendations with kubectl right-size commands
  • Monthly cost projection and wasted spend identification

Automation Runbooks

A library of pre-built runbooks for common Kubernetes operations. Each runbook is a step-by-step automated workflow — run from the UI with a single click, with full output visibility and run history.

  • Diagnose CrashLoopBackOff: scan events, pull previous container logs, restart analysis
  • OOMKilled patch: detect OOM pods, bump memory limit +256Mi, trigger rollout restart
  • Rollback failed deployment: view revision history, execute rollback, post-health check
  • Force delete stuck Terminating pods with gracePeriodSeconds=0
  • Scale deployment replicas up or down with rollout watch
  • Cleanup evicted/failed pods to free namespace quota
  • Cordon & drain node: cordon, list evictable pods, generate drain command
  • Audit TLS certificates: decode secrets, report expiry, renewal recommendations
  • Debug ImagePullBackOff: surface pull errors, output fix commands
  • Full run history with per-step output, duration, and pass/fail status

Installation

Quick Start

From zero to running cluster in under 10 minutes.

01

Clone the repository

git clone https://github.com/vynops/VynOps cd vynops/apps/web
02

Configure your environment

cp .env.local.example .env.local # Required AUTH_SECRET=<generate: openssl rand -base64 32> NEXTAUTH_URL=http://localhost:3030 GROQ_API_KEY=<from console.groq.com — free tier available> K8S_API_URL=https://your-cluster-api-server # Optional but recommended PROMETHEUS_URL=http://prometheus:9090 ALERTMANAGER_URL=http://alertmanager:9093 LOKI_URL=http://loki:3100 SLACK_WEBHOOK_URL=https://hooks.slack.com/...
03

Install & run

npm install npm run dev # App running at http://localhost:3030 # Default login: set up via AUTH_SECRET
04

Connect your first cluster

# Add cluster via the UI dashboard, or via API: curl -X POST http://localhost:3030/api/clusters \ -H 'Content-Type: application/json' \ -d '{ "name": "production", "apiUrl": "https://your-k8s-api-server", "token": "your-service-account-token" }' # Response: {"id":"clus_1","name":"production","status":"healthy"}

Requirements

Node.js18.17.0 or later
Kubernetes clusterAny v1.24+
kubectlConfigured with cluster access
Groq API KeyFree tier — console.groq.com
PrometheusOptional but strongly recommended
LokiOptional — enables AI log correlation
JaegerOptional — distributed trace integration
PM2Optional — recommended for production

Environment Variables

Full reference for .env.local. Copy from .env.local.example to start.

VariableDescriptionRequired
AUTH_SECRETRandom 32-byte secret for NextAuth session signingrequired
NEXTAUTH_URLFull URL of your VynOps deployment (incl. port)required
GROQ_API_KEYGroq API key — free tier at console.groq.comrequired
K8S_API_URLKubernetes API server URL for default clusterrequired
K8S_TIMEOUT_MSRequest timeout for k8s API calls (default: 10000)optional
PROMETHEUS_URLPrometheus server URL for metrics queriesoptional
ALERTMANAGER_URLAlertmanager URL for alert webhook receiveroptional
LOKI_URLLoki URL for log queries (enhances AI analysis)optional
JAEGER_QUERY_URLJaeger Query URL for distributed tracingoptional
GRAFANA_URLGrafana URL for dashboard deep-link integrationoptional
SLACK_WEBHOOK_URLSlack incoming webhook for alert notificationsoptional
ALLOWED_DEV_ORIGINSComma-separated IPs for remote dev accessoptional
PORTHTTP port for the server.mjs process (default: 3030)optional

Architecture

Frontend
  • Next.js 15 App Router
  • React Server Components
  • Zustand + React Query
  • Framer Motion UI
API Layer
  • Next.js API Routes
  • NextAuth v5 session
  • Per-cluster header routing
  • Node.js WebSocket server
Integrations
  • Kubernetes API server
  • Prometheus HTTP API
  • Loki query API
  • Groq LLM inference
Multi-cluster routing

Each API call from the frontend passes X-Cluster-ID and X-Cluster-URL headers. The API layer uses these to route requests to the correct Kubernetes API server. No session-level cluster affinity — fully stateless.

WebSocket pod exec

Real-time pod log streaming and kubectl exec run through a custom Node.js server (server.mjs) that proxies WebSocket connections to the Kubernetes API. Must run via node server.mjs or PM2 — not npm start.

Tech Stack

Frontend

  • Next.js 15App Router + RSC
  • TypeScript 5.5Strict mode
  • Tailwind CSSDark-first
  • Framer MotionAnimations
  • Zustand 5State management
  • React QueryServer state

Auth & API

  • NextAuth v5AUTH_SECRET
  • Node.js server.mjsWebSocket host
  • PM2Process manager

AI & Inference

  • Groq AILLM inference
  • Llama-4-Scout-17bModel

Observability

  • PrometheusMetrics
  • LokiLogs
  • JaegerTraces
  • GrafanaDashboards
  • AlertmanagerAlert routing

Troubleshooting

ProblemSolution
Login redirects to 404 after credentialsSet NEXTAUTH_URL to the actual host:port you're accessing. Must match exactly.
All API routes return 404 after Linux deployDelete .next/ and rebuild: rm -rf .next && npm run build
AI Copilot returns "API key invalid"Use GROQ_API_KEY not OPENAI_API_KEY. Get a free key at console.groq.com
Cluster shows as "unreachable"Verify K8S_API_URL is reachable from the VynOps server. Test: curl -k $K8S_API_URL/healthz
No metrics appearing in dashboardsSet PROMETHEUS_URL to your Prometheus instance. Check /api/metrics/test endpoint.
WebSocket pod exec not workingEnsure you're running via server.mjs (node server.mjs), not npm start. npm start does not support WebSockets.
AUTH_SECRET error on startupVynOps uses NextAuth v5 — use AUTH_SECRET, not NEXTAUTH_SECRET. Generate: openssl rand -base64 32

Production Deployment

With PM2 (recommended)
npm run build NODE_ENV=production pm2 start server.mjs \ --name vynops \ --env production pm2 save && pm2 startup
With Docker
docker build -t vynops . docker run -d \ --env-file .env.local \ -p 3030:3030 \ --name vynops \ vynops
Free · Open Source · Self-hosted

Deploy in 10 minutes

No account. No cloud signup. Clone, configure, connect your cluster, and go.

Get Started View PricingTalk to us