Academy/VCAP — VCF Operations (3V0-22.25)
VCF

VCAP — VCF Operations (3V0-22.25)

VCF 9.0vcap-advanced

VCAP-level operations architecture, advanced monitoring dashboards, super metrics & custom groups, alert policies & automated remediation, capacity planning & rightsizing, API-driven extensibility, and multi-cloud observability for unified VMware Cloud Foundation fleet management.

3V0-22.25
VCAP
60
Questions
135m
Duration
300 (scaled score; Broadcom publishes no percentage or ceiling)
Pass Score
32
Objectives

Exam Blueprint Weights

Section titles, groupings and weights below are VCDX Academy study groupings, NOT the official Broadcom blueprint structure. Broadcom publishes no section weights. Always cross-check the official exam guide. Official exam guide ↗
Section 1 — Architecture
~15%
Section 2 — Capacity Management
~20%
Section 3 — Performance Analysis
~20%
Section 4 — Automation and Remediation
~20%
Section 5 — Custom Content and Compliance
~25%High Weight

Version Evolution

VCAP Operations covers advanced day-2 operations including performance optimization, capacity planning, and automated remediation. VCF 9.0 shifted operations tooling from Aria Operations to VCF Operations — a significant change in UI, API, and workflow. The exam tests scenario-based troubleshooting and optimization at scale.

Learning Outcomes

  • Understand VCF Operations internal architecture: node roles, data flow and retention, adapter execution pipeline, and rollup policies
  • Design and implement Super Metrics for business KPIs and chargeback using formula language with cross-object references
  • Build interactive dashboards with drill-down interactions, and design executive/operations/capacity planning dashboard patterns
  • Configure multi-level alerting: symptom definitions (static + dynamic thresholds) → alert definitions (correlated symptoms) → notifications (email/webhook/SNMP) → automated remediation
  • Perform capacity planning with Time Remaining forecasting, What-If analysis, and rightsizing workflows (conservative vs aggressive)
  • Leverage the VCF Operations REST API for automation, dashboard-as-code, and integration with ITSM/SIEM systems
  • Extend monitoring to multi-cloud environments (AWS/Azure/GCP/K8s) using Management Packs
  • Study the 3V0-22.25 Section 4 objectives taught in the last topic: reclaim and exclusions, cost drivers and pricing cards (cost vs price), policy hierarchy, business vs operational intent, Service Discovery and Telegraf, Management Pack Builder, Troubleshooting Workbench and Log Assist, Automation Central, Fleet Management (certificates, passwords, VCF Single Sign-On), License Management, compliance benchmarks, Config Drift and Audit Users; the same topic ends with a gap list of sub-objectives it does not teach, which you study from the exam guide

VCF Operations Internal Architecture#

VCF Operations (formerly vRealize Operations) is a distributed, horizontally scalable analytics platform. Understanding node roles, data architecture, and sharding patterns is essential for production deployments at scale.

Node Roles & Cluster Composition

VCF Operations clusters contain specialized node types:

Node RoleResponsibilityTypical CountStorage
PrimaryCluster orchestration, UI, API, decision engine (analytics)1SSD (fast I/O for analytics)
Primary replicaSynchronised standby for the primary, promoted on primary failure (HA)1 when HA is enabledSSD (sync with primary)
Data (Analytics)Time-series storage, analytics and roll-up computationAs sized with the VCF Operations sizing guidelines for the releaseSSD/NVMe (high IOPS for writes)
Cloud Proxy (recommended collector)Data collection from on-premises and remote data centres; 2+ proxies in a collector group give HA (failover after ~10 minutes); needed for application monitoring and data persistence (VCF 9.0.1 Cloud Proxy FAQ p.2975; objective 4.1 'Unified Cloud Proxies or Collector Groups')1+ per siteSized per KB 324340 (Small 2 vCPU/8 GB, Standard 4 vCPU/32 GB)
Remote Collector (legacy)Older collector type for remote vCenters; cloud proxy is recommended over it0 in new designsLocal cache (small)

Data Architecture (conceptual data flow)

The diagram shows how data moves through the cluster. Internal database engines, replication factors and similar implementation details are not documented as product facts; do not quote them as exam answers.

Write path (collector -> analytics cluster -> data nodes):
┌─────────────────────────┐
│ Collector (cloud proxy) │ (adapters fetch metrics from vCenter, NSX, vSAN)
└────────────┬────────────┘
             │
             ▼
┌──────────────────────────────────────┐
│ Analytics cluster (primary node)     │
│ - Receives metric stream             │
│ - Stores observations on data nodes  │
│ - Computes super metrics             │
│ - Triggers alerts                    │
└──────────────────┬───────────────────┘
                   │
          ┌────────┼────────┐
          │        │        │
       ┌──▼──┐  ┌──▼──┐  ┌──▼──┐
       │Data │  │Data │  │Data │
       │ N1  │  │ N2  │  │ N3  │
       └─────┘  └─────┘  └─────┘

Read path (dashboard query):
┌──────────────┐
│  Dashboard   │
│  query       │
└──────┬───────┘
       ├─→ 5-minute data (Time Series Data Retention, 6 months by default)
       └─→ 1-hour roll-ups (Additional Time Series Retention, 36 months by default)

Rollup Policies & Data Retention

VCF Operations automatically aggregates metrics across time dimensions:

Default retention (VCF Operations Global Settings, VCF 9.0.1 p.4189):


Time Series Data Retention: 6 months by default — the 5-minute collection data for every monitored object.

Additional Time Series Retention: 36 months by default (configurable up to 120 months) — after the regular retention expires, data is kept as 1-hour roll-ups for this further period.

There is no documented 1-day roll-up tier; long-term trend and capacity analysis read the 1-hour roll-ups.

Storage impact: size the cluster for the retention you set — the sizing KB for the release gives disk per node for the default retention; longer Additional Time Series Retention and higher object/metric counts raise the disk requirement proportionally (no fixed GB figures are documented for a generic estate).

Retention is global, not per policy: shorten Time Series Data Retention or Additional Time Series Retention for lab/dev instances with small disks; for compliance estates raise Additional Time Series Retention (up to 120 months) and size disk accordingly.

Adapter Execution Model: Collect → Transform → Load

Adapters fetch data via a three-stage pipeline:

Adapter Pipeline (per collection interval, e.g., every 5 min):


