Route Reflector Cluster Calculator for BGP Labs

August 24, 2026

Route Reflector Cluster Calculator

Size BGP route reflector clusters by client sessions, reflected path state, update fanout, platform limits, and operating headroom.

⚙Topology Presets
🖧Cluster Inputs
Controls memory and bandwidth labels in the output.
Changes the recommended cluster count and risk notes.
Profiles are planning limits, not vendor guarantees.
Include all RRs that peer with clients in the same logical cluster.
Leaf switches, border routers, hypervisors, or BGP-speaking nodes.
Dual-homing is the usual minimum for resilient iBGP.
Core routers, border reflectors, or special non-client sessions.
Each AFI/SAFI has independent path state and update streams.
For EVPN, count MAC/IP, IMET, prefix, and route-type entries together.
ECMP, add-path, multihoming, and duplicate advertisements increase this.
Includes AS path, communities, extended communities, next hop, labels, and NLRI overhead.
Use a peak estimate for failover, maintenance, or EVPN endpoint churn.
Higher means more peers can share encoded BGP UPDATE work.
Used directly when platform profile is Custom; otherwise shown as profile cap.
Reserve memory for BGP RIB, attributes, policy, logs, and daemon overhead.
Use path entries, not only unique prefixes, when add-path or multipath is enabled.
Applied to sessions, paths, update fanout, and memory estimates.

Cluster Sizing Results

Per-RR Sessions 0 ceil(client sessions / RRs) + mesh + non-client
Reflected Path State 0 clients per RR x prefixes x AFs x paths x buffer
Peak Update Fanout 0 inbound churn x recipients / packing gain
Lowest Headroom 0% min(session, memory, path headroom)
📊Platform Snapshot
500 Profile session cap
500k Profile path cap
4096 MB Memory budget
2 RR Recommended minimum
🗂BGP Topology Comparison Grid
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
💻Route Reflector Platform Reference
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
📐BGP Sizing Formula Reference
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
📈Common Project Sizes
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
🧭Route Reflector Cluster Rules
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
Reflection tip: Route reflectors reduce iBGP sessions but do not reduce the number of routes learned. Size memory from path entries, AFI/SAFI count, and attribute size, especially in EVPN or VPN labs.
Cluster tip: For two reflectors serving the same clients, use a consistent cluster design and identical outbound policy. For regional hierarchy, separate cluster IDs make troubleshooting loops and path hiding much easier.

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.

Route Reflector Cluster Calculator for BGP Labs

Related posts

Leave a Comment