Academy/VCP-VCF 9.0 Administrator (2V0-17.25)/Lab: Deploy VCF Automation and Create Cloud Template Catalog
This lab targets VCF 9.0

Lab: Deploy VCF Automation and Create Cloud Template Catalog

VCF 9.0Advancedadminautomation⏱ 150 min

Objectives

  • Deploy VCF Automation appliance and complete initial configuration
  • Add vCenter and NSX cloud accounts with validation
  • Create cloud zones, flavor mappings, image mappings, and network profiles
  • Design and deploy a multi-resource cloud template with VM + NSX network
  • Implement template versioning, inputs, and Day-2 action configuration
  • Publish template to Service Broker catalog with governance controls

Prerequisites

VCF management domain with VCF Operations, vCenter, and NSX Manager operational. Sufficient management-cluster resources for the chosen VCF Automation model (Simple: one Small node; High Availability: three Medium or Large nodes; VCF 9.0.1 docs p.494 Table 18 — take the per-node vCPU/RAM figures from the VCF 9.0 Automation sizing documentation). VM template available in Content Library.

Prior labs: vcp-admin-01

Required skills:

  • YAML syntax and structure
  • NSX segments and Tier-1 gateway concepts
  • VM templates and Content Libraries
  • Infrastructure-as-Code principles

Lab Environment

Holodeck VCF pod with management domain. VCF Automation deployed as nested VM. NSX configured with Tier-0/Tier-1 gateways.

Credentials

SystemUsernamePassword
vCenteradministrator@vsphere.local
VCF Automationadmin
NSX Manageradmin

Tasks

Task 1 Deploy VCF Automation Appliance and Initial Configuration

manageability

VCF Automation is the self-service and governance engine of VCF (not available in VVF). It is deployed by the VCF Installer or as a Day-N operation from VCF Operations fleet management, and runs as containers on a Kubernetes cluster that fleet management provisions on dedicated appliance nodes (VCF 9.0.1 docs p.494). This lab uses a VM Apps organization — the Aria Automation 8.x-style model kept in VCF 9.0 (Assembler/Service Broker). The All Apps model (Regions, provider networking, provider content library, organization VPC networking), which carries most Obj 4.4 bullets, is covered separately. Deployment and initial configuration is exam-relevant for Obj 4.4.

Step 1

Pre-flight check: verify resources in the management domain cluster. The Simple model is a single Small node (Table 18, p.494); the High Availability model is a three-node cluster of Medium or Large nodes. Confirm the management cluster has headroom for the chosen size in vCenter > Cluster > Monitor > Resource Reservation, and that the VCF Automation install binary is present in fleet management Binary Management.

Sufficient resources confirmed in the management cluster; install binary available.
Simple (single Small node) is for POC, evaluation, small non-critical, dev/test; High Availability (3 x Medium or Large) for production. Scaling a Simple node to Medium/Large forces the scale-out to three nodes.
Insufficient capacity in the management cluster makes the fleet management deployment fail at the infrastructure stage
Deploying to a workload domain instead of the management domain — Automation must run in the management domain
Step 2

Deploy from fleet management: in VCF Operations go to Fleet Management > Lifecycle and click Add on the automation tile. Deployment: Installation type New Install, Version 9.0.x, Deployment type Small (lab). Certificate: select or Add Certificate. Infrastructure: management-domain vCenter, cluster, folder, resource pool, network, datastore. Network: domain name, search path, DNS servers, time sync (NTP), IPv4 gateway and netmask. Components: node FQDN/IP and the admin password (Add Password). Run the precheck and submit.

Fleet management request runs; VCF Automation appliance node(s) appear in the management vCenter inventory.
Use static IPs and working forward and reverse DNS for the node FQDN. VCF 9.0.1 docs pp.3066, 3115.
Step 3

Monitor the request in VCF Operations (Fleet Management > Lifecycle request details and Fleet Management > Tasks). Fleet management provisions the Kubernetes cluster on the appliance node(s) and deploys the VCF Automation containers; allow 30-45 minutes. When the request completes, open the VCF Automation URL.

