Kubernetes on ZAPP

Deploy the ZAPP Aggregator

Mon, 01 Jan 0001 00:00:00 +0000

Deploy the ZAPP Aggregator before deploying ZAPP Listener instances.

The ZAPP Aggregator receives telemetry from listeners and exposes listener gRPC, UDP telemetry ingest, subscriber gRPC, metrics, and manifest endpoints.

ZAPP Aggregator values

Most deployments only need to review the image, replica count, ports, resources, metrics, and ServiceMonitor settings.

zappAggregator:
 enabled: true
 image:
 repository: nvcr.io/nvidia/zapp-aggregator
 tag: ""
 pullPolicy: IfNotPresent

 replicas: 1
 logLevel: info
 metricsPort: 8888
 manifestUI: true

 containerPorts:
 listenerGrpc: 9991
 udpTelemetry: 9992
 clientGrpc: 9999

 serviceMonitor:
 enabled: false
 interval: 30s

Important fields:

NVIDIA ZAPP documentation

Mon, 01 Jan 0001 00:00:00 +0000

Important

NVIDIA ZAPP Aggregation Protocol Pipeline is currently offered as a Developer Preview. The software may have limitations, may change significantly, and includes functionality that continues to be refined through testing and feedback. It should not be used in production environments except as part of an authorized collaboration.

Use this documentation to deploy and operate ZAPP telemetry infrastructure on Kubernetes.

These pages cover ZAPP concepts, components, pipeline configuration, plugins, deployment, and example listener configurations.

Redfish listener architecture

Mon, 01 Jan 0001 00:00:00 +0000

The Redfish listener example combines Redfish sensor discovery, a ZAPP Listener pipeline, and ZAPP Aggregator forwarding.

The Redfish listener discovers or collects telemetry from Redfish-enabled baseboard management controllers (BMCs) and forwards telemetry to the ZAPP Aggregator.

Main components

BMC Redfish endpoints: BMC Redfish endpoints provide sensor metadata and telemetry from managed infrastructure.
Sensor pipeline: The envPlugins.sensorPipeline configuration runs before pipeline components start. It loads or discovers sensors and populates the listener sensor manifest.
Redfish listener pipeline: The listener pipeline runs inside the zapp container. For Redfish deployments, the pipeline includes Redfish configuration and forwards telemetry to an aggregatorStreamer component.
ZAPP Aggregator: The ZAPP Aggregator receives telemetry from the listener and exposes metrics, manifest data, and subscriber gRPC access.

Data flow

The listener reads the pipeline file and expands environment and secret references.
The sensor pipeline reads envPlugins.sensorPipeline.
ZAPP discovers or loads Redfish sensors into the manifest.
Pipeline components start.
The listener forwards telemetry to the ZAPP Aggregator.
Operators inspect /metrics, /manifest, or /manifest.json to validate deployment health.

The Helm chart mounts the pipeline at /config/pipeline.yaml, mounts Redfish credential files as Kubernetes Secrets, and passes the ZAPP Aggregator address to the listener with --aggregator.

Redfish listener example

Mon, 01 Jan 0001 00:00:00 +0000

Use this example to understand, configure, monitor, and troubleshoot ZAPP telemetry collection for Redfish-enabled infrastructure.

Start with Deploy ZAPP Listeners if you already know the topology and need Helm values.

ZAPP Listener

Mon, 01 Jan 0001 00:00:00 +0000

A ZAPP Listener runs a telemetry pipeline from a YAML configuration file. A listener can receive ZAPP payloads, poll Redfish endpoints, process payload batches, forward telemetry to the ZAPP Aggregator, or expose telemetry directly to consumers.

A listener pipeline can poll BMC Redfish endpoints and expose the resulting time-series telemetry directly through a grpcServer component.

ZAPP overview

Mon, 01 Jan 0001 00:00:00 +0000

ZAPP collects telemetry from infrastructure systems and forwards it through a configurable pipeline. Many deployments include one or more ZAPP Listeners and one ZAPP Aggregator.

