Monitoring Kubernetes clusters isn’t just about collecting metrics; it’s about making insights accessible to the entire team. While traditional dashboards cater to individual engineers, organizations often need a Digital Wall: a large-screen, real-time monitoring display that keeps DevOps and SRE teams aligned.
With Prometheus, Grafana, and Skedler, you can build a visually appealing, automated, and shareable monitoring wall that keeps everyone informed.
Why a Digital Wall?
A digital wall is essentially a live visual dashboard projected on a big screen or accessible via a link, showing key metrics in real-time. It serves as
- A command center for your Kubernetes environment
- With a proactive monitoring tool issues are visible instantly
- A collaboration aid for DevOps, SRE, and application teams
Real-World Use Cases for a Digital Wall
- DevOps team 24/7 live monitoring
- Management dashboards showing KPIs
- Alerting and compliance reporting
- Infrastructure trend analysis and capacity planning
Common Challenges in Building a Digital Wall
Even with the right idea in mind, building a digital wall for Kubernetes monitoring comes with its own hurdles:
- Information Overload: Too many metrics make the dashboard unreadable.
- Data Source Fragmentation: Pulling metrics from multiple systems is complex.
- Performance Bottlenecks: Large clusters with high scrape frequency can slow dashboards.
- Downtime Risk: A digital wall is useless if the monitoring stack isn’t highly available.
- Lack of Automated Reports: Grafana OSS doesn’t send scheduled PDFs or Excel files.
- Visual Clarity: Small fonts and cluttered layouts make data hard to read from a distance.
- Security Concerns: Public dashboards risk exposing sensitive data.
- Alert Gaps: Relying only on visuals means issues might be missed if no one is watching.
Get Started with Skedler for
Automated Kubernetes Monitoring
Get Started Today
The Ideal Stack: Prometheus + Grafana + Skedler (PGS Stack)
Prometheus – Metrics Collection & Storage
Prometheus is the backbone of this stack, responsible for:
- Scraping metrics from Kubernetes and applications
- Storing them in a high-performance time-series database
- Powering alerts via Alertmanager
Grafana – Powerful Visualization Layer
Grafana turns Prometheus metrics into actionable insights by providing:
- Interactive dashboards with real-time updates
- Custom visualizations tailored for different teams or stakeholders
- Unified views that can combine data from Prometheus, MySQL, and other sources
Skedler – Automated Reporting for Grafana
While Grafana OSS is excellent for live dashboards, it lacks built-in reporting.
Skedler fills this gap with:
- Scheduled reports in PDF, Excel, or HTML formats
- No coding required for report setup
- Role-based access control to ensure the right people get the right data
- Audit-ready reports to meet compliance requirements
Kubernetes Monitoring Architecture with Prometheus, Grafana, and Skedler (PGS)
Why choose the above stack, and how does it solve the earlier problems?
This stack, often called the PGS Stack, is purpose-built to address the common challenges:
| Challenge | How the PGS Stack Solves It |
| Information Overload | Grafana lets you create role-based dashboards, showing each team only what’s relevant. |
| Data Source Fragmentation | Grafana supports multiple data sources (Prometheus, MySQL, Elasticsearch, Zabbix) in a single view. |
| Performance Bottlenecks | Prometheus recording rules precompute heavy queries for faster dashboard loads. |
| Downtime Risk | Kubernetes runs Prometheus and Grafana in HA mode for 24/7 uptime. |
| Lack of Automated Reports | Skedler adds scheduled PDF, Excel, or HTML reports with no coding. |
| Visual Clarity | Grafana’s kiosk mode, large panels, and dark mode improve readability. |
| Security Concerns | Grafana’s RBAC ensures only the right users see sensitive data. |
| Alert Gaps | Prometheus Alertmanager triggers alerts via email, Slack, PagerDuty, etc., in addition to the wall display. |
Step 1: Deploy Prometheus & Grafana in Kubernetes
The easiest way to deploy Prometheus and Grafana together is using the kube-prometheus-stack Helm chart:
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack
This installs:
- Prometheus (metrics collection)
- Grafana (visualization)
- Node Exporter (node-level metrics)
- kube-state-metrics (Kubernetes object metrics)
- Alertmanager (alerting)
Step 2: Access Grafana
Once the installation is complete:
- Port-forward the Grafana service:
kubectl port-forward svc/prometheus-grafana 3000:80
- Get the admin password:
kubectl get secret prometheus-grafana -o jsonpath="{.data.admin-password}" | base64 --decode- Log in at http://localhost:3000 (username: admin).
- Navigate to the Dashboards section in Grafana. You’ll find a list of predefined Kubernetes dashboards automatically provisioned by the kube-prometheus-stack, such as:
- Kubernetes / Compute Resources / Cluster
- Kubernetes / Compute Resources / Node (Pods)
- Kubernetes / Compute Resources / Workload
- Kubernetes / Networking / Cluster
- Kubernetes / Compute Resources / Cluster
These dashboards are ready to use and provide an instant view of cluster health, node performance, and workload status.
Step 3: Install the Google Guestbook App in Kubernetes (Optional)
For this example, we’ll install Guestbook, one of the most popular Kubernetes apps, and then monitor its CPU usage in Grafana. To demonstrate multi-tier workload monitoring, let’s deploy the Google Guestbook app, which includes:
- A frontend web interface (PHP-based)
- A Redis master for writes
- Redis replicas for reads
You can easily deploy all components with a single manifest:
kubectl create -f https://raw.githubusercontent.com/kubernetes/examples/master/guestbook/all-in-one/guestbook-all-in-one.yaml
You can verify that the pod is running:
kubectl get pods
Step 4: Monitor the App’s CPU Usage in Grafana
- In Grafana, choose the dashboard Kubernetes / Compute Resources / Pod.
- Filter by Namespace and select default (or the namespace where Guestbook is running).
- Filter by Pod Name and choose the appropriate pod.
You’ll now see:
- CPU usage (in cores)
- Memory consumption
- Pod restarts and status
Step 5: Add Skedler for Automated Reporting
A digital wall is great for real-time monitoring, but stakeholders may also want automated daily/weekly reports. That’s where Skedler comes in.
Install Skedler (Docker method):
sudo docker pull skedler/reports
sudo docker run --name skedler-xg -t -d -v skedlerdata:/var/lib/skedler-xg -p 0.0.0.0:3005:3005 skedler/reports /bin/bash
Connect Skedler to Grafana:
- Log in to Skedler
- Add Grafana as a data source
- Select the Kubernetes dashboard
- Schedule reports in PDF, PNG, or Excel formats
Step 6: Set Up the Digital Wall Display
- Create a dedicated Grafana dashboard view without sidebars
- Group the most critical panels:
- Node CPU & Memory usage
- Pod restarts
- Cluster-wide network traffic
- App CPU usage
- Node CPU & Memory usage
- Mount the display in your NOC room or enable public read-only sharing for your team.
Final Thoughts
A Digital Wall for Kubernetes transforms how teams monitor their clusters. With Prometheus and Grafana deployed in a single Helm installation, Guestbook as an example workload, and Skedler for automated reports, you get both real-time insights and scheduled summaries.
It’s not just about monitoring; it’s about empowering your team to act before problems escalate.
