Academy/VCP-VCF 9.0 Administrator (2V0-17.25)/Lab: Configure Multi-Tenant Project with Approval Policy and On-Demand Network
This lab targets VCF 9.0

Lab: Configure Multi-Tenant Project with Approval Policy and On-Demand Network

VCF 9.0Advancedadminautomationnetwork⏱ 120 min

Objectives

  • Create multi-tenant project with resource limits, naming conventions, and role assignments
  • Configure approval policies with conditional triggers and escalation
  • Set up on-demand NSX network profiles (routed and isolated)
  • Deploy templates with on-demand network and verify full network lifecycle
  • Configure lease management and resource reclamation to prevent sprawl
  • Design multi-tenancy at scale strategy for VCDX defense

Prerequisites

VCF Automation deployed with cloud accounts connected (Lab 13 completed). Cloud template 'Lab Web Server' available.

Prior labs: vcp-admin-13

Required skills:

  • VCF Automation UI navigation
  • NSX networking (Tier-0/Tier-1 gateways, segments)
  • Cloud template YAML syntax
  • Multi-tenancy concepts

Lab Environment

Holodeck VCF pod with VCF Automation and NSX integration. Tier-0 gateway configured with uplink. Tier-1 gateway available for on-demand segment attachment.

Credentials

SystemUsernamePassword
VCF Automationadmin
NSX Manageradmin

Tasks

Task 1 Create Multi-Tenant Project with Resource Governance

security

Projects are the primary resource boundary and tenancy unit in VCF Automation. Configuring resource limits, naming conventions, cloud zone mappings, and role assignments demonstrates enterprise multi-tenancy design — a key Obj 4.4 topic.

Step 1

Create project: VCF Automation → Administration → Projects → New Project. Name='dev-team-alpha'. Description='Development team Alpha - web application workloads'. Add members: assign test user with 'Member' role, assign admin with 'Administrator' role.

Project created with two members in different roles.
Project roles: Administrator = full control (templates, deployments, policies). Member = deploy from catalog, manage own deployments. Viewer = read-only. Supervisor = approve requests. Role granularity is critical for governance.
Assigning all users as Administrator — violates least-privilege principle
Not adding a Supervisor role — approval policies won't have an approver
Step 2

Configure resource limits: Project → Provisioning tab → Cloud Zones. Add 'Lab-Zone-01' with limits: Max Instances=10, Max CPU=40, Max Memory=80 GB, Max Storage=500 GB. Set priority=1 (if multiple zones, priority determines placement preference).

Cloud zone added to project with resource limits enforced.
Resource limits prevent any single project from consuming all infrastructure. Without limits, one team's runaway automation can starve others. In VCDX defense, explain how limits map to business unit budgets.
Setting limits too low — legitimate deployments get blocked, creating frustration
Not setting any limits — defeats the purpose of multi-tenancy governance
Step 3

Configure custom naming: Infrastructure → Administration → Custom Names → New Custom Name. Scope: Project (assign 'dev-team-alpha'). New Naming Template: Resource type = Machine, Template format = 'dta-${resource.name}-${###}'. Example output: 'dta-web-vm-001' (14 characters, within the 15-character Windows hostname limit). Use the preview to verify the format (VCF 9.0.1 docs pp.6309-6315).

Custom naming template configured. Preview shows expected VM name format.
Naming conventions enable: (a) quick identification of VM ownership, (b) cost allocation via name-based grouping, (c) audit trail for compliance. Use a short project code prefix (not the full project name) to identify the tenant and stay within 15 characters.
Naming templates that exceed 15-character Windows hostname limit — truncation causes unpredictable names
Not including a numeric suffix — name collisions when deploying multiple instances
Step 4

Create a second project for comparison: Name='qa-team-beta'. Members: different test user as Member. Cloud Zone: same 'Lab-Zone-01' but with different limits (Max Instances=5, Max CPU=20). Naming: project-scoped custom name 'qab-${resource.name}-${###}' (for example 'qab-web-vm-001', 14 characters).

