BGP is one of the fundamental protocols responsible for keeping the internet connected. It allows independently operated networks to exchange routing information and determine how traffic should travel between different autonomous systems.
Most explanations of BGP focus on its external operation: how an organization establishes connections with upstream providers, exchanges prefixes, and makes routing decisions based on attributes such as AS_PATH, LOCAL_PREF, and MED.
However, exchanging routes with external networks is only part of the problem.
Consider an autonomous system with multiple routers distributed across different locations. One router establishes an eBGP session with an upstream provider and receives a full internet routing table. Other routers within the same autonomous system also need access to this routing information. They need to know which destinations are reachable, which paths are available, and where traffic should be forwarded.
Manually configuring every router with individual static routes would quickly become impractical. Redistributing everything through an IGP would introduce a different set of problems, particularly when dealing with large routing tables.
This is where Internal Border Gateway Protocol (iBGP) comes into play.
iBGP provides a mechanism for distributing BGP routing information between routers belonging to the same autonomous system. It allows an organization to maintain a consistent routing view across its infrastructure without requiring every router to establish its own external BGP sessions.
Understanding how iBGP works is essential when designing networks that involve multiple border routers, redundant upstream connections, geographically distributed infrastructure, or complex routing policies.
In this article, we’ll take a closer look at how iBGP operates, how routes are exchanged, why the protocol has certain restrictions, and how to build a scalable iBGP architecture.
1. Understanding Autonomous Systems
Before looking at iBGP itself, it is important to understand the concept of an Autonomous System (AS).
An autonomous system is a collection of IP networks and routers operated by a single administrative entity under a common routing policy.
Each autonomous system is identified by an Autonomous System Number (ASN). ASNs are used by BGP to identify individual networks and determine how routing information travels between them.
For example, an organization might operate an autonomous system with ASN 65001. Within this network, several routers provide connectivity to internal infrastructure, data centers, and external providers.
A simplified architecture could look like this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Internet
|
+---------------+
| Upstream ISP |
| AS 64500 |
+---------------+
|
eBGP
|
+---------------+
| Router A |
| AS 65001 |
+---------------+
|
iBGP
|
+---------------+
| Router B |
| AS 65001 |
+---------------+
|
iBGP
|
+--------------+
| Router C |
| AS 65001 |
+--------------+
Router A establishes an eBGP session with the upstream provider. It receives routing information about destinations reachable through AS 64500.
Since Router A, Router B, and Router C all belong to AS 65001, they can establish iBGP sessions to exchange this information internally.
The important distinction is that the autonomous system remains the same throughout the internal routing process.
When a route is exchanged between iBGP peers, the local ASN is not added to the AS_PATH attribute again. The route remains within the same autonomous system, and its AS_PATH continues to describe the path through external autonomous systems.
This distinction is fundamental to how BGP prevents routing loops.
2. What exactly does iBGP do?
iBGP is responsible for distributing BGP routing information within an autonomous system.
It does not replace an Interior Gateway Protocol (IGP), nor does it calculate the shortest path through an organization’s internal network.
Instead, it distributes information about available BGP routes and their associated attributes.
To understand why this is necessary, consider a network with two border routers.
Router A has an upstream connection to Provider A, while Router B has an upstream connection to Provider B.
Both routers receive external routing information through eBGP.
Without iBGP, Router A would have no direct mechanism to communicate its learned BGP routes to Router B. Both routers would effectively operate with separate views of external reachability.
With iBGP, they can exchange this information and make routing decisions based on the routes available throughout the autonomous system.
This becomes particularly important in multi-homed environments.
For example, if Provider A becomes unavailable, Router B might still have a working connection through Provider B. Internal routers need to be aware of the available alternatives so that traffic can continue flowing through the network.
iBGP makes this information available without requiring every internal router to establish external peering sessions.
2.1 BGP uses TCP
Like eBGP, iBGP uses TCP as its transport protocol.
BGP establishes sessions over TCP port 179. Once the TCP connection is established, the routers exchange BGP messages to establish and maintain their peering relationship.
The protocol uses four primary message types:
| Message | Purpose |
|---|---|
| OPEN | Establishes a BGP session and exchanges capabilities and parameters |
| UPDATE | Advertises new routes or withdraws previously advertised routes |
| KEEPALIVE | Maintains the BGP session |
| NOTIFICATION | Reports errors and terminates a session |
Once a session reaches the Established state, both routers can exchange routing information.
Unlike some other routing protocols, BGP does not continuously flood its entire routing table to its neighbors.
Instead, it exchanges updates when routing information changes and maintains the state of previously advertised routes.
This makes BGP suitable for exchanging large amounts of routing information across complex networks.
2.2 iBGP does not modify the AS_PATH
One of the most important differences between iBGP and eBGP is how the AS_PATH attribute is handled.
When a router advertises a route through eBGP, it prepends its own ASN to the AS_PATH.
For example, assume a route originates in AS 64496 and is advertised through AS 64500 before reaching AS 65001.
The resulting AS_PATH might look like this:
1
64496 64500 65001
When Router A advertises this route to Router B through iBGP, the AS_PATH remains unchanged.
1
2
3
4
5
Router A:
AS_PATH: 64496 64500 65001
Router B:
AS_PATH: 64496 64500 65001
This is intentional.
If every internal router added its own ASN to the AS_PATH, the autonomous system would no longer have a consistent representation of the external path.
More importantly, BGP uses the presence of its own ASN in the AS_PATH to detect routing loops. Since all routers within an autonomous system share the same ASN, adding it during internal propagation would cause problems.
The AS_PATH attribute is therefore preserved when routes are exchanged through iBGP.
3. The iBGP Split-Horizon Rule
There is one particular behavior of iBGP that has significant consequences for network design.
A route learned from one iBGP peer cannot be advertised to another iBGP peer.
This is commonly referred to as the iBGP split-horizon rule.
It is defined in the BGP specification, RFC 4271, and exists to prevent routing loops within an autonomous system.
Consider the following topology:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
+------------+
| Router A |
| AS 65001 |
+------------+
|
iBGP
|
+------------+
| Router B |
| AS 65001 |
+------------+
|
iBGP
|
+------------+
| Router C |
| AS 65001 |
+------------+
Assume Router A receives a route from an external BGP neighbor.
Router A advertises this route to Router B through iBGP.
Router B now knows about the route, but it cannot advertise that same route to Router C through iBGP.
As a result, Router C never receives the route through this particular topology.
At first, this might seem unnecessarily restrictive. After all, why shouldn’t Router B simply forward the information it received?
The reason becomes clearer when considering what happens without this restriction.
Imagine that Router A advertises a route to Router B, Router B advertises it to Router C, and Router C eventually advertises it back to Router A.
Since iBGP does not prepend the local ASN to the AS_PATH, the routers would have no AS_PATH-based indication that the route has already circulated through their autonomous system.
This could create routing loops.
The split-horizon rule prevents this behavior by ensuring that routes learned through iBGP are not propagated to other iBGP peers.
There is, however, one important exception: route reflection.
We’ll look at that in a later section.
4. Why iBGP Requires a Full Mesh
The split-horizon rule introduces a requirement that has a significant impact on network scalability.
In a traditional iBGP deployment, every router must establish a direct peering relationship with every other router in the same autonomous system.
This is known as a full-mesh topology.
Consider an autonomous system with four routers:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
+------------+
| Router A |
+------------+
/ \
/ \
/ \
+------------+ +------------+
| Router B |--| Router C |
+------------+ +------------+
\ /
\ /
\ /
+------------+
| Router D |
+------------+
Every router establishes a session with all other routers.
This means the number of required BGP sessions increases rapidly as the network grows.
The number of required sessions can be calculated using the following formula:
[ S = \frac{n(n-1)}{2} ]
Where:
- (S) represents the total number of required sessions.
- (n) represents the number of routers participating in the iBGP mesh.
For example:
| Routers | Required sessions |
|---|---|
| 2 | 1 |
| 3 | 3 |
| 4 | 6 |
| 5 | 10 |
| 10 | 45 |
| 20 | 190 |
| 50 | 1,225 |
| 100 | 4,950 |
With ten routers, maintaining 45 BGP sessions is still manageable.
With 50 routers, however, the network already requires 1,225 individual sessions.
At 100 routers, that number increases to 4,950.
Every additional router increases the number of relationships that need to be configured, monitored, and maintained.
This creates unnecessary operational complexity and introduces additional failure scenarios.
It also means that adding a new router requires establishing sessions with every existing router in the autonomous system.
For larger networks, maintaining a traditional full mesh becomes impractical.
Fortunately, BGP provides mechanisms to address this problem.
The two most commonly discussed approaches are Route Reflectors and BGP Confederations.
5. Route Reflectors
Route Reflectors (RRs) are designed to solve the iBGP full-mesh requirement.
Instead of requiring every router to establish a session with every other router, selected routers take responsibility for distributing routing information between their peers.
A router configured as a Route Reflector can receive routes from its clients and advertise those routes to other clients.
This allows the network to maintain a much smaller number of BGP sessions.
Consider the following topology:
1
2
3
4
5
6
7
8
9
10
11
12
+-----------------+
| Route Reflector |
| RR1 |
+-----------------+
/ | \
/ | \
/ | \
+---------+ +----------+ +---------+
| Router | | Router | | Router |
| R1 | | R2 | | R3 |
| Client | | Client | | Client |
+---------+ +----------+ +---------+
In this example, R1, R2, and R3 establish iBGP sessions only with RR1.
When R1 advertises a route to RR1, the route reflector can advertise that route to R2 and R3.
The clients do not need to establish direct sessions with each other.
This significantly reduces the number of required sessions.
5.1 How route reflection works
Route reflectors distinguish between three types of peers:
- Client: A router that establishes an iBGP session with a route reflector and participates in its reflection hierarchy.
- Non-client: An iBGP peer that is not configured as a client.
- Route Reflector: A router responsible for reflecting eligible BGP routes between its peers.
The route-reflection process depends on where a route was learned.
The basic rules are:
| Route learned from | Route advertised to |
|---|---|
| Client | Other clients and non-clients |
| Non-client | Clients |
| eBGP peer | Clients and non-clients |
A route reflector does not simply forward every route it receives.
Normal BGP route-selection rules still apply, and route reflection operates on eligible routes selected for advertisement.
5.2 Preventing routing loops
Route reflection introduces a different mechanism for preventing routing loops.
Since routes can now be propagated between iBGP peers through an intermediary, BGP needs a way to identify routes that have already passed through a route-reflector hierarchy.
Two attributes are particularly important.
ORIGINATOR_ID
The ORIGINATOR_ID attribute identifies the BGP router ID of the router that originally advertised the route into the route-reflection hierarchy.
If a router receives a route containing its own router ID as the ORIGINATOR_ID, it rejects that route.
This prevents a route from being reflected back to its original source.
CLUSTER_LIST
The CLUSTER_LIST attribute contains the cluster IDs of route reflectors through which a route has passed.
Each route reflector adds its own cluster ID when reflecting a route.
If a route reflector receives a route containing its own cluster ID in the CLUSTER_LIST, it rejects the route.
This prevents routing loops between route reflectors.
Together, these attributes allow route reflection to scale beyond a traditional full-mesh architecture.
5.3 Multiple Route Reflectors
In production environments, relying on a single route reflector introduces an unnecessary single point of failure.
If the route reflector becomes unavailable, clients may lose access to newly advertised routing information and updates from other clients.
A common solution is deploying multiple route reflectors.
1
2
3
4
5
6
7
8
9
10
+-----------------+ +-----------------+
| Route Reflector |--------| Route Reflector |
| RR1 | | RR2 |
+-----------------+ +-----------------+
/ | \ / | \
/ | \ / | \
/ | \ / | \
+----+ +----+ +----+ +----+ +----+ +----+
| R1 | | R2 | | R3 | | R1 | | R2 | | R3 |
+----+ +----+ +----+ +----+ +----+ +----+
Each client establishes a session with both route reflectors.
This provides redundancy while keeping the number of sessions manageable.
Depending on the architecture, the route reflectors may also establish an iBGP relationship with each other.
Care must be taken when designing the cluster topology and reflection policies to avoid introducing unnecessary complexity or inconsistent routing information.
For larger networks, route reflectors are often distributed across different locations or network regions.
6. BGP Confederations
Route Reflectors are not the only mechanism available to address the full-mesh requirement.
BGP Confederations provide another approach.
A confederation divides a large autonomous system into multiple smaller autonomous systems, known as sub-autonomous systems.
From the perspective of external BGP peers, the confederation appears as a single autonomous system.
Internally, however, routers operate within their respective sub-ASNs.
For example, an organization operating ASN 65001 could divide its infrastructure into three sub-autonomous systems:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
+---------------------------+
| AS 65001 |
| Confederation |
| |
| +-------+ +-------+ |
| | AS | | AS | |
| |65011 |---|65012 | |
| +-------+ +-------+ |
| \ / |
| \ / |
| +-----+ |
| | AS | |
| |65013| |
| +-----+ |
+---------------------------+
Each sub-AS can maintain its own internal routing structure.
Confederation eBGP sessions are used between sub-ASes, while iBGP sessions are used within each sub-AS.
When routes are advertised outside the confederation, the internal confederation information is handled separately from the externally visible AS_PATH.
This allows a large network to reduce the number of required internal BGP sessions while maintaining a consistent external ASN.
Confederations are less commonly encountered in many modern network designs than route reflectors, but they remain a valid architectural option for particularly large or complex environments.
7. The Relationship Between iBGP and IGP
One of the most important aspects of an iBGP deployment is understanding its relationship with an Interior Gateway Protocol.
iBGP and IGPs serve different purposes.
An IGP, such as OSPF or IS-IS, is responsible for distributing internal network reachability information and calculating paths through the autonomous system.
iBGP distributes BGP routing information between routers.
These protocols complement each other.
A common misconception is that iBGP automatically provides everything required for traffic to reach an advertised destination.
It does not.
7.1 Understanding the NEXT_HOP attribute
Consider the following topology:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Provider
AS 64500
|
eBGP
|
+------------+
| Router A |
| 10.0.0.1 |
+------------+
|
iBGP
|
+------------+
| Router B |
| 10.0.0.2 |
+------------+
Router A establishes an eBGP session with an upstream provider.
The provider advertises a route to Router A with the following attributes:
1
2
3
Prefix: 203.0.113.0/24
NEXT_HOP: 192.0.2.1
AS_PATH: 64500
Router A subsequently advertises this route to Router B through iBGP.
By default, the NEXT_HOP attribute is preserved.
Router B therefore receives:
1
2
3
Prefix: 203.0.113.0/24
NEXT_HOP: 192.0.2.1
AS_PATH: 64500
The problem is that Router B must know how to reach 192.0.2.1.
If the IGP does not provide a route to this address, the BGP next hop is unreachable.
As a result, Router B may have the prefix in its BGP table without being able to install it as a usable route in its main routing table.
This is commonly referred to as a next-hop reachability problem.
7.2 Using next-hop-self
One way to address this is by configuring next-hop-self.
This tells a BGP router to advertise itself as the next hop when advertising routes to a particular neighbor.
For example, Router A could advertise the route to Router B with the following attributes:
1
2
3
Prefix: 203.0.113.0/24
NEXT_HOP: 10.0.0.1
AS_PATH: 64500
Router B now needs to reach Router A rather than the external provider’s next-hop address.
As long as the internal network provides reachability to Router A, the route can be installed and used.
The configuration in FRRouting looks like this:
1
2
3
router bgp 65001
neighbor 10.0.0.2 remote-as 65001
neighbor 10.0.0.2 next-hop-self
This is particularly useful in networks where internal routers should forward traffic through designated border routers.
However, next-hop-self should not be enabled blindly.
In some architectures, preserving the original next hop is intentional. For example, certain data center designs rely on direct next-hop reachability and specific forwarding behavior.
The correct configuration depends on the routing architecture.
8. Understanding BGP Route Selection
Exchanging routes is only one part of BGP.
Routers must also determine which route should be considered the best path when multiple alternatives exist.
BGP uses a decision process to select the preferred route based on several attributes and implementation-specific rules.
Some of the most important attributes are:
| Attribute | Description |
|---|---|
| LOCAL_PREF | Determines the preferred exit path within an autonomous system |
| AS_PATH | Represents the sequence of autonomous systems a route has traversed |
| ORIGIN | Indicates how the route was originally introduced into BGP |
| MED | Suggests a preferred entry point into an autonomous system |
| NEXT_HOP | Identifies the next-hop address used to reach a destination |
| WEIGHT | Vendor-specific attribute used by Cisco implementations |
A simplified explanation of the decision process is:
- Prefer the route with the highest vendor-specific weight, if applicable.
- Prefer the route with the highest LOCAL_PREF.
- Prefer locally originated routes under the applicable selection rules.
- Prefer the route with the shortest AS_PATH.
- Prefer the lowest ORIGIN type.
- Compare MED values when applicable.
- Apply eBGP/iBGP preference and other implementation-specific tie-breakers.
- Continue through the remaining best-path selection criteria.
The exact decision process depends on the BGP implementation and configuration.
8.1 LOCAL_PREF and internal routing decisions
LOCAL_PREF is particularly important in iBGP environments.
It is used to influence which exit point an autonomous system should use when multiple paths to the same destination exist.
Unlike MED, LOCAL_PREF is distributed throughout an autonomous system through iBGP and is not normally advertised to external BGP peers.
Consider an organization connected to two upstream providers:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
+-------------+
| Provider A |
+-------------+
|
eBGP
|
+-------------+
| Router A |
+-------------+
|
iBGP
|
+-------------+
| Router B |
+-------------+
|
eBGP
|
+-------------+
| Provider B |
+-------------+
Both providers advertise the same destination prefix.
The organization can use LOCAL_PREF to determine which provider should be preferred for outbound traffic.
For example:
1
2
3
4
5
Route via Provider A:
LOCAL_PREF: 200
Route via Provider B:
LOCAL_PREF: 100
Since higher LOCAL_PREF values are preferred, routers within the autonomous system will generally select the route through Provider A, assuming the other relevant selection conditions do not override it.
This allows routing policy to be centralized and distributed across the network rather than configured independently on every router.
It is worth remembering that LOCAL_PREF influences the outbound path selected by the autonomous system. It does not directly determine the return path taken by remote networks.
9. iBGP Session Design and Router IDs
When establishing iBGP sessions, there are several design considerations beyond simply configuring the neighbor’s IP address.
One of them is the BGP Router ID.
The Router ID is a 32-bit identifier used to identify a BGP speaker.
It is commonly represented as an IPv4 address, although it does not need to be an address assigned to a physical interface.
For example:
1
2
router bgp 65001
bgp router-id 10.255.0.1
Using explicitly configured Router IDs is generally preferable in larger environments because it avoids unexpected changes when interface addresses or interface states change.
Another important consideration is the source address used for BGP sessions.
9.1 Using loopback interfaces
In larger networks, iBGP sessions are commonly established between loopback addresses rather than physical interface addresses.
A loopback interface is a logical interface that remains operational as long as the router itself is operational, independently of individual physical interface states.
Consider two routers:
1
2
3
4
5
Router A:
Loopback0: 10.255.0.1/32
Router B:
Loopback0: 10.255.0.2/32
The routers can establish an iBGP session using these addresses.
However, two additional requirements must be satisfied:
- Each router must have an IP route to the other router’s loopback address.
- The BGP session must use the appropriate loopback as its source address.
In FRRouting, this can be configured using update-source:
Router A:
1
2
3
4
router bgp 65001
bgp router-id 10.255.0.1
neighbor 10.255.0.2 remote-as 65001
neighbor 10.255.0.2 update-source lo
Router B:
1
2
3
4
router bgp 65001
bgp router-id 10.255.0.2
neighbor 10.255.0.1 remote-as 65001
neighbor 10.255.0.1 update-source lo
The IGP must provide reachability between 10.255.0.1/32 and 10.255.0.2/32.
This approach makes the BGP session independent of a particular physical link.
If one link fails but another path remains available through the internal network, the BGP session can remain established.
That is one of the reasons loopback-based peering is widely used in service provider and larger enterprise architectures.
10. Configuring iBGP with FRRouting
Let’s put the concepts together and configure a basic iBGP deployment using FRRouting.
FRRouting (FRR) is an open-source routing software suite that supports several routing protocols, including BGP, OSPF, IS-IS, and others.
It is commonly used on Linux-based routers and network appliances.
For this example, we’ll configure two routers within AS 65001.
The routers will establish an iBGP session using their loopback interfaces.
10.1 Network topology
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
AS 65001
+--------------------+
+--------------------+
| Router A |
| |
| Lo0: 10.255.0.1/32 |
| |
+--------------------+
|
|
Internal IGP
|
|
+--------------------+
| Router B |
| |
| Lo0: 10.255.0.2/32 |
| |
+--------------------+
+--------------------+
Both routers belong to AS 65001.
The IGP is responsible for advertising the loopback addresses so that both routers can reach each other.
For simplicity, the following example focuses on the BGP configuration.
10.2 Router A configuration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
configure terminal
router bgp 65001
bgp router-id 10.255.0.1
neighbor 10.255.0.2 remote-as 65001
neighbor 10.255.0.2 update-source lo
address-family ipv4 unicast
neighbor 10.255.0.2 activate
exit-address-family
end
write memory
10.3 Router B configuration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
configure terminal
router bgp 65001
bgp router-id 10.255.0.2
neighbor 10.255.0.1 remote-as 65001
neighbor 10.255.0.1 update-source lo
address-family ipv4 unicast
neighbor 10.255.0.1 activate
exit-address-family
end
write memory
Both routers should now attempt to establish an iBGP session.
The session can only reach the Established state if the underlying IP connectivity is working and the TCP connection can be established.
10.4 Verifying the BGP session
FRRouting provides several commands for inspecting the BGP process.
To check the current BGP sessions:
1
show bgp summary
A successfully established session should show an uptime and received-prefix information rather than a connection state such as Active or Idle.
To inspect the neighbor in more detail:
1
show bgp neighbor 10.255.0.2
To inspect the IPv4 BGP routing table:
1
show bgp ipv4 unicast
To inspect routes installed in the system routing table:
1
show ip route
It is important to distinguish between the BGP routing table and the system routing table.
A route can exist in BGP without being selected for installation in the main routing table.
This can happen when another routing protocol provides a preferred route or when the BGP next hop is unreachable.
11. Common iBGP Problems and Troubleshooting
Although the basic configuration is relatively straightforward, iBGP deployments can become difficult to troubleshoot when multiple routing protocols and policy mechanisms are involved.
Several problems occur particularly frequently.
11.1 BGP session stuck in Active or Idle
If an iBGP session does not reach the Established state, the first thing to investigate is basic IP connectivity.
Check whether the routers can reach each other’s peering addresses:
1
ping 10.255.0.2
If loopback addresses are being used, verify that the IGP has installed the appropriate routes.
Next, check whether TCP port 179 is reachable and whether a firewall is blocking the connection.
Useful commands include:
1
2
3
ip route get 10.255.0.2
ss -tnp | grep ':179'
Also verify that both routers are configured with the same expected remote ASN.
A common mistake is configuring the wrong ASN on one side of the peering relationship.
11.2 Routes are visible in BGP but not in the routing table
This is another frequent issue.
A route may appear in the BGP table but not be installed in the Linux routing table.
Possible causes include:
- The BGP next hop is unreachable.
- Another routing protocol provides a preferred route.
- A routing policy prevents the route from being selected.
- The route is not eligible for installation due to another forwarding or platform constraint.
Start by inspecting the route:
1
show bgp ipv4 unicast 203.0.113.0/24
Then inspect the routing table:
1
show ip route 203.0.113.0/24
Pay particular attention to the NEXT_HOP attribute.
If the next hop cannot be resolved, the route cannot be used for forwarding.
11.3 Routes are not being propagated
If a router receives a route but another iBGP peer never sees it, the split-horizon rule should be one of the first things to investigate.
In a traditional iBGP topology, a router cannot advertise a route learned from one iBGP neighbor to another iBGP neighbor.
Verify whether the topology uses a full mesh or a route-reflector architecture.
Also inspect the advertised routes:
1
show bgp ipv4 unicast neighbors 10.255.0.2 advertised-routes
Route maps, prefix lists, and other routing policies can also prevent routes from being advertised.
11.4 BGP sessions repeatedly disconnect
Repeated session resets can indicate problems with the underlying network.
Common causes include:
- Unstable physical links.
- Routing instability affecting loopback reachability.
- Firewall timeouts or filtering.
- TCP connectivity issues.
- BGP hold-timer expiration.
- Resource exhaustion on the router.
Inspect the BGP neighbor details and system logs to determine why the session is being reset.
Do not immediately increase BGP timers to hide the problem. A session that repeatedly disconnects usually indicates something worth investigating in the underlying infrastructure.
12. When should you use iBGP?
iBGP becomes particularly useful when an autonomous system operates multiple routers that need to exchange BGP routing information.
Typical scenarios include:
Service provider networks
Internet service providers commonly use iBGP to distribute routing information across their networks. This allows routers in different locations to share externally learned routes without establishing separate eBGP sessions with every upstream provider.
Multi-homed enterprise networks
Organizations connected to multiple upstream providers can use iBGP to exchange routes between border routers and coordinate routing decisions.
Data center networks
Larger data center environments often use BGP as their primary routing protocol. iBGP can be used to distribute routing information between different network components, depending on the chosen architecture.
Geographically distributed infrastructure
Organizations operating multiple locations can use iBGP to exchange routing information across their infrastructure while maintaining a consistent autonomous system.
Redundant internet connectivity
When multiple border routers provide external connectivity, iBGP allows them to share routes and coordinate which external paths should be preferred.
Conclusion
iBGP is an essential component of modern BGP-based network architectures.
While eBGP handles routing information exchange between autonomous systems, iBGP ensures that this information can be distributed throughout an autonomous system.
Its behavior is fundamentally different from that of an IGP. It does not calculate internal network paths or replace protocols such as OSPF and IS-IS. Instead, it distributes BGP routing information and allows routers to make consistent routing decisions based on a shared set of routes and policies.
The iBGP split-horizon rule prevents routes learned from one internal peer from being advertised to another internal peer. While this helps prevent routing loops, it introduces the full-mesh requirement, which becomes increasingly difficult to maintain as networks grow.
Route Reflectors provide an elegant solution by allowing selected routers to distribute routing information on behalf of others. For particularly large environments, BGP Confederations provide another way to organize internal routing relationships.
There are also several details that should not be overlooked when designing an iBGP deployment. Next-hop reachability, IGP integration, route selection, Router IDs, and session source addresses all play an important role in determining whether the network behaves as expected.
Ultimately, iBGP is not simply a mechanism for exchanging routes between routers. It is a fundamental building block for maintaining consistent and scalable routing architectures within an autonomous system.
And as with most things in networking, getting the basic configuration running is usually the easy part. Designing it so that it continues to work when individual links, routers, or entire locations become unavailable is where the actual engineering begins.
Further Reading
- RFC 4271 - A Border Gateway Protocol 4 (BGP-4)
- RFC 4456 - BGP Route Reflection
- RFC 5065 - Autonomous System Confederations for BGP
- FRRouting Documentation
- RFC 4760 - Multiprotocol Extensions for BGP-4