Configuration on ZAPP

DSX plugin

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

The DSX plugin adds pipeline components for collecting GPU and platform power metrics from Redfish-capable DSX hosts. Use it when a ZAPP Listener needs to manage a DSX host inventory, poll Redfish metric reports, and optionally emit selected Redfish metrics as ZAPP time-series telemetry.

The current ZAPP Listener binary registers the DSX component types. If you build a custom listener image, confirm that the image includes the DSX component registrations before you use these component types in a pipeline.

gRPC pipeline component

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

Use grpcServer when a listener should expose telemetry directly to consumers. The component is terminal: it accepts pipeline input and serves the ZAPP gRPC service, but it does not produce downstream pipeline targets.

components:
 grpc:
 type: grpcServer
 address: :9998

Important fields:

type must be grpcServer
address is the TCP listen address for the gRPC server

Accepted input types:

*timeseries.Model
[]*zapp.Payload

Use grpcServer for direct listener-to-consumer deployments. Use the ZAPP Aggregator consumer API when you need one endpoint that combines telemetry from multiple listeners.

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 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.

Time-series telemetry

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

ZAPP represents decoded sensor telemetry as time-series models. Operators usually interact with this model indirectly through pipeline components, the ZAPP Aggregator, and gRPC subscriptions.

A time-series model contains:

readings, which group telemetry by sensor ID
Instance readings, which represent individual samples
Window readings, which represent aggregated samples over a time interval
snapshots, which represent the latest known values for multiple sensors at one timestamp

Pipeline components use time-series models when telemetry has been decoded and associated with the sensor manifest. For example, payloadProcessor converts NVIDIA time-series payloads into *timeseries.Model values, and redfishCollector emits *timeseries.Model values from Redfish polling.

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.

Concepts

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

Use these pages to understand the telemetry concepts that ZAPP components and plugins share.

Configure the pipeline

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

The Redfish listener pipeline is embedded in the listener Helm values under zapp.listeners[].config.pipeline. The chart mounts the content at /config/pipeline.yaml.

The Redfish pipeline discovers sensors before components start, then forwards telemetry to the ZAPP Aggregator.

Sensor pipeline

Configure Redfish endpoints under envPlugins.sensorPipeline. This block runs before components start and populates the listener manifest.

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

Important fields:

Redfish listener pipeline

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

A Redfish listener pipeline uses envPlugins.sensorPipeline to discover sensor metadata and a pipeline component to emit telemetry. The direct collector pattern uses redfishCollector to poll each configured baseboard management controller (BMC) and send time-series models to downstream targets.

envPlugins:
 sensorPipeline:
 maxRedfishConnections: 1
 redfishDevices:
 - endpoint: ${secrets.redfish_endpoint}
 username: ${secrets.redfish_username}
 password: ${secrets.redfish_password}
 tls:
 insecureSkipVerify: true
 manifest:
 path: /data/redfish-sensor-manifest.yaml
 forceReload: false

components:
 redfish:
 type: redfishCollector
 timeout: 30s
 samplePeriod: 5s
 targets:
 - target: aggregator
 cap: 1000
 leaky: true

Security note

Do not use tls.insecureSkipVerify: true in production. This setting disables certificate verification for Redfish connections. Use it only for local testing or lab environments with self-signed certificates. For production deployments, configure a trusted certificate authority for the BMC endpoints and leave tls.insecureSkipVerify unset or set it to false.

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:

Pipeline components

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

A ZAPP pipeline is a YAML map of named components. Each component declares a type, component-specific fields, and optional targets. Targets connect one component output to another component input.

Components usually fit one of three roles:

Source components receive or collect telemetry
Processing components convert or route telemetry
Terminal components forward telemetry to a service, network endpoint, or consumer API

Channels

Pipeline components pass data through typed channels. Source and processing components expose outputs with targets, and downstream components receive those outputs as inputs. During startup, ZAPP creates the channels, connects each target to the named component, and validates that the receiving component accepts that input type.

UDP listener and writer

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

Use udpListener to receive ZAPP UDP payload containers. Use udpWriter to forward payload batches to another UDP endpoint.

UDP listener

udpListener is a source component. It listens on a local UDP address, decodes ZAPP packets into payload batches, and sends those batches to configured targets.

components:
 listener:
 type: udpListener
 network: udp
 address: :9091
 allowedSources:
 - 10.0.0.0/24
 targets:
 - target: payloadProcessor
 cap: 1000
 leaky: true

Important fields:

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.