Second project created with different limits and naming convention.
Two projects sharing the same cloud zone demonstrates multi-tenancy: both deploy to the same infrastructure, but with independent governance, limits, and naming. This is exactly how enterprise VCF environments work.
Step 5

Test project isolation: Login as dev-team-alpha member → verify only 'Lab Web Server' templates shared with this project are visible. Login as qa-team-beta member → verify nothing is visible (no content shared yet). This confirms project-level content isolation.

Each project member sees only content shared with their project.
Content isolation is automatic — no additional configuration needed beyond content sharing (Lab 13 Task 5). This is the second layer of multi-tenancy after resource limits.

Validation Gate

Check: Two projects created with different resource limits, naming conventions, and member isolation verified

Expected: Projects visible with configured governance settings. Content isolation confirmed between projects.

Task 2 Configure Approval Policies with Conditional Triggers and Escalation

security

Approval policies enforce governance by requiring human review before provisioning. Conditional triggers allow granular control — small deployments auto-approve, large deployments require manager approval. This is critical for enterprise VCF deployment governance.

Step 1

Create approval policy: VCF Automation (VM Apps organization) → Content and Policies → Policies → Definitions → New Policy → Approval Policy (VCF 9.0.1 docs p.6211; All Apps: Manage & Govern → Policies → Definitions, p.5983). Name='Standard Deployment Approval'. Scope: Project='dev-team-alpha'. Approver mode: Any (any one listed approver can approve).

Approval policy shell created, scoped to dev-team-alpha project.
Approval policies can be scoped to: organization (all projects), specific project, or specific catalog item. Project-level scope is most common in multi-tenant environments.
Step 2

Configure conditional trigger: In the approval policy, add criteria:

Condition 1: 'When deployment request count > 2' (if requesting more than 2 VMs)
Condition 2: 'When flavor = large' (if requesting large VMs)

Approval type: User based. Approvers: admin user. Auto expiry decision: Reject. Auto expiry trigger: 3 (days the approvers have to respond; VCF 9.0.1 docs p.5984).

Approval policy with two conditional triggers configured.
Conditional triggers avoid approval fatigue. Small dev deployments (1-2 small VMs) auto-approve; large production deployments require review. This balances agility with governance.
Setting conditions too broadly — everything requires approval, defeating self-service
No timeout configured — pending approvals block resources indefinitely
Only one approver with no backup — approval bottleneck when approver is unavailable
Step 3

Create a second approval policy for higher-risk actions: Name='Production Change Approval'. Scope: apply when template has tag 'environment:prod'. Configure two-approver approval:

Approval type: User based
Approvers: technical reviewer (project admin) and change manager (organization admin)
Approver mode: All (every listed approver must approve; one rejection denies the request)
Auto expiry decision: Reject
Auto expiry trigger: 5 (days)

The trigger is a number of days, not business days (VCF 9.0.1 docs pp.5983-5984).

Approval policy requiring both approvers (Approver mode All) created for production deployments.
Requiring both a technical reviewer and a change manager maps to enterprise change management (ITIL): technical feasibility plus business/risk approval. In VCF, this aligns with CAB (Change Advisory Board) processes.
Circular approval chains — user is both requester and approver
No escalation path — stuck approvals with no resolution mechanism
Step 4

Test approval workflow: Login as dev-team-alpha member → Service Broker → Catalog → request 'Lab Web Server' with count=3 (triggers condition: count > 2). Verify: deployment shows 'Pending Approval'. Login as admin → Approvals → review request → Approve.

Request paused at 'Pending Approval'. After admin approval, deployment proceeds.
The approval workflow creates an audit trail: who requested, who approved, when, and any comments. This audit trail is essential for compliance reporting.
Step 5

Test auto-expiry: the Auto expiry trigger is set in whole days, so there is no minute-level shortcut. For the lab, edit 'Standard Deployment Approval' to Auto expiry trigger = 1 with Auto expiry decision = Reject. Login as member → request another deployment with count=3 and do not approve it. The next day, verify the request was rejected automatically and the requester was notified (VCF 9.0.1 docs p.5984).

