What is the best self-hosted monitoring and alerting tool for a small Kubernetes cluster that is easy to set up?

For a small Kubernetes cluster, the undisputed sweet spot for a self-hosted, easy-to-set-up monitoring and alerting solution comes down to two major variations of the gold standard open-source stack.

The best choice depends on whether you prefer the absolute standard with maximum community documentation or a lower-resource, drop-in alternative.

1. The Industry Standard: kube-prometheus-stack (Prometheus + Grafana + Alertmanager)

If you want something where every single K8s engineer on the planet knows the troubleshooting steps, this is it. It is packaged as a single Helm chart that deploys Prometheus Operator, Grafana, Node Exporter, Kube-State-Metrics, and Alertmanager.

• Why it fits small clusters: It has pre-configured dashboards for CPU, memory, pod health, and cluster events right out of the box.
• Ease of setup: Deployed entirely via Helm with a single command (helm install).
• Pros: Massive community, endless tutorials, deep metrics, and native PromQL.
• Cons: Can be a bit of a memory hog if your small cluster is running on constrained edge nodes or tiny VPS instances (Prometheus consumes baseline RAM to store time-series data locally).
• Get started: Follow the installation guide via Prometheus Documentation or the chart on Artifact Hub - kube-prometheus-stack.

2. The Lightweight Alternative: VictoriaMetrics K8s Stack

If your small cluster is resource-constrained (like a small K3s cluster on a couple of Raspberry Pis or tiny cloud VMs), the VictoriaMetrics K8s Stack is a fantastic drop-in alternative to the Prometheus stack.

• Why it fits small clusters: VictoriaMetrics is engineered to use significantly less memory and CPU than Prometheus while maintaining compatibility with Prometheus metrics and Grafana dashboards.
• Ease of setup: Like Prometheus, it uses an operator-based Helm chart (victoria-metrics-k8s-stack ) that auto-configures scraping for core Kubernetes components.
• Pros: Highly optimized resource usage, smaller storage footprint, and excellent performance.
• Cons: A slightly smaller community than Prometheus, though documentation and operator patterns are mature.
• Get started: Check out the official details on VictoriaMetrics Helm Charts.

3. The Modern All-in-One: SigNoz

If you want metrics, logs, and traces unified in a single, modern UI without stitching Grafana, Prometheus, and a separate log collector together, SigNoz is an OpenTelemetry-native rising star.

• Why it fits small clusters: It provides a clean, single-pane-of-glass experience that feels closer to Datadog than a DIY Grafana setup.
• Ease of setup: Deploys smoothly via a Helm chart.
• Pros: Native OpenTelemetry support, gorgeous modern UI, lower learning curve for application troubleshooting.
• Cons: Heavier resource footprint than a bare-bones metric scraper, though efficient for what it delivers.
• Get started: Review the guide on SigNoz Documentation.

Recommendation

• Go with kube-prometheus-stack if you just want it to work and want to leverage thousands of pre-existing Grafana community dashboards.
• Go with VictoriaMetrics if your cluster resources are tightly squeezed.

To narrow this down further, let me know:

• How many nodes and what kind of hardware/RAM are you running on?
• Do you also need log aggregation bundled in, or just metrics and alerts?

For a small Kubernetes cluster where ease of setup matters, my pick is kube-prometheus-stack (Prometheus + Grafana + Alertmanager).

Why I’d choose it

• Kubernetes-native: It monitors nodes, kubelets, the API server, workloads, and cluster state using Prometheus, kube-state-metrics, and node-exporter.
• Good defaults: It comes with dashboards and preconfigured alerting rules, so you aren't starting from scratch.
• One ecosystem: Prometheus handles metrics, Grafana handles visualization, and Alertmanager handles notifications.
• Scales well: It's not overkill if your cluster grows from a few nodes to dozens.
• Huge community: Troubleshooting and examples are plentiful.

The main downside is that it is more complicated than the word "easy" might suggest. You're installing several components and Kubernetes CRDs rather than one tiny application.

My ranking for your use case