ZAPP Listeners collect or receive telemetry near the source. A ZAPP Aggregator receives telemetry from multiple listeners and exposes one client-facing endpoint.

ZAPP Listener

A ZAPP Listener runs a configured telemetry pipeline. Depending on the pipeline, the listener can receive telemetry packets, discover sensors, collect Redfish telemetry, process payloads, and forward telemetry to the ZAPP Aggregator or directly to downstream consumers.

Deploy ZAPP Listeners

Mon, 01 Jan 0001 00:00:00 +0000

Deploy ZAPP Listener instances after the ZAPP Aggregator is running.

For the current Redfish listener deployment, enable only the redfish listener entry and set zapp.aggregatorHost to the ZAPP Aggregator gRPC service.

Redfish listener values

Helm replaces list values as a whole. If your values file redefines zapp.listeners, include the complete Redfish listener entry, including config.pipeline.

zapp:
 enabled: true
 image:
 repository: nvcr.io/nvidia/zapp
 tag: ""
 pullPolicy: IfNotPresent

 aggregatorHost: "zapp-aggregator.<namespace>.svc.cluster.local:9991"
 metricsPort: 8888
 manifestUI: true

 listeners:
 - name: redfish
 enabled: true
 replicas: 1
 metricsPort: 8011
 config:
 pipeline: |
 metricsPort: 8011
 envPlugins:
 sensorPipeline:
 maxRedfishConnections: 1
 redfishDevices:
 - endpoint: ${secrets.redfish_endpoint}
 username: ${secrets.redfish_username}
 password: ${secrets.redfish_password}
 version: 1.11.0
 manifest:
 path: /data/redfish-sensor-manifest.yaml
 forceReload: false
 components:
 listener:
 type: udpListener
 network: udp
 address: :9091
 targets:
 - target: payloadProcessor
 cap: 1000
 leaky: true
 payloadProcessor:
 type: payloadProcessor
 timeseries:
 targets:
 - target: aggregator
 default:
 targets:
 - target: aggregator
 aggregator:
 type: aggregatorStreamer

Important fields:

DSX plugin example

Mon, 01 Jan 0001 00:00:00 +0000

Use this example to deploy a ZAPP Listener that uses DSX plugin components to collect GPU power metrics from Redfish-capable hosts.

The standard ZAPP Listener binary includes the DSX component registrations. This example configures the registered dsxMetrics component type in the listener pipeline.

Deployment pattern

Deploy the ZAPP Aggregator first. Then deploy a ZAPP Listener with a DSX pipeline.

In this pattern:

zapp.listeners defines and enables the DSX Redfish listener
dsxMetrics manages the host inventory and polls Redfish metrics
DSX_REDFISH_PROXY_ENDPOINT configures an optional deployment-wide Redfish proxy endpoint
known_sensors_file loads the chart-provided DSX sensor catalog
host_persistence_path preserves host registrations in the listener data volume
metrics_service.listen_address exposes the DSX management gRPC service inside the listener pod
aggregatorStreamer forwards time-series telemetry to the ZAPP Aggregator

Encryption Secret

The built-in DSX listener persists managed host registrations. Before you enable the listener, create a Kubernetes Secret for the persistence encryption key:

ZAPP Aggregator

Mon, 01 Jan 0001 00:00:00 +0000

The ZAPP Aggregator receives telemetry from ZAPP Listeners and exposes a stable API surface for consumers. Use it when you need centralized listener fan-in, manifest visibility, and one client endpoint for telemetry subscribers.

Helm values

Most deployments review image, replica, port, resource, and monitoring settings first.

zappAggregator:
 enabled: true
 image:
 repository: nvcr.io/nvidia/zapp-aggregator
 tag: ""
 pullPolicy: IfNotPresent

 replicas: 1
 metricsPort: 8888
 manifestUI: true

 containerPorts:
 listenerGrpc: 9991
 udpTelemetry: 9992
 clientGrpc: 9999

 serviceMonitor:
 enabled: false
 interval: 30s