Request rejected automatically after the Auto expiry trigger period (1 day).
Auto-deny prevents resource reservation leaks. Without timeout, pending approvals can hold resource allocations indefinitely, blocking other deployments.
Setting timeout too short — legitimate approvals denied before approver can review
Not notifying approvers about pending requests — approval sits unnoticed

Validation Gate

Check: Approval policies with conditional triggers operational, two-approver (Approver mode All) policy configured, auto-expiry rejection verified

Expected: Deployment requests requiring approval pause correctly. Approval and auto-deny workflows functioning.

Task 3 Configure On-Demand NSX Network Profiles and Deploy

manageability

On-demand networks are created dynamically per deployment — demonstrating deep VCF Automation + NSX integration. This is a differentiating VCF capability (not available in VVF) and a high-value VCDX design topic.

Step 1

Configure on-demand routed network: Infrastructure → Network Profiles → edit 'Lab-Network-Profile' (from Lab 13) → Networks tab → On-Demand Networks → Add. Configure:

Type: Routed
CIDR: 172.16.0.0/16
Subnet Size: /24
Tier-1 Gateway: Select existing Tier-1 (or 'Create new' for per-deployment isolation)
Transport Zone: Overlay transport zone
IP Range: DHCP (or static with Automation-managed IPAM)

On-demand routed network configuration added to network profile.
Routed on-demand networks are attached to a Tier-1 gateway and allow East/West traffic between routed networks; reachability from upstream depends on Tier-1/Tier-0 route advertisement. For one-way (NAT) access to upstream networks use networkType: outbound; for no outside access use private (VCF 9.0.1 docs p.6144). Each deployment gets its own /24 subnet from the CIDR.
CIDR pool too small — exhausted quickly with many deployments. Use /16 minimum for production
Selecting wrong transport zone — must match NSX overlay transport zone configured during VCF deployment
Not connecting Tier-1 to Tier-0 — on-demand segments are created but have no upstream connectivity
Step 2

Configure the on-demand isolated (private) network in a second network profile, so that it has its own CIDR and capability tag: Infrastructure → Network Profiles → New Network Profile 'Lab-Isolated-Profile' (same account/region), capability tag 'env:lab-isolated' → Network Policies → Create an on-demand network:

Transport Zone: Overlay transport zone
CIDR: 10.100.0.0/16
Subnet Size: /24
No external subnet (private networks do not allow any outside access)
DNS: Internal DNS server IP

The cloud template requests this network with networkType: private (VCF 9.0.1 docs pp.6144-6145).

Second network profile 'Lab-Isolated-Profile' with an on-demand private network policy and capability tag 'env:lab-isolated'.
Private (isolated) networks do not allow any outside access — VMs can communicate within the segment only. Use for: database tiers that should not be internet-accessible, internal application communication, PCI-DSS isolated workloads.
Confusing private with outbound — private allows no outside access; outbound gives one-way (NAT) access to upstream networks
Not providing DNS for isolated networks — VMs can't resolve hostnames
Step 3

Create multi-network template using both on-demand types:

formatVersion: 1
inputs:
  size:
    type: string
    enum: [small, medium]
    default: small
resources:
  web-vm:
    type: Cloud.vSphere.Machine
    properties:
      image: ubuntu-2204
      flavor: '${input.size}'
      networks:
        - network: '${resource["web-net"].id}'
  app-vm:
    type: Cloud.vSphere.Machine
    properties:
      image: ubuntu-2204
      flavor: '${input.size}'
      networks:
        - network: '${resource["web-net"].id}'
        - network: '${resource["db-net"].id}'
  web-net:
    type: Cloud.NSX.Network
    properties:
      networkType: routed
      constraints:
        - tag: 'env:lab'
  db-net:
    type: Cloud.NSX.Network
    properties:
      networkType: private
      constraints:
        - tag: 'env:lab-isolated'