Request shows completed; VCF Automation login page loads.
There is no OVA boot log to watch: progress is in the fleet management request. If a stage fails, retry from the request after fixing the cause (DNS, NTP, capacity).
Trying to access the UI before the fleet management request completes leads to misleading errors
Clock skew between the Automation nodes and vCenter/VCF Operations causes authentication failures — verify NTP in the Network stage
Step 4

Access VCF Automation UI: https://vcf-auto.lab.local → login with admin credentials. Navigate through the initial setup wizard: accept EULA, configure telemetry preferences, verify the identity provider (VCF Single Sign-On through VCF Identity Broker).

VCF Automation Cloud Assembly dashboard loads successfully.
VCF 9.0 uses VCF Identity Broker for VCF Single Sign-On, consumed as an embedded service on vCenter or deployed as a multi-node appliance cluster (VCF 9.0.1 docs p.517). Connect it to Active Directory or a federated identity provider so Automation users and groups come from the corporate directory. vIDM/Workspace ONE Access was the 8.x model.
Step 5

Add vCenter Cloud Account: Infrastructure → Cloud Accounts → Add → vSphere. Enter: Name='vcsa-01', FQDN=vcsa-01.lab.local, Username=administrator@vsphere.local, Password. Click 'Validate' → then 'Add'.

vCenter cloud account shows 'Connected' status. Discovered resources: clusters, datastores, networks, templates listed.
Cloud account data collection runs every 10 minutes. Initial discovery takes 2-3 minutes. If 'Validate' fails: check network connectivity, DNS resolution, and credential permissions.
Using vCenter IP instead of FQDN — causes certificate validation issues
Insufficient permissions — the service account needs Administrator role on vCenter
Step 6

Add NSX Cloud Account: Infrastructure → Cloud Accounts → Add → NSX-T. Enter: Name='nsx-01', FQDN=nsx-01.lab.local, credentials. Associate with vCenter account (select 'vcsa-01' from dropdown). Validate and add.

NSX cloud account shows 'Connected'. Associated with vCenter cloud account.
NSX association with vCenter is critical — it enables on-demand networking in cloud templates. Without association, Cloud.NSX.Network resource type won't work.
Forgetting to associate NSX with vCenter — templates referencing NSX networks will fail
NSX Manager certificate trust issue — import NSX Manager cert into Automation trust store

Validation Gate

Check: Cloud Assembly → Infrastructure → Cloud Accounts shows both vCenter and NSX connected and associated

Expected: Both cloud accounts show 'Connected' status with discovered infrastructure resources

Task 2 Configure Cloud Zones, Flavors, Images, and Network Profiles

manageability

Cloud zones, flavors, images, and network profiles create the abstraction layer between physical infrastructure and cloud templates. These abstractions enable infrastructure-agnostic template design — a core VCF Automation principle.

Step 1

Create Cloud Zone: Infrastructure → Cloud Zones → New Cloud Zone. Name='Lab-Zone-01', Account='vcsa-01', Compute: select management cluster. Add capability tags: 'env:lab', 'tier:standard'. Set placement policy: 'default' (spread across hosts).

Cloud Zone created with management cluster compute and capability tags.
Cloud zones define WHERE templates can deploy. Capability tags are the matching mechanism — templates request capabilities, cloud zones provide them. This is the core of VCF Automation placement logic.
Not adding capability tags — templates using constraint tags won't match any cloud zone
Selecting wrong cluster — ensure the cloud zone maps to the intended compute resource
Step 2

Create Flavor Mappings: Infrastructure → Flavor Mappings → New Flavor Mapping. Create three sizes:

  1. Name='small' → Map to vcsa-01: 2 vCPU, 4GB RAM
  2. Name='medium' → Map to vcsa-01: 4 vCPU, 8GB RAM
  3. Name='large' → Map to vcsa-01: 8 vCPU, 16GB RAM
Three flavor mappings created and mapped to vCenter cloud account.
Flavors abstract VM sizing. Template authors use flavor names (small/medium/large) instead of explicit CPU/RAM values. This enables the same template to deploy with different sizes on different cloud accounts.
Creating flavors without mapping to a cloud account — they won't be usable in templates
Inconsistent naming across cloud accounts — standardize on t-shirt sizes (small/medium/large)
Step 3

