KubeDB

By AppsCode

CONTACT SALES

New to KubeDB? Please start here.

Visualize Elasticsearch Metrics with Grafana Dashboard

KubeDB exposes Elasticsearch metrics through a sidecar exporter. Once Prometheus scrapes those metrics, you can visualize them in Grafana using a pre-built KubeDB dashboard. This tutorial walks through the full setup: deploying the monitoring stack, enabling monitoring on an Elasticsearch instance, and importing the Grafana dashboard.

Before You Begin

  • You need a Kubernetes cluster with kubectl configured. If you do not already have a cluster, you can create one by using kind.

  • KubeDB must be installed in your cluster with kubedb-metrics enabled. Follow the setup guide here and make sure to include the flag below during installation:

    --set kubedb-metrics.enabled=true

    kubedb-metrics creates MetricsConfiguration objects for each database type, which Panopticon (Step 2) uses to expose metrics to Prometheus.

  • To keep monitoring resources isolated, we use a separate monitoring namespace and deploy the database in the grafana-es namespace.

    $ kubectl create ns monitoring
namespace/monitoring created

$ kubectl create ns grafana-es
namespace/grafana-es created

Note: YAML files used in this tutorial are stored in docs/examples/elasticsearch/monitoring folder in GitHub repository kubedb/docs.

Configuration

These two steps — deploying kube-prometheus-stack and installing Panopticon — are shared prerequisites for all KubeDB database monitoring guides. If you have already completed them in another guide, skip to Step 1.

Step 1: Deploy kube-prometheus-stack

kube-prometheus-stack installs Prometheus, Prometheus Operator, Alertmanager, and Grafana together. This is the recommended way to get the full monitoring stack on Kubernetes.

Add the prometheus-community Helm repo and install:

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

$ helm upgrade --install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set grafana.image.tag=7.5.5

Wait for all pods to be ready:

$ kubectl get pods -n monitoring
NAME                                                   READY   STATUS    RESTARTS   AGE
alertmanager-prometheus-kube-prometheus-alertmanager-0 2/2     Running   0          2m
prometheus-grafana-xxxx                                3/3     Running   0          2m
prometheus-kube-prometheus-operator-xxxx               1/1     Running   0          2m
prometheus-kube-prometheus-prometheus-0                2/2     Running   0          2m
prometheus-kube-state-metrics-xxxx                     1/1     Running   0          2m

Find the serviceMonitorSelector label that Prometheus uses to pick up ServiceMonitor objects. You will need this label when enabling monitoring on the Elasticsearch instance.

$ kubectl get prometheus -n monitoring -o jsonpath='{.items[0].spec.serviceMonitorSelector}'
{"matchLabels":{"release":"prometheus"}}

The label is release: prometheus.

Step 2: Install Panopticon

Panopticon is the Appscode operator that reads MetricsConfiguration objects created by kubedb-metrics and exposes them to Prometheus. It must be installed before enabling kubedb-metrics.

$ helm repo add appscode https://charts.appscode.com/stable/
$ helm repo update

$ helm upgrade --install panopticon appscode/panopticon \
  --version v2026.4.30 \
  --namespace kubeops --create-namespace \
  --set monitoring.enabled=true \
  --set monitoring.agent=prometheus.io/operator \
  --set monitoring.serviceMonitor.labels.release=prometheus \
  --set-file license=/path/to/kubedb-license.txt \
  --wait --timeout 5m0s

Verify panopticon is running:

$ kubectl get pods -n kubeops
NAME                          READY   STATUS    RESTARTS   AGE
panopticon-xxxx               1/1     Running   0          1m

Setup

Step 1: Deploy Elasticsearch with Monitoring Enabled

Below is the Elasticsearch object with monitoring configured to use Prometheus Operator.

apiVersion: kubedb.com/v1
kind: Elasticsearch
metadata:
  name: es-grafana-topo
  namespace: grafana-es
spec:
  version: "xpack-9.2.3"
  topology:
    master:
      replicas: 2
      storage:
        storageClassName: "local-path"
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi
    data:
      replicas: 3
      storage:
        storageClassName: "local-path"
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi
    ingest:
      replicas: 2
      storage:
        storageClassName: "local-path"
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 1Gi
  deletionPolicy: WipeOut
  monitor:
    agent: prometheus.io/operator
    prometheus:
      serviceMonitor:
        labels:
          release: prometheus
        interval: 10s

Here,

  • monitor.agent: prometheus.io/operator tells KubeDB to create a ServiceMonitor for this instance.
  • monitor.prometheus.serviceMonitor.labels must match the serviceMonitorSelector label of your Prometheus (release: prometheus).
  • monitor.prometheus.serviceMonitor.interval sets the scrape interval to 10 seconds.

Create the Elasticsearch instance:

$ kubectl create -f https://github.com/kubedb/docs/raw/v2026.6.19/docs/examples/elasticsearch/monitoring/coreos-prom-es.yaml
elasticsearch.kubedb.com/es-grafana-topo created

Wait for it to be Ready:

$ kubectl get elasticsearch -n grafana-es es-grafana-topo
NAME              VERSION       STATUS   AGE
es-grafana-topo   xpack-9.2.3   Ready    83m

KubeDB creates a stats service named {elasticsearch-name}-stats for the exporter:

$ kubectl get svc -n grafana-es --selector="app.kubernetes.io/instance=es-grafana-topo"
NAME                     TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)     AGE
es-grafana-topo          ClusterIP   10.43.201.71   <none>        9200/TCP    84m
es-grafana-topo-master   ClusterIP   None           <none>        9300/TCP    84m
es-grafana-topo-pods     ClusterIP   None           <none>        9200/TCP    84m
es-grafana-topo-stats    ClusterIP   10.43.18.99    <none>        56790/TCP   84m

