Academy/VCAP — VCF Automation (3V0-21.25)
VCF

VCAP — VCF Automation (3V0-21.25)

VCF 9.0vcap-advanced

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 Identity & Multi-tenancy Architecture#

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)

TypeWorkload domains it consumesConsumption surfaceIsolation
All Apps OrganizationWorkload domains with a Supervisor deployed on NSX VPC networking; runs containers and VMsOrganization portal, IaaS services console (vSphere Namespaces, VKS clusters, VMs via VM Service), Kubernetes API layer, TerraformEach 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 OrganizationWorkload domains whose clusters run only VMs (the upgraded Aria Automation 8.x model: cloud templates, catalog, Assembler)Organization portal catalog and cloud templatesCloud 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)

LevelRoleWhat it does
OrganizationOrganization AdministratorFull 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
OrganizationOrganization AuditorRead-only version of the Organization Administrator
OrganizationOrganization UserCan log in; must be added to a project to do anything
OrganizationDefer to Identity ProviderPermissions are derived from the identity provider's claims
ProjectProject AdministratorSees all project content, performs all Day-2 actions, manages project members and settings, creates resources in the IaaS services console, manages catalog approval requests
ProjectProject Advanced UserRequests catalog items and creates resources in the services console; Day-2 actions on all project resources
ProjectProject UserCatalog only; Day-2 actions on own deployments; no IaaS services console
ProjectProject AuditorRead-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.

Advanced Cloud Templates (YAML) — Design Patterns#

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)

formatVersion: 1
inputs:
  size:
    type: string
    enum: [small, medium, large]
    default: small
  env:
    type: string
    enum: [dev, prod]
resources:
  web:
    type: Cloud.vSphere.Machine
    properties:
      image: ubuntu-22
      flavor: '${input.size}'
      constraints:
        - tag: 'env:${input.env}'
      networks:
        - network: '${resource.net.id}'
  net:
    type: Cloud.NSX.Network
    properties:
      networkType: existing
outputs:
  address:
    value: '${resource.web.address}'

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

ABX Actions Production Patterns#

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

NeedABX actionOrchestrator workflow
Short integration call, tag/property mutation, webhookYesPossible, heavier
Long-running, multi-step with human interaction or waitsFlow action up to 5 hYes (hours/days, resumable)
Rich plug-in ecosystem (vSphere, NSX, REST hosts, SOAP, AD)Limited to what the script importsYes
Reuse as Day-2 resource action or custom resource lifecycleYesYes

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 Broker & Subscription Model#

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 topicBlockableIssued
Approval EventsYesWhen an action that requires approval is triggered
Compute allocationYesBefore resource names and host selections are allocated (both modifiable); once per cluster of machines
Compute reservationYesAt reservation time; placement order can be changed
Compute provisionYesBefore the resource is provisioned at the hypervisor; per machine; allocated IP can be changed
Compute initial power onYesAfter provisioning, before first power-on (vSphere only)
Compute post provisionYesAfter a resource is provisioned; per machine
Compute removal / Compute post removalYesBefore / after a compute resource is removed
Compute gateway, NAT provisioning and removal (pre/post)YesAround network gateway and NAT resources
Compute post migration reconcile statusNoAfter a managed VM moved by vMotion is reconciled
Custom resource post provisionYesAfter custom-resource operations
Template configuration / Template version configurationNoOn 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.

Service Broker Catalog Design#

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 toPolicyPurpose
Catalog requestsApproval PolicyApprovers must accept before provisioning; pending items appear in the approvers' Inbox
Catalog requestsDay 2 Action PolicyWhich users or groups may run which actions on deployed resources
Catalog requestsLease PolicyMaximum lifetime of a deployment; on expiry the deployment is destroyed and resources reclaimed (with grace/extension settings)
IaaS services requests (All Apps)IaaS Resource PolicyPolicy-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.

Approval policies (VCF 9.0.1 — Configure Approval Policies)

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

Git integration (VCF 9.0.1 — Git integrations; Prepare Your GitLab Environment)

  • 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

  1. Lint and schema-validate YAML and Terraform on every pull request.
  2. Deploy to a sandbox project from the branch; run a smoke test (deployment succeeds, outputs present, subscriptions fired).
  3. 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.
  4. 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.

VCF Automation API Mastery#

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)

  1. 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.
  2. 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>
  1. Call the APIs with Authorization: Bearer <access token>; when it expires, repeat step 2 — the API token is the refresh token.
  2. To control access-token expiry, register an OAuth client and use its token instead.
  3. 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.

API surfaces

SurfaceUsed for
Provider Management Portal APIRegions, Supervisors, Zones, Namespace Classes, organizations, identity providers, certificates, rights bundles, quotas
Organization portal APIs (All Apps)Projects, namespaces, VPCs, content libraries, policies, catalog
Kubernetes API layerOrganization 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 PowerCLIPython/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#

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.

Exam Mapping: 3V0-21.25 — Advanced VCF 9.0 Automation

  • 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 3 — Extensibility: ABX actions, event subscriptions, Orchestrator workflows, custom resources, resource (Day-2) actions, external integrations
  • Section 4 — Multi-Cloud Governance: multi-organization tenancy, roles, approval policies, lease policies, quotas, content sharing, VPC-based isolation
  • 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

Labs in This Section

📝 Quiz — VCAP Advanced Automation

0/55 correct

Architecture and Design

Q1
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
  • VM-Apps-Org
  • Single shared project
  • Legacy vRA tenancy
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.
Q2
Which VCF Automation microservice primarily handles catalog/blueprint compilation and deployment orchestration?
  • RabbitMQ broker only
  • PostgreSQL
  • Blueprinting/Deployment service
  • Identity Broker
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.
Q3
For active/active high availability of VCF Automation services, the recommended deployment uses:
  • Manual DNS failover
  • External vCenter HA only
  • A single node with snapshots
  • VMSP-based multi-node cluster with pod replicas across nodes
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.
Q4
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.
Q5
Integration with NSX VPC for All-Apps-Org primarily delivers:
  • Shared flat networks across all tenants
  • L2 bridging to legacy VLANs only
  • Per-tenant isolated networking with self-service subnet provisioning
  • Gateway firewall bypass
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.

Blueprint and Template Design

Extensibility

Multi-Cloud Governance

GitOps and Operations

🃏 Flashcards — VCAP Advanced Automation

54 cards
Card 1 of 54
VMware Management Services Platform (VMSP)
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.
Was this page useful?
Type to search. ↑ ↓ to move, Enter to open, Esc to close.