Route Reflector Cluster Calculator
Size BGP route reflector clusters by client sessions, reflected path state, update fanout, platform limits, and operating headroom.
Cluster Sizing Results
| Topology | Best use | Session formula | Cluster-ID pattern | Main sizing risk |
|---|---|---|---|---|
| Full-mesh iBGP | Very small labs | n x (n - 1) / 2 total | No RR cluster ID | Explodes as routers grow |
| Single route reflector | Temporary tests | clients + non-clients | One cluster ID | Single control-plane failure |
| Dual route reflectors | Home lab and small fabric | 2 x clients plus RR mesh | Same ID for same cluster | Update fanout during churn |
| Quad route reflectors | Medium leaf-spine | client sessions split over 4 RRs | One ID per cluster | RR-to-RR policy consistency |
| Hierarchical reflectors | Regional or WAN scale | edge clients plus core RR peers | Unique ID per tier/region | Path hiding and policy leaks |
| Platform profile | Planning session cap | Planning path cap | Memory budget | Useful fit |
|---|---|---|---|---|
| FRRouting small VM | 500 sessions | 500k path entries | 4096 MB | Home lab, small EVPN fabric |
| FRRouting medium VM | 1500 sessions | 2M path entries | 8192 MB | Lab leaf-spine or dual-site |
| VyOS routing VM | 1200 sessions | 1.5M path entries | 8192 MB | WAN lab and route policy testing |
| BIRD or GoBGP server | 2000 sessions | 2.5M path entries | 8192 MB | Route collector style control plane |
| Vendor virtual router | 3000 sessions | 5M path entries | 16384 MB | Large lab, POP, or staged migration |
| Metric | Formula used | Why it matters | Home lab target | Scale warning |
|---|---|---|---|---|
| Client sessions per RR | ceil(clients x RR per client / RR count) | Shows session load before RR mesh | Under 200 | Watch TCP and keepalive CPU |
| RR mesh sessions | RR count - 1 per reflector | Needed so reflectors share learned paths | 1 to 3 | Large flat RR sets add policy risk |
| Path state | clients per RR x prefixes x AF x paths | Memory is driven by paths, not routers | Under 60% cap | Add-path and EVPN multiply state |
| Update fanout | inbound changes x recipients / packing gain | Approximates encoded UPDATE work | Under 1000/min | Failures create bursty churn |
| Memory model | path entries x (attributes + 128 B) | Includes route object and attribute overhead | 25%+ headroom | Communities and labels increase bytes |
| Project | RR count | Client routers | Typical path state | Design note |
|---|---|---|---|---|
| Mini BGP lab | 2 | 4 to 8 | Under 25k paths | Good for policy and failover drills |
| Proxmox EVPN rack | 2 | 6 to 18 | 50k to 250k paths | EVPN route types make prefix counts misleading |
| Small leaf-spine fabric | 2 to 4 | 24 to 80 | 250k to 2M paths | Use consistent client policies on both RRs |
| Dual-site lab | 4 | 20 to 60 | 200k to 1.5M paths | Use separate cluster IDs per site or tier |
| Metro POP lab | 4 to 8 | 80+ | 1M+ paths | Prefer regional hierarchy over one large flat cluster |
| Rule | Practical value | Reason | Calculator input affected | Operational check |
|---|---|---|---|---|
| Use at least two RRs for production | 2 per client | A single RR is a control-plane outage domain | Reflectors per client | Each client has two established sessions |
| Keep cluster IDs deliberate | One per logical cluster | Cluster list prevents reflection loops | Topology type | RR pair uses the intended cluster ID |
| Count AFI/SAFI separately | IPv4, IPv6, EVPN, VPNv4 | Each family has separate Adj-RIB and updates | Address families carried | Show bgp summary per family |
| Plan for peak churn | Maintenance rate, not idle rate | RR CPU spikes when many routes change | Changed prefixes per minute | Measure during failover tests |
| Leave path-state headroom | 25% minimum | Policy changes and add-path can double entries | Overhead buffer and platform cap | Alert before 70% sustained usage |
Connecting boxes is great, it’s how you build out a data center fabric or test one in a home lab. You get those boxes fired up and then give them their IP addresses and wait as they blink there lights. But now you’ve reached the routing layer and you’re confronted with reality of BGP.
Should all routers be full-mesh? That’s going to crush your CPU with a session count. In fact, the session count will crush your CPU before you even import a single prefix. This is where route reflectors comes into play. It breaks the need for a full mesh. Instead of peering with each and every router, let the clients peer with just a handful of reflectors.
How to Plan Your BGP Network
The math become tricky here and I built a calculator to run it for you. The biggest mistake engineers make is assuming that session count is the only metric that matters. They don’t. A “session” are a TCP connection. That doesn’t matter. What matters is path state… How many prefixes does each node has to learn? And how do you represent them? How much memory do you use for each one?
Remember, the reflector has to hold all these paths in memory because every prefix a client learns is reflected back to every other client. If you’re doing EVPN, then you aren’t just carrying IPv4 routes. You’re carrying Ethernet auto-discovery entries, MAC/IP routes and multicast entries too. Each of these address families takes its own Adj-RIB. They also consume distinct memory! You can choose the number of address families with the tool, that affects the memory estimate. If you don’t pay attention to this then you might end up crashing due to out of memory issues when things grows large.
Churn. Remember that this is a dynamic network. And you have to account for things like a link going down or even someone changing a policy. How does the route reflector notify everyone? That’s what we call update fanout.
If there’s a lot of churn (such as when you’re drilling through a failover) then you need headroom. Update-group packing efficiency is a technical term for the ability of the daemon to batch up same updates to peers. So it’s able to group identical updates together for multiple peer.
Update fanout, how many clients the reflector has to update when a route changes? Path and session limits is not just about how much RAM you have. You’ll need plenty of processing power to encode & send those updates too!
Anything related to production requires redundancy, and there’s no room for negotiation. A single route reflector are a single point of failure. When it goes down your clients lose all their routes. Dual-homing is the traditional approach. Each client peers with two reflectors, which provides resilience. However, this mean double the number of client sessions different than a single reflector setup.
Changing the reflectors per client setting updates the session count automaticly on the calculator. Also note that it reminds you to maintain consistency in the Cluster ID. Your two reflectors in your cluster has different IDs, which the BGP protocol views as two distinct clusters. This breaks the reflection logic and creates loops.
But when it comes to memory sizing, our intuition goes out the window. There is no guessing what size of VM you want. Instead, you must understand how much space your paths are taking up (average path attribute size). Longer AS paths will be larger. More communities and more extended communities on an EVPN will also consume more space. The tool computes your total memory requirements by multiplying the number of prefixes times the number of paths per prefix times the size per path. That gives you a realistic memory budget.
Oversizing is good but overshooting is bad. You should of not run your BGP daemon anywhere near full memory. Ninety percent is not stable. Leave yourself some headroom; ideally twenty five percent for add-path scenarios and/or policy changes.
Lastly, there is topology. Small labs will benefit from flat clusters; large fabrics demand hierarchies. Combining these also comes at cost. You need to carefully plan to prevent path hiding problem. Thankfully, there are presets in the calculator for typical scenarios. These range from tiny dual-RR labs to giant metro POP clusters. They’re not hard rules but starting points. This help you know where to begin.
You tweak the inputs based off your policy requirements and hardware capabilities. You are not only connecting everything together. You are building a fabric that supports the weight of your routes. Respect the math, start with the basics. Let the control plane do what it does best.