KubeDB also creates a ServiceMonitor in the grafana-es namespace:

$ kubectl get servicemonitor -n grafana-es
NAME                    AGE
es-grafana-topo-stats   3m

Verify it carries the correct label:

$ kubectl get servicemonitor -n grafana-es es-grafana-topo-stats -o jsonpath='{.metadata.labels}'
{"release":"prometheus", ...}

Step 2: Verify Prometheus is Scraping

Port-forward the Prometheus pod:

$ kubectl port-forward -n monitoring \
  prometheus-prometheus-kube-prometheus-prometheus-0 9090
Forwarding from 127.0.0.1:9090 -> 9090
Forwarding from [::1]:9090 -> 9090

Open http://localhost:9090/targets in your browser. Look for an entry whose service label matches es-grafana-topo-stats. Its state should be UP.

If the target is missing, check that the ServiceMonitor label (release: prometheus) matches the Prometheus serviceMonitorSelector.

Prometheus Target

Step 3: Access Grafana

Port-forward the Grafana service:

$ kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80
Forwarding from 127.0.0.1:3000 -> 80

Open http://localhost:3000. The username is admin. Retrieve the auto-generated password from the secret:

$ kubectl get secret -n monitoring prometheus-grafana \
  -o jsonpath='{.data.admin-password}' | base64 -d
FieldValue
Usernameadmin
Passwordoutput of the command above

Grafana Login

After a successful login you will see the Grafana home page:

Grafana Home

Step 4: Configure Prometheus as a Data Source

If you installed Grafana via kube-prometheus-stack, Prometheus is already configured as the default data source — skip to Step 5.

For a standalone Grafana installation:

  1. Go to Connections → Data sources → Add new data source.

  2. Select Prometheus.

  3. Set the URL to your Prometheus service:

    http://prometheus-operated.monitoring.svc:9090

  4. Click Save & test. You should see Data source is working.

Step 5: Import KubeDB Elasticsearch Dashboard

The KubeDB Elasticsearch dashboards are distributed as JSON files. Each JSON file is a complete dashboard definition — panels, queries, variables, and layout — that Grafana loads in one shot. Without importing, you would have to build every panel and write every PromQL query by hand. Importing lets you skip that entirely.

Three dashboards are available. Download all three JSON files from the appscode/grafana-dashboards repository (elasticsearch/ folder):

FileDashboard
elasticsearch_summary_dashboard.jsonKubeDB / Elasticsearch / Summary
elasticsearch_pods_dashboard.jsonKubeDB / Elasticsearch / Pod
elasticsearch_databases_dashboard.jsonKubeDB / Elasticsearch / Database

Import steps (repeat for each of the three files):

  1. In Grafana, click the + icon in the left sidebar.
  2. Select Import from the menu.
  3. Click Upload JSON file and select one of the downloaded .json files.
  4. In the Prometheus dropdown that appears, select your Prometheus data source.
  5. Click Import.

The import page looks like this — click Upload dashboard JSON file to select the file:

Grafana Import Dashboard

After importing all three files, they will appear under Dashboards in the left sidebar.

Dashboard NameDescription
KubeDB / Elasticsearch / SummaryCluster health, shard status, JVM heap usage, CPU/memory/storage, network
KubeDB / Elasticsearch / PodPer-node JVM heap, GC time, thread pool queues and rejections, CPU/memory usage
KubeDB / Elasticsearch / DatabaseIndex-level indexing rate, search rate, search latency, field data cache, segment count

Step 6: Explore the Dashboard

After opening a dashboard, use the dropdown filters at the top to focus on a specific instance.

VariableApplies toWhat to select
namespaceAll dashboardsNamespace where your Elasticsearch is deployed (e.g., grafana-es)
appAll dashboardsName of your Elasticsearch instance (e.g., es-grafana-topo)
podPod, Database dashboardsA specific pod, or All for an aggregated view
indexDatabase dashboard onlyA specific index, or All

KubeDB / Elasticsearch / Summary — start here for a cluster health overview:

  • Cluster Health — green/yellow/red status, active shards, relocating shards, unassigned shards
  • Node Count — total nodes in the cluster
  • JVM Heap Used % — aggregate heap usage across all nodes
  • CPU / Memory / Storage — resource consumption vs. requests and limits
  • Network — receive and transmit bandwidth

KubeDB Elasticsearch Summary Dashboard

KubeDB / Elasticsearch / Pod — drill into a specific node:

  • JVM Heap — used vs. max heap per node
  • GC Collection Time — time spent in young/old generation GC
  • Thread Pool — queue size and rejected count per thread pool (search, index, bulk)
  • CPU / Memory — per-pod resource usage over time

KubeDB Elasticsearch Pod Dashboard

KubeDB / Elasticsearch / Database — index-level metrics:

  • Indexing Rate — documents indexed per second
  • Search Rate — queries executed per second
  • Search Latency — p50/p95/p99 query latency
  • Field Data Cache Evictions — high eviction rates indicate memory pressure
  • Segment Count — number of Lucene segments per index

KubeDB Elasticsearch Database Dashboard

## Cleaning up
# Remove the Elasticsearch instance
kubectl delete elasticsearch -n grafana-es es-grafana-topo

# Remove namespaces
kubectl delete ns grafana-es

# Uninstall monitoring stack (optional)
helm uninstall prometheus -n monitoring
helm uninstall panopticon -n kubeops
kubectl delete ns monitoring kubeops

Next Steps

What's on this Page

Search
Improve This Page