Multi-tier template with routed (web) and isolated (DB) networks created.
This template demonstrates the classic 3-tier pattern: web tier on a routed network (reachable from upstream only if the Tier-1/Tier-0 advertise it), app tier dual-homed with one NIC on each network, DB tier on a private network (internal only). Dual-homing is a lab shortcut: app-to-DB traffic no longer crosses a gateway, so no Gateway Firewall sees it; the DFW still filters each of the app VM's vNICs (vDefend Distributed Firewall docs: a firewall is instantiated on each virtual NIC), but the guest itself now joins the two segments. In a production design justify it or route app-to-DB traffic through a gateway with Gateway Firewall/DFW policy.
Using 'isolated' instead of 'private' in YAML — VCF Automation uses 'private' for isolated networks in template syntax
Assuming NSX DFW rules can connect segments — the DFW filters traffic at each vNIC but does not route; a private segment needs a routed path, or a dual-homed VM, which joins the segments through the guest and must be justified
Step 4

Deploy the multi-network template. Monitor in real-time:

  1. VCF Automation: Deployments → watch resource creation steps
  2. NSX Manager: Segments → observe new segments appearing dynamically
  3. NSX Manager: Tier-1 Gateways → observe routed segment attachment
  4. vCenter: VMs created, NICs connected to correct segments
Two VMs deployed. Two NSX segments created dynamically. Web segment attached to Tier-1 gateway. DB segment isolated. App VM dual-homed.
This cross-platform observation (Automation → NSX → vCenter) is powerful for understanding the full orchestration chain. Each platform shows a different perspective of the same deployment.
Step 5

Verify network lifecycle: Delete the deployment. Monitor cleanup:

  1. VCF Automation: Deployment deleted
  2. vCenter: VMs removed
  3. NSX Manager: Both on-demand segments deleted automatically
  4. NSX Manager: Tier-1 gateway connection cleaned up

Verify: no orphaned segments remain in NSX Manager.

Complete cleanup. No orphaned NSX segments or Tier-1 gateway connections.
Automatic network lifecycle management is a key value proposition: NSX segments are created per-deployment and destroyed on deletion. No manual network cleanup needed. Compare this to traditional networking where VLAN provisioning is a multi-day ticket.
Orphaned segments if Automation-NSX integration breaks during deletion — check NSX cloud account connectivity
Deletion blocked if VMs have active connections or DFW rules referencing the segment

Validation Gate

Check: On-demand routed and isolated networks deployed via cloud template, then cleanly destroyed with no orphaned NSX resources

Expected: Full network lifecycle verified: dynamic creation → VM attachment → deletion → cleanup

Task 4 Configure Lease Management and Resource Reclamation

manageability

Lease management prevents resource sprawl by automatically expiring deployments. Combined with VCF Operations Reclaim, it ensures unused infrastructure is recovered. This addresses the #1 concern with self-service: uncontrolled resource consumption.

Step 1

Create a lease policy: VCF Automation (VM Apps organization) > Content and Policies > Policies > Definitions > New Policy > Lease Policy (VCF 9.0.1 docs p.6220; All Apps: Manage & Govern > Policies > Definitions > New Policy > Lease Policy, p.5991). Scope: project 'dev-team-alpha'. Maximum Lease = 7 days, Maximum Total Lease = 30 days, Grace period = 3 days. Leases are policies scoped to organization or project, not a project Provisioning-tab setting (VCF 9.0.1 docs pp.5990-5991).

Lease policy created and applied to deployments in 'dev-team-alpha'.
Maximum Lease is the initial active period; renewals up to Maximum Total Lease; Grace period is the time between expiry and deletion. If no grace period is set it defaults to 1 day, so expiry never destroys immediately. With no lease policy at all, deployments never expire.
Assuming no grace period means immediate destruction — it defaults to 1 day
Maximum Total Lease too long (365 days) — defeats the purpose of lease management
Expecting increased lease values to extend existing deployments — updated policies apply to new deployments only
Step 2