Create Image Mapping: Infrastructure → Image Mappings → New Image Mapping. Name='ubuntu-2204' → Map to vcsa-01: select the Ubuntu 22.04 VM template from Content Library. Add second mapping: Name='photon-5' → Map to vcsa-01: select Photon OS 5 template.

Two image mappings created, each pointing to a Content Library VM template.
Image mappings abstract VM templates. In multi-cloud scenarios, 'ubuntu-2204' could map to different templates on different cloud accounts (vSphere template vs AWS AMI). In VCF, they map to Content Library templates.
Step 4

Create Network Profile: Infrastructure → Network Profiles → New Network Profile. Name='Lab-Network-Profile'. Account='vcsa-01'. Add existing NSX segments available for deployment (management segment, workload segments). Configure IP assignment: the cloud template in the next task (Design and Deploy Cloud Template with NSX Integration) requests assignment: static, so define a static IP range on the selected segment (a DHCP-only profile cannot satisfy a static request). Add capability tag 'env:lab' to the network profile: constraint tags in a cloud template's network components are matched to network tags and network-profile capability tags, not to cloud-zone tags (VCF 9.0.1 docs p.6144).

Network profile created with NSX segments, a static IP range and capability tag env:lab.
Network profiles define WHICH networks templates can use and HOW IPs are assigned. For on-demand networking (Lab 14), you'll add on-demand network configuration to this profile.
Not including enough IP addresses in static ranges — deployments fail with 'no available IP' error
Mixing DHCP and static assignment without clear documentation causes IP conflicts
Step 5

Verify infrastructure abstraction completeness: Infrastructure → Overview. Check that all four abstractions are configured: Cloud Zones (1+), Flavor Mappings (3), Image Mappings (2+), Network Profiles (1+). The 'Configure' tab should show no warnings.

Infrastructure overview shows all abstractions configured with no warnings.
A complete infrastructure abstraction layer is the foundation for cloud template design. Missing any component causes template deployment failures with cryptic error messages.

Validation Gate

Check: Cloud zone, flavor mappings, image mappings, and network profile all created and showing in Infrastructure → Overview

Expected: All infrastructure abstractions configured with capability tags, VM template mappings, and network configuration ready for template use

Task 3 Design and Deploy Cloud Template with NSX Integration

manageability

Cloud templates are Infrastructure-as-Code (IaC) artifacts that define deployable infrastructure. This task covers YAML template design with inputs, constraints, and NSX network integration — the core skill for VCF Automation administration.

Step 1

Create new template: Cloud Assembly → Design → New Cloud Template. Project='Lab Project', Name='Lab Web Server'. Start with the visual canvas — drag 'Cloud.vSphere.Machine' and 'Cloud.NSX.Network' onto the canvas. Connect them (draw line from VM network port to network resource).

Visual canvas shows VM connected to NSX network. YAML auto-generated.
The visual canvas and YAML editor are bidirectional — changes in one reflect in the other. For complex templates, YAML editing is faster; for learning, the canvas helps visualize relationships.
Step 2

Switch to YAML editor and refine the template:

formatVersion: 1
inputs:
  size:
    type: string
    title: VM Size
    description: Select compute size
    enum:
      - small
      - medium
      - large
    default: small
  hostname:
    type: string
    title: Hostname
    description: VM hostname (lowercase, no spaces)
    pattern: '^[a-z][a-z0-9-]{2,14}$'
resources:
  web-vm:
    type: Cloud.vSphere.Machine
    properties:
      name: '${input.hostname}'
      image: ubuntu-2204
      flavor: '${input.size}'
      customizationSpec: linux-customization
      networks:
        - network: '${resource["web-net"].id}'
          assignment: static
  web-net:
    type: Cloud.NSX.Network
    properties:
      networkType: existing
      constraints:
        - tag: 'env:lab'
YAML template with input parameters, regex validation, and NSX network reference.
Key YAML concepts: 'inputs' define user-provided values at request time. 'resources' define infrastructure. '${input.xxx}' references input values. '${resource["name"].id}' references other resources. Constraints on a machine match cloud-zone capability tags; constraints on a network component match network tags and network-profile capability tags (here env:lab on Lab-Network-Profile).
YAML indentation errors — use 2 spaces, never tabs
Missing quotes around expressions with special characters: ${resource["web-net"].id}
Constraint tag mismatch — the tag in the template must exactly match a tag on a cloud zone or network profile
Step 3

