Academy/VMware Avi Load Balancer 30.x Administrator (6V0-22.25)
VCF

VMware Avi Load Balancer 30.x Administrator (6V0-22.25)

VCF 9.0add-on exams (6V0)

Avi Load Balancer (formerly NSX Advanced Load Balancer). Controller cluster, Service Engines, virtual services, SSL/TLS, WAF, GSLB, analytics. Broadcom's recommended option for general-purpose load balancing in VCF 9, in place of the built-in NSX load balancer. Administrator exam (VMware Avi Load Balancer 30.x Administrator), 65 questions, 90 minutes, 70 % passing.

6V0-22.25
VCP
65
Questions
90m
Duration
70%
Pass Score
49
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 — Avi Architecture
~20%
Section 2 — Virtual Service Configuration
~25%High Weight
Section 3 — Application Profiles
~20%
Section 4 — Analytics and Troubleshooting
~20%
Section 5 — Operations
~15%

Version Evolution

Avi Load Balancer (formerly NSX Advanced Load Balancer, ALB; Avi Networks was acquired by VMware in 2019) is the load balancer Broadcom recommends for general-purpose L4-L7 load balancing in VCF. Evolution: (1) Architecture became modular—separate Controller (control plane, Raft consensus) from Service Engines (data plane, DPDK-based).

(2) VCF 9.0: general-purpose load balancing with the built-in NSX load balancer is no longer part of the VCF entitlement and Broadcom recommends Avi, a superset of NSX load balancing; the NSX load balancer stays entitled for VCF infrastructure components and Layer 4 load balancing for vSphere Supervisor (VCF 9.0.1 docs p.235). (3) Service Engine deployment modes evolved: bare metal for 100+ Gbps, VMs for small deployments, Kubernetes pods for cloud-native.

(4) HA modes: Elastic HA N+M (default; each virtual service on one SE, M spare SE capacity), Elastic HA Active/Active (each virtual service on two or more SEs), and Legacy HA (active/standby pair). (5) GSLB (Global Server Load Balancing) enables multi-site deployments with DNS steering and active-passive health checking. (6) Certificate management centralized; OCSP stapling and SNI routing supported. (7) Avi Controller cluster sizing critical: 3-node HA with Raft for production (can tolerate 1 node failure).

Key operational: SE sizing directly impacts throughput and connection rate; oversizing wastes resources, undersizing causes queueing.

Learning Outcomes

  • Understand VMware Avi Load Balancer 30.x Administrator concepts and architecture
  • Explain Controller cluster HA: a 3-node cluster with majority quorum tolerates one node failure; a single Controller is a single point of failure for the management plane (SEs go headless but keep serving).
  • Describe Controller failover behaviour with the documented Avi figures: 10 s heartbeat, 40 s failure detection, 50-60 s leader election, cluster VIP moves by gratuitous ARP, data plane unaffected, configuration blocked on a minority partition.

Avi Architecture & Deployment#

Avi Load Balancer (NSX Advanced Load Balancer, ALB) is a software-defined application delivery controller. Unlike traditional hardware appliances, Avi separates control plane (Controller) from data plane (Service Engines), enabling elastic scaling and multi-cloud deployment.

┌────────────────────────────────────────────────────────────────┐
│                         Control Plane                          │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │  Avi Controller Cluster (3-node HA, Raft Consensus)      │  │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐    │  │
│  │  │  Master      │  │  Replica-1   │  │  Replica-2   │    │  │
│  │  │  (Leader)    │  │  (Standby)   │  │  (Standby)   │    │  │
│  │  │  min. Small  │  │  min. Small  │  │  min. Small  │    │  │
│  │  │  6vCPU/32GB  │  │  6vCPU/32GB  │  │  6vCPU/32GB  │    │  │
│  │  └──────────────┘  └──────────────┘  └──────────────┘    │  │
│  └──────────────────────────────────────────────────────────┘  │
│                                                                │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │  Built-in analytics (on the Controller cluster)          │  │
│  │  • Real-time metrics (latency, throughput, errors)       │  │
│  │  • Logs and health scores per virtual service            │  │
│  │  • Anomaly detection on collected metrics                │  │
│  └──────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────┘
            ↓ Config (policy sync)      ↑ Metrics and logs
┌────────────────────────────────────────────────────────────────┐
│                           Data Plane                           │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │  Service Engines (SEs) - Distributed across cluster      │  │
│  │ ┌──────────────────────────────────────────────────────┐ │  │
│  │ │ SE-1 (ESX-1)        SE-2 (ESX-2)        SE-N (ESX-N) │ │  │
│  │ │ ┌────────────────┐  ┌────────────────┐               │ │  │
│  │ │ │ Virtual        │  │ Virtual        │               │ │  │
│  │ │ │ Services:      │  │ Services:      │               │ │  │
│  │ │ │ • VS-web:443   │  │ • VS-api:8443  │               │ │  │
│  │ │ │ • VS-web:80    │  │ • VS-db:3306   │               │ │  │
│  │ │ │ Pool: web-pool │  │ Pool: api-pool │               │ │  │
│  │ │ │ Throughput:    │  │ Throughput:    │               │ │  │
│  │ │ │ 5Gbps          │  │ 3Gbps          │               │ │  │
│  │ │ │ Connections:   │  │ Connections:   │               │ │  │
│  │ │ │ 100K active    │  │ 50K active     │               │ │  │
│  │ │ └────────────────┘  └────────────────┘               │ │  │
│  │ └──────────────────────────────────────────────────────┘ │  │
│  └──────────────────────────────────────────────────────────┘  │
│                   ↓ Requests to pool members                   │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │  Backend Pool Members (Physical Servers/Cloud VMs)       │  │
│  │  • web-pool: web-1, web-2, web-3                         │  │
│  │  • api-pool: api-1, api-2, api-3                         │  │
│  │  • db-pool: db-master (primary), db-replica (backup)     │  │
│  └──────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────┘

Health score per object (virtual service, pool, server, SE) = performance score minus resource, anomaly and security penalties; an anomaly is traffic outside the statistical norm for the period (Avi 31.1 Monitoring and Operability Guide: Health Score Codes).