Configure lease notifications: VCF Automation emails deployment owners through the system notification scenarios 'Deployment Lease Expiring' and 'Deployment Lease Expired' (an email server must be configured); no separate lease-notification policy surfaced in the VCF 9.0.1 docs. Customise the text: Administer → Notifications → Scenarios → expand 'Deployment Lease Expiring' → Customize → edit subject and body (for example 'Your deployment is about to expire. Renew it or save your work.') → Preview → Save → Send test. Repeat for 'Deployment Lease Expired' (VCF 9.0.1 docs p.6014; scenario names p.287).

Lease Expiring and Lease Expired notification emails customised with organisation text; test email received.
Notifications are the user-friendly side of lease management. Without notifications, lease enforcement feels punitive. With notifications, it feels like a managed lifecycle.
Step 3

Test lease lifecycle: Deploy a catalog item with default 7-day lease. Check deployment details → Lease tab → verify expiry date. Test lease extension: Actions → Extend Lease → request 7 additional days. Verify total lease doesn't exceed maximum (30 days).

Deployment created with 7-day lease. Lease extended to 14 days. Extension beyond 30 days blocked.
Lease extension requests can be configured to require approval — useful for production deployments where extensions should be justified.
Step 4

Configure resource reclamation in VCF Operations (reclamation is a VCF Operations capability, not a VCF Automation policy):

  1. VCF Operations → Home → Optimize Capacity → Reclaim, then click the Settings link on the Reclaim page: review how idle VMs, powered-off VMs and snapshots are defined (VCF 9.0.1 docs p.3352)
  2. On the Reclaim page select the data center and the cluster behind 'Lab-Zone-01', select idle VMs owned by the lab projects → SCHEDULE ACTION → create a job (for example Power off idle VMs) with email updates
  3. For oversized VMs use Home → Optimize Performance → Rightsizing and schedule a downsize job only after owner agreement
  4. Review and edit the scheduled jobs under Operations → Automation Central

VCF Automation leases handle time-based expiry; VCF Operations Reclaim handles utilisation-based waste (VCF 9.0.1 docs pp.3349-3355).

Reclaim settings reviewed; a scheduled reclaim job with email updates visible in Automation Central; oversized VMs reviewed in Rightsizing.
Reclamation addresses the gap between lease management (time-based) and actual usage. A VM with a valid lease but zero utilization is wasting resources. Reclamation identifies these waste patterns.
Aggressive reclamation thresholds — flagging VMs that are legitimately idle (batch jobs, standby servers)
Auto-destroying idle VMs without notification — users lose important development environments
Step 5

Create a governance summary report: Review across all projects:

  1. Total active deployments per project
  2. Resource consumption vs limits (% utilized)
  3. Deployments approaching lease expiry (next 7 days)
  4. Idle/oversized VMs flagged for reclamation
  5. Approval requests pending

Document this as the 'Multi-Tenant Governance Dashboard' data source for VCF Operations (Lab 11-12 integration).

Governance summary showing cross-project resource utilization, lease status, and reclamation candidates.
This summary view is what IT leadership wants: visibility into self-service consumption patterns, compliance with governance policies, and actionable waste reduction recommendations.

Validation Gate

Check: Lease policy configured, lease notification emails customised, lease extension tested, reclaim job scheduled in VCF Operations, governance summary reviewed

Expected: Full lifecycle governance operational: lease enforcement → notification → extension → reclamation

Task 5 Multi-Tenancy at Scale Design and VCDX Defense

manageability

This capstone task synthesizes all VCF Automation concepts (projects, templates, approval, networking, leases) into a cohesive multi-tenancy strategy suitable for VCDX defense. The focus shifts from technical configuration to architectural design rationale.

Step 1

Document a multi-tenancy reference architecture for 10 development teams:

  1. Project Structure: 10 projects (one per team), shared cloud zones with per-project resource limits
  2. Template Strategy: Shared template library (org-level) + team-specific templates (project-level)
  3. Network Isolation: On-demand routed networks for externally-facing workloads, isolated for internal/PCI
  4. Approval Matrix: Dev environment = auto-approve, Staging = tech lead approval, Production = CAB approval
  5. Lease Policy: Dev = 7 days, Staging = 30 days, Production = no expiry (managed by change request)
  6. Cost Allocation: Per-project costing via VCF Operations custom groups + rate cards