Test deploy: Click 'Deploy' → Deployment Name='test-web-01' → provide inputs (size=small, hostname='test-web-01') → Deploy. Monitor deployment progress: Deployments → click deployment → watch resource provisioning steps.

Deployment succeeds. VM created in vCenter, connected to NSX segment. Deployment status shows 'Create - Successful'.
Watch the deployment timeline — it shows each provisioning step: allocate compute → create VM → configure network → customize OS. If any step fails, the error appears here with details.
Deployment fails with 'No matching cloud zone' — check capability tag alignment between template constraints and cloud zone tags
Network attachment fails — verify NSX segments are included in the network profile
Customization fails — ensure customization spec exists in vCenter and matches the OS type
Step 4

Verify deployment in vCenter: confirm VM exists with correct name, CPU/RAM matching selected flavor, connected to expected NSX segment. In NSX Manager, verify the VM's logical port appears on the correct segment.

VM visible in vCenter with correct sizing. NSX logical port confirmed.
Cross-platform verification (Automation → vCenter → NSX) demonstrates the full integration chain. This is the operational proof that cloud templates work end-to-end.
Step 5

Delete test deployment: Deployments → select 'test-web-01' → Actions → Delete. Monitor cleanup: VM deleted from vCenter, NSX logical port removed. Verify no orphaned resources.

Deployment deleted. No orphaned VM or NSX resources.
Clean deployment lifecycle (create → use → delete) with no orphaned resources is a key VCF Automation value proposition. Compare this to manual VM provisioning where cleanup is often forgotten.

Validation Gate

Check: Cloud template deployed successfully with VM on NSX segment, then cleanly deleted with no orphaned resources

Expected: Full deployment lifecycle verified: create → verify → delete → confirm cleanup

Task 4 Template Versioning, Advanced Inputs, and Day-2 Actions

manageability

Production-grade templates need versioning for change management, advanced inputs for flexibility, and Day-2 actions for lifecycle management. These capabilities distinguish VCF Automation from simple VM provisioning.

Step 1

Version the template: Cloud Assembly → Design → open 'Lab Web Server' → click 'Version' → Version='1.0' → Description='Initial release: single VM with existing NSX network'. Release to catalog: check 'Release this version to the catalog'.

Template version 1.0 created and released.
Versioning enables rollback. If v2.0 has issues, you can revert catalog to v1.0. Always version before making significant changes.
Step 2

Enhance template with advanced inputs. Add to inputs section:

  disk_size:
    type: integer
    title: Additional Disk (GB)
    description: Size of additional data disk
    minimum: 10
    maximum: 500
    default: 50
  environment:
    type: string
    title: Environment
    enum:
      - dev
      - staging
      - prod
    default: dev

Add to web-vm properties:

      storage:
        disks:
          - capacityGb: '${input.disk_size}'
            name: data-disk
      tags:
        - key: environment
          value: '${input.environment}'
Template updated with additional disk and environment tag inputs.
Advanced inputs enable self-service consumers to customize deployments without template changes. Input validation (min/max/pattern) prevents misconfiguration at request time.
Missing minimum/maximum on integer inputs — users can request unreasonable disk sizes
Tag values not matching any downstream policies — ensure environment tags align with governance rules
Step 3

Configure Day-2 governance: in VCF Automation (VM Apps organization) go to Content and Policies > Policies > Definitions > New Policy > Day 2 Actions Policy (VCF 9.0.1 docs p.6217). Scope it to the project, choose the role (for example project member) and select the allowed actions (Resize, Add Disk, Power On/Off, Create/Revert Snapshot). Remember: the first Day 2 policy switches from 'everyone can do everything' to an inclusion list — only users matched by a policy can run the selected actions (VCF 9.0.1 docs pp.5985-5986).

Day 2 Actions policy created for the project with the selected actions.
Day 2 Actions policies are an inclusion list scoped by organization or project, role and criteria. With no policy defined there is no governance at all. (VM Apps path: Content and Policies > Policies > Definitions, VCF 9.0.1 docs p.6209/p.6217; the All Apps equivalent is Manage & Govern > Policies > Definitions, p.5986.)
Defining no Day 2 policy at all — then every user can run every action, including Delete
Defining the first policy for one role only and locking everyone else out of all actions until further policies exist
Step 4