Avi Pulse, where used, is an optional cloud-hosted Broadcom service connected to the Controller; it is not part of the control-plane cluster and does not receive configuration pushes.

Data Flow (Incoming Request):

Client → SE vNIC (ingress) → Virtual Service (VIP)

  • → Service Engine process (load balance, SSL termination, WAF)
  • → Health check & pool member selection (round-robin, consistent hash, etc.)
  • → Backend pool member
  • ← Response (SE encryption/compression, connection tracking)
  • ← Client

Controller Cluster & Raft Consensus

Controller Cluster Architecture:

Avi Controller runs as a 3-node cluster using Raft consensus for distributed decision-making. Only the leader (master) accepts configuration changes; followers replicate state.

Controller Cluster Topology (3-Node HA):

┌─────────────────┐       ┌─────────────────┐       ┌─────────────────┐
│ Controller 1    │←─────→│ Controller 2    │←─────→│ Controller 3    │
│ Master (Leader) │ Raft  │ Replica 1       │ Raft  │ Replica 2       │
│ min 6vCPU/32GB  │ TCP   │ min 6vCPU/32GB  │       │ min 6vCPU/32GB  │
└────────┬────────┘       └────────┬────────┘       └────────┬────────┘
         │                         │                         │
         └─────────────────┬───────┴─────────────────────────┘
                           │ Config Distribution
  • ↓
  • All Service Engines
  • (SEs subscribe to config
  • updates via gRPC)

Raft Consensus Protocol:

  1. Leader Election: One controller elected as leader (via Raft voting)
  2. Configuration Sync: All changes committed to leader's log
  3. Replication: Leader replicates changes to followers
  4. Commit: Change confirmed when majority (2/3) nodes acknowledge
  5. Failover: if the leader fails, the followers declare it down after 40 s (four missed 10-second heartbeats) and elect a new leader in about 50-60 s; Service Engines keep forwarding throughout (Avi 30.2 Administration Guide, Controller Cluster)

Configuration Changes Timeline:

  • Admin configures Virtual Service via Controller UI
  • ↓ (accepted by Master, logged)
  • Master logs change locally (immediate acknowledgment to admin)
  • ↓
  • Master sends "Append Log Entry" to Replicas 1 & 2
  • ↓
  • Both replicas acknowledge log entry
  • ↓
  • Master waits for majority (2/3) acknowledgment
  • ↓
  • Change marked as committed
  • ↓
  • Master pushes config to all Service Engines (gRPC)
  • ↓
  • SEs load new config, validate (syntax, semantic checks)
  • ↓
  • SEs send ACK to Controller
  • ↓
  • Configuration change complete (end-to-end: ~2-5 seconds for production scale)

Failure Scenarios:

Scenario 1: Replica 1 fails

  • Master, Replica 2 form quorum (2/3)
  • Cluster continues accepting config changes
  • Replica 1 rejoins when online, syncs latest changes

Scenario 2: Master fails

  • Followers detect no heartbeat for 40 s (heartbeat every 10 s, 4 missed = down)
  • Followers elect a new leader: about 50-60 s, during which no configuration changes and no management UI
  • New leader claims the cluster VIP (gratuitous ARP) and accepts config changes
  • Data plane: no impact — SEs keep serving with their current configuration
  • Control-plane outage for a leader failure: roughly 1.5 minutes end to end; the timers are not configurable

Scenario 3: Split brain (network partition)

  • Two partitions: Master + 1 Replica vs. 1 Replica
  • Master partition (2/3) can accept config changes
  • Replica partition (1/3) cannot (quorum lost)
  • Configuration changes blocked on replica-only partition
  • When partition heals, replica partition merges and syncs latest state

Exam Focus:

Understand Raft consensus enables HA without external coordination. 3-node cluster can tolerate 1 node failure (2/3 quorum). If you have 1 controller, any failure = complete outage. Never run single-controller deployment in production.

Service Engines & Deployment Modes

Service Engines (SEs):

Data plane entities running on physical servers, hypervisors, or cloud instances. SEs are stateful proxies (an L7 or SSL virtual service terminates the client connection and opens a separate server-side connection). SEs do communicate: in a scaled-out virtual service the primary SE receives client traffic and forwards a share of it at Layer 2 to the MAC address of secondary SEs (Avi 30.2 Configuration Guide, Virtual Service Scaling).

Service Engine Sizing (vSphere Deployment):

SE vCPU, memory and disk are set per SE Group. The documented minimum is 1 vCPU, 2 GB RAM and 15 GB of storage per SE (Avi 30.2 Installation Guide, Preparing for Installation). Throughput, SSL transactions per second and concurrent connections per SE grow with vCPU count and depend on the traffic mix (L4 or L7, SSL, WAF). Size from the per-core figures in the Avi 30.2 "Sizing Service Engines" guidance and confirm with a load test; do not rely on fixed per-size rules of thumb.

Elastic Scaling:

  • A virtual service can be scaled out to more SEs and scaled back in, manually or by an auto-scale policy; set the thresholds from measured load (check the Avi 30.2 Configuration Guide for current defaults).
  • For Elastic HA Active/Active keep Minimum Scale per Virtual Service at 2 (the default minimum in active/active mode) and set a maximum the SE Group capacity can absorb (Avi 30.2 Configuration Guide, Elastic High Availability for Avi Load Balancer Service Engines).

Deployment Modes (Access Level):

  1. Write Access (vCenter cloud, recommended): the Controller holds vCenter credentials with write rights and creates, resizes and deletes Service Engine VMs itself; VIP/SE network placement is automated.
  2. Read Access: the Controller reads vCenter inventory (networks, hosts) but cannot create VMs — SEs are deployed manually from the SE OVA and attach to the Controller.
  3. No Access (No Orchestrator): no vCenter integration; SEs are deployed and networked by the administrator, the Controller only manages them after they register. Used where vCenter credentials cannot be shared.

(Avi 30.2 Installation Guide — Deploying Avi Load Balancer Controller in VMware vCenter, Modes of Deployment.) In VCF the Avi Controller is registered as an NSX cloud (NSX Cloud Connector), which places SEs through NSX Manager rather than vCenter directly.