Multi-tenancy reference architecture documented with 6 design pillars.
This reference architecture is your VCDX design document for VCF Automation. Each pillar has a clear design decision with rationale.
Step 2

Design NSX IP planning for on-demand networks at scale:

Assume: 10 teams, average 20 active deployments per team, each deployment needs 1 routed + 1 isolated subnet.

Calculation:

  • Total subnets needed: 10 teams x 20 deployments x 2 networks = 400 subnets
  • Each subnet is /24 (254 usable IPs)
  • Routed pool: 172.16.0.0/12 (1,048,576 IPs = 4,096 /24 subnets) — sufficient
  • Isolated pool: 10.0.0.0/8 (16,777,216 IPs = 65,536 /24 subnets) — sufficient

Document: CIDR allocation per team for troubleshooting (172.16.0.0/16 for team 1, 172.17.0.0/16 for team 2, etc.).

IP planning document with per-team CIDR allocation.
IP exhaustion is the #1 operational risk with on-demand networking at scale. Pre-planning CIDR allocation prevents mid-production IP pool exhaustion. Include buffer for growth.
Step 3

Design escalation matrix for approval bottlenecks:

  1. If primary approver doesn't respond within 24 hours → notify backup approver
  2. If backup approver doesn't respond within 24 hours → auto-escalate to org admin
  3. If deployment is tagged 'emergency' → bypass normal approval, require post-deployment review
  4. Weekly report: approval response times, auto-denied requests, emergency bypasses

Document as an operational runbook for VCF Automation governance.

Escalation matrix documented with SLAs per approval level.
Approval bottlenecks are the most common complaint about governance. Having a documented escalation path with SLAs prevents self-service from degrading into a ticket system.
Step 4

VCDX Defense Preparation — document responses:

  1. 'How do you design a multi-tenant VCF Automation environment for 10 development teams?'

Answer: Project-per-team model with shared cloud zones and per-project resource limits. Capability tags control placement. Naming conventions enable cost allocation. Content sharing controls template visibility. This balances isolation with infrastructure efficiency.

  1. 'What's the network isolation strategy with on-demand NSX segments?'

Answer: Routed for tiers that need upstream reachability (web, with Tier-1/Tier-0 route advertisement), private (isolated) for internal/sensitive tiers (database). Per-team CIDR allocation prevents IP conflicts. Tier-1 gateway per deployment provides routing isolation. NSX DFW micro-segmentation adds application-level security within segments.

  1. 'How do you prevent IP exhaustion with on-demand networking?'

Answer: Pre-allocate CIDR blocks per team (/16 each from a /12 pool). Monitor subnet utilization via NSX Manager API. Alert at 80% pool utilization. Lease policies destroy expired deployments and reclaim their resources (VCF 9.0.1 docs p.5981, p.5990); without a lease policy, deployments never expire. VCF Operations Reclaim targets idle and powered-off VMs, snapshots and orphaned disks, not NSX segments. Emergency procedure: expand pool or consolidate underutilized team allocations.

  1. 'What happens when an approver is unavailable for a week?'

Answer: Escalation matrix with backup approvers. 24-hour SLA per approval level. Emergency bypass for critical deployments with post-review. Weekly governance report tracks approval response times and identifies bottleneck approvers.

  1. 'How do you justify the complexity of VCF Automation to leadership?'

Answer: ROI model — compare manual provisioning (5 days average, 2 hours admin time per VM) vs self-service (15 minutes, zero admin time). At 100 VMs/month: manual = 200 admin hours, self-service = 10 hours (governance overhead). Annual savings = 2,280 admin hours. That's the productivity argument. The governance argument: automated compliance, audit trail, and cost transparency.

Five VCDX defense responses documented with quantified business justification.
VCDX panelists test architectural depth AND business justification. Having both technical design rationale and quantified ROI makes your defense bulletproof.

Validation Gate