Uptime Kuma is worth considering if by "monitoring" you mostly mean "tell me when my services are down." It supports HTTP/TCP/Ping/DNS and many notification channels, with a very approachable UI. GitHub But it isn't a replacement for Prometheus when you want CPU, memory, pod health, Kubernetes resource usage, etc.

What I'd actually deploy

For a small cluster, I'd start with:

kube-prometheus-stack → Prometheus + Grafana + Alertmanager

and configure alerts for:

• Node CPU/memory/disk pressure
• Node down
• Pod crash loops
• Deployment replicas unavailable
• Persistent volume nearly full
• Kubernetes API problems
• Certificate expiration
• High CPU/memory on important workloads

Then send Alertmanager notifications to Discord, Slack, email, or another channel you already use.

If you want the absolute minimum-effort setup, I can also give you a single Helm command + a small values.yaml that gets kube-prometheus-stack running on a small cluster with persistent storage and Discord/Slack/email alerts.

For a small cluster, I'd start with:

kube-prometheus-stack → Prometheus + Grafana + Alertmanager

and configure alerts for:

• Node CPU/memory/disk pressure
• Node down
• Pod crash loops
• Deployment replicas unavailable
• Persistent volume nearly full
• Kubernetes API problems
• Certificate expiration
• High CPU/memory on important workloads

Then send Alertmanager notifications to Discord, Slack, email, or another channel you already use.

For a small self-hosted Kubernetes cluster where ease of setup matters most, I’d pick Netdata.

My recommendation: Netdata

Netdata is particularly good if you want to install something and immediately get useful dashboards and alerts rather than assembling a monitoring stack.

• Very easy Kubernetes deployment: its Helm chart installs the monitoring components and automatically discovers nodes, pods, containers, and services.
• Low configuration: you get CPU, memory, disk, network, Kubernetes/container metrics and preconfigured health alerts without first designing a Prometheus/Grafana setup.
• Real-time visibility: Netdata collects at per-second resolution, which is useful for catching short-lived CPU, memory, or network problems.
• Self-hostable: the Netdata Agent is open source, and its Kubernetes deployment can run on your cluster.
• Small-cluster friendly: Netdata's current documentation describes Kubernetes setup as roughly 5–10 minutes.

The alternative I'd choose for a "serious" Kubernetes setup

Prometheus + Grafana + Alertmanager, usually via the kube-prometheus-stack Helm chart.

It's the better long-term choice if you want maximum flexibility and the Kubernetes ecosystem standard. You get PromQL, enormous exporter/dashboard support, Kubernetes service discovery, and very customizable alerting. Grafana can also work directly with Prometheus and Alertmanager for alert management.

The downside is that you're really operating several components rather than one monitoring product. The Prometheus Operator makes this considerably easier, but it is still more maintenance than Netdata.

Quick comparison

| Netdata | Prometheus + Grafana --- | --- | --- Setup difficulty | ⭐ Very easy | ⭐⭐⭐ Moderate Useful dashboards immediately | Excellent | Good Prebuilt alerts | Excellent | Good Kubernetes ecosystem | Good | Excellent Custom metrics/PromQL | Good | Excellent Resource footprint | Lower | Higher Long-term flexibility | Good | Excellent Best for | Small clusters, homelabs, simple ops | Production/platform teams

Bottom line: For a 1–10 node cluster and "I want monitoring working tonight," use Netdata. For a cluster you're expecting to grow substantially or where you'll eventually build custom SLOs, application metrics, and sophisticated alerting, start with kube-prometheus-stack instead.

If you tell me roughly how many nodes/pods you have and whether it's k3s, EKS, GKE, AKS, or vanilla Kubernetes, I can give you a minimal Helm installation and recommended alerts.

For a small Kubernetes cluster, the absolute best self-hosted, easy-to-set-up monitoring and alerting solution comes down to a clear industry standard or a lighter, modern alternative depending on your exact resource constraints.

1. The Undisputed Standard: kube-prometheus-stack (Helm)