Key Takeaways

  • Exam Focus: Understand Raft consensus enables HA without external coordination. 3-node cluster can tolerate 1 node failure (2/3 quorum). If you have 1 controller, any failure = complete outage. Never run single-controller deployment in production.
  • SE HA modes (Avi Configuration Guide, Elastic HA): Elastic HA N+M (default) — each virtual service is placed on one SE, M buffer SEs absorb M SE failures by re-placing the VSs; Elastic HA Active/Active — each VS runs on at least two SEs (Minimum Scale per Virtual Service, default 2) so an SE loss removes capacity, not availability; Legacy HA Active/Standby — one SE pair per SE group, used for hardware-like deployments. Holodeck constraint: limited resources mean small SEs; test performance.
  • GSLB Design for Multi-Site: two or more Avi Controller clusters (GSLB leader + follower sites) with a DNS virtual service steering clients. The GSLB service is defined by the application FQDN, the member virtual services at each site (identified by IP or VS — names may differ), and the priority/ratio and health-monitoring settings that decide which member answers (Avi 30.2 GSLB Guide). GSLB does not replicate the local VS configuration; build equivalent VSs per site.
  • Certificate Management: SSL/TLS certificates and keys are held as objects on the Controller and pushed to the SEs; a Certificate Management Profile lets the Controller renew certificates automatically before expiry (Avi docs: Automatic Certificate Renewal). OCSP stapling reduces client latency (client doesn't query OCSP responder). SNI routing enables multi-tenant (different cert per hostname on same VIP). Recommendation: manage certificates centrally on the Controller rather than per SE.
  • Avi Controller Cluster Sizing: 3-node minimum for HA (Raft quorum). Single controller = single point of failure. Minimum Controller size is Small (6 vCPU/32 GB RAM, from 30.2.1); size up by scale (Medium 10 vCPU/32 GB, Large 16 vCPU/48 GB). All three nodes must be the same size and less than 20 ms RTT apart (Avi 30.2 Installation Guide, Preparing for Installation). The leader handles configuration; the followers replicate it and primarily handle analytics data collection. Backup/restore via API for disaster recovery.

Avi Controller Cluster Deep Dive — Raft Consensus & HA#

The Avi Controller is the control plane for all load balancing policies, virtual service configurations, and analytics. A 3-node cluster provides HA through Raft consensus, a distributed state machine replication algorithm. Understanding Raft mechanics and failure scenarios is essential for architect-level deployment.

Raft Consensus Overview

What is Raft?

Raft is a consensus algorithm that ensures all nodes in a cluster agree on the same state. Unlike Paxos, Raft emphasizes simplicity and ease of understanding.

Key Concepts:

RAFT CLUSTER STRUCTURE:

┌─────────────────────────────────────────────────────┐
│ 3-Node Raft Cluster                                 │
├──────────────┬──────────────┬──────────────────────┤
│ Controller-1 │ Controller-2  │ Controller-3         │
│ (LEADER)     │ (FOLLOWER)   │ (FOLLOWER)           │
│              │              │                      │
│ Term: 5      │ Term: 5      │ Term: 5              │
│ Log Index: 42│ Log Index: 42│ Log Index: 42        │
│ Vote For: 1  │ Vote For: 1  │ Vote For: 1          │
└──────────────┴──────────────┴──────────────────────┘
       │                │                │
       │                │                │
   Append Entries    Append Entries   Append Entries
   (Heartbeat or     (Heartbeat or    (Heartbeat or
    New Log Entry)    New Log Entry)   New Log Entry)
       │                │                │
       └────────────────┼────────────────┘
                        │

COMMITTED ENTRIES
(safe state across all nodes)

  • QUORUM = N/2 + 1 nodes
  • For 3 nodes: quorum = 2 nodes
  • → Can tolerate 1 node failure
  • → 2 nodes minimum for consensus (if one fails, 2 remaining quorum)
  • → If 2 nodes fail: cluster cannot make decisions (read-only mode)

Raft State Machine & Terms

Each node in a Raft cluster maintains state: leadership, term counter, and log entries (mutations).

NODE STATE (Persistent on disk):

┌─────────────────────────────────────┐
│ Term (epoch counter)                │
│  - Incremented on each election     │
│  - Used to determine stale leaders  │
├─────────────────────────────────────┤
│ Voted For (which candidate this     │
│  term; used to prevent duplicate    │
│  votes in same term)                │
├─────────────────────────────────────┤
│ Log Entries [ { Index, Term, Cmd }] │
│  - Append-only; never deleted       │
│  - Each entry: index + term + actual│
│    command (e.g., "create VS foo")  │
├─────────────────────────────────────┤
│ Commit Index                        │
│  - Last log index known to be       │
│    applied to state machine         │
│  - Updated only by leader           │
├─────────────────────────────────────┤
│ Last Applied                        │
│  - Last log index applied to        │
│    application state                │
│  - Followers lag behind leader      │
└─────────────────────────────────────┘

ELECTION PROCESS (generic Raft paper values — Avi's documented values are a 10 s heartbeat, 40 s failure detection and a 50-60 s election, Avi 30.2 Controller Cluster; do not quote the millisecond figures for an Avi RTO):

  1. FOLLOWER TIMEOUT (textbook Raft: no heartbeat for 150–300 ms; Avi: 40 s)
  • → Increment term
  • → Become CANDIDATE
  • → Send RequestVote to all peers
  • → Vote for self
  1. CANDIDATE WAITS FOR VOTES (1–2 seconds)
  • → If majority votes: become LEADER (term 5 → 6)
  • → If another candidate becomes leader: follow it
  • → If timeout: increment term again; retry election
  1. NEW LEADER (term 6)
  • → Send Append Entries heartbeat to all followers immediately
  • → Followers reset election timer
  • → Cluster stable; can accept new configs

EXAMPLE TIMELINE (textbook Raft timings in ms, for the algorithm only; an Avi Controller election takes 50-60 s):

Time  Controller-1     Controller-2     Controller-3
────────────────────────────────────────────────────
0     LEADER (T:5)    FOLLOWER (T:5)   FOLLOWER (T:5)
      Sending HB      Waiting...        Waiting...

1     (hb timeout 150ms on C2, C3)

150   LEADER (T:5)    FOLLOWER        CANDIDATE
      Sending HB      →Timeout        (T:6)
                      Become CAND      Vote self
                      (T:6)            Send RequestVote
                      Vote self
                      Send RequestVote

160                   Recv vote from C3 (T:6)
                      Majority = 2/3
                      Become LEADER (T:6)

170                   LEADER (T:6)    Recv Append
                      Send HB to all  Entries from C2
                                      Follower (T:6)

200   Recv HB (T:6)
      from C2
      Convert to FOL
      (T:6)

      [STABLE AGAIN; C2 is new leader; C1, C3 followers]

Log Replication & Quorum

Write Path (New Configuration):

Client sends request to Leader (Controller-1):

"Create VS 'web-pool'"

Leader appends to own log:

[Index: 43, Term: 5, Cmd: "create VS web-pool"]

Leader sends Append Entries to Followers (C2, C3):

"Log entry 43, please append"

Followers append to log:

C2 & C3 each store entry 43

Followers respond:

"Entry 43 appended successfully"

Leader counts responses:

Self + C2 + C3 = 3/3 (quorum achieved!)

Leader commits entry:

Updates commit index to 43

Leader applies to state machine:

Virtual service "web-pool" created locally

Leader responds to client:

"Virtual service web-pool created" (HTTP 201 from the Controller API).

What Avi documents versus textbook Raft: the Avi Administration Guide describes a leader and followers, majority quorum, a 10 s heartbeat, 40 s failure detection and a 50-60 s election; it does not expose log indexes or terms to the administrator. Use the Raft model to reason about quorum and split-brain, and quote only the Avi figures for failover times.

Key Takeaways

  • Exam Tip: when asked about Avi cluster resilience, mention: (1) 3-node cluster, majority quorum (2 of 3), (2) leader election on leader failure — 40 s detection + 50-60 s election, management plane unavailable meanwhile, (3) followers-only partition cannot accept configuration (quorum lost), (4) split-brain prevention — the majority side keeps the leader and the cluster VIP, (5) data plane unaffected — SEs keep serving (headless if the whole cluster is lost), (6) backup/restore of the configuration for DR.

Service Engine Architecture — Data Plane Excellence#

Service Engines (SEs) are the data plane for Avi, handling all packet processing, load balancing decisions, and connection management. Understanding SE internals—DPDK acceleration, CPU pinning, SE groups, and HA modes—is critical for performance design.

Service Engine Data Plane (DPDK-Based)

What is DPDK?

Data Plane Development Kit; bypasses Linux kernel networking stack. Packets processed in userspace, avoiding context switches and kernel overhead.

Traditional Linux Kernel Networking vs. DPDK:

TRADITIONAL KERNEL STACK:

┌────────────────────────┐
│ Application (Avi SE)   │
├────────────────────────┤
│ Linux Kernel (Syscall) │ ← Context switch (~10 µs)
├────────────────────────┤
│ Network Driver (NIC)   │ ← DMA, interrupts
└────────────────────────┘

Latency per packet: 10–100 µs

CPU utilization: 30–50% (kernel scheduling overhead)

DPDK USERSPACE STACK:

┌────────────────────────┐
│ Avi SE (DPDK app)      │ ← Packet poll-mode (no interrupts)
│                        │ ← Direct NIC access (hugepages)
├────────────────────────┤
│ NIC Queues (lockless)  │ ← Ring buffers
└────────────────────────┘

Latency per packet: 1–5 µs (10x faster!)
CPU utilization: 80–95% (but higher throughput per core)

TRADE-OFF: Dedicated cores (can't oversubscribe); higher throughput

DPDK SE Initialization:

SE BOOT SEQUENCE:

  1. VM Start: SE size comes from the SE Group (minimum 1 vCPU, 2 GB RAM, 15 GB storage — Avi 30.2 Installation Guide)
  • Reserve hugepages (for packet buffers, descriptor rings)
  • Initialize DPDK EAL (Environment Abstraction Layer)
  1. Core use:
  • Packet-processing threads run in poll mode on the SE's vCPUs
  • How dispatcher and proxy work is spread across vCPUs depends on SE size and SE Group settings; do not assume a fixed per-vCPU role map

Effect: polling cores show high CPU by design (no interrupts, no context switches)

  1. NIC Queue Steering (RX):
  • NIC receives packet on physical queue 0
  • Steering rule: filter by 5-tuple → route to a processing core
  • Distributes load across processing cores
  • Avoids cache-line bouncing (NUMA-aware)
  1. Packet Ring Initialization:
  • RX ring: NIC → SE (256–4096 buffers per ring)
  • TX ring: SE → NIC (256–4096 buffers per ring)
  • Lockless; FIFO order (no spinlocks)
  1. Ready for Traffic:
  • SE polls RX ring continuously
  • Dequeues and processes packets in poll mode
  • Enqueues to TX ring
  • NIC DMA reads and sends

PERFORMANCE:

  • Throughput, packet rate and connection rate per SE depend on vCPU count, packet size, features in use (SSL, L7 policies, WAF) and the NIC; take per-core figures from the Avi 30.2 "Sizing Service Engines" guidance and measure in your own environment rather than quoting fixed numbers

Service Engine Groups & Tenancy Models

SE Group Definition:

A collection of SEs with shared configuration, placement policy, and resource allocation.

Single SE Group per Application Tier (Isolation Model):

TOPOLOGY:

Web Tier SEs (SE Group: web-group)

├─ web-se-01 (10.0.1.x)
├─ web-se-02 (10.0.1.x)
└─ web-se-03 (10.0.1.x)

Placement: Spread across esx01, esx02, esx03
Network: Routed via NSX Tier-1

App Tier SEs (SE Group: app-group)

├─ app-se-01 (10.0.2.x)
├─ app-se-02 (10.0.2.x)
└─ app-se-03 (10.0.2.x)

Placement: Spread across esx04, esx05, esx06
Network: Routed via NSX Tier-1

DB Tier SEs (SE Group: db-group)

├─ db-se-01 (10.0.3.x)
└─ db-se-02 (10.0.3.x)

Placement: Spread across esx07, esx08
Network: Isolated VLAN (not routed)

BENEFITS:

  • Tenant isolation (web group can't see app traffic)
  • Resource isolation (web group doesn't steal DB group CPU)
  • Easy scaling (add SE to web-group without touching app-group)
  • Failure isolation (web SE crash doesn't affect app)

DRAWBACK:

  • More VMs to manage (9 total SEs for 3 tiers)
  • Resource fragmentation (each group pre-allocates resources)

Multi-Tenant SE Group (Cost Optimization):

SINGLE SE GROUP, MULTIPLE TENANTS:

Shared SE Group (se-group-shared)

├─ se-01
├─ se-02
└─ se-03

Virtual Services (all on same SEs):

├─ VS: web-prod (tenant: acme-corp)
├─ VS: web-staging (tenant: acme-corp)
├─ VS: app-uat (tenant: beta-customer)
├─ VS: api-v2 (tenant: internal-platform)
└─ VS: crm-lb (tenant: salesforce-ops)

BENEFITS:

  • Fewer VMs (3 SEs vs. 9)
  • Better resource utilization (idle capacity shared)
  • Simpler management (one SE group)

DRAWBACKS:

  • Noisy neighbor risk (one tenant's traffic spike affects others)
  • Resource contention (shared CPU, memory, network)
  • Complexity in troubleshooting (mixed logs)
  • Less security isolation (multitenancy in same process)

HA Modes — Elastic N+M, Elastic Active/Active, Legacy

Avi defines SE high availability per SE group (Avi Configuration Guide, High Availability and Redundancy):

Elastic HA N+M (default):

  • Each virtual service is placed on exactly one SE. N = the SEs needed to host the current virtual services (from Virtual Services per Service Engine); M = buffer SEs (Buffer Service Engines field) kept to absorb M SE failures without reducing capacity.
  • On SE failure the Controller re-places the affected virtual services onto the buffer SE (or spins one up); existing connections on the failed SE are lost, new connections resume once the VS is placed.

Example (N=3, M=1):

├─ SE-01: VS-A (1000 RPS)
├─ SE-02: VS-B (800 RPS)
├─ SE-03: VS-C (500 RPS)
└─ SE-04: buffer (no VS placed)

SE-01 failure:

├─ Controller detects the SE as down (SE heartbeat / health checks)
├─ VS-A is placed on SE-04 (ARP/GARP for the VIP; route advertisement if BGP VIP)
├─ VS-B and VS-C unaffected
└─ Buffer is now 0 until SE-01 recovers or a new SE is created

Elastic HA Active/Active:

  • Each virtual service runs on at least two SEs (Minimum Scale per Virtual Service, default 2; Maximum Scale per Virtual Service caps scale-out). Traffic is shared across the SEs (ECMP/BGP or the primary SE distributing flows).
  • Losing one SE reduces capacity for the VSs it carried; availability is maintained because the other SEs already serve them. Preferred for latency-sensitive services where a re-placement gap is unacceptable.

Legacy HA Active/Standby:

  • One active SE and one standby SE per SE group; every VS is on the active SE, the standby takes over all VSs on failure. Maps to appliance-style load balancers; no elasticity.

Choosing for VCF designs:

  • Management-plane services (VCF Operations, Automation, Supervisor ingress): Elastic HA Active/Active or N+M with M ≥ 1 in a dedicated SE group per tenant or domain.
  • Keep SE groups per NSX Tier-1 / tenant for isolation; size the buffer from the SE failure domain (host or rack), not from a fixed rule of thumb.
  • The exam objective 1.7 names "Active Active/N+M"; know that these are two Elastic HA modes, not one.

Key Takeaways

  • For exam: Elastic HA N+M (default) places each VS on one SE with M buffer SEs; Elastic HA Active/Active places each VS on ≥2 SEs (Minimum Scale per VS, default 2); Legacy HA is one active/one standby SE. Choose Active/Active where a re-placement gap is unacceptable, N+M for capacity-efficient HA.

Virtual Service Configuration Matrix — All Types#

Virtual Services (VS) are the core unit of load balancing in Avi. Understanding all types—L4, L7 (HTTP/HTTPS, HTTP/2, QUIC), DNS, GSLB—and their configuration matrices is essential for comprehensive design.

L4 Virtual Services (TCP/UDP/SCTP)

TCP Virtual Service (Stateful, Connection-Based):

CONFIGURATION:

  • Name: databases-tcp
  • Type: L4
  • Protocol: TCP
  • VIP: 10.0.1.100:3306 (MySQL port)
  • Pool: db-backend (3 backend servers on port 3306)
  • HA Mode: Active/Active
  • Connection Timeout: 600 sec
  • SSL: None (native protocol not encrypted)

Pool Members:

├─ 10.0.3.10:3306 (weight 1, active)
├─ 10.0.3.11:3306 (weight 1, active)
└─ 10.0.3.12:3306 (weight 1, active)

Load Balancing Algorithm: Round-Robin (sequential connections)
Persistence: NONE (each new connection can go to different backend)

TRAFFIC FLOW:

Client 10.0.2.5:54321 → VIP 10.0.1.100:3306

  ├─ SE receives TCP SYN
  ├─ Lookup pool member (RR: 10.0.3.10)
  ├─ NAT: Rewrite src to SE IP (10.0.1.101)
  ├─ Forward to backend 10.0.3.10:3306
  ├─ Backend responds; SE receives response
  ├─ NAT: Rewrite dst to VIP (10.0.1.100)
  └─ Send to client (client sees response from VIP)

Connection Table Entry:

  • Client: 10.0.2.5:54321 → VIP 10.0.1.100:3306
  • Backend: 10.0.1.101:54321 → 10.0.3.10:3306 (SE's src becomes this)
  • TTL: 600 sec (TCP idle timeout)

UDP Virtual Service (Connectionless):

CONFIGURATION:

  • Name: dns-udp
  • Type: L4
  • Protocol: UDP
  • VIP: 10.0.1.101:53 (DNS)
  • Pool: dns-servers (3 backend servers)
  • Connection Timeout: 2 min (UDP shorter than TCP)

Pool Members:

├─ 10.0.3.20:53
├─ 10.0.3.21:53
└─ 10.0.3.22:53

TRAFFIC FLOW:

Client 10.0.2.50:12345 → VIP 10.0.1.101:53

  ├─ SE receives UDP packet
  ├─ Create connection entry (5-tuple)
  ├─ Forward to pool member (RR: 10.0.3.20:53)
  ├─ Backend responds with DNS answer
  ├─ SE translates response; send to client
  └─ Connection aged out after 2 min of inactivity

DIFFERENCE FROM TCP:

  • No SYN/ACK handshake; stateless protocol
  • First packet creates entry; subsequent packets within TTL reuse entry
  • No connection cleanup (timeout-based)
  • Faster (no TCP overhead); lower latency

SCTP Virtual Service (Rare; Telecom/Diameter):

Protocol:

Stream Control Transmission Protocol; hybrid of TCP + UDP

Use Case:

Telecom signaling (Diameter, S1AP); load balancing 3GPP core networks

Avi Support:

Yes; treated similarly to TCP (stateful, connection-based)

Performance:

Similar to TCP (connection overhead)

L7 Virtual Services (HTTP, HTTPS, HTTP/2, HTTP/3 QUIC)

HTTP Virtual Service (Cleartext):

CONFIGURATION:

  • Name: web-http
  • Type: L7
  • Protocol: HTTP
  • VIP: 10.0.1.102:80
  • Pool: web-servers (3 Apache/Nginx backends)
  • HTTP Profile: default

HTTP Request Handling:

├─ Client: GET /api/v1/products
├─ SE intercepts; reads HTTP headers
├─ Content-Switch rule: If URI = /api/* → route to api-pool
├─ Otherwise → route to web-pool
├─ Rewrite rule: Add header "X-Forwarded-For:

"

Pool Selection:

├─ /api/v1/* → api-pool (3 servers on port 8000)
├─ /static/* → cdn-pool (CDN origin cache)
└─ /* → web-pool (3 servers on port 80)

Session Persistence: HTTP Cookie

├─ SE inserts: Set-Cookie: AVIX_ID=se01-conn123
├─ Client stores cookie
├─ Next request includes cookie
├─ SE routes to same backend (session stickiness)

TRAFFIC FLOW:

Client GET http://example.com/api/v1/products

  ├─ TCP SYN → VIP 10.0.1.102:80
  ├─ TCP ACK; connection established
  ├─ Client sends HTTP GET with headers
  ├─ SE reads headers; matches rule: URI=/api
  ├─ Select pool member from api-pool (RR or persistent)
  ├─ Rewrite Host header (if needed)
  ├─ Forward HTTP GET to 10.0.3.30:8000
  ├─ Server responds: HTTP/1.1 200 OK
  ├─ SE adds Set-Cookie header (persistence)
  ├─ Forward response to client
  └─ Connection closed after response (HTTP/1.0) or keep-alive

LATENCY ADDED BY LB:

  • TCP handshake: the SE (a full proxy) completes the client handshake first, then uses a separate server-side connection — a new one adds a backend round trip, a reused one (connection multiplexing) does not
  • HTTP header parsing: 0.1–0.5 ms
  • Rule evaluation: 0.05–0.2 ms
  • Total LB overhead: ~0.2–1 ms per request

HTTPS Virtual Service (TLS-Encrypted):

CONFIGURATION:

  • Name: web-https
  • Type: L7
  • Protocol: HTTPS (HTTP over TLS)
  • VIP: 10.0.1.103:443
  • Pool: web-servers-secure (3 backends on port 443)

TLS/SSL Configuration:

├─ Certificate: example.com (RSA 2048, or ECDSA P-256)
├─ Cipher Suite: TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (strong)
├─ Min TLS Version: 1.2
├─ Max TLS Version: 1.3
├─ Session Reuse: Enabled (tickets, cache)
├─ OCSP Stapling: Enabled (cert freshness proof)

TRAFFIC FLOW:

Client TLS ClientHello → VIP 10.0.1.103:443

  ├─ SE receives ClientHello (plaintext; SNI visible)
  ├─ Extract SNI (Server Name Indication): example.com
  ├─ Match against cert store; select certificate
  ├─ SE performs TLS handshake (SE acts as server)
  ├─ E.g., ECDHE key exchange + AES-256-GCM encryption
  ├─ Client and SE now have encrypted session
  ├─ Client sends encrypted HTTP GET /api/v1/products
  ├─ SE decrypts payload; reads HTTP header
  ├─ Apply content-switch rule (same as HTTP)
  ├─ Re-encrypt to backend (SSL bridging):
  │    ├─ SE → Backend TLS handshake (SE acts as client; backend certificate validated against the configured PKI profile)
  │    ├─ Encrypted HTTP GET forwarded to the selected pool member
  │    └─ Backend response decrypted by the SE, logged, re-encrypted to the client
  └─ Client receives the response over the original TLS session

Design notes:

  • SSL termination (decrypt at SE, plain HTTP to the pool) is the default pattern inside a trusted segment; SSL bridging (re-encrypt) where the backend must see TLS or compliance requires encryption in transit end to end; SSL passthrough (L4, no decryption) when the SE must not hold the certificate — content switching is then limited to SNI.
  • Certificate and key live in the Controller and are pushed to the SEs; use SNI with multiple certificates on one VIP for multi-tenant hosting.

SSL/TLS Complete Reference — Ciphers, Certificates, Handshakes#

TLS is the foundation of secure web traffic. Architects must understand cipher suite selection, certificate lifecycle management, and the handshake process to design secure, performant load balancing.

SSL/TLS Profiles in Avi

Profile Components:

SSL PROFILE: production-strict

Cipher Suite Configuration:

├─ Ciphers (List view; Avi prefers the listed order while 'Prefer client cipher ordering' is Off, the default):
│  1. TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 (strongest + fastest)
│  2. TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
│  3. TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
│  4. TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
│  5. TLS_AES_256_GCM_SHA384 (one of three supported TLS 1.3 suites with
│     TLS_AES_128_GCM_SHA256 and TLS_CHACHA20_POLY1305_SHA256; selected in the
│     cipher list or set in the Ciphersuites option under the String view —
│     Avi 31.1 'Creating an SSL/TLS Profile'; TLS 1.3 suites cannot be used
│     with older versions — RFC 8446)
│
├─ Disabled (insecure):
│  - TLS_RSA_WITH_* (no forward secrecy; AVOID)
│  - TLS_*_WITH_DES_* (weak encryption)
│  - TLS_*_EXPORT_* (export-grade; 40-bit keys)

TLS Version Enforcement (the profile's Version selection):

├─ Select TLS 1.2 and TLS 1.3; leave TLS 1.0 and 1.1 unselected
├─ Selecting TLS 1.3 adds the Early Data (0-RTT) option, which needs SSL session reuse

Session Management:

├─ Enable SSL Session Reuse: On (the default); SSL Session Expiration sets the lifetime in seconds
│  └─ Method 1: Session ID (server-side cache; ~256 bytes per session)
│  └─ Method 2: Session Tickets (stateless; encrypted on client)
├─ Ticket keys: rotate regularly and keep ticket lifetime short
│  (set both from your security policy; check the Avi SSL profile for the current options)

OCSP Stapling:

├─ Status: enabled on the application certificate (enable_ocsp_stapling)
├─ Frequency Interval: e.g. 21600 s (6 hours), as in the Avi example; allowed range 60–31536000 s
├─ Benefit: Client doesn't need to query OCSP responder (faster; privacy)

HSTS (HTTP Strict-Transport-Security; set in the HTTP application profile, and its absence lowers the SSL score):

├─ Status: Enabled
├─ Max-Age: 31536000 (1 year)
├─ Include SubDomains: Yes
├─ Preload: Yes (submit to browser preload list)
├─ Effect: Browser enforces HTTPS for all future requests (1 year)

Client Certificate Authentication (mTLS):

├─ Client SSL Certificate Validation (HTTP application profile → Security): Require
│        (the client must present a certificate for the connection to continue;
│        Request asks for one but the connection does not fail without it; None = off)
├─ PKI Profile (mandatory): holds the internal corporate CA
├─ Validation: Verify chain; reject self-signed

Cipher Order Preference:

├─ Prefer client cipher ordering: Off (the default) — the profile's cipher order wins
├─ Effect: Server chooses best cipher (not client-picked weak cipher)

TLS 1.2 vs. TLS 1.3 Handshake Differences

TLS 1.2 Handshake (2 round trips before application data; 200 ms at 100 ms RTT — RFC 5246):

ROUND TRIP 1 (Client Hello):

┌─────────────────────────────────────┐
│ Client → Server (100 ms RTT)         │
│ ClientHello                          │
│ ├─ Supported TLS versions: 1.0–1.2  │
│ ├─ Cipher suites: 20+ options       │
│ ├─ Supported curves: P-256, P-384   │
│ ├─ SNI: example.com                 │
│ └─ Random nonce (client_random)     │
└─────────────────────────────────────┘

Time: 0 ms (client sends immediately after TCP ACK)

ROUND TRIP 2 (Server Response):

┌─────────────────────────────────────┐
│ Server → Client (RTT 100 ms)         │
│ ServerHello + Certificate + DHE     │
│ ├─ Selected TLS version: 1.2        │
│ ├─ Selected cipher: TLS_ECDHE_...   │
│ ├─ Server certificate               │
│ ├─ ECDHE public key (ephemeral)     │
│ ├─ Random nonce (server_random)     │
│ └─ Signature (cert private key)     │
└─────────────────────────────────────┘
  • Time: 100 ms (client received server response)
  • CPU: Server: ~10 ms for cert verification + key exchange
  • Client: ~10 ms for cert verification

ROUND TRIP 3 (Client Finishes):

┌─────────────────────────────────────┐
│ Client → Server (RTT 100 ms)         │
│ ClientKeyExchange + ChangeCipherSpec│
│ ├─ Client's ECDHE public key        │
│ ├─ MAC (message auth code)          │
│ └─ Finished (verification)          │
└─────────────────────────────────────┘

Time: 200 ms (client sends after computing shared key)
CPU: Client: ~20 ms for key derivation

ROUND TRIP 4 (Server Finishes) - Optimized (wait for client ack):

┌─────────────────────────────────────┐
│ Server → Client (RTT 100 ms)         │
│ ChangeCipherSpec + Finished         │
└─────────────────────────────────────┘

Time: application data can follow after 2 RTT = 200 ms

TOTAL HANDSHAKE TIME: 2 RTT = 200 ms (with 100 ms RTT); the server Finished arrives with the first response, so the client does not wait a third round trip
CPU TIME: Server ~10 ms; Client ~30 ms

ISSUE: 2 round trips before the first byte — high latency for long-distance clients (200 ms at 100 ms RTT, more on mobile)

TLS 1.3 Handshake (1 round trip = 100 ms at 100 ms RTT; 0-RTT on resumption — RFC 8446):

REDESIGNED FOR SPEED:

ROUND TRIP 1 (Client Hello + Early Data):

┌─────────────────────────────────────┐
│ Client → Server (RTT 100 ms)         │
│ ClientHello                          │
│ ├─ Supported TLS 1.3 only            │
│ ├─ Supported curves: X25519, P-256  │
│ ├─ Client's ephemeral public key    │
│ ├─ SNI: example.com                 │
│ └─ Pre-shared key (if resuming)     │
│                                      │
│ Early Data (optional; 0-RTT):        │
│ ├─ Encrypted HTTP GET (if resuming) │
│ └─ Uses PSK derived key              │
└─────────────────────────────────────┘

Time: 0 ms (client sends; now includes ephemeral key)

  • KEY DIFFERENCE: Client sends ECDHE public key in ClientHello
  • → Server can immediately compute shared secret
  • → No need for ServerKeyExchange roundtrip!

ROUND TRIP 2 (Server Response):

┌─────────────────────────────────────┐
│ Server → Client (RTT 100 ms)         │
│ ServerHello                          │
│ ├─ Selected TLS 1.3                  │
│ ├─ Server's ephemeral public key    │
│ ├─ {EncryptedExtensions}            │
│ ├─ {Certificate, CertificateVerify} │
│ └─ {Finished}                       │
└─────────────────────────────────────┘

Time: 100 ms — client derives the keys and sends its Finished together with the first HTTP request

TOTAL HANDSHAKE TIME: 1 RTT = 100 ms (with 100 ms RTT); 0 RTT for resumed sessions with early data (replay risk — enable only for idempotent requests)

(Option names: Avi Load Balancer 31.1 Configuration Guide — Creating an SSL/TLS Profile; SSL Client Certificate Validation; OCSP Stapling.)

Avi relevance: the SE terminates TLS 1.3 when TLS 1.3 is selected in the SSL/TLS profile; enabling TLS 1.3 halves handshake latency for new connections versus TLS 1.2, and session resumption (tickets) plus OCSP stapling remove further round trips. Measure with the Avi virtual service analytics (SSL handshake latency) rather than quoting fixed millisecond figures.

References & Further Reading#

Reference Links & Further Reading

  • Avi Load Balancer 30.2 Installation Guide — Preparing for Installation (system requirements, including Controller and Service Engine minimum resources): https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-installation-guide/preparing-for-installation.html
  • Avi Load Balancer 30.2 Configuration Guide — High Availability and Redundancy (SE HA modes, virtual service scaling): https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-configuration-guide/high-availability-and-redundancy-.html
  • Avi Load Balancer Controller Cluster — Avi Load Balancer 30.2 Administration Guide: https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-administration-guide/controller-cluster.html
  • Virtual Services — Avi Load Balancer 30.2 Configuration Guide: https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-configuration-guide/load-balancing-overview/virtual-services.html
  • SSL Certificates (SSL/TLS profiles and certificates) — Avi Load Balancer 30.2 Administration Guide: https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-administration-guide/access-settings/certificates/ssl-certificates.html
  • Global Server Load Balancing — Avi Load Balancer 30.2 GSLB Guide: https://techdocs.broadcom.com/us/en/vmware-security-load-balancing/avi-load-balancer/avi-load-balancer/30-2/vmware-avi-load-balancer-gslb-guide.html
  • RFC 8446 — The Transport Layer Security (TLS) Protocol Version 1.3 (the RFC Editor now marks it obsoleted by RFC 9846): https://www.rfc-editor.org/rfc/rfc8446
  • RFC 8439 — ChaCha20 and Poly1305 for IETF Protocols (obsoletes RFC 7539): https://www.rfc-editor.org/rfc/rfc8439

Additional Hands-On Practice Labs (VCF 5.2 / 9.x)#

Targeted practice labs for deeper mastery of Avi Alb topics on VCF 5.2 and VCF 9.x.

Exam Mapping: 6V0-22.25 — VMware Avi Load Balancer 30.x Administrator

  • See the VMware Avi Load Balancer 30.x Administrator exam guide for detailed objectives

Labs in This Section

📝 Quiz — Avi Load Balancer

0/50 correct

Avi Architecture

Q1
In the Avi three-tier architecture, which tier handles application data-plane traffic?
  • Service Engines (SEs)
  • Controller cluster
  • SDDC Manager
  • vCenter
Service Engines (SEs) handle application data-plane traffic — they receive client connections, process load balancing decisions, and forward to backend servers. The Controller manages configuration. SDDC Manager and vCenter are infrastructure management.
Q2
How many nodes are required for an Avi Controller cluster in production, and what does the cluster VIP provide?
  • 1 node; manual failover
  • 2 nodes; round-robin DNS
  • 3 nodes; single management endpoint with leader election
  • 5 nodes; data-plane forwarding
A 3-node Controller cluster provides a single management endpoint via a cluster VIP with leader election for HA. 2 nodes lack quorum. 1 node has no redundancy. 5 nodes is over-provisioned. Controllers don't forward data-plane traffic.
Q3
Which object is a logical grouping of Service Engines sharing HA mode, placement, and resource settings?
  • Service Engine Group
  • Pool Group
  • Virtual Service
  • Tenant
A Service Engine Group is a logical grouping of SEs sharing HA mode, placement rules, and resource settings. Virtual Services define application front-ends. Pool Groups aggregate pools. Tenants provide RBAC isolation.
Q4
Elastic scale-out on Avi refers to:
  • Horizontal pod autoscaling in Kubernetes
  • Resizing backend VMs via DRS
  • Automatic deployment of additional SEs to scale a Virtual Service
  • Adding Controller nodes at runtime
Elastic scale-out automatically deploys additional SEs to distribute load when a Virtual Service exceeds the capacity of a single SE. It's not about adding Controllers, resizing VMs, or K8s HPA.
Q5
In VCF, Avi is integrated primarily via:
  • Direct install on ToR switches
  • An NSX Cloud connector on the Avi Controller, connected to NSX Manager and vCenter, so Service Engines are deployed and attached to NSX segments automatically
  • An agent inside each VM
  • Manual OVA deployment only
In VCF 9, Avi Load Balancer integrates through an NSX Cloud connector configured on the Avi Controller (Avi Load Balancer for VMware Cloud Foundation 9.0 guide, "Configuring the Cloud Connector for the NSX Cloud"), which automates Service Engine deployment and segment attachment. VCF Automation 9.0 no longer supports Avi Load Balancer cloud accounts or Avi blueprint resources (VCF 9.0.1 docs p.239), and the SDDC Manager-driven path belongs to VCF 5.2. Manual OVA-only, ToR installs and VM agents are not the VCF integration model.

Virtual Service Configuration

Application Profiles

Analytics and Troubleshooting

Operations

🃏 Flashcards — Avi Load Balancer

50 cards
Card 1 of 50
Avi Controller
The management and control-plane component of Avi Load Balancer, typically deployed as a 3-node cluster (one Leader, two Followers) fronted by a Cluster IP; smaller/lab deployments can use a single Controller. Holds configuration, analytics, and API; never handles data-plane traffic. Loss of the Controller cluster does not affect running Virtual Services served by Service Engines.
Was this page useful?
Type to search. ↑ ↓ to move, Enter to open, Esc to close.