STAGE 1: COLLECT

  • Adapter instance contacts target system (vCenter, NSX, vSAN)
  • Uses REST API, SNMP, syslog, or proprietary protocol

STAGE 2: TRANSFORM

  • Raw data (performance counters, state info) → VCF Operations object model
  • Example: vSphere counter "cpu.usage" (MHz) → ResourceKind Host metric "cpu.usage%"
  • Applies unit conversion, normalization
  • Filters (discard if below threshold)
  • Aggregates (sum, avg across samples)

STAGE 3: LOAD

  • Transformed metrics are sent to the analytics cluster
  • The analytics cluster stores them on the data nodes

Adapter Concurrency:

  • Each adapter instance (for example one per vCenter) collects on its own schedule on the collector that runs it, so one slow target does not hold up the others.
  • Scale collection by spreading adapter instances across cloud proxies and collector groups (sized per the cloud proxy sizing KB), not by tuning internal thread counts; per-adapter concurrency and timeout defaults are not documented exam facts.

Solution Model & Metadata Hierarchy

VCF Operations' data model defines object types and relationships:

Solution Model - Resource Kind Hierarchy:


DataCenter (top-level container)

├─ Cluster (vSphere cluster)
│  ├─ Host
│  │  ├─ NUMA Node
│  │  └─ NIC
│  ├─ VM
│  │  ├─ vDisk
│  │  └─ vNIC
│  └─ vSAN Cluster (sub-object within Cluster)
│     ├─ vSAN Disk Group
│     ├─ vSAN Disk
│     └─ vSAN Component
├─ Datastore
│  └─ Datastore Disk
├─ Network
│  ├─ vSwitch
│  ├─ Portgroup
│  └─ Uplink NIC
└─ NSX Objects (if NSX is monitored)
   ├─ NSX Manager
   ├─ NSX Edge
   ├─ Logical Switch
   └─ Logical Port