• What it is: A comprehensive community Helm chart that deploys Prometheus, Grafana, Alertmanager, Node Exporter, and kube-state-metrics all at once.
• Why it’s great for small clusters: It is the de facto standard for Kubernetes. Almost every cloud-native tool natively exposes Prometheus metrics, meaning everything in your cluster will "just work" out of the box with zero custom configuration. It includes pre-built Grafana dashboards for cluster and pod health, plus Alertmanager for robust routing.
• The Catch: Standard Prometheus stores metrics in RAM/local disk and can be a bit heavy on memory if your cluster is severely resource-constrained (e.g., a tiny single-node edge or Raspberry Pi cluster).
• Ease of setup: Very high via Helm (helm install monitoring prometheus-community/kube-prometheus-stack).

2. The Resource-Efficient Alternative: victoria-metrics-k8s-stack

• What it is: A drop-in alternative to the Prometheus stack that uses VictoriaMetrics (vmagent and VictoriaMetrics single-node) instead of Prometheus.
• Why it’s great for small clusters: It uses 7x–10x less storage space and significantly less memory than Prometheus while remaining 100% compatible with Grafana and standard Prometheus scrapers (ServiceMonitors ). If your small cluster runs on limited VPS nodes or constraint hardware, this prevents monitoring from eating up all your overhead.
• Ease of setup: Just as easy as the Prometheus stack via its official VictoriaMetrics Helm Charts repository.

3. The Modern All-in-One UI: SigNoz

• What it is: An open-source, OpenTelemetry-native application observability platform that packages metrics, logs, and traces into a single sleek UI.
• Why it’s great for small clusters: If you want a modern, unified interface without stitching together Prometheus for metrics and Loki/EFK for logs, SigNoz provides an intuitive single-pane-of-glass experience with straightforward alerting out of the box.
• The Catch: It doesn't have quite the same massive legacy ecosystem of pre-tuned Kubernetes component alerts as Prometheus, but it's vastly easier on the eyes.

Recommendation Summary

• Go with kube-prometheus-stack if you want the safest, most documented path where every third-party app you deploy will have built-in monitoring support.
• Go with victoria-metrics-k8s-stack if your small cluster has tight RAM/CPU limits and you want lower resource consumption.

If you'd like, let me know:

• Your approximate node count and available RAM per node
• Whether you also need log aggregation alongside metrics and alerting

I can provide the exact Helm values or installation commands tailored to your environment.

For a small Kubernetes cluster, my pick is Prometheus + Grafana via kube-prometheus-stack. It gives you the best balance of easy setup, Kubernetes-native monitoring, useful dashboards, and real alerting.

Why I’d choose it

• One Helm install gets you Prometheus, Grafana, Alertmanager, node-exporter, kube-state-metrics, dashboards, and a set of useful alert rules.
• It understands Kubernetes resources directly—nodes, pods, deployments, containers, etc.
• Alertmanager handles notifications and alert routing rather than making you build that yourself.
• Grafana gives you ready-made Kubernetes dashboards.
• It's the ecosystem you're least likely to outgrow if your "small cluster" becomes a medium one.

A basic installation is roughly:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install monitoring prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace

Then expose Grafana through an Ingress, Gateway, or temporary kubectl port-forward.

What about Uptime Kuma?

github.com is even easier if your main concern is simply "tell me when my services are down." It supports HTTP/TCP/Ping/DNS checks and many notification services.

But I wouldn't use it instead of Prometheus for Kubernetes infrastructure monitoring. Uptime Kuma answers:

"Is my application reachable?" Prometheus/Grafana answers:

"Why is my application broken, which pod/node is responsible, and are resources running out?"

My recommendation

For a small cluster, I'd start with kube-prometheus-stack alone and only add Uptime Kuma if you specifically want external-style uptime checks/status pages.

If you tell me whether you're running k3s, Talos, EKS, GKE, MicroK8s, or vanilla Kubernetes, I can give you a minimal production-ready Helm configuration that keeps the resource usage low.

For a small Kubernetes cluster, the undisputed sweet spot for a self-hosted, easy-to-set-up, and comprehensive monitoring and alerting tool comes down to a choice between the industry standard or a modern all-in-one alternative.

The top recommendations tailored for a small footprint and straightforward installation include:

