VMware vSphere and Apache Hudi Integration

Input and output integration overview

The VMware vSphere Telegraf plugin provides a means to collect metrics from VMware vCenter servers, allowing for comprehensive monitoring and management of virtual resources in a vSphere environment.

Writes metrics to Parquet files via Telegraf’s Parquet output plugin, preparing them for ingestion into Apache Hudi’s lakehouse architecture.

Integration details

VMware vSphere

This plugin connects to VMware vSphere servers to gather a variety of metrics from virtual environments, enabling efficient monitoring and management of virtual resources. It interfaces with the vSphere API to collect statistics regarding clusters, hosts, resource pools, VMs, datastores, and vSAN entities, presenting them in a format suitable for analysis and visualization. The plugin is particularly valuable for administrators who manage VMware-based infrastructures, as it helps to track system performance, resource usage, and operational issues in real-time. By aggregating data from multiple sources, the plugin empowers users with insights that facilitate informed decision-making regarding resource allocation, troubleshooting, and ensuring optimal system performance. Additionally, the support for secret-store integration allows secure handling of sensitive credentials, promoting best practices in security and compliance assessments.

Apache Hudi

This configuration leverages Telegraf’s Parquet plugin to serialize metrics into columnar Parquet files suitable for downstream ingestion by Apache Hudi. The plugin writes metrics grouped by metric name into files in a specified directory, buffering writes for efficiency and optionally rotating files on timers. It considers schema compatibility—metrics with incompatible schemas are dropped—ensuring consistency. Apache Hudi can then consume these Parquet files via tools like DeltaStreamer or Spark jobs, enabling transactional ingestion, time-travel queries, and upserts on your time series data.

Configuration

VMware vSphere

[[inputs.vsphere]]
  vcenters = [ "https://vcenter.local/sdk" ]
  username = "[email protected]"
  password = "secret"

  vm_metric_include = [
    "cpu.demand.average",
    "cpu.idle.summation",
    "cpu.latency.average",
    "cpu.readiness.average",
    "cpu.ready.summation",
    "cpu.run.summation",
    "cpu.usagemhz.average",
    "cpu.used.summation",
    "cpu.wait.summation",
    "mem.active.average",
    "mem.granted.average",
    "mem.latency.average",
    "mem.swapin.average",
    "mem.swapinRate.average",
    "mem.swapout.average",
    "mem.swapoutRate.average",
    "mem.usage.average",
    "mem.vmmemctl.average",
    "net.bytesRx.average",
    "net.bytesTx.average",
    "net.droppedRx.summation",
    "net.droppedTx.summation",
    "net.usage.average",
    "power.power.average",
    "virtualDisk.numberReadAveraged.average",
    "virtualDisk.numberWriteAveraged.average",
    "virtualDisk.read.average",
    "virtualDisk.readOIO.latest",
    "virtualDisk.throughput.usage.average",
    "virtualDisk.totalReadLatency.average",
    "virtualDisk.totalWriteLatency.average",
    "virtualDisk.write.average",
    "virtualDisk.writeOIO.latest",
    "sys.uptime.latest",
  ]

  host_metric_include = [
    "cpu.coreUtilization.average",
    "cpu.costop.summation",
    "cpu.demand.average",
    "cpu.idle.summation",
    "cpu.latency.average",
    "cpu.readiness.average",
    "cpu.ready.summation",
    "cpu.swapwait.summation",
    "cpu.usage.average",
    "cpu.usagemhz.average",
    "cpu.used.summation",
    "cpu.utilization.average",
    "cpu.wait.summation",
    "disk.deviceReadLatency.average",
    "disk.deviceWriteLatency.average",
    "disk.kernelReadLatency.average",
    "disk.kernelWriteLatency.average",
    "disk.numberReadAveraged.average",
    "disk.numberWriteAveraged.average",
    "disk.read.average",
    "disk.totalReadLatency.average",
    "disk.totalWriteLatency.average",
    "disk.write.average",
    "mem.active.average",
    "mem.latency.average",
    "mem.state.latest",
    "mem.swapin.average",
    "mem.swapinRate.average",
    "mem.swapout.average",
    "mem.swapoutRate.average",
    "mem.totalCapacity.average",
    "mem.usage.average",
    "mem.vmmemctl.average",
    "net.bytesRx.average",
    "net.bytesTx.average",
    "net.droppedRx.summation",
    "net.droppedTx.summation",
    "net.errorsRx.summation",
    "net.errorsTx.summation",
    "net.usage.average",
    "power.power.average",
    "storageAdapter.numberReadAveraged.average",
    "storageAdapter.numberWriteAveraged.average",
    "storageAdapter.read.average",
    "storageAdapter.write.average",
    "sys.uptime.latest",
  ]

  datacenter_metric_include = [] ## if omitted or empty, all metrics are collected
  datacenter_metric_exclude = [ "*" ] ## Datacenters are not collected by default.

  vsan_metric_include = [] ## if omitted or empty, all metrics are collected
  vsan_metric_exclude = [ "*" ] ## vSAN are not collected by default.

  separator = "_"
  max_query_objects = 256
  max_query_metrics = 256
  collect_concurrency = 1
  discover_concurrency = 1
  object_discovery_interval = "300s"
  timeout = "60s"
  use_int_samples = true
  custom_attribute_include = []
  custom_attribute_exclude = ["*"]
  metric_lookback = 3
  ssl_ca = "/path/to/cafile"
  ssl_cert = "/path/to/certfile"
  ssl_key = "/path/to/keyfile"
  insecure_skip_verify = false
  historical_interval = "5m"
  disconnected_servers_behavior = "error"
  use_system_proxy = true
  http_proxy_url = ""

