VM-to-VM Traffic: The Invisible East-West Path
Here is a conversation your monitoring system has never seen, even though it may be the biggest one on your network. A web application VM asks a database VM for data. The database answers — thousands of times a second, gigabits of traffic. Both VMs live on the same virtualization host, so the entire exchange happens as memory copies inside one physical server. No cable carries it. No switch port counts it. No firewall in the rack inspects it. If you drew your network from what your physical tools can see, this conversation would not exist.
Admins call server-to-server traffic east-west traffic (as opposed to north-south, the traffic entering and leaving your network through the firewall). Virtualization created the most extreme form of it: east-west traffic that never touches the network at all. Most days, that invisibility is harmless — even a gift, since the traffic is fast and free. But a co-located backup job may flatten a host. Or a security review may ask "who can talk to whom," or an application may get slow for no visible reason. On that day, the invisible path becomes your problem.
This guide is about getting your sight back. You will learn why same-host traffic bypasses the physical world and the three situations where that genuinely matters. You will learn four ways to gain visibility — compared honestly, cheapest first. And you will learn how VM placement decisions trade performance against observability. It ends with a worked example: tracking down two VMs hammering each other on a host whose network graphs looked perfectly calm.
In this guide
- Why same-host traffic never touches a wire
- When the invisible path actually matters
- Option 1: per-VM hypervisor counters
- Option 2: port mirroring at the virtual layer
- Option 3: host-based capture agents
- Option 4: flow export from the virtual switch
- The honest comparison
- Placement: pin apart or pin together?
- Worked example: finding the two chatty VMs
Why same-host traffic never touches a wire
Here is a quick recap of the mechanics (the full story is in the virtual switch guide). Every VM's virtual network card plugs into a virtual switch — a software switch inside the hypervisor. When VM A sends a frame to VM B and both sit on the same vSwitch, the vSwitch looks up B's MAC address. The vSwitch finds B locally and copies the frame from A's memory buffers to B's. The frame is never handed to a physical network card, because there is no reason to — the destination is already inside the building.
Three properties follow, and each one surprises people the first time:
- It can be faster than any cable you own. The path runs at memory-and-CPU speed. Two VMs can exchange data at rates that would saturate several physical uplinks. That also means the load appears on the host's CPU and memory subsystem, not on the network.
- No physical tool can see it. Port counters, a SPAN/mirror session on your physical switch, a tap on the cable, and an inspection appliance in the rack all watch wires. This traffic uses none. The counters are not underreporting; there is genuinely nothing there to count.
- Physical security controls are not in the path. A firewall sitting between two VLANs in the rack still does its job for traffic that crosses it. But two VMs on the same port group and host reach each other without ever leaving the hypervisor. So anything enforced only in the physical network simply is not consulted.
One boundary is worth stating precisely, because it trips people up constantly: the invisible zone is the host, not the cluster. Two VMs on different hosts talk over the physical uplinks like any other pair of servers, fully visible to your normal tools. The same two VMs, migrated onto one host tomorrow, vanish from the wires. Whether a given conversation is visible to you can literally change overnight without anyone touching a setting. That fact matters again in the placement section below.
East-west blindness is not unique to virtualization. Traffic between two physical servers on the same switch also skips your firewall and most of your monitoring. That broader problem is covered well in the east-west traffic guide. What is unique here is the extreme case: inside a host there is no wire even in principle. So techniques that work elsewhere (mirror a switch port, tap a link) have nothing to attach to. You need vantage points inside the hypervisor, which is what the four options below provide.
When the invisible path actually matters
Let's be honest first: most same-host traffic needs no special attention. Nobody should packet-capture every heartbeat between two application servers. The invisible path earns your attention in three specific situations.
Backup and copy jobs between co-located VMs
A backup proxy VM pulling data from a database VM on the same host moves that data at memory speed. That is wonderful for the backup window, rough on everything else. The transfer burns host CPU cycles and floods the host's memory bus, and every other VM on that host competes for the same resources. Here is the classic symptom. At backup time, every VM on one host gets sluggish, users complain, and every network graph you own stays flat. The flood never touched the network. If you only remember one scenario from this guide, make it this one. It resolves a remarkable number of "the network is slow every night at nine" mysteries.
Chatty application tiers that happen to be co-located
A web VM and its database VM on the same host enjoy a gloriously fast private path — and quietly become dependent on it. The application's performance now assumes memory-speed, near-zero-latency communication that appears in no capacity plan, because no counter records it. Then one VM migrates to another host (an admin rebalances, a host enters maintenance, an automatic scheduler decides). The conversation lands on the physical uplinks for the first time. Latency jumps from microseconds to real network round trips. Throughput drops to cable speeds, and uplink utilization climbs. The application is suddenly "slow since yesterday" with no configuration change anyone remembers making.
Security blind spots
If an attacker compromises one VM, the easiest place to spread is a neighbor on the same host. That lateral movement never crosses a wire, so intrusion detection watching physical links sees nothing. Compliance reviews trip over the same fact. "All server traffic is inspected" is simply untrue once two servers share a hypervisor, unless something at the virtual layer does the inspecting. You do not need to solve this today, but you should never claim visibility you do not have.
Option 1: per-VM hypervisor counters
The hypervisor forwards every frame, so it counts every frame — including the invisible ones. Every mainstream platform keeps per-VM (strictly, per-vNIC) counters: bytes and packets in and out, often drops too. They are readable in the management interface, over the platform's API, or from the host's command line. This is the cheapest visibility that exists: no agents, no capture, no licensing surprises, negligible overhead, and it is already running.
Always start here. Per-VM counters answer "who is busy and how busy" for every VM regardless of whether its traffic touches a wire. Pull them into your monitoring system on a schedule and you get baselines, rankings, and alerting on the whole east-west world for nearly free.
The honest limitation: counters are totals, not conversations. They tell you that a VM moved forty gigabytes, not with whom. Often you can infer the partner. When two VMs on the same host show mirror-image spikes at the same minutes, the deduction writes itself. But inference has limits, which is what the next three options are for.
Tip: hypervisor counters are cumulative — ever-growing odometers, not speedometers. Your monitoring tool (or your script) must compute the difference between two readings divided by the time between them to get a rate. A "traffic" number that only ever goes up is an odometer you are misreading.
Option 2: port mirroring at the virtual layer
Physical switches can copy one port's traffic to another for analysis; most virtual switches can do the same between virtual ports. Configure a mirror of the suspect VM's virtual port. Aim the copy at an analyzer — typically a VM on the same host running a packet-capture tool. You see the actual frames of the invisible conversation: source, destination, protocol, payload sizes, retransmissions, everything.
This is the right tool for a deep-dive diagnosis. The moment you need to know exactly what two VMs are saying to each other, nothing beats real packets. The costs are equally real. Mirroring duplicates every frame in software, so a busy port's mirror measurably taxes the host's CPU. Captures of a memory-speed conversation generate enormous files fast. The analyzer VM must live in the right place (mirrored traffic generally should not cross the physical network). Platforms differ in what they offer. On some, virtual-port mirroring needs the cluster-wide distributed switch rather than the basic one. Treat it like scaffolding: put it up for the investigation, take it down after. A forgotten mirror session quietly wastes host CPU forever.
Option 3: host-based capture agents
Instead of asking the infrastructure to show you the traffic, you can stand inside an endpoint of the conversation. Install a capture tool or monitoring agent in the guest OS itself. It sees every packet that VM sends and receives — wire or no wire, because it watches the VM's own network stack. In-guest capture utilities exist for every operating system, and many monitoring agents can continuously report connection tables and traffic summaries from inside.
There are strengths. The technique works on any hypervisor (the technique does not care what is underneath). It sees exactly what the application experiences and doubles as your view into encrypted-by-the-network environments. There are weaknesses, too. It only covers VMs where the agent is installed, so environment-wide visibility means agent sprawl. That means deployment, updates, credentials, and a little CPU and memory tax in every guest, plus a security review. Capture capability inside servers is a gift to an attacker if mismanaged. In practice, agents shine as a targeted tool. They shine on the handful of VMs you genuinely need conversation-level detail from. Or they shine temporarily during an investigation when virtual-layer mirroring is not available.
Option 4: flow export from the virtual switch
A flow record is a summary of one conversation. It gives who talked to whom, on which ports and protocol, when, and how many bytes and packets. It is the phone bill rather than the phone tap. Physical routers and switches have exported flow records for ages. Many virtual switches (commonly the distributed, cluster-wide kind) can do the same. Those switches can send records for every conversation they forward — including the ones that never touch a wire — to a flow collector you run.
Where available, this is the best ongoing answer to the east-west question. It gives conversation-level visibility of all VM traffic, continuously, without agents in guests and without capture-sized storage. You finally see the invisible path in your top-conversations reports next to everything else. There are caveats. It must exist on your platform and edition (check — it is a classic premium-tier feature). It needs a collector and flow-analysis tooling on your side. Flow export summarizes rather than captures (you get who-talked-to-whom, not packet contents). The export itself consumes a little host CPU and produces real traffic toward the collector on busy hosts.
The honest comparison
| Option | Answers | Setup effort | Ongoing cost | Best used as |
|---|---|---|---|---|
| Per-VM counters | Who is busy, how busy, when | Minimal — already running | Negligible | The permanent baseline; always on |
| Virtual port mirroring | Exact packets of one VM's traffic | Moderate; platform-dependent | Host CPU + storage while active | Short, deep investigations |
| In-guest capture / agents | Everything one VM sends and receives | Per-VM install and upkeep | Small tax in every covered guest | Targeted VMs; any-hypervisor fallback |
| vSwitch flow export | All conversations, summarized | Collector + platform feature required | Modest host CPU + collector traffic | Continuous east-west accounting |
The pattern to take away: counters always, flows if your platform offers them, mirroring and agents when a specific question justifies the cost. Teams get into trouble by inverting this. They reach for packet capture to answer questions the free counters already could, or deploy agents everywhere for data nobody reads.
Placement: pin apart or pin together?
Once you can see chatty pairs, a design question follows: should two VMs that talk constantly share a host, or be kept apart? Most platforms let you express either choice as a rule. Generically, that is an affinity rule ("keep these VMs together") or an anti-affinity rule ("never put these on the same host"). Placement and migration decisions must respect that rule.
Pinning together buys performance: lowest possible latency, throughput beyond any cable, and zero load on the physical uplinks. The conversation stays off the wires entirely. Here is the price. The pair now shares one failure domain (one host dies, the whole application dies with it). Their conversation is invisible to physical inspection, and their combined load lands on one host's CPU and memory.
Pinning apart buys resilience and visibility. The pair survives a single host failure, and their traffic crosses uplinks where your normal monitoring, mirroring, and security tooling can see it. The price is real network latency in every exchange, and permanent load on the uplinks. Check the arithmetic in the uplink contention guide before you volunteer a chatty pair for wire duty.
There is no universally right answer — it depends on whether the pair's bottleneck is performance, availability, or auditability. What is universally wrong is deciding by accident. Unpinned VMs drift between hosts as load balancing and maintenance shuffle them. So the pair is co-located some weeks and separated others, and its performance changes personality each time. Decide deliberately, write the rule, and record why in your virtual network documentation.
Worked example: finding the two chatty VMs
Theory into practice. The scenario: users report that "everything on the intranet crawls" for about an hour each evening. Your dashboards show the relevant host's uplinks nearly idle at those times — yet the host's CPU is pegged. Classic invisible-path fingerprint. Here is the hunt, step by step:
- Step 0 — pin down the window. Get one concrete timestamp from an affected user ("it was terrible at ten past nine"). Vague complaints make every graph ambiguous; a window turns them into evidence.
- Step 1 — rank the per-VM counters. Pull per-vNIC rates for every VM on the suspect host for the complaint window and sort them. This is the same top-talker discipline you would use on a physical network, applied inside the host:
host hv-03, per-vNIC average rate, 21:00-22:00 vm tx-mbit rx-mbit report-01 2843.7 41.9 dw-01 39.2 2851.3 web-02 61.5 58.0 mail-01 22.4 19.8 (uplink-1 tx+rx during same window: 210 mbit)
- Step 2 — do the subtraction.
report-01transmits about 2.8 gigabits sustained; the host's uplinks carry barely a tenth of that in total. Traffic that VMs send but wires never carry has only one explanation: it stayed inside the host. You now know it is VM-to-VM. - Step 3 — pair the counters. One VM's transmit spike is another's receive spike.
report-01sends 2.8 gigabits;dw-01receives 2.8 gigabits over the same minutes. There is your conversation, found with nothing but free counters. - Step 4 — confirm and characterize. The names suggest a reporting server hammering a data warehouse. A ten-minute virtual port mirror (or an in-guest capture on either VM) confirms it: one bulk query connection, evening batch reports. Take the mirror down when you are done.
- Step 5 — decide the fix. All the usual options open up. Reschedule the batch to a quieter hour, tune the monster query, give the pair an affinity decision on a beefier host, or cap the job. The right one is a judgment call; the point is you are choosing with evidence instead of guessing.
- Step 6 — leave a tripwire. Add per-VM rate alerts for the pair (and ideally a host-CPU alert with them), so next time the job misbehaves, monitoring tells you before the users do.
Total tooling required for steps 1 through 3: none you did not already have. That is the recurring lesson of the invisible path — the hypervisor was watching all along; you just had to ask it.
Where to go next
Same-host VM traffic never touches a wire; that is usually a gift, sometimes a trap, and always something your physical tools cannot see. Start every question with per-VM counters. Escalate to mirroring, agents, or flow export only when the question deserves it. And make placement a decision instead of an accident. The neighboring guides continue the story. They cover what happens when the traffic does hit the wires, and how the host's own health explains network mysteries. Both are part of Virtualization & Hypervisor Networking.
Put this into practice with SysPeep Monitor
Conversation-level detail lives in your hypervisor's tools. But the symptoms of invisible traffic surface in metrics SysPeep Monitor watches all day. Those are host CPU, uplink utilization, interface errors, and per-device baselines. SysPeep Monitor auto-discovers hosts and switches, polls them over SNMP, WMI, and SSH, and alerts the moment the numbers move. Try it free on any Windows machine.
Download Free TrialLearn About SysPeep