In today’s multi-cloud environment, customers need a single pane of glass to visualize and monitor their storage estate across all platforms. Now, with Google Cloud NetApp Volumes (GCNV) Flex Unified with ONTAP mode enabled, customers can use NetApp Harvest to connect their storage estate to modern monitoring infrastructure.
Enterprises now run ONTAP® across multiple clouds — Google Cloud, AWS, ANF etc. — alongside on-premises clusters. Each platform has its own metrics vocabulary, and customers are forced to go to multiple dashboards to manage their storage estate.
NetApp Harvest solves this by providing a single collection and visualization layer that works the same way everywhere. This eliminates the fragmentation that comes from using a different monitoring tool in every environment.
What is NetApp Harvest?
NetApp Harvest is an open-source metrics collection engine purpose-built for all NetApp offerings like ONTAP, StorageGRID & E-series. It connects your storage infrastructure to modern observability platforms — Prometheus, Grafana, Google Cloud Monitoring, InfluxDB — plugging into your existing monitoring infrastructure. Enabling you to see every performance counter, capacity trend, and hardware health signal in real time.
Out-of-the-box Harvest provides a set of pollers, collectors, templates, exporters, an optional auto-discover daemon, and a set of ONTAP, StorageGRID, E-Series and Cisco Nexus Switch dashboards for Prometheus and Grafana.
What Harvest Collects (Metrics)
Harvest collects a wide range of ONTAP metrics categorized into:
- Performance: IOPS (read/write/other), latency (avg/min/max), throughput (MB/s) at volume, SVM, node, and aggregate levels
- Capacity: Used/available/total capacity for volumes, aggregates, SVMs; snapshot space; tiering ratios
- Hardware Health: Disk status (failed, missing), shelf health, node health, system health alerts
- Security: Anti-ransomware status, certificate validity, login events via EMS
- SnapMirror: Replication lag, transfer status, relationship health
- Network: LIF status, port utilization, NFS/CIFS/iSCSI operations per second
The full metric catalog is documented at netapp.github.io/harvest/24.08/ontap-metrics.
On GCNV, Harvest supports:
- Direct metric pushing to Google service endpoints
- Poller health monitoring
- Hot adding monitoring for new ONTAP nodes without stack restart
How Harvest enables unified real-time monitoring.
Harvest seamlessly integrates into your monitoring estate by abstracting away the hyperscaler & ONTAP version. It runs as a local collector alongside each deployment & pushes a consistent set of metrics to a central time-series database.
- Google Cloud (GCNV): Harvest → Prometheus + Grafana or OpenTelemetry Collector → Google Cloud Monitoring (Stackdriver)
- AWS (FSxN): Harvest → Prometheus + Grafana (on EKS)
- Azure (ANF): Harvest → Prometheus → Azure Managed Prometheus → Azure Monitor + Grafana
- On-premises: Harvest → Prometheus + Grafana or InfluxDB + Grafana
If your team prefers to use a cloud-native backend — Stackdriver on GCP, Azure Monitor on Azure — Harvest supports that too, through connectors like OpenTelemetry.
While typical metrics explorers may only refresh every five minutes, NetApp Harvest ensures you never rely on outdated information during critical issues by providing real-time monitoring for enterprise-grade storage.
Architecture: Modular and Simple
Harvest has a clean, modular architecture built around five components:
- Pollers are lightweight daemon processes — one per monitored cluster — that orchestrate data collection and export.
- Collectors implement the protocols needed to talk to ONTAP. Harvest ships with REST and RestPerf collectors for modern ONTAP releases, EMS collectors for event-driven alerts, and legacy ZAPI collectors for backward compatibility.
- Templates are YAML files that define exactly which metrics to collect for each object type — volumes, SVMs, aggregates, nodes, LUNs, NFS operations, and more.
- Exporters encode collected metrics and route them to your observability backend. Harvest ships with native exporters for Prometheus (pull-based), InfluxDB (push-based), and can integrate with OpenTelemetry Collectors for routing to cloud-native backends like Google Cloud Monitoring or Azure Monitor.
Authentication is straightforward: Harvest connects using a read-only ONTAP user account, so there's zero risk of accidental configuration changes.
┌──────────────────────────────────────────────────────────────┐
│ DATA SOURCES │
│ │
│ ┌──────────┐ ┌──────────────┐ ┌─────────┐ │
│ │ ONTAP │ │ StorageGRID │ │ E-Series│ │
│ └────┬─────┘ └──────┬───────┘ └────┬────┘ │
└────────┼───────────────────┼───────────────────┼─────────────┘
│ │ │
▼ ▼ ▼
┌──────────────────────────────────────────────────────────────┐
│ COLLECTORS │
│ │
│ ┌──────┐ ┌──────────┐ ┌─────┐ ┌──────────┐ │
│ │ REST │ │ RestPerf │ │ EMS │ │ ZAPI* │ │
│ └──┬───┘ └────┬─────┘ └──┬──┘ └────┬─────┘ │
└──────┼───────────┼───────────┼──────────┼───────────────────-┘
│ │ │ │
▼ ▼ ▼ ▼
┌──────────────────────────────────────────────────────────────┐
│ HARVEST POLLER │
│ (one per monitored cluster) │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ Templates (YAML) │ │
│ │ volumes · SVMs · aggregates · nodes · LUNs │ │
│ │ NFS ops · SnapMirror · disks · shelves │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ harvest.yml config │ credentials (Basic / OAuth) │
└──────────────────────┬───────────────────────────────────────┘
│
│ exposes /metrics (:2000+)
▼
┌──────────────────────────────────────────────────────────────┐
│ EXPORTERS │
│ │
│ ┌────────────────────┐ ┌────────────────────┐ │
│ │ Prometheus (pull) │ │ InfluxDB (push) │ │
│ └─────────┬──────────┘ └─────────┬──────────┘ │
└─────────────┼───────────────────────────┼────────────────────┘
│ │
▼ ▼
┌──────────────────────────┐ ┌────────────────────────────────┐
│ Prometheus :9090 │ │ InfluxDB │
│ (time-series storage) │ │ (time-series storage) │
└────────────┬─────────────┘ └──────────────┬─────────────────┘
│ │
├──────────┐ │
▼ ▼ ▼
┌────────────────┐ ┌─────────────────┐ ┌────────────────┐
│ Grafana :3000 │ │ OTEL Collector │ │ Grafana :3000 │
│ (dashboards) │ │ │ │ │ (dashboards) │
└────────────────┘ │ ▼ │ └────────────────┘
│ Google Cloud │
│ Monitoring / │
│ Azure Monitor │
└─────────────────┘
* ZAPI: legacy, for older ONTAP releases
Setting up Harvest on GCNV Flex Unified with Ontap-mode enabled.
Find the latest guide at: netapp.github.io/harvest/latest
Let’s take a look at a quick setup to hit the ground running. Harvest is container-ready and supports several deployment options. Today, I will tell you how to set up harvest natively and use Docker Compose to set up Prometheus and Grafana in one go.
Prerequisites:
- Create Flex Unified storage pool with Ontap-mode
- Install Docker Engine & Go on a Linux host.
- Enable outbound access to monitored systems (netapp.googleapis.com)
- Ensure NetApp Volumes / GCNV ONTAP APIs are reachable from the host
Step 1: Install Harvest & configure harvest.yml
git clone https://github.com/NetApp/harvest.git
cd harvest
# check the version of go required in the go.mod file
make build
bin/harvest version
Configure harvest.yml:
Add a poller to your harvest.yml with the full GCNV resource path as addr and set gcnv_ontap_mode: true. We also add an exporter for Prometheus.
Exporters:
prometheus1:
exporter: Prometheus
addr: 0.0.0.0
port_range: 2000-2030
Defaults:
exporters:
- prometheus1
Pollers:
gcnv-pool:
datacenter: <region-label>
addr: netapp.googleapis.com/v1/projects/<PROJECT>/locations/<LOCATION>/storagePools/<POOL>/ontap
gcnv_ontap_mode: true
credentials_script:
path: /opt/harvest/gcnv-token.sh
schedule: 5m
timeout: 10s
collectors:
- Rest
- KeyPerf
- Ems
exporters:
- prometheus1
Step 2: Setup Authentication
One-time requirement:
gcloud config set project <PROJECT>
gcloud auth login # or activate-service-account
gcloud auth application-default login
gcloud auth print-access-token # must work
GCNV uses Bearer token authentication. Use credentials_script to supply a token at runtime. The script must print authToken: <token> to stdout.
Sample Script (gcnv-token.sh):
#!/bin/bash
echo "authToken: $(gcloud auth print-access-token)"
Check:
chmod +x /path/to/gcnv-token.sh
/path/to/gcnv-token.sh \# must print authToken: ...
We are now ready to start Harvest!
Step 3: Start Harvest (native)
bin/harvest start
bin/harvest status
The output should look similar to this:
Datacenter | Poller | PID | PromPort | Status
-----------+---------+---------+----------+----------
DC-01 | gcnv-pool | 1280145 | 13000 | running
The logs of each poller can be found in /var/log/harvest/
With Harvest ready, it can be plugged into your existing infrastructure. For now, let’s set up prometheus and graphana through docker.
Step 4: Generate Prometheus/Grafana files (Docker only)
docker pull ghcr.io/netapp/harvest:latest
docker run --rm \
--env UID=$(id -u) --env GID=$(id -g) \
--env HARVEST_DOCKER=1 \
--entrypoint "bin/harvest" \
--volume "$(pwd):/opt/temp" \
--volume "$(pwd)/harvest.yml:/opt/harvest/harvest.yml" \
ghcr.io/netapp/harvest:latest \
generate docker full \
--output harvest-compose.yml
Check status with docker ps.
- You could also use your own preferred Kubernetes version.
Step 5: Point Prometheus at native poller
HOST_IP=$(hostname -I | awk '{print $1}')
cat > container/prometheus/harvest_targets.yml <<EOF
- targets:
- ${HOST_IP}:2000
EOF
In prom-stack.yml, under prometheus, add:
extra_hosts: - "host.docker.internal:host-gateway"Step 6: Start Prometheus + Grafana UI stack
docker compose -f prom-stack.yml up -dAnd you should now be able to see the prometheus and grafana dashboards up and running.
Verify:
Prometheus: http://<host>:9090/targets
Grafana: http://<host>:3000
In GCNV, today you can look at ONTAP dashboards for LUN, Security, SVM, Volumes, Volumes by SVM and Volume Deep Dive.
Let’s check out the volume dashboards:
ONTAP: Volume
ONTAP: Volume Deep Dive
Get started with Harvest on Google Cloud NetApp Volumes today!
Harvest is open-source under the Apache 2.0 license. You can deploy it right now! Leverage the power of NetApp Harvest, and connect your storage infrastructure to modern observability platforms today.
Follow the documentation: https://netapp.github.io/harvest/26.05/
What’s next: Take a look at one of the most exciting feature of Harvest: Harvest MCP
It transforms telemetry into an AI-accessible layer that delivers intelligent, conversational, insights into your entire NetApp data estate, with a consistent experience across all three. The result is an AI-driven, conversational interface that queries, analyzes and interprets real time.
Read about it here:
Get involved and stay connected!
- Get involved and star Harvest GitHub repository
- Join joining the communities in Discord and GitHub Discussions
- It’s a terrific way to collaborate, learn, and stay informed.