Version the enhanced template: Version='2.0' → Description='Added data disk, environment tags, Day-2 actions'. Deploy v2.0 to verify: test with disk_size=50, environment=dev. Confirm additional disk attached and vSphere tag applied.

v2.0 deployed with additional disk and environment tag visible in vCenter.
Test every version before releasing to catalog. A broken template version in the catalog destroys user trust in self-service.
Step 5

Test Day-2 action: On the test deployment → Actions → Resize → change to 'medium'. Monitor the resize operation. Verify in vCenter that CPU/RAM updated (may require VM restart depending on hot-add configuration).

VM resized to medium flavor. CPU/RAM updated in vCenter.
Hot-add capability (add CPU/RAM without restart) depends on VM hardware version and guest OS. If hot-add isn't enabled, the resize requires a maintenance window.

Validation Gate

Check: Template versioned (v1.0 and v2.0), advanced inputs working, Day-2 actions operational

Expected: Full template lifecycle demonstrated: version → enhance → test → Day-2 operations

Task 5 Publish to Service Broker Catalog with Governance and VCDX Defense

manageability

Service Broker is the self-service storefront. Publishing templates with governance controls (content sharing, entitlements, policies) completes the admin-to-consumer handoff. This task ties together all VCF Automation concepts for VCDX defense.

Step 1

Configure content source: Service Broker → Content & Policies → Content Sources → New → VMware Cloud Templates. Select the project containing 'Lab Web Server'. Validate and save. The content source syncs templates to Service Broker.

Content source created. 'Lab Web Server' template appears in catalog.
Content sources are the bridge between Cloud Assembly (design) and Service Broker (consumption). Templates must be versioned and released to appear in Service Broker.
Step 2

Configure content sharing: Service Broker → Content & Policies → Content Sharing → Add Items. Share 'Lab Web Server' with project 'dev-team-alpha' (created in Lab 14, or create a new project). Set sharing scope: this project only.

Template shared with specific project. Only project members can see and request it.
Content sharing controls visibility. Without explicit sharing, templates are invisible to project members even if they exist in the catalog. This is the first layer of governance.
Step 3

Create custom form: Service Broker → Content & Policies → select 'Lab Web Server' → Custom Form. Customize the request form: reorder fields, add help text to inputs, group related inputs, hide advanced options behind an 'Advanced' section. Save form.

Custom request form with improved UX for self-service consumers.
Custom forms make self-service approachable for non-technical users. A well-designed form reduces support tickets and misconfiguration. Include sensible defaults and clear descriptions.
Exposing too many technical inputs to non-technical users — hide complexity behind sensible defaults
Not testing the form as a non-admin user — the admin view differs from the consumer view
Step 4

Test self-service flow: Login as a project member (non-admin). Navigate to Service Broker → Catalog → locate 'Lab Web Server'. Fill in the request form → submit. Verify deployment starts (or enters approval queue if approval policy is configured from Lab 14).

Self-service request submitted. Deployment starts or enters approval queue.
The self-service test validates the complete workflow: content sharing → catalog visibility → request form → deployment. Test as a non-admin to see exactly what consumers see.
Step 5

VCDX Defense Preparation — document responses:

  1. 'How does VCF Automation change the operational model from admin-provisioned to self-service?'

Answer: VCF Automation shifts IT from ticket-based provisioning (days/weeks) to catalog-based self-service (minutes). Admins define templates and governance; consumers request and manage their own infrastructure. The admin role shifts from provisioner to platform engineer.

  1. 'What governance controls prevent resource sprawl?'

Answer: Five layers of governance: (a) Cloud zone resource limits, (b) Project-level instance/resource quotas, (c) Lease policies with auto-expiry, (d) Approval policies for large deployments, (e) Naming conventions for auditability. Together they create a self-service model with guardrails.

  1. 'How would you design a multi-tier application template with web, app, and DB tiers on separate NSX segments?'

Answer: Three Cloud.NSX.Network resources with different networkType (routed for web-facing, isolated for app-to-DB). NSX DFW policies applied via segment tags. Tier-1 gateway for north-south traffic. Template inputs allow tier sizing independently.

  1. 'What happens when a cloud template deployment fails halfway?'