Apache Hudi

[[outputs.parquet]]
  ## Directory to write parquet files in. If a file already exists the output
  ## will attempt to continue using the existing file.
  directory = "/var/lib/telegraf/hudi_metrics"

  ## File rotation interval (default is no rotation)
  # rotation_interval = "1h"

  ## Buffer size before writing (default is 1000 metrics)
  # buffer_size = 1000

  ## Optional: compression codec (snappy, gzip, etc.)
  # compression_codec = "snappy"

  ## When grouping metrics, each metric name goes to its own file
  ## If a metric’s schema doesn’t match the existing schema, it will be dropped

Input and output integration examples

VMware vSphere

1. Dynamic Resource Allocation: Utilize this plugin to monitor resource usage across a fleet of VMs and automatically adjust resource allocations based on performance metrics. This scenario could involve triggering scaling actions in real time based on CPU and memory usage metrics collected from the vSphere API, ensuring optimal performance and cost-efficiency.

2. Capacity Planning and Forecasting: Leverage the historical metrics gathered from vSphere to conduct capacity planning. Analyzing the trends of CPU, memory, and storage usage over time helps administrators anticipate when additional resources will be needed, avoiding outages and ensuring that the virtual infrastructure can handle growth.

3. Automated Alerting and Incident Response: Integrate this plugin with alerting tools to set up automated notifications based on the metrics gathered. For example, if the CPU usage on a host exceeds a specified threshold, it could trigger alerts and automatically initiate predefined remediation steps, such as migrating VMs to less utilized hosts.

4. Performance Benchmarking Across Clusters: Use the metrics collected to compare the performance of clusters in different vCenters. This benchmarking provides insights into which cluster configurations yield the best resource efficiency and can guide future infrastructure enhancements.

Apache Hudi

1. Transactional Lakehouse Metrics: Buffer and write Web service metrics as Parquet files for DeltaStreamer to ingest into Hudi, enabling upserts, ACID compliance, and time-travel on historical performance data.

2. Edge Device Batch Analytics: Telegraf running on IoT gateways writes metrics to Parquet locally, where periodic Spark jobs ingest them into Hudi for long-term analytics and traceability.

3. Schema-Enforced Abnormal Metric Handling: Use Parquet plugin’s strict schema-dropping behavior to prevent malformed or unexpected metric changes. Hudi ingestion then guarantees consistent schema and data quality in downstream datasets.

4. Data Platform Integration: Store Telegraf metrics as Parquet files in an S3/ADLS landing zone. Hudi’s Spark-based ingestion pipeline then loads them into a unified, queryable lakehouse with business events and logs.

Feedback

Thank you for being part of our community! If you have any general feedback or found any bugs on these pages, we welcome and encourage your input. Please submit your feedback in the InfluxDB community Slack.