Each resource kind has:

  • Metrics (numeric: cpu.ready, memory.usage, etc.)
  • Properties (text: hostname, version, config, etc.)
  • Relationships (parent/child, for example Cluster → Host → VM; used by super metric depth and by dashboards' object relationship widgets)
  • Alerts and symptoms evaluated against the policy that applies to the object

In VCF Operations 9.0 the same model is extended with VCF-aware objects (VCF Instance, Fleet, management domain, workload domain, NSX and vSAN objects) delivered by the VCF management packs; the VCF Operations collector appliance and cloud proxies run the adapters.

Key Takeaways

  • Node roles: Primary (UI, API, analytics), Primary Replica (synchronised standby, promoted on primary failure), Data (time-series storage and analytics), Cloud Proxy (recommended data collector; collector groups for HA; Remote Collector is legacy). Fleet management, collector and SDDC Manager appliances sit alongside the cluster.
  • Adapter execution: Collect → Transform → Load pipeline run by adapter instances on collectors (cloud proxies); scale collection with more cloud proxies and collector groups. Internal concurrency, timeout and database details are not documented exam facts.
  • Data retention (Global Settings): 5-minute time-series data kept 6 months by default; Additional Time Series Retention keeps 1-hour roll-ups for a further 36 months by default (up to 120). Size the cluster for the retention you set; retention is global, not per policy.
  • Solution model hierarchy: Datacenter → Cluster → Host → VM; each resource kind has metrics (numeric), properties (text), and relationships (parent/child). Custom objects definable via custom groups.

Super Metrics, Custom Groups & Multi-Tenancy#

Super Metrics enable computed KPIs that aggregate raw metrics across objects. Custom Groups organize infrastructure by business context rather than physical topology. Together they power multi-tenant chargeback, executive reporting, and cost optimization.

Super Metric Architecture

Super Metrics are user-defined formulas that combine metrics from one or more objects into a single derived value. They execute at collection time (every 5 minutes by default) and are stored as first-class metrics — available in dashboards, alerts, views, and reports.

Formula Language & Operators (VCF 9.0.1 docs p.4180-4185; metric keys use the group|key form shown in the metric reference):

Basic operators: + - * / ( )

Aggregation functions (examples for a super metric assigned to a cluster):
  avg(${adaptertype=VMWARE, objecttype=VirtualMachine, metric=cpu|usagemhz_average, depth=2})       # average across the cluster's VMs
  sum(${adaptertype=VMWARE, objecttype=VirtualMachine, metric=mem|consumed_average, depth=2})       # total across the cluster's VMs
  max(${adaptertype=VMWARE, objecttype=HostSystem, metric=disk|maxTotalLatency_latest, depth=1})    # peak across the cluster's hosts
  count(${adaptertype=VMWARE, objecttype=VirtualMachine, metric=sys|poweredOn, depth=2, where=($value==1)})   # powered-on VMs

Cross-object references:
  ${adaptertype=VMWARE, objecttype=ClusterComputeResource, resourcename=<cluster name>, metric=cpu|usagemhz_average}   # one named object
  ${this, metric=...}   # relative to the object the super metric is assigned to
  depth=1               # direct children only
  depth=-1              # parent objects, one level UP (on a cluster, depth=-1 reads the data center; depth=2 reads the VMs; p.4185)

Where clause (p.4180):
  where=($value==1)                    # compares the value of the metric being aggregated
  where=(${metric=group|key} > 0)      # tests a different metric of the same object

Conditional logic: ternary operator condition ? value_if_true : value_if_false (p.4181), the documented conditional form; write conditions this way rather than as if()
  ${this, metric=cpu|readyPct} > 10 ? 1 : 0      # binary flag on a VM: 1 when CPU Ready is above 10%

Key Super Metric Design Patterns:


  1. Cluster CPU Contention (average VM CPU Ready %):
avg(${adaptertype=VMWARE, objecttype=VirtualMachine, metric=cpu|readyPct, depth=2})

Assigns to: Cluster Compute Resource. Purpose: average percentage of time the cluster's VMs waited for CPU. The VCF Operations metric reference says to check whether the host is overloaded when CPU Ready is above 10% (VCF 9.0.1 docs p.4267). Do not divide CPU ready time (milliseconds) by CPU usage (MHz): the units do not form a percentage.

  1. Per-VM Cost Allocation (illustrative rates):
(${this, metric=cpu|usagemhz_average} * 0.02) + (${this, metric=mem|consumed_average} / 1024 / 1024 * 0.005) + (${this, metric=virtualDisk|totalReadLatency_average} * 0.001)

Assigns to: Virtual Machine. Purpose: cost per VM based on resource consumption (CPU rate + Memory rate + Storage rate).

  1. Unhealthy Hosts per Cluster:
count(${adaptertype=VMWARE, objecttype=HostSystem, attribute=badge|health, depth=1, where=($value>=0 && $value<100)})

Assigns to: Cluster Compute Resource. Purpose: number of hosts whose health badge is below green, as a trendable cluster KPI. Badge|Health is already a 1-100 score (Green 100, Yellow 75, Orange 50, Red 25, Unknown -1; VCF 9.0.1 docs p.4418), so no formula is needed to normalise health states.

Custom Groups & Dynamic Membership:


Custom Groups organize objects by business logic rather than infrastructure topology:

Group Types:

  • Static: Manually selected objects (useful for fixed sets)
  • Dynamic: Membership rules evaluated at collection time
  • Rule criteria: Object type, metric threshold, property match, tag match, relationship
  • Example: "All VMs where cpu.usage > 80% AND tag contains 'production'"

Use Cases:

  • Application mapping: Group all VMs/hosts/datastores for "ERP System" across clusters
  • Cost center allocation: Group by department tag for chargeback
  • Compliance scope: Group PCI-relevant workloads for audit reporting
  • Tier classification: Gold/Silver/Bronze based on SLA tags

Multi-Tenancy with Custom Groups:

  • Each tenant gets a custom group scoping their infrastructure view
  • Dashboards, alerts, and reports are filtered to the group scope
  • RBAC: assign group-level read access to tenant admins
  • Chargeback: super metrics applied at group level calculate per-tenant costs

Best Practices for Super Metric Design:


  1. Always test formulas on a small group before deploying to production objects
  2. Keep depth as small as the question needs: depth=1 for direct children, depth=2 only when the metric lives two levels down (VMs under a cluster); negative depth walks up to the parent, not down. Super metrics over very large hierarchies (10,000+ children) are costly at every collection cycle
  3. Use meaningful names: "cluster_cpu_contention_pct" not "sm_001"
  4. Document the formula purpose and expected range in the description field
  5. Set appropriate alert thresholds on super metrics — they behave like any other metric
  6. Export super metric definitions (the export is a JSON file, for example SuperMetric.json; VCF 9.0.1 docs p.4182) for version control and migration between environments

Key Takeaways

  • Super Metrics combine raw metrics into business KPIs using formula language with aggregation functions (avg/sum/max/count) and cross-object references (depth, where clauses).
  • Custom Groups enable business-context organization (application, cost center, compliance scope) with static or dynamic membership rules evaluated at collection time.
  • Multi-tenancy pattern: Custom Group per tenant + RBAC scoping + Super Metrics for chargeback = tenant-specific dashboards and cost allocation.
  • Super Metric design: plan the formula before building it (VCF 9.0.1 docs p.4177), set depth to the relationship level being aggregated (depth cannot be 0; p.4179), test on small groups first, use meaningful names, document formula purpose.

Dashboards, Views & Executive Reporting#

VCF Operations dashboards provide real-time and historical visualization of infrastructure health, performance, and capacity. Views and reports enable structured data export for compliance, capacity planning, and executive communication.

Dashboard Architecture:


Dashboard Components:

Widgets: Individual visualization elements (chart, heatmap, scoreboard, topology map, etc.)

Interactions: Cross-widget linking (click a host in a list, other widgets filter to that host)

Self-Provider: Widget has its own data source (static metric selection)

External-Provider: Widget receives data from another widget's selection (interactive drill-down)

Widget Types & Use Cases:

  • Metric Chart: Time-series line/bar chart for trending (cpu.usage over 7 days)
  • Scoreboard: Single KPI value with threshold coloring (green/yellow/red)
  • Heat Map: Grid showing relative metric intensity across objects (VM density per cluster)
  • Top-N: Ranked list of objects by a metric (Top 10 VMs by CPU usage)
  • Topology Map: Visual relationship map (Cluster → Host → VM → Datastore)
  • Distribution: Histogram showing metric distribution (VM CPU allocation spread)
  • Object Relationship: Parent-child traversal for root cause analysis

Dashboard Design Patterns for VCDX:


Pattern 1: Executive NOC Dashboard (Non-Technical Audience)

  • Row 1: Scoreboard widgets — Overall Health (green/yellow/red), Total VMs, Active Alerts
  • Row 2: Heat map — Cluster utilization (CPU + Memory + Storage)
  • Row 3: Trend chart — Week-over-week workload growth
  • Key principle: No technical jargon, traffic-light colors, big numbers

Pattern 2: Operations Drill-Down Dashboard

  • Left panel: Object list (hosts, filtered by alert status)
  • Right panel: Metric chart (auto-updates based on left panel selection)
  • Bottom panel: Alert list (filtered to selected object)
  • Key principle: Click-to-drill from summary to detail

Pattern 3: Capacity Planning Dashboard

  • Widget 1: Time Remaining (days until CPU/Memory/Storage exhaustion)
  • Widget 2: Demand vs Capacity trend lines
  • Widget 3: What-If scenarios (add 50 VMs — when does capacity run out?)
  • Widget 4: Rightsizing recommendations (oversized VMs wasting capacity)
  • Key principle: Forward-looking, actionable recommendations

Views & Reports:


Views are structured data queries that return tabular results:

  • List View: All VMs with columns (Name, CPU Usage, Memory Usage, Disk Latency, Power State)
  • Trend View: Selected metrics over time for selected objects
  • Distribution View: Statistical spread of a metric across objects

Reports combine views into formatted documents:

  • Templates: Pre-built (Cluster Utilization, VM Rightsizing, Chargeback)
  • Custom: User-defined combining multiple views with headers/footers
  • Scheduling: Daily/weekly/monthly auto-generation and email delivery
  • Formats: PDF or CSV (VCF 9.0.1 docs p.4150)

Report Design for Compliance:

  • PCI DSS: Monthly report on security-related metrics (failed logins, config changes)
  • SOX: Quarterly capacity and change audit report
  • Internal SLA: Weekly uptime and performance report per service tier

Dashboard Best Practices:


  1. Use interactions (self-provider → external-provider) for drill-down — don't create separate dashboards
  2. Limit widgets per dashboard to 8-12 — too many causes performance issues
  3. Use consistent color schemes: green=good, yellow=warning, red=critical (match alert definitions)
  4. Include time context: always show the time range in the dashboard title or header
  5. Export dashboard definitions as JSON for version control and migration

Key Takeaways

  • Dashboard architecture: Self-Provider widgets (static data source) vs External-Provider (dynamic, fed by other widget selections) enable interactive drill-down without separate dashboards.
  • Three dashboard design patterns: Executive NOC (traffic-light, big numbers), Operations Drill-Down (click-to-detail), Capacity Planning (forward-looking, what-if scenarios).
  • Views query structured data (list, trend, distribution); Reports combine views into scheduled documents (PDF/CSV) for compliance and executive reporting.
  • Dashboard limits: 8-12 widgets max per dashboard for performance; use interactions for drill-down; export definitions as JSON for versioning.

Alert Policies, Symptom Definitions & Automated Remediation#

VCF Operations uses a multi-level alerting framework: Symptom Definitions (individual metric conditions) combine into Alert Definitions (correlated conditions), which trigger Notifications and optionally Automated Remediation actions. Understanding this hierarchy is critical for designing production-grade monitoring.

Alerting Architecture — Symptom → Alert → Notification Pipeline:


LEVEL 1: SYMPTOM DEFINITION

What: A single condition on a metric or property
Example: "CPU usage > 90% for 3 consecutive collection cycles"

Types:

Metric / Property: threshold on a metric that VCF Operations monitors (static or dynamic) or on a configuration property

Message Event: events received as messages from a VCF Operations component or from an external system through its REST API

Fault Event: faults that monitored systems publish (events that affect object availability)

Metric Event: a threshold violation reported by an external monitored system; the external system manages the threshold, not VCF Operations

Logs: log-based symptoms defined after integration with VCF Operations for logs

Smart Early Warning: predefined, not configurable; fires when the number of anomalies on an object is over the trending threshold

(Symptom types in the alert definition editor: VCF 9.0.1 docs p.3176-3177)

Wait Cycles: # of consecutive violations before symptom fires (reduces flapping)

Cancel Cycles: # of consecutive clear readings before symptom clears

Dynamic Thresholds (DT):

  • VCF Operations learns normal behavior per object over 7+ days
  • DT adjusts thresholds based on historical patterns (business hours vs night)
  • Example: CPU usage normal at 70% during business hours but only 20% at night
  • A spike to 50% at 3 AM triggers DT alert, but 70% at 2 PM does not

LEVEL 2: ALERT DEFINITION

  • What: One or more symptoms combined with logic (AND/OR)
  • Example: "CPU usage > 90% AND Memory usage > 85% AND Disk latency > 20ms"
  • Criticality: Info, Warning, Immediate, Critical
  • Impact: Health, Risk, Efficiency (determines badge type on objects)
  • Type: Application, Virtualization, Hardware, Storage, Network
  • Correlation: Multiple symptoms must fire simultaneously to trigger the alert
  • This reduces alert noise by ensuring multiple conditions confirm a real issue

LEVEL 3: NOTIFICATION

What: Action taken when alert fires/clears

Channels:

  • Email: SMTP integration with customizable templates
  • Webhook: REST callback to external systems (PagerDuty, ServiceNow, Slack)
  • SNMP Trap: v1/v2c/v3 to network management systems
  • Log File: Write to local log for external collection

Escalation: route by criticality with separate notification rules (for example Critical → webhook + email, Warning → email); timed escalation is normally handled in the ITSM or paging tool that receives the webhook
Suppression: Maintenance windows to silence alerts during planned work

LEVEL 4: AUTOMATED REMEDIATION

What: the action behind an alert's first-priority recommendation runs without user intervention when the alert triggers. Automation is deactivated in policies by default; activate it per alert by setting Automate = Local in the policy's Alert / Symptom Definitions pane
Actions supported for automation (VCF 9.0 docs, Actions Supported for Automation):

  • Power On VM, Power Off VM, Shut Down Guest OS for VM
  • Set CPU Count / Memory / CPU Count And Memory for VM (each also as a Power Off Allowed variant), Set CPU Resources / Memory Resources for VM
  • Move VM
  • Delete Powered Off VM, Delete Idle VM

Snapshots and custom SSH or REST scripts are not on the automation list
Safety: no approval step or cooldown setting is documented for automated actions. Limit risk by design: automate only well-understood recommendations, scope the policy to a small custom group first, and review runs in Recent Tasks (Submitted By shows automationAdmin; the Automated and Alert columns identify the trigger)

Alert Design Anti-Patterns to Avoid:


  1. Alert storms: Too many low-threshold alerts → operations team ignores all alerts

Fix: Use dynamic thresholds, set appropriate wait cycles (3+), suppress during maintenance

  1. Symptomless alerts: Alert on single metric without correlation → high false positive rate

Fix: Always use multi-symptom alerts (CPU + Memory + Disk = real problem, not noise)

  1. Missing escalation: All alerts go to same channel → critical mixed with informational

Fix: Design tiered notification chains: Info → log only; Warning → email; Critical → webhook + email

  1. No remediation policy: All alerts require manual intervention → slow MTTR

Fix: Automate safe actions (vMotion, rightsizing) for well-understood scenarios; reserve manual for complex issues

Key Takeaways

  • Alerting pipeline: Symptom Definition (single condition) → Alert Definition (correlated symptoms with AND/OR logic) → Notification (email/webhook/SNMP) → Optional Automated Remediation (the first-priority recommendation's action, e.g. Move VM or Set CPU Count/Memory, when the policy sets Automate = Local).
  • Dynamic Thresholds learn per-object baselines over 7+ days, adapting to business-hour vs off-hour patterns — reduces false positives from static thresholds.
  • Multi-symptom correlation is key: alert on 'CPU > 90% AND Memory > 85%' is far more meaningful than alerting on CPU alone.
  • Alert design: use wait cycles (3+) to reduce flapping, tiered notifications for escalation, maintenance windows for suppression, and testing of automated actions on a non-production scope before enabling them in production policies.

Capacity Planning, Rightsizing & What-If Analysis#

Capacity planning in VCF Operations uses predictive analytics based on historical trends to forecast resource exhaustion, identify rightsizing opportunities, and model what-if scenarios for infrastructure changes. This is one of the highest-value VCAP Ops topics — it directly impacts CapEx decisions and is a frequent VCDX design defense topic.

Capacity Planning Model:


VCF Operations calculates three capacity dimensions for each cluster:

  1. Time Remaining: Days until a resource (CPU, Memory, Storage) runs out of usable capacity

Calculation: the capacity engine runs a statistical demand model once every 24 hours and projects upper and lower demand bounds over a 1-year window; Time Remaining is where the chosen bound (conservative = upper, aggressive = mean of upper and lower) meets usable capacity (VCF 9.0.1 p.5222)

Headroom is set in the policy, not by a demand threshold: the Capacity Buffer element (CPU, memory and disk space, for the Demand and Allocation models; default 0) reduces usable capacity, and the Time Remaining and Capacity Remaining elements set when alerts trigger (VCF 9.0 docs, policy capacity elements)

Buffer: Additional headroom for HA, maintenance, burst (e.g., N+1 = one host worth of capacity reserved)

  1. Recommended Size: the maximum projected utilization from now to 30 days after the Time Remaining warning threshold (default 120 days, so 150 days ahead), excluding vSphere HA; VCF Operations caps the result to keep it conservative (VCF 9.0.1 docs p.5223)

Rightsizing for VMs:

Oversized: VM allocated 8 vCPU that has never used more than about 10% CPU → the reclaim is capped at 50% of the allocation, so the recommendation is 4 vCPU (not 1 or 2)

Undersized: VM allocated 2 vCPU running hot with high ready time → recommend 4 vCPU (an increase is capped at 100% of the current allocation)

Idle: VM powered on but <1% CPU/Memory/Network for 30+ days → candidate for decommission

Rightsizing for clusters:

Over-provisioned: cluster 30% utilized → candidate for consolidation
Under-provisioned: cluster 85%+ utilized → add hosts or redistribute workloads

  1. Capacity Remaining: Headroom in each resource after accounting for HA, buffer, and committed capacity

Formula: Total Capacity - HA Reserve - Buffer - Current Demand = Remaining
HA Reserve: typically 1 host worth of CPU/Memory (N+1) or 2 hosts (N+2 for critical workloads)

What-If Analysis:


What-If scenarios model the impact of hypothetical changes before committing resources:

Scenario Types:

  • Add Workloads: "What if we deploy 50 new VMs with 4 vCPU / 16 GB RAM each?"
  • → Shows: new Time Remaining, resource utilization after addition
  • Remove Workloads: "What if we decommission the legacy ERP cluster?"
  • → Shows: capacity freed, potential consolidation opportunity
  • Add Hosts: "What if we add 4 new hosts to the cluster?"
  • → Shows: extended Time Remaining, new utilization percentage
  • Hardware Refresh: "What if we replace 10 old hosts with 5 new (higher-spec) hosts?"
  • → Shows: capacity comparison (old vs new), consolidation ratio

What-If Execution:

  1. Select target cluster
  2. Choose scenario type
  3. Input parameters (VM count, resource profile, host spec)
  4. Run analysis → VCF Operations recalculates capacity projections
  5. Compare results: current state vs. proposed state side-by-side

Rightsizing Workflow:


Step 1: Identify candidates

  • In VCF Operations select Optimize under Capacity in the left pane, click a data center and open the Rightsize tab, which lists Oversized VMs and Undersized VMs by cluster (VCF 9.0.1 docs p.5242); idle and powered-off VMs are on the Reclaim tab (p.5238)

Step 2: Review recommendations

  • Each VM shows: Current allocation, Recommended allocation, Expected savings
  • Risk level is set in the policy (VCF 9.0.1 Capacity Engine and Calculations, p.5222):
  • Conservative: uses the upper-bound demand projection (production workloads)
  • Aggressive: uses the mean of the upper- and lower-bound projections (non-critical workloads, more reclamation, more risk)

Step 3: Apply changes

  • Manual: Admin reviews and applies in vSphere Client
  • Automated: VCF Operations + Action Adapter can auto-resize (hot-add if supported)
  • Scheduled: Apply rightsizing during maintenance window

Step 4: Monitor post-change

  • After rightsizing, monitor for 7-14 days: CPU ready time increase? Memory ballooning? Disk latency spike?
  • If degradation detected: revert and adjust recommendation sensitivity

Cost Optimization with Chargeback/Showback:


Chargeback: actual billing to business units based on resource consumption
Showback: informational report without actual billing (transparency without enforcement)

Cost Model Configuration:

  • CPU Rate: $0.02 per MHz per month
  • Memory Rate: $0.005 per GB per month
  • Storage Rate: $0.10 per GB per month
  • Network Rate: $0.001 per Mbps per month

Cost Report Output:

  • Per-VM: Monthly cost based on actual consumption × rates
  • Per-Group: Aggregated cost for custom groups (departments, applications)
  • Per-Cluster: Infrastructure cost allocated proportionally

VCDX Design Consideration: Capacity planning parameters significantly impact procurement cycles. A Time Remaining threshold shorter than the procurement lead time means late warning — procurement lead time for new hardware is typically 8-16 weeks. An oversized Capacity Buffer or an over-long threshold means premature investment. Align the Time Remaining threshold with the procurement lead time (for example 12 weeks) and keep deliberate headroom in the Capacity Buffer.

Key Takeaways

  • Three capacity dimensions: Time Remaining (days to exhaustion from the capacity engine's demand projection — upper bound for the conservative risk level, mean of upper and lower bounds for aggressive, VCF 9.0.1 docs p.5222), Recommended Size (rightsizing based on actual usage), Capacity Remaining (headroom after HA/buffer reserves).
  • What-If analysis models hypothetical changes (add/remove workloads, add hosts, hardware refresh) before committing resources — key for CapEx planning.
  • Rightsizing workflow: Identify candidates (oversized/undersized/idle) → Review recommendations (conservative vs aggressive) → Apply changes → Monitor post-change for 7-14 days.
  • Chargeback/showback: cost model with per-resource rates (CPU/Memory/Storage/Network) → per-VM/group/cluster cost reports. Align the Time Remaining threshold with hardware procurement lead time (for example 12 weeks) and hold headroom in the policy Capacity Buffer; no demand-threshold setting is documented.

VCF Operations API, Extensibility & Multi-Cloud Observability#

VCF Operations exposes a comprehensive REST API for automation, integration, and extensibility. The API enables programmatic access to all operations functions — metrics, alerts, dashboards, capacity, and configuration — enabling infrastructure-as-code patterns for operations management.

REST API Architecture:


Base URL: https://<vcf-ops-fqdn>/suite-api/api/

Authentication: Token-based (acquire via POST /auth/token/acquire with username/password)

Response Format: JSON by default; XML responses are deprecated in 9.0 and returned only when requested in the Accept header (VCF 9.0.1 docs p.237)

API Categories (confirm exact endpoints and parameters in the API reference that VCF Operations serves at https://<vcf-ops-fqdn>/suite-api/):

/resources: Query objects (hosts, VMs, clusters) with metric data; custom groups are exposed under /resources/groups

/alerts: Read alerts and manage alert definitions

/supermetrics: Super metric definitions

/reports: Generate and download reports programmatically

Common API Workflows:


  1. Bulk Metric Export (for external analytics):
  • GET /resources?resourceKind=VirtualMachine&pageSize=1000 → returns the list of VM resource IDs
  • POST /resources/stats/query (with resource IDs + metric keys + time range) → returns time-series metric data for all VMs
  • Use case: feed VCF Operations data into Splunk, Elasticsearch or a data lake
  1. Alert-to-Ticket Integration:
  • Query /alerts for active alerts of Critical criticality (filter parameter names per the API reference)
  • Create the incident through the ITSM API, or use the Service-Now Notification or Webhook Notification outbound plug-in instead of polling
  • Use case: keep VCF Operations alerts and ITSM incidents in step
  1. Dashboard-as-Code:
  • Export dashboard definitions from the dashboard management page and store them in a Git repository for version control
  • Import them into the next environment (dev → staging → production); check the API reference before scripting this step
  1. Automated Rightsizing Pipeline:
  • Export the oversized and undersized VM list (Rightsizing page, or a rightsizing view or report as CSV)
  • Filter to the VMs whose owners have approved the change
  • Apply via vSphere API (reconfigure VM with new CPU/Memory values)
  • Re-check the VM in VCF Operations after the change

Management Packs (Extensibility):


Management Packs extend VCF Operations to monitor non-VMware systems:

Built-in Packs:

- vCenter: vSphere infrastructure (hosts, VMs, clusters, datastores)
- vSAN: vSAN health, performance, capacity
- NSX: Network virtualization components
  • VCF: Cloud Foundation lifecycle and health

Marketplace Packs (VMware and partner-authored; installed from the in-product Marketplace):

  • AWS: EC2, EBS, RDS, S3, Lambda monitoring
  • Azure: Virtual Machines, Storage, SQL, AKS monitoring
  • Kubernetes: Cluster, node, pod, container metrics
  • Dell/HP/Lenovo: Hardware health via iDRAC/iLO/XCC SNMP
  • NetApp/Pure/Dell Storage: SAN/NAS performance and capacity

Custom Packs (User-authored):

  • Built with Management Pack Builder, built into VCF Operations (console: Developer Center > Management Pack Builder): design, test and install custom management packs from JSON or XML REST API sources, with no code (VCF 9.0.1 docs p.102, p.5018; exam objective 4.8)
  • Define objects, metrics, properties and relationships from the REST source, or extend existing objects with new metrics and relationships
  • Export the design (a zip containing the design JSON file), extract the JSON from the zip and import it into another VCF Operations instance, then install it there (VCF 9.0.1 docs p.5019 Importing or Exporting a Design, p.5027)
  • Use case: Monitor custom applications or proprietary systems

Multi-Cloud Observability:


VCF Operations provides a single pane of glass across:

  • On-premises: vSphere/vSAN/NSX via native adapters
  • AWS: via AWS management pack (CloudWatch metrics + Config)
  • Azure: via Azure management pack (Monitor metrics + Resource Graph)
  • GCP: via GCP management pack (Google Cloud Platform service metrics)
  • Kubernetes: via Kubernetes management pack (kube-state-metrics + cAdvisor)

Cross-Cloud Correlation:

  • Application spans on-prem VMs + AWS EC2 + K8s pods
  • Custom group contains all objects regardless of cloud
  • Super metrics aggregate CPU/Memory/Cost across clouds
  • Single dashboard shows application health across all environments

API Security Best Practices:


  1. Use service accounts for API integrations (not personal admin accounts)
  2. Token expiry: default 6 hours; for long-running integrations, implement token refresh
  3. Rate limiting: the API returns HTTP 429 Too Many Requests when clients send too many requests (VCF 9.0.1 docs p.7978); batch queries and back off on 429
  4. TLS: All API calls must use HTTPS; verify certificates in production integrations
  5. Audit: All API calls are logged in VCF Operations audit trail — used for compliance reporting

Key Takeaways

  • REST API categories: /resources (objects + metrics; custom groups under /resources/groups), /alerts, /supermetrics, /reports; confirm other endpoints in the in-product API reference. Token-based auth (POST /auth/token/acquire) with 6-hour token expiry; JSON is the default response format in 9.0.
  • Key API workflows: bulk metric export to SIEM/data lake, alert-to-ticket integration with ITSM, dashboard-as-code via Git, automated rightsizing pipeline.
  • Management Packs extend monitoring to AWS/Azure/GCP/K8s/hardware/storage — enabling multi-cloud observability from a single platform.
  • Multi-cloud correlation: custom groups span clouds, super metrics aggregate cross-cloud KPIs, single dashboards show application health across all environments.

3V0-22.25 Objective Coverage: Reclaim, Cost, Intent, Applications and Fleet#

The 3V0-22.25 exam guide (Last Updated 11/11/2025) puts every testable objective in Section 4, Objectives 4.1 to 4.16; Sections 1, 2, 3 and 5 have no testable objectives. This block adds the objectives the topics above do not teach in depth. It does not cover every sub-objective of the guide: the gap list at the end of the block names what is still to study. Facts are from the VCF 9.0 documentation on techdocs.broadcom.com; the page title is named so you can find it.

Reclaim and Exclusions (Objective 4.2)

  • Reclaim lives under Capacity > Optimize (Reclaim, Rightsize and Workload Placement tabs) and lists Powered Off VMs, Idle VMs, Snapshots and Orphaned Disks, highest priority on the left (Using Reclaim to Free Up Resources)
  • Reclamation Settings (gear icon, applies to all data centers) include or exclude each type, set how long a VM must be powered off or idle, and set the VM idleness criteria; a VM matching several types is counted once, in the higher-ranked type (Reclamation Settings)
  • EXCLUDE VM(S) keeps selected VMs out of any reclaim action
  • The allocation model is used for capacity only when you turn it on in the policy (set overcommit ratios); it also changes the reclaimable memory and disk shown on Reclaim (Policy Allocation Model Element)
  • A custom profile shows how many more objects of a given size fit in the available capacity; define it under Configurations > Custom Profiles and select it in the policy Capacity card (Policy Custom Profile Element)

Cost and Price (Objective 4.4)

  • Cost is what the infrastructure costs you: cost drivers (eight in total; you can set totals for the License, Labor, Network, Maintenance and Facilities drivers) override the reference costs and are distributed across hosts and VMs (Overview of Cost Drivers)
  • Price is what you charge: pricing cards are rate-based or cost-based and are assigned to vCenter instances or clusters; a cluster policy takes precedence over the vCenter policy for resources under that cluster, and prices are recalculated every 24 hours (Pricing Overview)
  • Provider pricing for VCF Automation tenants is set on the Provider Pricing card of a policy, and chargeback capabilities come from deploying VCF Automation with the VCF Installer (Configuring Provider Pricing Details; Activating Chargeback Capabilities)
  • The Cost vs. Price dashboards check that the price charged covers the cost of running the VMs (Project Cost vs. Price); the currency for cost calculation is chosen with Set Currency

Policy Hierarchy (Objective 4.5)

  • Active policies are ranked 1, 2 and so on, with 1 the highest; when several policies apply, the highest-priority one wins, except that a policy assigned directly to an object is enforced even if its priority is lower. The default policy applies to objects with no other policy, and an element you do not override is inherited from the base policy (VCF Operations policies)

Business and Operational Intent (Objective 4.6)

  • Operational intent is the policy Workload Automation goal: Balance (performance first; spread load for maximum headroom), Moderate (minimise workload contention) or Consolidate (minimise the number of clusters used, for cost); Cluster Headroom is the buffer kept free (for example 20 percent), and a large headroom limits optimisation (Workload Automation Policy Settings)
  • Business intent uses vCenter tags (category:name) to place VMs on clusters or hosts with matching tags, or to exclude VMs and clusters from Workload Placement (Capacity > Optimize > Workload Placement > Business Intent > Edit). Host-based placement makes VCF Operations create and manage DRS rules and deactivate conflicting user-created VM-VM and VM-Host rules; you must acknowledge this (Business Intent Workspace)

Application Monitoring (Objective 4.7)

  • Service Discovery discovers the services running in each VM and the dependencies between VMs; it needs VCF Operations Advanced or Enterprise (Discovering Services and Applications using the Service Discovery Adapter)
  • Product-managed Telegraf is deployed and managed from VCF Operations to collect OS and application metrics (Monitoring Application Services using Product-Managed Telegraf)
  • Open-source Telegraf is installed by you on Linux or Windows and posts metrics to a cloud proxy (a helper script adds the configuration); Broadcom supports only the initial configuration, after which the Telegraf community supports the agent (Monitoring Application Services and Operating Systems using Open Source Telegraf)

Management Pack Builder (Objective 4.8)

  • A no-code tool, built into VCF Operations under Developer Center (no separate appliance in 9.0), that brings data in from an external API to create new objects or extend existing ones with data, relationships and events; designs from the earlier standalone builder can be imported (Management Pack Builder)

Troubleshooting Workbench and Log Assist (Objective 4.9)

  • Troubleshooting Workbench: start it from an alert (TROUBLESHOOT button) or by searching for an object, and investigate known and unknown issues around that object (Discovering Potential Evidences Using the Troubleshooting Workbench)
  • Log Assist generates log bundles for a Broadcom support case and attaches the active diagnostic findings automatically; its link is on the Diagnostics Findings tab (Use Log Assist to Accelerate Your Support Cases)

Automation Central (Objective 4.1)

  • Jobs that automate reclaim (delete old snapshots, delete or power off idle VMs, delete powered-off VMs) and rightsizing (downsize oversized, scale up undersized VMs), plus scheduled power on, power off and reboot; jobs can also be created from the Reclaim and Rightsizing pages in the context of a recommendation (Automation Central; Create Job from Reclaim or Rightsizing)

Fleet Management and Licensing (Objective 4.14 in part, Objective 4.15)

  • Certificates: Fleet Management > Certificates; auto-renewal is activated separately for VCF Management and VCF Instance components and renews 60 days before expiry (Set Up Automatic Renewal of Certificates in VMware Cloud Foundation)
  • Passwords: view password alerts, update and remediate component passwords in the VCF Operations console; expiry and connection status refresh once a day, and the SDDC Manager API gives real-time information (Managing Accounts and Passwords for VMware Cloud Foundation Components)
  • Identity: VCF Single Sign-On, configured in the VCF Operations console, gives one login across the VCF components except SDDC Manager and ESX (Configuring VCF Single Sign-On)
  • Licences are added to a registered VCF Operations instance from the VCF Business Services console (License Management > Licenses > Add to VCF Operations) and then assigned to vCenter instances; one licence can be in only one VCF Operations instance at a time (Add a License to VCF Operations)

Compliance, Config Drift and Audit (Objective 4.16)

  • Compliance benchmarks: VCF benchmarks based on the VCF Security Baseline, plus regulatory frameworks you activate (VCF Benchmarks based on VMware Cloud Foundation Security Baseline)
  • Configuration Drifts compares vCenter instances (9.0 or later, with a configuration template attached) and vSphere clusters (with Configuration Profiles enabled) against their desired state (Using the Configuration Drifts Overview Page)
  • Audit reports: User Activity Audit (logins, actions, password changes, certificate activation, logouts) and User Permissions Audit, among others (Audit Users and the Environment in VCF Operations)

Gap list: sub-objectives of the 3V0-22.25 guide that are not taught in this section, or are named without the procedure. Study them from the guide and the VCF 9.0 documentation.

  • 4.1: Day 2 operational tasks as a set; configuring Unified Cloud Proxies and collector groups (named in the architecture topic's sizing table only); scaling VCF Operations, VCF Operations for logs and VCF Operations for networks; configuring Role-Based Access Control in VCF Operations (one tenant-scoping bullet in the Custom Groups topic only); configuring a new integration.
  • 4.2: excluding VMs from rightsizing and the policy settings for rightsizing; configuring advanced capacity management features.
  • 4.3: What-If scenarios for HCI hosts and for migrating workloads to or from VMware Cloud and a public cloud; committing multiple What-If scenarios.
  • 4.4: configuring Billing for resources (Chargeback appears only as an activation prerequisite).
  • 4.6: the stages for configuring Operational Intent and Business Intent; host-based versus cluster-based business intent as a contrast; the benefit of Advanced Workload Placement with VCF Automation.
  • 4.7: creating Business Applications; Application Monitoring as a feature; deploying and configuring the Managed Telegraf agent for operating system and application metrics (this block compares Service Discovery, Managed Telegraf and open-source Telegraf only).
  • 4.8: installing and configuring a marketplace management pack such as Kubernetes (named in the extensibility topic, no procedure).
  • 4.9: configuring an outbound plug-in (named in the API topic only).
  • 4.12: configuring VCF Operations for logs, log event alert queries, dashboards and content packs.
  • 4.13: monitoring networks with VCF Operations for networks.
  • 4.14: scaling Fleet Management - Lifecycle and upgrading the components of a VCF fleet.

Key Takeaways

  • 3V0-22.25 tests only Section 4 (Objectives 4.1-4.16). Areas beyond the earlier topics (the block ends with a gap list of sub-objectives it does not teach): reclaim, cost and price, policy hierarchy, business and operational intent, application monitoring, Management Pack Builder, Troubleshooting Workbench and Log Assist, Automation Central, Fleet Management, licensing, compliance, config drift and audit.
  • Operational intent = the policy Workload Automation goal (Balance, Moderate, Consolidate) plus Cluster Headroom; business intent = vCenter tags that drive or exclude placement, and host-based placement hands DRS rule management to VCF Operations.
  • Cost (cost drivers) is what the infrastructure costs; price (rate-based or cost-based pricing cards on vCenter instances or clusters) is what you charge. Check one against the other with the Cost vs. Price dashboards.
  • Fleet Management: certificate auto-renewal runs 60 days before expiry; VCF Single Sign-On covers every VCF component except SDDC Manager and ESX; licences come from the VCF Business Services console into one VCF Operations instance.

Exam Mapping: 3V0-22.25 — Advanced VCF 9.0 Operations

  • Objective 4.1 - Complete Day 2 Tasks in VCF Operations
  • Objective 4.2 - Manage VCF Capacity with VCF Operations
  • Objective 4.3 - Forecast VCF Capacity Growth in VCF Operations
  • Objective 4.4 - Cost Management in VCF Operations
  • Objective 4.5 - Managing VCF Operations with VCF Policy
  • Objective 4.6 - Workload Optimization in VCF Operations
  • Objective 4.7 - Monitor Applications with VCF Operations
  • Objective 4.8 - Installing Management Packs and creating Custom Management Packs in VCF Operations
  • Objective 4.9 - VCF Operations Troubleshooting Tools and Methodologies
  • Objective 4.10 - Creating Custom Dashboards, Views and Reports in VCF Operations
  • Objective 4.11 - Creating Super Metrics in VCF Operations
  • Objective 4.12 - Log Event Monitoring and Analysis in VCF Operations
  • Objective 4.13 - Monitoring Networks in VCF Operations for networks
  • Objective 4.14 - Complete Fleet Management activities in VCF Operations
  • Objective 4.15 - Manage VCF licensing with VCF Operations
  • Objective 4.16 - Monitor Security, Compliance and Configuration in VCF Operations

Labs in This Section

📝 Quiz — VCAP Advanced Operations

0/65 correct

Architecture

Q1
A remote datacenter has limited WAN and must forward metrics locally before sending to the analytics cluster. Which component do you deploy?
  • SDDC Manager clone
  • Second analytics cluster
  • Remote Collector or Cloud Proxy
  • Additional vCenter
Remote Collector/Cloud Proxy collects data at remote sites with limited WAN and forwards to the analytics cluster, minimizing bandwidth usage. A second analytics cluster is overkill. Additional vCenter doesn't help with monitoring. SDDC Manager clones aren't a thing.
Q2
Which deployment model provides horizontal scale for metric ingest and analytics?
  • Multi-node analytics cluster
  • HA pair
  • Standalone single node
  • Witness-only node
Multi-node analytics clusters provide horizontal scale for metric ingest and analytics, distributing load across nodes. Standalone single node doesn't scale. HA pair provides redundancy but limited scale. Witness nodes support quorum, not analytics.
Q3
An 'object' in VCF Operations is best defined as:
  • A monitored entity exposing metrics, properties, and relationships
  • A disk group
  • A dashboard widget
  • A syslog source only
An 'object' in VCF Operations is a monitored entity exposing metrics, properties, and relationships — VMs, hosts, datastores, etc. form the object model. It's not a dashboard widget, syslog source, or disk group.
Q4
VCF Operations for Logs stores long-term archived logs using:
  • An NFSv3 shared-storage archive location
  • vSAN File Services exclusively
  • Only local disk
  • Email archive
The archive location for VCF Operations for Logs must be on NFS version 3 shared storage with enough capacity, and the archiving period must exceed the retention period (VCF 9.0.1 p.877; VVS ILA-VAOL-CFG-012 uses a 400 GB NFS share). Object storage is not an archive target in the source; local disk alone, vSAN File Services and email are not the documented mechanism.
Q5
VCF Identity Broker centralizes authentication across:
  • Only SDDC Manager
  • Only vCenter
  • Only NSX Manager
  • VCF Operations, Automation, and related services via AD/LDAP/SAML/OIDC
VCF Identity Broker centralizes authentication across VCF Operations, Automation, and related services via AD/LDAP/SAML/OIDC integration. It's not limited to only vCenter, NSX Manager, or SDDC Manager.

Capacity Management

Performance Analysis

Automation and Remediation

Custom Content and Compliance

🃏 Flashcards — VCAP Advanced Operations

79 cards
Card 1 of 79
Analytics Node
A VCF Operations cluster role running the metric, property, and event processing pipeline, backing the analytics UI. Multiple analytics nodes partition data for scale. They host adapters, collectors-of-last-resort, and alerting.
Was this page useful?
Type to search. ↑ ↓ to move, Enter to open, Esc to close.