Answer: VCF Automation supports partial deployment rollback. Failed resources are cleaned up; successfully created resources can be retained (configurable). Deployment history shows exactly which step failed and why. Recovery: fix the issue and re-deploy, or manually clean up orphaned resources.

Four VCDX defense responses documented.
VCF Automation is a VCF-exclusive capability (not in VVF). Panelists will test whether you understand the operational model shift, not just the technical configuration.

Validation Gate

Check: Template published to Service Broker catalog, content sharing configured, custom form created, self-service request tested, VCDX defense responses prepared

Expected: Complete self-service workflow operational from template design to consumer request

Final Validation

VCF Automation deployed, cloud accounts connected, infrastructure abstractions configured, cloud template designed with versioning and Day-2 actions, published to Service Broker catalog with governance.

✓ Cloud accounts (vCenter + NSX) connected and associated → Both show 'Connected' with discovered resources

✓ Infrastructure abstractions complete (cloud zone, flavors, images, network profile) → All configured with capability tags and mappings

✓ Cloud template deploys VM with NSX network → VM running, connected to NSX segment, additional disk attached

✓ Template versioned (v1.0, v2.0) with Day-2 actions → Version history visible, Day-2 resize/snapshot/power operations functional

✓ Catalog item available in Service Broker → Project members can request deployment via custom form

Cleanup / Restore

Snapshot: post-vcf-automation

• Delete test deployments

• Take snapshot 'post-vcf-automation'

Design Reflection (VCDX)

Panelist: How does VCF Automation change the operational model from admin-provisioned to self-service? What governance controls prevent resource sprawl? How do you handle template versioning in a multi-team environment?

Requirements

  • Self-service VM provisioning for development teams with < 15 minute delivery
  • Network isolation per deployment via NSX integration
  • Governance via approval policies and resource limits
  • Template versioning with rollback capability
  • Day-2 lifecycle management for deployed resources

Constraints

  • VCF Automation footprint depends on the model: Simple (one Small node, no application-level HA) or High Availability (three Medium or Large nodes); size the management cluster from the VCF 9.0 Automation sizing documentation
  • Cloud templates limited to configured cloud zones and mapped resources
  • NSX integration required for on-demand networking capabilities
  • Content Library VM templates must be maintained and patched regularly

Assumptions

  • Development teams understand catalog request workflow and self-service model
  • VM templates in Content Library are hardened and approved by security team
  • NSX segments pre-configured or on-demand policies defined before template authoring
  • Naming conventions enforced at project level prevent resource identification issues

Risks

  • Resource sprawl without lease management — orphaned VMs accumulate cost
  • Stale VM templates with unpatched vulnerabilities create security exposure
  • Over-complex templates increase troubleshooting difficulty and reduce adoption
  • Single-node Automation appliance is a single point of failure for self-service platform
  • Template version conflicts in multi-team environments without branching strategy

Self-Assessment Discussion Prompts

  1. How would you design a multi-tier application template with web, app, and DB tiers on separate NSX segments?
  2. What approval workflow would you recommend for production deployments vs dev/staging?
  3. How do you handle template versioning when multiple teams contribute templates?
  4. What's the migration path from manually provisioned VMs to Automation-managed deployments?
  5. How does VCF Automation compare to Terraform for IaC in a VCF environment?

Extensions

Integrate VCF Automation with external IPAM (Infoblox) for enterprise IP address management

Create ABX (Action-Based Extensibility) scripts for custom provisioning logic (e.g., register VM in CMDB)

Design multi-cloud templates that deploy to both vSphere and public cloud via cloud accounts

Implement GitOps workflow: templates stored in Git, CI/CD pipeline deploys to Automation

⚠ Known Pitfalls

Deploying Automation with insufficient resources — services crash intermittently under memory pressure
Not associating NSX cloud account with vCenter — on-demand networking silently fails
Releasing untested template versions to catalog — breaks consumer trust in self-service
Over-engineering templates with too many inputs — simplicity drives adoption
Leaving Day 2 actions ungoverned — with no Day 2 Actions policy all users can run all actions; the first policy you create becomes the inclusion list

References

Was this page useful?
Type to search. ↑ ↓ to move, Enter to open, Esc to close.