Important fields:

Components

Mon, 01 Jan 0001 00:00:00 +0000

ZAPP deployments are built from two runtime components: ZAPP Listeners and the ZAPP Aggregator. Listener pipelines run near telemetry sources. The ZAPP Aggregator provides central fan-in, listener coordination, and consumer-facing APIs.

Use these pages to understand what each component runs, which configuration fields matter first, and where pipeline configuration fits into a deployment.

Configure Redfish Secrets

Mon, 01 Jan 0001 00:00:00 +0000

Redfish endpoints and credentials should come from Kubernetes Secrets. The listener reads secret files and expands ${secrets.<name>} references before it parses the pipeline YAML.

Secret keys

The default Redfish listener values use these keys:

redfish_endpoint
redfish_username
redfish_password

The pipeline references them like this:

redfishDevices:
 - endpoint: ${secrets.redfish_endpoint}
 username: ${secrets.redfish_username}
 password: ${secrets.redfish_password}

Use an existing Secret

Use existingSecret when another system manages the Secret.

zapp:
 listeners:
 - name: redfish
 secrets:
 - name: redfish-credentials
 existingSecret: redfish-credentials
 mountPath: /secrets/redfish

The Secret must contain a key named redfish-credentials. The value should be dotenv-style content:

Monitor the Redfish listener

Mon, 01 Jan 0001 00:00:00 +0000

The listener and ZAPP Aggregator expose HTTP monitoring endpoints when metricsPort is greater than 0.

HTTP endpoints

Use these endpoints for health and telemetry inspection:

Endpoint	Purpose
`/metrics`	Prometheus metrics
`/manifest`	Sensor manifest web page
`/manifest.json`	Sensor manifest JSON

On the ZAPP Aggregator, the manifest page also shows connected listeners and sensor counts.

Port-forward the ZAPP Aggregator manifest

kubectl --namespace <namespace> port-forward svc/zapp-aggregator-metrics 8888:8888

Open the manifest page:

http://localhost:8888/manifest

Request manifest JSON:

Plugins

Mon, 01 Jan 0001 00:00:00 +0000

Plugins extend the ZAPP pipeline with additional component types. Use them when built-in components do not cover a site-specific telemetry source, protocol, processor, or output.

Plugin component packages live in the ZAPP repository and are compiled into the ZAPP Listener binary. When the listener starts, those packages register their component types with the pipeline registry.

Enable a plugin component by using its registered type in the listener pipeline:

components:
 dsx:
 type: dsxMetrics
 # DSX-specific configuration omitted.
 targets:
 - target: aggregator

 aggregator:
 type: aggregatorStreamer

For Kubernetes deployments, use a ZAPP Listener image that includes the plugin component registrations you need.

Deployment

Mon, 01 Jan 0001 00:00:00 +0000

Use these pages to deploy the ZAPP Aggregator and Redfish listener chart in your own infrastructure with Helm.

Deploy the ZAPP Aggregator first. Then adapt the ZAPP Listener chart for the telemetry sources in your environment and point ZAPP Listeners at the ZAPP Aggregator listener gRPC service.

Troubleshoot the Redfish listener

Mon, 01 Jan 0001 00:00:00 +0000

Start with Kubernetes readiness, then check listener configuration, ZAPP Aggregator connectivity, Redfish access, and telemetry validation.

Use Kubernetes checks, HTTP monitoring endpoints, and zest to isolate Redfish listener deployment problems.

Check pods and releases

helm list --namespace <namespace>
kubectl get pods --namespace <namespace>
kubectl get statefulsets --namespace <namespace>

If a pod is not ready, describe it and inspect recent events:

Examples

Mon, 01 Jan 0001 00:00:00 +0000

Use these examples as concrete deployment paths for specific ZAPP Listener configurations.