- **Why it’s great:** Grafana has heavily streamlined its native Kubernetes monitoring approach. Instead of manually stitching together disparate operators, Grafana provides an official, opinionated Helm Chart for Kubernetes Monitoring that deploys a streamlined telemetry pipeline (using Grafana Alloy) directly connecting your cluster metrics, logs, and pre-built dashboards with minimal friction.
- **Pros:** Gorgeous out-of-the-box dashboards, unified alerting (via Grafana Alerting), and a much cleaner configuration experience than traditional multi-component stacks.
- **Cons:** Still leans on Grafana's ecosystem for visualization, though it can run entirely self-hosted.[](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/) [[1]](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/)

- **Why it’s great:** This is the de-facto open-source standard for Kubernetes. While assembling it piece-by-piece is tedious, the community-maintained `kube-prometheus-stack` Helm chart bundles Prometheus, Grafana, Alertmanager, Node Exporter, and kube-state-metrics into a single command.
- **Pros:** Massive community, hundreds of pre-configured alerts for K8s components (pod crash loops, node pressure, high CPU), and every cloud-native tool natively exports Prometheus metrics.
- **Cons:** Can be resource-heavy (memory usage scales with active time-series data) and configuration tuning requires learning PromQL and Alertmanager syntax.[](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/) [[1]](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/)[[2]](https://devopsboys.com/blog/prometheus-vs-victoria-metrics-comparison-2026)[[3]](https://www.dash0.com/comparisons/best-kubernetes-monitoring-tools)

- **Why it’s great:** SigNoz is an open-source, OTel-native (OpenTelemetry) APM and monitoring tool that positions itself as a self-hosted alternative to Datadog. It provides a single, unified UI for metrics, traces, and logs.
- **Pros:** Much more modern and cohesive user interface than Prometheus/Grafana; remarkably straightforward to install via Helm with fewer moving parts to cross-configure.
- **Cons:** Smaller community ecosystem than Prometheus, meaning fewer hyper-specific edge-case dashboards out of the box.[](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/) [[1]](https://www.reddit.com/r/kubernetes/comments/1jdc0k9/which_free_kubernetes_monitoring_stack_would_you/)

Recommendation Summary

• Go with Grafana Kubernetes Monitoring if you want the smoothest modern setup experience with incredible visualization and built-in alerts.
• Go with kube-prometheus-stack if you want the absolute standard that every Kubernetes engineer knows how to troubleshoot.

To help narrow down the best fit, tell me:

• What is your cluster size (how many nodes/pods)?
• Are you looking for metrics and alerts only , or do you also need log aggregation and tracing?

For a small Kubernetes cluster, the undisputed community standard for self-hosted monitoring and alerting that remains surprisingly straightforward to deploy is the kube-prometheus-stack Helm chart.

However, depending on how lightweight you want your footprint to be, a couple of top-tier options stand out for small setups:

1. The Gold Standard: kube-prometheus-stack (Prometheus + Grafana + Alertmanager)

• What it is: The all-in-one bundle maintained by the Prometheus community. It deploys Prometheus (for metrics collection), Grafana (for visualization), Alertmanager (for routing alerts), and kube-state-metrics along with node-exporters.
• Why it’s easy: You don’t wire pieces together manually. A single Helm install gets you comprehensive, pre-built Grafana dashboards tracking CPU, memory, pod restarts, and cluster health immediately.
• The Catch: It can feel a bit "heavy" resource-wise if your cluster is running on minimal edge hardware or a tiny single-node k3s setup, consuming roughly 500MB–1GB of RAM out of the box.
• Get Started: Review the configuration options on the kube-prometheus-stack Helm Chart documentation.

2. The Lightweight Alternative: VictoriaMetrics Stack (victoria-metrics-k8s-stack)

• What it is: A drop-in replacement for the Prometheus stack that uses VictoriaMetrics as the time-series database backend.
• Why it’s easy: It uses a very similar Helm-based deployment (victoria-metrics-k8s-stack ) giving you Grafana and alerting out of the box, but it is architected to use significantly less CPU and memory.
• The Catch: PromQL is mostly supported, but troubleshooting weird edge-case metrics queries might occasionally require checking VictoriaMetrics-specific documentation instead of pure Prometheus docs.
• Get Started: Check out the deployment steps via the VictoriaMetrics K8s Stack Helm Chart.

3. The Minimalist Agent: Netdata

• What it is: A real-time, highly visual monitoring agent that installs via a single Helm chart as a DaemonSet.
• Why it’s easy: It collects metrics at 1-second resolution (as opposed to Prometheus's default 60-second intervals) and requires almost zero configuration to give you an exhaustive, gorgeous out-of-the-box UI for your cluster nodes and containers.
• The Catch: It shifts away from the standard PromQL/Grafana ecosystem, which is fine for a small cluster, but less transferable if you are looking to learn enterprise Kubernetes observability standards.
• Get Started: Explore the installation workflow on the Netdata Kubernetes Monitoring Guide.

To help narrow down the ideal choice for your exact setup, tell me:

• What is the approximate size/resource capacity of your cluster (e.g., single Raspberry Pi, a couple of VPS nodes)?
• Do you already have a preference for Grafana dashboards?

For a small Kubernetes cluster where ease of setup matters most, I’d pick Netdata. If you want the more standard, extensible Kubernetes monitoring stack, pick kube-prometheus-stack.

My recommendation: Netdata

Netdata is unusually easy to get running on Kubernetes. Its Helm chart deploys a parent plus node-level collectors, automatically gathers Kubernetes/node/container metrics, and includes built-in alerting.

Why I’d choose it for a small cluster:

• Very little configuration — install the Helm chart and you immediately get Kubernetes dashboards and metrics.
• Built-in alerts — hundreds of preconfigured alerts are available, with integrations such as email, Slack, Discord, PagerDuty, and Teams.
• Excellent out-of-the-box visibility — nodes, pods, containers, control-plane components, resource usage, OOMs, etc.
• No need to learn PromQL just to answer basic questions.
• It can run with local agents/parents, so you aren't required to send your monitoring data to a third-party SaaS.

The basic Kubernetes installation is essentially:

helm repo add netdata https://netdata.github.io/helmchart/
helm repo update
helm install netdata netdata/netdata

Netdata currently recommends its Kubernetes Helm deployment for full Kubernetes observability.

The alternative: kube-prometheus-stack

If you're comfortable with a little more complexity, kube-prometheus-stack is what I'd choose for a cluster that you expect to grow.

It bundles Prometheus + Grafana + Alertmanager + node-exporter + kube-state-metrics + Prometheus Operator, with prebuilt dashboards and alert rules.

Its big advantages are:

• Massive Kubernetes ecosystem
• PromQL for sophisticated queries
• Extremely customizable alerts
• Grafana dashboards
• Excellent integration with other infrastructure
• Skills transfer directly to many production environments

The downside is that you're managing several components and eventually need to understand concepts like ServiceMonitor, PrometheusRule, PromQL, retention, and storage.

Quick comparison

| Netdata | kube-prometheus-stack --- | --- | --- Setup | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ Out-of-box dashboards | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ Out-of-box alerting | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ Customization | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ Learning curve | Low | Medium/high Resource footprint | Low/moderate | Moderate Kubernetes ecosystem | Good | Excellent Best for | Small/easy clusters | Long-term/advanced monitoring

Bottom line: For a 1–10 node homelab, development cluster, or small production Kubernetes deployment, I'd start with Netdata. If you're deliberately building monitoring skills or expect sophisticated application-level metrics and alerting, go straight to kube-prometheus-stack.

If you tell me roughly how many nodes/pods you have and whether this is homelab or production, I can give you a minimal setup (including persistent storage and Slack/email alerts) without unnecessary observability components.

For a small Kubernetes cluster where ease of setup matters, I’d pick Prometheus + Grafana via the kube-prometheus-stack Helm chart.

It’s not the absolute simplest monitoring tool, but it’s the best balance of easy deployment, Kubernetes awareness, alerting, dashboards, and room to grow. The chart bundles Prometheus, Alertmanager, Grafana, kube-state-metrics, and node-exporter, so you don't have to assemble the pieces yourself.

My ranking

1. Prometheus + Grafana (kube-prometheus-stack) — best overall

• Kubernetes-native
• Excellent cluster/node/pod metrics
• Alertmanager handles notifications
• Huge ecosystem of dashboards and exporters
• Easy enough to install with Helm
• More complexity than the alternatives, but you're unlikely to outgrow it

2. Netdata — easiest

• Extremely quick to get useful dashboards
• Automatic metric collection and service discovery
• Built-in alerting
• Much less configuration than Prometheus/Grafana
• Better if your priority is "I want to see what's happening right now" rather than building a sophisticated Kubernetes monitoring system.

3. Uptime Kuma — excellent companion, not a replacement

• Fantastic for "is this service reachable?" monitoring
• Very easy to deploy
• Lots of notification integrations
• Doesn't give you the detailed Kubernetes resource metrics you'd want for diagnosing problems.

What I'd actually deploy

For a small cluster, I'd start with:

kube-prometheus-stack → Prometheus + Grafana + Alertmanager

Then configure alerts for things like:

• Node CPU/memory pressure
• Nodes becoming unavailable
• Pods stuck pending
• CrashLoopBackOff
• Deployment replicas unavailable
• Persistent volumes filling up
• High CPU/memory utilization
• Certificate expiration
• Kubernetes API/server problems

You can get a surprisingly capable setup with essentially one Helm installation and a small values file.

If your cluster is really tiny (e.g. 1–3 nodes and a handful of workloads) and you care more about minimal operational overhead than Kubernetes-native metrics, I'd choose Netdata instead. Current comparisons consistently put it ahead on time-to-first-dashboard and simplicity, while Prometheus/Grafana wins on flexibility and long-term Kubernetes monitoring.

Bottom line: 👉 Best overall: kube-prometheus-stack 👉 Easiest: Netdata 👉 Best simple uptime companion: Uptime Kuma

If you tell me roughly how many nodes/Pods you have and whether this is homelab or production, I can recommend a very lightweight setup and give you the exact Helm commands and values I'd use.

For a small Kubernetes cluster, the definition of "easy to set up" usually depends on whether you prefer an industry-standard ecosystem with a bit of configuration weight or a modern all-in-one unified UI that abstracts the complexity.

The top options that balance self-hosting, low footprint, and relative ease of setup include:

• kube-prometheus-stack (The De Facto Standard)
  • What it is: A community Helm chart that bundles Prometheus, Grafana, Alertmanager, node-exporter , and kube-state-metrics.
  • Why it's great: It is the standard for a reason. With a single helm install , you get deep cluster metrics, out-of-the-box alerting rules for K8s health, and thousands of pre-built Grafana dashboards.
  • The Catch: While installation is a one-liner, configuring Alertmanager or navigating Grafana's alerting layout has a steeper learning curve.
• SigNoz (The Modern All-in-One Alternative)
  • What it is: An open-source, self-hosted APM and observability platform designed as an alternative to Datadog. It natively supports metrics, traces, and logs using OpenTelemetry.
  • Why it's great: It provides a unified, modern user interface for both metrics and alerting out-of-the-box, meaning you don't have to stitch together Prometheus, Alertmanager, and Grafana manually. Deployment via their Helm chart is clean and straightforward.
  • The Catch: It consumes slightly more unified resources than a stripped-down Prometheus, and advanced custom metric queries don't have quite as massive an ecosystem of documentation as PromQL.
• Grafana Kubernetes Monitoring Helm Chart
  • What it is: Grafana's streamlined integration approach (using Alloy/Agent behind the scenes) designed to bypass the traditional multi-container headaches.
  • Why it's great: It points your cluster data directly into a cohesive, simplified Kubernetes monitoring view inside Grafana without forcing you to manually map every single recording rule and dashboard mixin.
  • The Catch: Relies heavily on Grafana's cloud-connected or unified agent approach, which may feel less modular if you just want raw Prometheus access.

Recommendation Summary

If you want maximum community support and zero abstraction , go with the kube-prometheus-stack Helm chart. If you want a clean, single-pane-of-glass UI for alerts and metrics without dealing with legacy-feeling Alertmanager configurations, deploy SigNoz.

To help narrow down the best fit, tell me:

• Do you also need log aggregation (Loki/Elastic) or just metrics and alerts?
• Where is the cluster hosted (e.g., local k3s, bare-metal, small cloud VPS)?