VCAP-level automation architecture, cloud templates, ABX extensibility, service broker integration, and infrastructure-as-code patterns for production VCF environments.
3V0-21.25
VCAP
60
Questions
135m
Duration
300 (scaled score; Broadcom publishes no percentage or ceiling)
Pass Score
35
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 and Design
~15%
Section 2 — Blueprint and Template Design
~30%High Weight
Section 3 — Extensibility
~15%
Section 4 — Multi-Cloud Governance
~20%
Section 5 — GitOps and Operations
~20%
Version Evolution
vRealize Automation 8.x became Aria Automation 8.x and, in VCF 9.0, VCF Automation: a fleet-level service deployed by the VCF Installer, licensed and lifecycled from VCF Operations, with two organization types (All Apps on Supervisor/NSX VPC; VM Apps for VM-only clusters carrying the Aria Automation cloud-template model forward). Identity moved to organization identity providers (LDAP, SAML, OIDC) and VCF Single Sign-On through the VCF Identity Broker; vIDM is deprecated. API authentication is an OAuth 2.0 API token (90-day default) exchanged for a one-hour access token; the 8.x Identity Service login flow is no longer used. Aria Automation 8.x upgrades to VCF Automation 9.0 and is then imported into VCF Operations.
Learning Outcomes
Describe VCF Automation 9.0 tenancy and identity: Provider Management Portal, All Apps and VM Apps organizations, projects, Regions/Zones/Namespace Classes, identity providers and VCF SSO, predefined and custom roles
Design cloud templates and placement abstractions for VM Apps organizations and know when All Apps constructs (namespaces, VKS clusters, VPCs) replace them
Implement event-driven extensibility with the documented event topics, blocking priorities and ABX/Orchestrator runnables, including recovery runnables
Govern consumption with approval, lease, Day-2 action and IaaS resource policies, scoped by project and criteria, and expose it through the catalog
Automate VCF Automation through Git content sources, the Terraform providers and the OAuth 2.0 token-based APIs with idempotent, observable pipelines
VCF Automation 9.0 is the fleet-level consumption and governance layer of VCF. It runs as a set of services deployed by the VCF Installer into the management domain of the first VCF Instance and is licensed and lifecycled from VCF Operations. Identity and tenancy are built on three layers: the Provider Management Portal, organizations, and projects.
Organization types (VCF 9.0 Getting Started — Add Workload Domains to Your Cloud Organization Structure)
Type
Workload domains it consumes
Consumption surface
Isolation
All Apps Organization
Workload domains with a Supervisor deployed on NSX VPC networking; runs containers and VMs
Organization portal, IaaS services console (vSphere Namespaces, VKS clusters, VMs via VM Service), Kubernetes API layer, Terraform
Each organization receives its own VPCs; Supervisors and Zones are assigned to the organization through Region Quotas; vSphere Namespaces are created inside projects from Namespace Classes
VM Apps Organization
Workload domains whose clusters run only VMs (the upgraded Aria Automation 8.x model: cloud templates, catalog, Assembler)
Organization portal catalog and cloud templates
Cloud zones, projects and policies; no Supervisor
A workload domain (and its vCenter and clusters) cannot be used by both organization types at the same time.
Provider constructs the organizations consume: a Region is a collection of Supervisors that share an NSX Local Manager; Zones are vSphere clusters supplying compute to a Supervisor; a vSphere Namespace is a logical pool of CPU, memory and storage from one to three Zones that runs a project's workloads; Namespace Classes (three system classes small/medium/large, customisable) set default limits, storage classes, VM classes and content libraries.
Identity (VCF 9.0.1 — Managing Identity Providers in VCF Automation)
Identity providers: an LDAP connection at system or organization level, a SAML integration per organization, and an OpenID Connect integration per organization — one integration per IdP technology, several technologies at once, and user names must not collide across them.
VCF Single Sign-On: the VCF Identity Broker (VIDB) configured in VCF Operations can be the identity provider for VCF Automation; an existing OIDC configuration on the provider organization must be removed first, and the VCF SSO tab then replaces the OIDC tab.
VMware Identity Manager (vIDM) is deprecated with no upgrade path to 9; it survives only as the authentication source of an upgraded Aria Automation 8.x (VM Apps) tenant until it is replaced.
Roles (VCF 9.0.1 — Managing Predefined User Roles in VCF Automation)
Level
Role
What it does
Organization
Organization Administrator
Full access to the organization portal: projects and project users, integrations such as Git, blueprints and catalog items, namespaces and VPCs, content libraries, policies, event subscriptions
Organization
Organization Auditor
Read-only version of the Organization Administrator
Organization
Organization User
Can log in; must be added to a project to do anything
Organization
Defer to Identity Provider
Permissions are derived from the identity provider's claims
Project
Project Administrator
Sees all project content, performs all Day-2 actions, manages project members and settings, creates resources in the IaaS services console, manages catalog approval requests
Project
Project Advanced User
Requests catalog items and creates resources in the services console; Day-2 actions on all project resources
Project
Project User
Catalog only; Day-2 actions on own deployments; no IaaS services console
Project
Project Auditor
Read-only
Custom organization roles are created in Access Control with two permission categories per UI section — View and Manage — and extend the predefined roles across all projects (not restricted by project membership). Predefined organization roles are managed by the provider administrator in the Provider Management Portal. There is no "Designer" or project "Viewer" role in VCF Automation 9.0.
API tokens and service identities (VCF 9.0.1 — Getting Your Authentication Token)
An API token is created in the organization portal (My Account > API Tokens) and acts as the OAuth 2.0 refresh token; default lifetime 129600 minutes (90 days), adjustable in the Provider Management Portal > General Settings > Timeouts (0 = never expires) and fixed at creation.
The access token is obtained from the token endpoint and expires after one hour by default:
POST https://<vcfa-fqdn>/tm/oauth/tenant/<org>/token
Content-Type: application/x-www-form-urlencoded
grant_type=refresh_token&refresh_token=<API token>
Registering an OAuth client lets you set a different access-token expiry. The Identity Service API of Aria Automation 8.x is no longer used to obtain refresh tokens programmatically (changed in 9.0).
Design pattern: one API token per integration owned by a dedicated user with the least role that works (Organization Auditor for read-only reporting; Project Administrator scoped to the project for provisioning), rotation aligned to the configured lifetime, and secrets held in the consumer's vault, not in templates.
Key Takeaways
Two organization types: All Apps (Supervisor on NSX VPC; containers and VMs; Regions, Zones, Namespace Classes, VPCs) and VM Apps (VM-only clusters; cloud templates and catalog); a workload domain can belong to only one type.
Predefined roles: Organization Administrator / Auditor / User (plus Defer to Identity Provider) and Project Administrator / Advanced User / User / Auditor; custom organization roles add View or Manage per UI section — no Designer or Viewer role.
Identity: LDAP, SAML and OIDC (one integration per technology) or VCF Single Sign-On through the VCF Identity Broker; vIDM is deprecated and lives on only as an upgraded VM Apps tenant's auth source.
API access: UI-created API token (90-day default, configurable, fixed at creation) exchanged at /tm/oauth/tenant/{org}/token for a one-hour access token; design for least-privilege token owners and vault-held secrets.
Cloud templates are the VM Apps organization's deployable definitions (VCF Automation for VM Apps, formerly Aria Automation Assembler). All Apps organizations consume Supervisor services, VKS clusters and VM Service VMs through namespaces instead, so the exam tests both models — know which one a scenario names.
Template structure (VCF 9.0.1 — Specifying formatVersion in Blueprints; resource type references)
Design patterns that matter in a defence or an exam scenario
Abstraction through mappings: image mappings, flavor mappings and network profiles translate template-level names into per-cloud-zone artefacts; constraint tags on resources are matched against capability tags on cloud zones, compute and networks to drive placement.
Conditional and iterative resources:count with ${input.x} for repeated machines, allocatePerInstance, and property bindings between resources (${resource.a.property}) — avoid circular bindings.
Property groups centralise repeated inputs; custom naming templates standardise machine names; project-level and organization-level governance (policies) is applied at request time, not in the template.
Versioning: templates are versioned and released to the catalog; de-release or restore versions; Git-sourced templates get a new version when imported content differs from the top version (Template version configuration is a non-blockable event topic you can subscribe to for change notification).
Terraform in VCF Automation (VCF 9.0.1 — Terraform providers): three open-source providers cover the platform end to end — the Terraform Provider for VCF Automation (Provider Management Portal resources and a subset of All Apps organization resources such as Supervisor namespaces, with greenfield provider-side and tenant-side examples), the Terraform Provider for Kubernetes for Organization Portal resources exposed through the Kubernetes API layer (such as projects), and the Terraform Provider for VMware Aria Automation for VM Apps organization resources and All Apps resources not yet on the Kubernetes API layer (such as blueprints). The NSX Terraform Provider, extended in VCF 9.0 for VPCs and Transit Gateways, is a separate networking tool, not one of the three. Templates may also embed Terraform configurations for VM Apps.
What a VCDX panel probes
Why a template rather than a Namespace Class or an IaaS resource policy for a given requirement (consumption model first, tool second).
Where the guardrail lives: approval, lease and Day-2 action policies apply to catalog requests; IaaS Resource policies (CEL expressions) apply to services-console requests in All Apps organizations.
How change is controlled: Git as the source of truth, released versions in the catalog, event subscriptions on version configuration for audit.
Key Takeaways
Cloud templates belong to the VM Apps model (formatVersion/inputs/resources/outputs; Cloud.vSphere.Machine, Cloud.NSX.Network); All Apps organizations consume Supervisor namespaces and Kubernetes/VM Service resources instead.
Placement is abstraction: image and flavor mappings plus network profiles per cloud zone, constraint tags matched to capability tags; governance is applied at request time through policies, not hard-coded in templates.
Three open-source Terraform providers cover VCF Automation 9.0: the VCF Automation provider (Provider Management Portal + All Apps namespaces), the Kubernetes provider (Kubernetes API layer, such as projects) and the VMware Aria Automation provider (VM Apps organizations, and blueprints and catalog items not yet on the Kubernetes API layer).
Action-Based Extensibility (ABX) runs small scripts in response to events or as Day-2 actions. The documented term is action-based extensibility (not 'Automation by Example').
Facts to carry into the exam (VCF 9.0.1 — Create extensibility actions; Extensibility actions)
Runtimes: Python, Node.js and PowerShell scripts, or a flow-type action that chains actions; dependencies are declared with the action (pip/npm) or uploaded as a bundle.
Timeouts: scripting-type actions have a maximum timeout of 15 minutes; flow-type actions up to five hours (or no limit if left blank). Timeout and memory are set with the "Set custom timeout and limits" option.
Versions: subscriptions use the latest released version of an action — release the version you want after editing.
Where the code runs: the Node.js and Python runtimes can run on-premises in the platform's own runtime or be offloaded to AWS Lambda when the action is configured with an AWS endpoint; design the data-residency and egress implications before choosing.
Secrets: store credentials as encrypted secrets or constants and read them from the action's context/inputs; never embed them in the script body or in template properties.
Recovery: a blocking subscription can name a recovery runnable item (action or workflow) that runs when the primary fails, with the ebs.recover.continuation property deciding whether the chain continues.
Production patterns
Idempotency: every action must be safe to run twice (CMDB record exists → update, not create). Event retries and recovery runnables assume it.
Short, single-purpose actions chained by a flow action or by subscription priority, rather than one long script that approaches the 15-minute ceiling.
Structured logging (JSON lines) so Action Runs and VCF Operations for logs can index fields; include the deployment id and resource id in every line.
Inputs as the contract: declare and type the inputs; read event payload fields (resourceNames, hostSelections, customProperties) rather than re-querying the API when the topic already carries them.
Test in the editor with saved sample inputs, then release a version; keep the previous released version to roll back a subscription quickly.
ABX versus VCF Operations Orchestrator workflows
Need
ABX action
Orchestrator workflow
Short integration call, tag/property mutation, webhook
Yes
Possible, heavier
Long-running, multi-step with human interaction or waits
Reuse as Day-2 resource action or custom resource lifecycle
Yes
Yes
Choose by duration, plug-in need and team skills; both are first-class runnable items in subscriptions.
Key Takeaways
ABX = action-based extensibility: Python, Node.js, PowerShell or flow actions; scripting actions time out at 15 minutes maximum, flow actions at five hours; subscriptions run the latest released version.
Design actions idempotent and single-purpose, type their inputs, log structured lines, keep secrets in encrypted constants, and add a recovery runnable item to blocking subscriptions.
Pick Orchestrator workflows for long-running, resumable or plug-in-heavy integrations; pick ABX for short event-driven calls and property/tag mutation.
Event subscriptions connect lifecycle events to ABX actions or VCF Operations Orchestrator workflows. Subscriptions are created under Extensibility > Subscriptions and are scoped by event topic, optional conditions, a runnable item and (for blocking topics) priority, timeout and a recovery runnable.
Event topics (VCF 9.0.1 — Event topics provided with VCF Automation for VM Apps, Table 1655; selection)
Event topic
Blockable
Issued
Approval Events
Yes
When an action that requires approval is triggered
Compute allocation
Yes
Before resource names and host selections are allocated (both modifiable); once per cluster of machines
Compute reservation
Yes
At reservation time; placement order can be changed
Compute provision
Yes
Before the resource is provisioned at the hypervisor; per machine; allocated IP can be changed
Compute initial power on
Yes
After provisioning, before first power-on (vSphere only)
Compute post provision
Yes
After a resource is provisioned; per machine
Compute removal / Compute post removal
Yes
Before / after a compute resource is removed
Compute gateway, NAT provisioning and removal (pre/post)
Yes
Around network gateway and NAT resources
Compute post migration reconcile status
No
After a managed VM moved by vMotion is reconciled
Custom resource post provision
Yes
After custom-resource operations
Template configuration / Template version configuration
No
On template create/delete and on version create, release, de-release, restore
All topics can be used to add or update custom properties or tags on the resource; a failed runnable item fails the corresponding task. Blockable = the task waits for the subscription to finish (and can be failed by it); non-blockable topics fire asynchronously.
Priority and ordering (VCF 9.0.1 — Blocking event topics)
Blocking subscriptions run in priority order; the highest priority value is 0 (zero). Example in the docs: priority 0 changes the machine name, priority 1 records it.
Several blocking subscriptions with the same topic and priority run in reverse alphabetical order of subscription name — deterministic, not parallel.
After all blocking subscriptions complete, non-blocking subscriptions for the topic fire at the same time.
A blocking subscription has a timeout; design the chain so the sum of the blocking steps stays inside the request's tolerance.
Conditions
Subscriptions carry a condition (a JavaScript-style expression over the event payload) so one topic can serve several teams: filter on project name, template name, custom properties (for example event.data.customProperties.env === 'prod') or request type. Keep conditions in the subscription, not in the action, so the action stays reusable and the audit trail shows why it fired.
Design guidance
Use the earliest topic that carries what you need: naming → Compute allocation; IP changes → Compute provision; CMDB/IPAM registration → Compute post provision; clean-up → Compute removal / post removal.
Pair every blocking subscription that writes to an external system with a recovery runnable item.
Record topic, priority, condition and runnable per subscription in the design; the panel will ask what happens when one fails.
Key Takeaways
Event topics are named (Compute allocation, Compute provision, Compute post provision, Compute removal, Approval Events, Template version configuration …) and carry a Blockable flag; there are no com.vmware.cac.* identifiers.
Blocking subscriptions run by priority with 0 as the highest value; equal priorities run in reverse alphabetical order of name; non-blocking subscriptions fire together afterwards.
Put filtering in the subscription condition, pair external writes with a recovery runnable item, and choose the earliest topic that already carries the data you need.
The catalog is where project members request what the organization has published — cloud templates, Orchestrator workflows, ABX actions, Terraform configurations and marketplace items — governed by policies that the organization administrator defines under Manage & Govern > Policies.
Policy types (VCF 9.0.1 — Managing Policies in VCF Automation)
Applies to
Policy
Purpose
Catalog requests
Approval Policy
Approvers must accept before provisioning; pending items appear in the approvers' Inbox
Catalog requests
Day 2 Action Policy
Which users or groups may run which actions on deployed resources
Catalog requests
Lease Policy
Maximum lifetime of a deployment; on expiry the deployment is destroyed and resources reclaimed (with grace/extension settings)
IaaS services requests (All Apps)
IaaS Resource Policy
Policy-as-code constraints (Common Expression Language, as in the Kubernetes API) on provisioned IaaS resources such as VMs and Kubernetes clusters
Scope and criteria: a policy applies to the whole organization or to selected projects; criteria refine it (project name, namespace name, namespace class, deployment name, …). Multiple policies are evaluated, ranked and merged into an effective policy; the Policy Assignments tab shows what applies where and Policy Enforcement audits when policies were applied. New policies apply to current and new deployments.
Created at Manage & Govern > Policies > Definitions > New Policy > Approval Policy with a scope, optional criteria (for example a catalog item), approval type, approver mode and approvers.
Approvers can be chosen users and groups, or role based — Project Administrators or Project Auditor; a project without a dedicated administrator does not get a project-scoped role-based policy applied.
Approver mode decides whether any one approver suffices or all must approve; the policy also sets the behaviour when nobody responds (auto-approve or auto-reject after the wait period).
Approval Events is a blockable event topic, so an ABX action or Orchestrator workflow can notify or integrate an external ticketing system when an approval is requested.
There is no YAML policy language for approvals and no built-in 'Finance' or 'CISO' approver role; map business approvers to groups from the identity provider.
Catalog design patterns
Project-level sharing: publish a content source to selected projects; use projects (not organizations) for team separation inside one tenant.
Request forms: custom forms on catalog items hide or show fields by condition and validate inputs; keep the form the single place where a user supplies data, and let subscriptions enrich the rest.
Lease defaults per project tier (dev short, prod unlimited with Day-2 action policy restricting destroy) and quotas at organization and project level complement the approval policy.
Day-2: resource actions (power, snapshot, resize, custom actions) are controlled by Day 2 Action policies; custom resources expose their own lifecycle actions.
Defence angle: show the policy stack as a table (scope → criteria → policy → approvers/limits) and explain the effective-policy merge for a project that falls under two policies.
Key Takeaways
Four policy types: Approval, Day 2 Action and Lease (catalog requests) plus IaaS Resource policies in CEL for services-console requests; scoped to the organization or projects and refined by criteria, merged into an effective policy.
Approval policies are UI-defined (Manage & Govern > Policies): scope, criteria, approval type, approver mode, approvers (users/groups or Project Administrators / Project Auditor roles) and the no-response outcome; Approval Events is a blockable topic for integrations.
Design the catalog around projects for separation, custom forms for input, leases and quotas for reclamation and Day-2 action policies for control — and present the stack as scope → criteria → policy → approver.
Infrastructure as Code at Scale — GitOps with VCF Automation#
Infrastructure as code at scale means Git is the source of truth for templates, actions and Terraform, and VCF Automation is a consumer of released versions.
Supported flavours are GitHub (cloud and Enterprise on-premises), GitLab (cloud and Enterprise on-premises) and Bitbucket on-premises, each a separate integration; the integration is created under Administer > Connections > Integrations with the repository URL and a token, then projects are added with the repository path, branch and folder that hold blueprints (one folder per blueprint, each file named blueprint.yaml with name and version fields) or action scripts.
When imported blueprint content differs from the top version, a new version is created (a draft edited in VCF Automation stops syncing until you create a new version). Blueprints cannot be pushed to Git from VCF Automation; action versions created in VCF Automation are saved to Git automatically.
Content sources sync on a schedule and can be re-synced on demand; blueprint edits should happen in Git, with the UI treated as read-only for synced blueprints.
Repository layout (one pattern that keeps reviews small)
automation/
templates/ # one folder per blueprint, each blueprint.yaml carrying name and version
web-tier/
blueprint.yaml
db-tier/
blueprint.yaml
actions/ # ABX actions, one folder per action with its dependencies file
cmdb-register/
handler.py
requirements.txt
terraform/
provider/ # Provider Management Portal resources (VCF Automation provider)
tenant/ # organization layout, content libraries, namespaces
policies/ # exported policy definitions kept for review, applied through the API/Terraform
Pipeline stages
Lint and schema-validate YAML and Terraform on every pull request.
Deploy to a sandbox project from the branch; run a smoke test (deployment succeeds, outputs present, subscriptions fired).
Merge to the integrated branch and let the sync import the new version (a Git tag is for your own traceability; the VCF Automation Git documentation does not map tags to versions); promote by sharing the released version to production projects.
Record the released version in the change ticket; keep the previous version available for rollback.
Terraform (VCF 9.0.1 — Terraform providers in VCF Automation)
Terraform Provider for VCF Automation: CRUD for the Provider Management Portal and a subset of All Apps organization resources (for example Supervisor namespaces); the GitHub greenfield examples are split into a provider part (organizations, vCenter and NSX instances, provider gateways, roles) and a tenant part (organization layout such as content libraries).
Terraform Provider for Kubernetes: resources exposed through the VCF Automation Kubernetes API layer.
Terraform Provider for VMware Aria Automation: VM Apps organization resources, and All Apps resources not yet exposed through the Kubernetes API layer (for example blueprints and the catalog).
Adjacent, not one of the three: the NSX Terraform Provider, extended in VCF 9.0 for VPCs, Transit Gateways and related constructs.
State: keep Terraform state in a remote backend with locking; never in the repository.
GitOps for Kubernetes workloads
VKS clusters provisioned through an All Apps organization are ordinary Kubernetes clusters: GitOps controllers (Argo CD, Flux) deploy application manifests to them, and container images come from a registry (Harbor is the common choice alongside VKS). Keep platform GitOps (templates, policies, namespaces) and application GitOps (manifests) in separate repositories with separate approvers.
Design guidance: define who may change what (Organization Administrator for integrations and content sources; Project Administrator for project sharing), where secrets live (never in Git; in the platform's secrets or an external vault), and how a bad release is reverted (previous version re-shared, Terraform plan reviewed before apply).
Key Takeaways
Git is the source of truth: integrations under Administer > Connections > Integrations (GitHub, GitLab, Bitbucket on-premises), projects mapped to repository, branch and folder; an import whose content differs from the top version creates a new version, and blueprints cannot be pushed to Git from VCF Automation.
Terraform in VCF Automation 9.0 uses the VCF Automation provider (provider and tenant parts), the Kubernetes provider (Kubernetes API layer) and the VMware Aria Automation provider (VM Apps organizations, blueprints, catalog); keep state in a locked remote backend.
Separate platform GitOps (templates, policies, namespaces) from application GitOps (Argo CD / Flux manifests to VKS clusters) with distinct repositories and approvers.
The VCF Automation APIs are the automation surface for everything the portals do. Authentication is OAuth 2.0 bearer tokens; the Aria Automation 8.x Identity Service login flow is gone in 9.0.
Authentication (VCF 9.0.1 — Getting Your Authentication Token)
Create an API token in the organization portal (My Account > API Tokens). Default lifetime 129600 minutes = 90 days; the provider administrator can change the default under Provider Management Portal > General Settings > Timeouts (0 = unlimited); a token's lifetime is fixed when it is created.
Exchange it for an access token (one hour by default):
POST https://<vcfa-fqdn>/tm/oauth/tenant/<org>/token
Content-Type: application/x-www-form-urlencoded
Accept: application/json
grant_type=refresh_token&refresh_token=<API token>
Call the APIs with Authorization: Bearer <access token>; when it expires, repeat step 2 — the API token is the refresh token.
To control access-token expiry, register an OAuth client and use its token instead.
The 8.x POST /csp/gateway/am/api/login and /iaas/api/login username/password flow is not the 9.0 method; service accounts are API tokens held by a dedicated user with the least role required.
Organization resources exposed as Kubernetes objects (used by the Terraform Kubernetes provider and kubectl)
VCF Automation for VM Apps APIs (IaaS, blueprint, catalog, deployment, ABX)
Cloud templates, deployments, Day-2 actions, extensibility — the former Aria Automation API families, with apiVersion pinning
VCF SDK and PowerCLI
Python/Java SDK and PowerCLI cmdlets generated from the OpenAPI specifications
Working practices
Pin apiVersion on the VM Apps APIs so that responses do not change under you between releases; the API documentation lists the version per family.
Treat long-running operations as asynchronous: provisioning calls return a request/deployment id; poll its status with a bounded backoff (for example 5 s doubling to 60 s, deadline from the lease or SLA) rather than a tight loop.
Idempotency: look up before create (deployment name within the project; namespace name within the organization) so a retried pipeline does not duplicate resources.
Pagination: list endpoints page; iterate until the page is empty rather than assuming one call returns everything.
Errors: 401 means the access token expired (refresh), 403 means the token's role lacks the right (fix the role, do not widen the token owner to Organization Administrator by default), 409 usually means the object exists.
Observability: log the request id returned by the API with every call so support can correlate with the platform's Events and Tasks view in the Provider Management Portal.
Key Takeaways
9.0 authentication: UI-created API token (90-day default, configurable, fixed at creation) → POST /tm/oauth/tenant/{org}/token with grant_type=refresh_token → one-hour bearer access token; the 8.x Identity Service login is no longer the method.
Know the surfaces: Provider Management Portal API, All Apps organization APIs and Kubernetes API layer, VM Apps IaaS/blueprint/catalog/deployment/ABX APIs with apiVersion pinning, and the VCF SDK/PowerCLI generated from the OpenAPI specs.
Automate asynchronously (request id + bounded polling), idempotently (look up before create), with least-privilege token owners and the request id logged for support correlation.
Integration patterns connect VCF Automation to the systems around it. In 9.0 the integration points are: event subscriptions (ABX actions, Orchestrator workflows), the APIs and Terraform providers, identity providers, Git content sources, and VCF Operations.
Pattern 1 — ITSM / CMDB registration (ServiceNow or any REST CMDB)
Trigger: Compute post provision (blocking) with a recovery runnable item that deletes a half-created CI on failure; Compute post removal to retire the CI.
Data: resource name, IP, project, owner and deployment id from the event payload; the CI id written back as a custom property on the resource so Day-2 actions can find it.
Approval: Approval Events subscription posts the approval request to the ITSM change record; approvers act in VCF Automation (Inbox) or the ITSM webhook calls the approval API with a service token.
Pattern 2 — IPAM and DNS
Trigger: Compute provision (blocking) — the allocated IP can be changed at this topic; register DNS at Compute post provision; release at Compute removal.
Alternative: NSX VPC subnets and IP blocks handled by the platform in All Apps organizations; integrate IPAM at the Provider layer (IP blocks, VPC connectivity profiles) rather than per VM.
Pattern 3 — Configuration management
Trigger: Compute post provision → ABX action calls the configuration tool's API (for example an Ansible Automation Platform job template) with the inventory built from the event payload; poll the job with bounded backoff inside the 15-minute scripting limit or hand off to an Orchestrator workflow for longer runs.
Pattern 4 — Identity
Organization identity providers (LDAP, SAML, OIDC) or VCF SSO through the VCF Identity Broker; group-to-role mapping at organization and project level; Defer to Identity Provider where claims should decide.
Pattern 5 — Observability and cost
VCF Operations collects VCF Automation (All Apps and VM Apps organizations) through its management packs for health, capacity and pricing; forward ABX and platform logs to VCF Operations for logs; alert on failed subscriptions and approval backlogs.
Pattern 6 — Multi-tenancy at the network layer
All Apps organizations receive NSX VPCs; inter-VPC and external connectivity run through Transit Gateways and VPC connectivity profiles defined by the provider; a design states per organization the CIDR allocation, the connectivity profile and whether the organization may create its own VPCs.
Anti-patterns a panel will catch
Credentials in template properties or action code instead of secrets.
Non-idempotent actions on blocking topics without a recovery runnable.
One Organization Administrator token used by every pipeline.
Governance implemented in scripts (approvals, leases, quotas) that the platform's policies already provide.
Key Takeaways
Integrate at the right layer: event subscriptions for lifecycle hooks (CMDB, IPAM, DNS, config management), the provider layer for network and quota constructs, identity providers for access, VCF Operations for observability.
Every external write on a blocking topic needs idempotency and a recovery runnable item; every integration needs its own least-privilege API token.
Use the platform's policies (approval, lease, Day-2 action, IaaS resource) for governance instead of re-implementing them in scripts.
Section 1 — Architecture and Design: VCF Automation 9 architecture and deployment model; All Apps vs VM Apps organizations; component model (provider side: Regions of Supervisors, Zones = vSphere clusters; tenancy: Organization > Project > vSphere Namespace); HA/DR; integration with NSX VPC, vSphere Supervisor and VCF Operations
Section 2 — Blueprint and Template Design: cloud template YAML (inputs, resources, outputs), property bindings and conditional/iterative resources, cloud zones and mappings, naming templates, property groups, versioning and release, Terraform providers
Section 5 — GitOps and Operations: Git integration, GitOps for Kubernetes delivery, CI/CD with a registry, Day-2 lifecycle, service catalog, troubleshooting, VCF Operations monitoring
Note: these are the VCDX Academy study groupings (content/exam-metadata.json); the official 3V0-21.25 exam guide at the URL above is the authority for objectives and must be cross-checked
A service provider wants strict tenant isolation with per-tenant VPC networking and independent lifecycle. Which organizational model is most appropriate in VCF Automation 9?
All-Apps-Org provides strict tenant isolation with per-tenant VPC networking, independent lifecycle management, and dedicated resources. A VM Apps org contains and administers its own resources (cloud accounts, zones, profiles) — the model existing vCD orgs migrate into — but does not provide per-tenant VPC isolation. Single shared project offers no isolation. Legacy vRA tenancy is deprecated in VCF 9.
The Blueprinting/Deployment service in VCF Automation compiles YAML cloud templates (blueprints), orchestrates resource allocation through Cloud Zones, and drives provisioning workflows across infrastructure providers. It is the central orchestration engine for catalog item deployment.
VCF Automation HA uses VMSP-based multi-node clusters with pod replicas distributed across nodes for active/active availability. Single-node with snapshots provides no HA. External vCenter HA protects vCenter, not Automation services. Manual DNS failover is not an HA strategy.
How do the VCF Automation 9.0 provider and tenancy constructs relate?
Namespace → Instance → Project
Org → Fleet → Zone → Project
Provider side: a Region is one or more Supervisors (it can span vCenter instances) and its Zones map to vSphere clusters; tenancy side: Organization → Project → vSphere Namespace, with Organizations consuming Regions through region quotas
Fleet → Instance → Region → Zone → Organization → Project → Namespace as one strict containment chain
Provider infrastructure and tenancy are two chains, not one. A Region groups one or more Supervisors and may span vCenter instances, so it is not a child of a single VCF Instance; Zones within a Region map to vSphere clusters. An Organization is a top-level tenancy entity that is granted Regions through region quotas and contains Projects, which contain vSphere Namespaces. The strict seven-level chain mixes the two and is not how the constructs nest.
NSX VPC integration with All-Apps-Org delivers per-tenant isolated networking with self-service subnet provisioning, giving each tenant their own network boundary. Shared flat networks defeat the purpose of isolation. L2 bridging alone doesn't provide self-service. Gateway firewall bypass is a security anti-pattern.
In VCF Automation 9.0 (formerly Aria Automation), which backend service provides the self-service catalog and governance layer on top of Assembler blueprints in a VM Apps organization?
Service Broker provides the self-service catalog and governance layer, presenting Assembler blueprints (cloud templates) as catalog items governed by policies. In 9.0 the Assembler, Service Broker and Orchestrator user interfaces are merged into one UI (Consume menu for the catalog, Design menu for blueprints, Content & Policies menu for content sources and policies), but the Service Broker and Assembler services remain unchanged in the backend, including their role-based access control (VCF 9.0.1 docs p.112). Orchestrator (VCF Operations orchestrator) handles workflow automation. Code Stream / VCF Automation Pipelines is no longer supported in VCF 9.0 (p.239). Log Insight is for log management.
Extensibility subscriptions link extensibility (ABX) actions or orchestrator workflows to event topics, and the Event Broker Service dispatches events to the subscribed actions and workflows (VCF 9.0.1 docs p.6428). The orchestrator is the embedded VCF Operations orchestrator, previously known as VMware Aria Automation Orchestrator (p.112). The Assembler design UI is presentation-only. Service Broker handles the catalog. SDDC Manager manages infrastructure lifecycle, not extensibility.
The high availability model deploys VCF Automation as a three-node cluster: the cluster gives application-level availability and vSphere HA gives appliance-level availability (VCF 9.0.1 docs p.896-897). VCF Automation is deployed by the VCF Installer or by VCF Operations fleet management (p.893), and fleet management manages its Kubernetes cluster (p.494). A single appliance with snapshots isn't HA. Active/passive with storage replication lacks application-level failover. Separate standalone components don't give integrated HA.
Projects control who has access to cloud templates and to which cloud zones members can deploy them. Administrators add users and cloud zones to a project, and anyone who deploys must be a member of at least one project (VCF 9.0.1 docs p.6199). Cloud zones and projects have a many-to-many relationship (p.6133). These constructs keep the same names in 9.0 VM Apps organizations. The tenant boundary above them is the organization itself (All Apps or VM Apps, p.473), and All Apps organizations use regions, projects and vSphere Namespaces instead of cloud zones (p.910). Blueprints are deployment templates. Flavors define compute sizes. Image Mappings map OS images. None of them provide organizational segregation.
A cloud zone is a section of compute resources specific to a cloud account type (such as vSphere or AWS) and to a region. Placement uses its capability tags and placement policy, and cloud zones are assigned to projects (VCF 9.0.1 docs p.6133). The term is unchanged in 9.0 for VM Apps organizations; All Apps organizations use regions and vSphere Namespaces instead (p.910). It's not a catalog item, blueprint version, or policy definition.
How is the VCF Automation 9.0 platform itself hosted and kept running?
As a single Windows-based IaaS server with an external SQL Server database, managed through SDDC Manager
As vSphere Pods inside the workload domain's vSphere Supervisor, operated by the organization administrator
As containers in a Kubernetes cluster on dedicated virtual appliances; VCF Operations fleet management sets up that cluster during installation and manages it transparently
As a set of independent appliances, one per microservice, each patched separately with vSphere Lifecycle Manager baselines
VCF Automation runs on containers in a Kubernetes cluster deployed on dedicated virtual appliances, and each node shows up in the vCenter inventory. During installation, the fleet management services set up the Kubernetes cluster that runs the VCF Automation containers and services, and VCF Operations fleet management then manages that cluster transparently (VCF 9.0.1 docs p.494). Supervisor vSphere Pods are where organization workloads run, not the VCF Automation platform. Organization administrators consume namespaces and do not operate the platform. The Windows IaaS server and the one-appliance-per-microservice designs do not match this containerized architecture.
The 'count' property on a resource enables iterative creation — setting count to an input variable creates N instances dynamically. Static duplicate blocks don't scale. Random UUIDs are identifiers, not iteration constructs. Separate blueprints per count is unmaintainable.
The count property with a conditional expression (e.g., 'count: ${input.env == "prod" ? 1 : 0}') controls whether a resource is deployed — cloud templates have no 'condition:' property. Property binding passes values between resources. Catalog filters control visibility. Terraform providers are for external IaC, not conditional deployment.
Property Groups share a reusable set of input properties across multiple blueprints, avoiding duplication. Flavor Mappings define compute sizes. Cloud Accounts connect to infrastructure. Naming Templates control resource naming conventions.
Placement constraints like 'ssd:true' match Cloud Zones tagged with 'ssd:true', ensuring deployments land on appropriate infrastructure. Placement doesn't deploy to any zone, fail all deployments, or ignore tags when constraints are specified.
The 'inputs' section in a Cloud Template defines user-supplied values at request time (e.g., VM name, environment, size). 'resources' define infrastructure objects. 'outputs' expose deployment results. 'formatVersion' specifies the template schema version.
You need to deploy an NSX-backed load balancer alongside a multi-machine blueprint. Which Cloud.LoadBalancer property specifies the routes (VIP/port/pool)?
The 'routes' property on Cloud.LoadBalancer specifies the VIP, ports, and pool configuration for traffic distribution. 'networks' define network attachments. 'flavor' and 'image' are for compute resources, not load balancers.
${resource.<name>.<property>} references properties from another resource in the same template, enabling cross-resource binding. ${input.someValue} references inputs. @@property@@ and #ref() are not valid Cloud Template syntax.
To publish a new version of a cloud template to the catalog in a VCF Automation 9.0 VM Apps organization, which sequence is correct?
Export to SDDC Manager and re-import
Directly edit the catalog (Service Broker) database
Use vCenter Content Library tagging
Save the template, create a Version, release that version, then re-import it from its content source (Content & Policies > Content Sources, Save & Import) into the catalog
From the design page, click Version to capture a version. From Version History, release it (a Current Draft cannot be released until it is versioned). Then, in Content & Policies > Content Sources, open the project's content source and click Save & Import so catalog users get the new version (VCF 9.0.1 docs p.6248). The blueprint API exposes the same version-then-release flow (p.8223). In 9.0 the Service Broker UI is merged into the Content & Policies and Consume menus, while the service remains in the backend (p.112). Direct DB editing is unsupported. SDDC Manager doesn't manage catalog content. vCenter Content Library is for VM templates, not cloud templates.
Cloud.Terraform.Configuration deploys unmanaged/third-party resources via Terraform modules integrated through a Terraform Cloud Zone. Cloud.Machine is for VMs. Cloud.NSX.Segment creates network segments. Cloud.vSphere.Disk adds storage.
In an All Apps organization, a blueprint requests a traditional virtual machine in a vSphere Namespace. Which Supervisor service, turned on when the Supervisor is activated, runs that VM workload?
Activating a Supervisor turns on three services: Kubernetes for container workloads, Velero for backing up the management components, and VM Service for VM workloads (VCF 9.0.1 docs p.913). In an All Apps organization, traditional VMs and vSphere Kubernetes Service container workloads both run on the Supervisor resources defined in vSphere Namespaces (p.910). The vSphere Namespace class sets which VM classes, and therefore which VM sizes, the blueprint can request (p.913). Velero only handles backup. The Kubernetes service runs container workloads, not VMs. vSphere Lifecycle Manager is not a Supervisor service.
compute.provision.post fires after VM creation, making it ideal for post-provision enrichment like CMDB updates with the VM's IP. compute.provision.pre fires before creation (no IP yet). deployment.request.pre is too early. blueprint.validation is for schema checks.
ABX supports Python, Node.js, and PowerShell runtimes, providing flexibility for different automation needs. It's not limited to PowerShell. ABX actions can absolutely call REST APIs. ABX complements vRO but doesn't replace all workflows.
vRO workflows excel at complex multi-step processes with checkpoints, retries, and long-running tasks due to their stateful, persistent execution model. A single ABX action lacks state management. Hardcoded YAML and static properties can't handle complex logic.
Custom Resources backed by ABX/vRO enable full CRUD lifecycle management for external objects (e.g., NetScaler LB). Plain outputs only expose values. Service Broker icons are cosmetic. Event subscriptions without handlers don't manage lifecycle.
A Resource Action combined with an Approval Policy enables Day-2 operations (like snapshots) with management approval gates. A vRO workflow alone lacks the approval mechanism. RBAC controls access, not approval flows. Lease expiry is automatic, not approval-driven.
An ABX action written in Python needs to call an external REST API during provisioning. Which event topic is typically used to inject custom logic before the VM is created in vSphere?
compute.provision.pre (or compute.allocation.pre) fires before VM creation, allowing custom logic like IP reservation, CMDB pre-registration, or external REST API calls before the VM is provisioned. Post events fire after creation. Failed and completed events are reactive.
ABX runs serverless-style scripts ideal for lightweight, stateless logic. Orchestrator provides complex, stateful, multi-step workflows with rich plug-ins and checkpointing. They're not functionally identical, not platform-specific, and both can call REST APIs.
A Subscription in Extensibility binds an event topic to an ABX action or Orchestrator workflow, triggering execution when the event fires. Project roles control access. Cloud Zone tags drive placement. Content Sources import blueprints.
The event payload/context is passed between subscribed actions — actions can read, modify, and return updated properties that subsequent actions receive. This enables data flow without external state stores. Global variables, shared databases, and email are not the designed mechanism.
Best practice: use a non-blocking test subscription scoped to a dev project first, with versioning and rollback. This validates the action without impacting production. Global enablement, skipping testing, and limiting to synchronous-only all increase risk.
A High Availability VCF Automation design must put a third-party load balancer (for example VMware Avi Load Balancer) in front of the cluster. Which statement is correct?
The external load balancer must be configured in the VCF Installer wizard during initial deployment and cannot be added later
It is an optional step after deployment: the external load balancer sends traffic to the native Kubernetes load balancer, which is set up automatically at deployment and cannot be removed
The external load balancer replaces the native Kubernetes load balancer, which you remove after deployment
The external load balancer reuses the VIP, FQDN and certificate assigned at deployment, so no extra addressing is needed
Both deployment models use the native Kubernetes load balancer by default, and it is set up automatically when VCF Automation is deployed. An external load balancer is an optional manual step after deployment, and it points to the native load balancer as the ingress point (VCF 9.0.1 docs p.896, p.937). The native load balancer cannot be removed, so the external one cannot replace it. The external load balancer also needs its own VIP, FQDN and certificate on top of those assigned at deployment (p.897), so it cannot reuse them.
Project Member / Developer can request catalog items and manage deployments but cannot modify cloud accounts or infrastructure configuration. System Admin and Org Admin have elevated privileges. Viewer only is too restrictive for requesting items.
A lease policy with auto-destroy causes deployment destruction at expiry unless the user requests an extension. Resources are not auto-renewed. Leases don't pause indefinitely. Projects aren't deleted — only the deployment resources are affected.
Organization-level and project-level quota policies enforce resource consumption limits across projects. Cloud Zone constraints limit placement but don't enforce quotas. Pricing cards track cost, not enforce limits. vCenter resource pools are infrastructure-level, not governance-level.
Content sharing policies on catalog items control which consumer organizations can see and request them. Manual YAML copying is unsustainable. Sharing vCenter credentials is a security violation. Git push to consumer bypasses governance.
Approval Policies with criteria on request inputs (e.g., CPU count > 8) require manager approval before provisioning. Lease policies control lifetime. Day 2 Actions Policies govern post-deployment operations. Content Sharing controls catalog visibility.
Lease Policy controls the maximum deployment lifetime. Approval Policy gates provisioning. Quota Policy limits resource consumption. Deployment Limit Policy restricts the number of deployments.
Content sharing policies control which catalog items are available to which users and groups, at organization, selected-project or single-project scope (VCF 9.0.1 docs p.6229-6230). Day 2 Actions policies entitle users to an inclusion list of actions on deployments, applied by scope (organization or project), role and criteria (p.6215-6216). In 9.0 both live under the Content & Policies menu, which replaces the separate Service Broker UI (p.112). Blueprint Version, NSX DFW, and Cloud Zone Tag policies serve different purposes.
Custom Properties and tags on projects/deployments flow into VCF Operations for cost attribution and chargeback reporting through the operations cost integration. vSAN labels, SDDC Manager WLD, and NSX groups don't provide cost-center tagging for chargeback.
Tags on Cloud Zones combined with Constraint Tags on resources enable input-driven placement — e.g., env=dev routes to AWS zones tagged 'cloud:aws', env=prod routes to vSphere zones tagged 'cloud:vsphere'. Hard-coded IPs, version numbers, and cost profiles don't drive placement.
VCF Automation (and VCF Identity Broker) nodes follow an immutable infrastructure model. Upgrades, patches and general maintenance replace the nodes using a pre-defined VM template (VCF 9.0.1 docs p.273). Because those templates sit in the vCenter inventory, enabling a stretched cluster needs a workaround: convert the templates to VMs temporarily, then back again (p.273). VCF Operations fleet management manages the underlying Kubernetes cluster (p.494). In-place patching with vLCM baselines or SDDC Manager async patches goes against the immutable model, and organization administrators do not operate the platform.
In a multi-tenant VCF Automation 9.0 design, one organization wants to create and publish its own Orchestrator workflows inside that organization. What does the architecture require?
The organization uses the embedded VCF Operations orchestrator of the Provider Consumption Organization, scoped by project
Nothing: organizations cannot use Orchestrator workflows, and only ABX actions can be published outside the Provider Consumption Organization
A dedicated external VCF Operations orchestrator instance for that organization, deployed and managed by the Provider Admin; each organization can have only one instance
Several external orchestrator instances per organization, one per project, deployed by the organization administrator
The embedded VCF Operations orchestrator is installed with VCF Automation by default. The provider admin uses it in the Provider Consumption Organization (PCO) to build workflows and publish them to organizations. Those workflows run on the embedded orchestrator even when a user in another organization runs them (VCF 9.0.1 docs p.938, p.940). An organization that wants to create and publish its own workflows cannot use the PCO's embedded orchestrator. It needs an external, dedicated orchestrator instance, which the Provider Admin deploys, manages and grants access to. Each organization can have only one such instance (p.938-939). The 'several instances per project' option breaks that one-per-organization limit. The 'no Orchestrator' option is wrong because published PCO workflows are available to all organizations.
Git integration with auto-import on branch enables blueprints committed to Git to appear automatically in VCF Automation. Manual import per commit is unsustainable. RSS feeds don't exist for this purpose. REST API upload is possible but not automatic.
ArgoCD reconciles Kubernetes manifests from Git to VKS clusters in a GitOps pipeline, ensuring the desired state in Git matches the live cluster state. It doesn't compile blueprints, manage licenses, or create disk groups.
ABX action run logs in Extensibility → Action Runs show stdout, stderr, and stack traces for debugging. vCenter events are too high-level. NSX and ESXi logs don't capture ABX execution details.
The Service Broker catalog provides self-service consumption without exposing the underlying infrastructure. In the VCF Automation 9.0 UI the catalog sits under the Consume menu, and the Service Broker service remains unchanged in the backend (VCF 9.0.1 docs p.112). Assembler is the blueprint design service (the Design menu in 9.0). NSX Manager handles networking. SDDC Manager manages VCF infrastructure.
A Day-2 resource action like Resize changes VM CPU/memory on an existing deployment without redeployment. Redeploying destroys and recreates. Manual vCenter edits bypass governance. Delete-and-recreate loses data.
Content Source of type GitHub/GitLab/Bitbucket integrates with the Project for version-controlled storage of Cloud Templates and ABX actions. SDDC Manager CMDB doesn't store templates. Content Library stores VM images. NSX backup is for network config.
Event Broker subscriptions come in two kinds: workflow subscriptions trigger a VCF Operations Orchestrator workflow, and action subscriptions trigger an extensibility action (ABX), a lightweight script that runs after the event (VCF 9.0.1 pp.6429-6431). VCF Automation Pipelines (Code Stream) is no longer supported in VCF 9.0 (release notes End of Support, p.239), so no pipeline stage can be the answer.
The Deployment's Request Details and History shows the provisioning task timeline with specific error messages. This is the FIRST place to look for deployment failures. ESXi logs, NSX events, and vCenter alarms provide supporting detail but aren't the primary diagnostic.
Resize/Reconfigure allows CPU and memory changes on a running VM without redeployment. Delete destroys the VM. Change Lease adjusts lifetime. Power Off stops the VM but doesn't change sizing.
Which VCF Automation backup strategy is recommended?
vSphere snapshots of running appliances
Snapshot-based replication only
Use the file-based backup/restore through VCF Operations fleet management (to the fleet-level SFTP server), aligned with product guidance, plus Git as source of truth for content
Copy the PostgreSQL data directory while the service is running
VCF Automation is backed up and restored from VCF Operations: Fleet Management > Lifecycle > VCF Management > Components > VCF Automation > Backup & Restore, with backups written to the fleet-level SFTP server configured in fleet management and schedules set per component (VCF 9.0.1 docs p.3031-3032). Keep Git as source of truth for content (blueprints, ABX actions). VM snapshots of running appliances are not a supported backup method. Copying PostgreSQL while running risks corruption. Snapshot-based replication alone is not a backup.
The Kubernetes-based runtime introduced in VCF 9 that hosts VCF Automation microservices as containers rather than legacy appliances. It enables consistent packaging, scaling, and upgrades. It replaces the older vRA appliance model.
VM-Apps-Org Model
A VCF Automation tenancy design focused on VM-centric consumption, where orgs primarily consume vSphere Cloud Zones to deploy VMs with light modern-app surface. It is simpler to operate and is the default for estates migrating from vRA. It coexists with but is distinct from the All-Apps-Org model.
All-Apps-Org Model
A VCF Automation tenancy design that exposes both VM and modern-app (VKS, NSX VPC) consumption to tenants with strong isolation. It requires NSX VPC and Supervisor integration. It is the recommended model for modern multi-tenant platforms.
Region/Zone Hierarchy
A VCF Automation placement concept where a Region groups Zones (vSphere clusters or cloud locations), and zones carry capacity and capability tags used for placement decisions. Templates target Regions; the scheduler picks a Zone. It is the primary placement abstraction.
Tenant Manager
The VCF Automation microservice responsible for organization, project, and user lifecycle, including isolation boundaries. It underpins every multi-tenant feature. It is part of the Automation control plane rather than the data plane.
Automation Orchestrator (VRO)
VCF Automation Orchestrator (vRO; formerly Aria Automation Orchestrator / vRealize Orchestrator): the embedded workflow engine that executes long-running, multi-step automations callable from blueprints, event subscriptions, and day-2 actions. Supports JavaScript/ECMAScript, PowerShell, SSH, REST, and vendor plugins. The extensibility backbone of VCF Automation.
VCF Automation Services Architecture
VCFA is delivered as a multi-node Services Appliance hosting Assembler, Service Broker, Orchestrator, and Pipelines (formerly Code Stream — same product, renamed) behind a common identity and UI. Deployed via SDDC Manager/VCF Installer.
Provider vs Tenant Context
VCFA is multi-tenant: Provider admins manage clouds, infrastructure, and policies globally; Tenant admins consume assigned resources within Org/Project scope and cannot see other tenants.
Project
The deployment unit in VCFA that binds members, cloud zones, flavor/image mappings, and resource quotas. Blueprints are published to Service Broker through Projects.
Cloud Account vs Cloud Zone
A Cloud Account stores credentials/endpoints for a provider (vCenter, AWS, NSX). A Cloud Zone is a provisioning target (cluster/region) derived from an account and associated with capability tags used by placement logic.
The declarative VCF Automation language used to define inputs, resources, and outputs for deployable blueprints. It resembles a superset of CloudFormation with VMware-specific resource types. It is version-controlled like any IaC artifact.
Property Binding
A cloud template mechanism that references another resource's attribute (for example, a VM IP into a load-balancer pool member) so the template wires itself at deploy time. It eliminates hardcoded values. It is the key to composing multi-resource blueprints.
Image Mapping
A VCF Automation abstraction that maps a friendly image name (for example, 'Ubuntu-22.04') to concrete OS images per Cloud Zone. Templates refer to the friendly name, decoupling design from infrastructure specifics. Admins edit mappings without touching templates.
Flavor Mapping
A VCF Automation abstraction that maps a T-shirt size (for example, 'Small', 'Large') to concrete CPU/memory specs per Cloud Zone. Like image mappings, it decouples blueprints from provider details. It standardizes sizing across a catalog.
Property Group
A reusable set of named inputs shared across multiple blueprints, for example a common 'Compliance' input set. Editing the group propagates to all consumers. It is the DRY mechanism for blueprint design.
Terraform Provider (vcfa)
A first-party Terraform provider for VCF Automation that enables Infrastructure-as-Code workflows targeting VCF Automation resources such as projects, blueprints, and deployments. It complements YAML templates for teams that already standardize on Terraform. It is officially supported by Broadcom.
Cloud Template Inputs
Top-level 'inputs' block in YAML declaring parameters presented in Service Broker. Inputs support type (string/number/boolean/array/object), constraints (enum, minimum, maxLength), and default values.
Resource Dependencies (dependsOn)
Explicit ordering in a Cloud Template via 'dependsOn' or implicit via reference expressions (${resource.xxx.yyy}). Controls provisioning order when implicit references are insufficient.
Blueprint Versioning
Cloud Templates can be versioned and released; Service Broker catalog items reference a specific version. Tenants always deploy a released version; drafts are editable only in Assembler.
Outputs Block
YAML section that returns computed values (VM IPs, URLs, credentials) to the consumer after successful deployment, accessible via API and Service Broker UI.
NSX Edge Tier-0 HA modes in VCF 5.2?
Active-Active (higher throughput) and Active-Standby (stateful services).
ABX Action
An Action-Based Extensibility function written in Python, Node.js, or PowerShell that runs serverlessly on VCF Automation. ABX actions hook into blueprint lifecycle events or implement custom resources. They are the lightweight alternative to vRO workflows.
Event Subscription
A VCF Automation configuration that binds an ABX action or vRO workflow to a specific lifecycle event (Pre-Provision, Post-Provision, Pre-Decommission). Subscriptions can be scoped to projects or blueprints. They are the standard extensibility hook.
Custom Resource Type
A blueprint-usable resource backed by an ABX action or vRO workflow implementing CRUD lifecycle, letting administrators model anything — a ServiceNow CI, an external DB schema, an API call — as a native template resource. It is the framework for extending the catalog surface.
Day-2 Resource Action
A post-deployment operation (for example, 'Add Disk', 'Snapshot', 'Restart Service') exposed on a deployed resource, implemented via ABX or vRO. Actions can require approval workflows. They turn a one-shot deployment into a managed lifecycle object.
vRO Workflow
A multi-step automation in the Orchestrator canvas, combining scripting, decision logic, and plugin calls. Workflows handle complex orchestration that exceeds a single ABX function. They are reusable across blueprints, event subscriptions, and day-2 actions.
ServiceNow Integration Pattern
A common VCF Automation extensibility pattern that uses ABX or vRO to create, update, and close ServiceNow incidents/CIs in response to deployment events. It embeds CMDB compliance into provisioning. It is a widely shared reference implementation.
ABX Action Runtimes
Action-Based eXtensibility supports Python 3.x, Node.js, and PowerShell runtimes, running in isolated containers with a configurable timeout and memory limit. Shared secrets are injected via action constants.
Event Topic
The named lifecycle event an Event Subscription binds to (e.g., compute.provision.pre, deployment.action.post). Each topic has a defined payload schema the handler can read and (for 'pre' events) mutate.
Blocking vs Non-Blocking Subscription
Blocking subscriptions pause the workflow until the handler returns, allowing mutation of inputs or cancellation. Non-blocking subscriptions are fire-and-forget and cannot affect the pipeline.
Custom Resource Lifecycle Hooks
Custom Resource Types declare create, read, update, and destroy actions (vRO workflows or ABX actions). Each hook receives the resource inputs/state and returns the updated state.
Microsoft CA prerequisites for VCF 5.2?
Web Enrollment + CA on same machine, Basic Auth enabled on CertSrv IIS site, template duplicated from WebServer with 'Subject is supplied in the request'.
Approval Policy
A VCF Automation governance construct that requires one or more approvers to sign off before a deployment, day-2 action, or lease extension proceeds. Approvals can be sequential or parallel, role-based or user-based. They integrate with email and external systems.
Lease Policy
A VCF Automation rule that attaches an expiration date to deployments, with configurable actions on expiry (destroy, suspend, notify). Leases prevent sprawl and force intentional extension. They are the main hygiene tool for self-service platforms.
Resource Quota
A VCF Automation limit on CPU, memory, storage, or object counts enforced per organization or project. Quotas block over-consumption and inform chargeback. They are configured per resource type and can be soft or hard.
Content Sharing Policy
A rule that exposes blueprints, actions, or property groups from a provider org to consumer orgs, retaining central authoring while enabling broad use. It is the multi-tenant publishing mechanism. It is separate from per-blueprint entitlements.
NSX VPC (Automation)
The NSX tenant-network construct that VCF Automation provisions per org in All-Apps-Org deployments, providing isolated L3 networking with its own Tier-1, subnets, and optional transit gateway. It delivers hard network isolation without per-tenant Tier-0 work. It is the underpinning of modern multi-tenancy.
Fleet-Wide Role Mapping
A VCF Automation RBAC pattern that uses groups from VCF Identity Broker to assign System Admin, Org Admin, Project Admin, Developer, and Viewer roles consistently across instances. It replaces per-instance local assignments. It is the best-practice foundation for large estates.
Approval Policy Conditions
Approval policies trigger based on project, blueprint, deployment cost, resource type, or custom expressions. Approvers can be users, groups, or vRO workflows; SLAs drive auto-approve/reject behavior.
Day-2 Action Policy
Policy that restricts which Day-2 actions (power-off, reconfigure, delete) are available per role/project. Fine-grained control over what tenants can do post-deploy.
Project Resource Limits
Quota-style limits on CPU, memory, storage, and instance count per project. Deployments are blocked when a request would exceed the limit; dashboards show current utilization.
Placement Policy
Controls how VCFA picks a host/cluster within a cloud zone: DEFAULT (first applicable host by availability), BINPACK (pack the most-loaded eligible host), SPREAD (distribute across hosts). Zone selection across projects is governed by the project placement policy plus constraint tags.
Avi Load Balancer requirements in VCF 5.2?
3-node controller cluster mandatory. Deployed through SDDC Manager per workload domain.
Git Integration (VCF Automation)
A configuration that connects VCF Automation to a Git repository so blueprints and ABX actions are auto-imported and version-controlled. Commits become the source of truth; the UI becomes a view. It is the foundation of GitOps for VM-centric platforms.
ArgoCD Pipeline
A GitOps continuous-deployment tool commonly paired with VCF Automation for Kubernetes workloads, reconciling Git state with VKS cluster state. ArgoCD runs inside a VKS cluster and receives manifests produced by VCF Automation blueprints. It closes the loop between catalog and runtime.
Harbor Registry
A CNCF container registry included with VKS and referenced by VCF Automation blueprints for modern-app deployments. It supports image signing, vulnerability scanning, and replication. It is the preferred private registry in VCF 9.
Service Catalog
The VCF Automation self-service surface where consumers request published blueprints, actions, and content. It is curated per project with entitlements. It is the primary end-user interface of the platform.
Deployment Event Log
The time-ordered record of every action VCF Automation took during a deployment, including ABX and vRO invocations. It is the starting point for troubleshooting failures. Each entry links to detailed logs and payloads.
Fleet Management Integration (Automation)
The VCF Operations fleet view of VCF Automation health — microservice status, queue depths, and deployment success rates — across a VCF Fleet. It surfaces automation-platform problems alongside infrastructure problems. It replaces standalone Automation monitoring.
GitOps Push vs Pull
VCFA can push blueprints/ABX actions to a Git repo (export), or pull them on commit (import via webhook). Pull with signed commits is the recommended pattern for production change control.
Code Stream Pipeline Stages
A pipeline is a sequence of stages, each containing tasks (CI build, deploy blueprint, run test, approval). Conditional execution and rollback actions are configured per stage.
Pipeline Endpoint
A reusable connection object for external systems: Jenkins, Git, Jira, Kubernetes, Docker registry, vRO. Endpoints carry credentials and base URLs consumed by pipeline tasks.
Deployment Update vs Redeploy
Update applies changes in place (resize disk, add NIC) preserving the resource identity; Redeploy destroys and recreates. Blueprint changes may force redeploy depending on the resource type and property.
Was this page useful?Thanks — noted.
Type to search. ↑↓ to move,
Enter to open, Esc to close.