Check: Multi-tenancy reference architecture documented, IP planning completed, escalation matrix designed, VCDX defense responses prepared

Expected: Comprehensive multi-tenancy design with operational governance and VCDX defense readiness

Final Validation

Multi-tenant projects configured with governance, approval policies with conditional triggers and escalation, on-demand NSX networking for routed and isolated topologies, lease management with reclamation, and VCDX-ready multi-tenancy reference architecture.

✓ Two projects with different resource limits and naming conventions → Project isolation verified — content and resource boundaries enforced

✓ Approval policies with conditional triggers → Small deployments auto-approve, large deployments pause for approval

✓ On-demand routed and isolated NSX segments created and cleaned up → Network lifecycle tied to deployment lifecycle — no orphans

✓ Lease policy with Maximum Lease, Maximum Total Lease and Grace period → Maximum Lease 7 days, Maximum Total Lease 30 days, Grace period 3 days scoped to the project; expiring deployments email the owner

✓ Reclaim job in VCF Operations for idle VMs → Idle VMs identified on the Reclaim page; scheduled job with email updates listed in Automation Central

✓ Multi-tenancy reference architecture for 10 teams documented → Project structure, network isolation, approval matrix, IP planning, escalation — all documented

Cleanup / Restore

• Delete test deployments

• Take snapshot 'post-multi-tenant-lab'

• Note: Leave projects and policies configured for future lab reference

Design Reflection (VCDX)

Panelist: How do you design a multi-tenant VCF Automation environment for 10 development teams? What's the network isolation strategy with on-demand NSX segments? How do you prevent approval bottlenecks while maintaining governance?

Requirements

  • Multi-team self-service with resource isolation and content boundaries
  • Automated network provisioning per deployment with routed and isolated options
  • Cost control via lease management and resource reclamation
  • Governance via approval policies with conditional triggers and escalation
  • IP address management at scale for on-demand NSX segments

Constraints

  • On-demand networking requires NSX integration (not available in VVF)
  • Approval workflows add latency to provisioning — must balance governance with agility
  • Resource limits may block legitimate large deployments — need exception process
  • IP pool sizing limits maximum concurrent on-demand segments
  • Lease enforcement may destroy active development environments

Assumptions

  • Teams accept project-based tenancy model with per-team resource limits
  • Lease policies acceptable to all teams (dev teams expect shorter leases, prod expects longer)
  • NSX IP range large enough for on-demand segments at expected scale
  • Backup approvers available for escalation within SLA
  • Reclamation thresholds tuned per workload type (batch jobs have different patterns than web servers)

Risks

  • IP exhaustion if on-demand segments not cleaned up — monitor pool utilization
  • Approval bottleneck if primary approver unavailable — escalation matrix mitigates
  • Naming collisions across projects — project name prefix prevents but relies on convention enforcement
  • Lease expiry destroying active workloads — notifications and grace period mitigate
  • Resource limit conflicts — one team needs more than allocated, requiring governance process to adjust

Self-Assessment Discussion Prompts

  1. How would you design approval workflows that don't create bottlenecks?
  2. What's the NSX IP planning strategy for on-demand networks at scale?
  3. How do you balance lease management enforcement with developer productivity?
  4. What's the operational model for managing 10+ projects with different governance requirements?
  5. How would you handle a team that consistently exceeds their resource limits?

Extensions

Implement RBAC with Active Directory group-based project membership for automated onboarding

Create a self-service portal using VCF Automation custom forms with organization-specific branding

Integrate on-demand networking with Infoblox IPAM for enterprise IP address management

Build automated compliance reports showing per-project governance adherence

⚠ Known Pitfalls

Deploying multi-tenancy without adequate IP planning — leads to IP exhaustion at scale
Single approver per project without backup — creates availability-dependent bottleneck
Lease policies without notifications — destroys developer trust in self-service platform
VCF Operations Reclaim settings and jobs that are too aggressive — flags legitimate idle workloads (batch, DR standby)
Not testing approval workflows end-to-end as a non-admin user — admin bypass masks governance gaps

References

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