EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco-proprietary hybrid routing protocol that combines the best features of distance-vector and link-state protocols. For the CCNA 200-301 exam (objective 3.5), you must be able to configure, verify, and troubleshoot EIGRP in a lab environment. Real-world networks use EIGRP for its fast convergence, low overhead, and support for unequal-cost load balancing. This lab chapter walks you through a full EIGRP configuration on a simple topology, covering neighbor formation, route advertisement, metric calculation, and verification commands you will see on the exam.
Jump to a section
Imagine a postal delivery network where each post office (router) must learn the best route to deliver mail to any neighborhood (subnet). EIGRP works like a team of couriers who exchange 'route cards' (Hello packets) every 5 seconds to discover neighboring offices. When a new route is learned, the courier sends a 'reliable update' (Update packet) that the receiving office must acknowledge with a 'receipt' (ACK). If a courier fails to send a Hello for 15 seconds (Hold Time), the route is considered dead. Each route card carries a composite metric based on the slowest leg (bandwidth) and total distance (delay). The courier uses the Diffusing Update Algorithm (DUAL) to calculate the best path (successor) and a backup path (feasible successor) that is guaranteed loop-free. If the best route fails, EIGRP instantly switches to the backup without recalculating—like a courier knowing a second bridge to cross if the main one is out. This 'feasibility condition' ensures that the backup path has a lower metric than the best path from the successor's perspective, preventing loops. EIGRP also supports unequal-cost load balancing by sending mail along multiple paths proportionally, using the 'variance' multiplier. In the lab, you will configure EIGRP on routers, watch neighbors form, and verify the routing table populates with D (EIGRP) routes.
What is EIGRP and Why It Exists
EIGRP (Enhanced Interior Gateway Routing Protocol) is a Cisco-proprietary routing protocol that operates as an advanced distance-vector protocol. It was introduced in 1994 as an enhancement to IGRP (Interior Gateway Routing Protocol). EIGRP is classified as a hybrid protocol because it uses distance-vector logic for route calculation but incorporates link-state features like neighbor discovery and reliable updates. The primary reasons to use EIGRP include fast convergence (due to DUAL), low overhead (only partial updates when changes occur), and support for unequal-cost load balancing. For the CCNA exam, you need to know how to configure EIGRP for IPv4, verify neighbor adjacencies, and interpret the routing table.
How EIGRP Works Step by Step at the Packet/Frame Level
EIGRP uses five packet types: - Hello: Used for neighbor discovery and keepalive. Multicast to 224.0.0.10. Sent every 5 seconds on high-bandwidth links (>= 1.544 Mbps) and every 60 seconds on low-bandwidth links. - Update: Contains routing information. Sent reliably (requires ACK). Unicast to a new neighbor, multicast when multiple neighbors need update. - Query: Sent when a route is lost and no feasible successor exists. Multicast to 224.0.0.10. - Reply: Response to a Query. Unicast. - ACK: Acknowledgment of a reliable packet. Contains no data.
Neighbor Discovery: When a router is configured with EIGRP, it begins sending Hello packets out all EIGRP-enabled interfaces. The Hello contains the AS number, K-values, hold time, and subnet mask. A neighbor is formed when two routers receive each other's Hello packets with matching AS numbers and K-values, and their interfaces are in the same subnet. The default Hold Time is 3 times the Hello interval (15 seconds on high-speed links).
Route Exchange: Once neighbors are formed, they exchange their full routing table using Update packets. Updates are sent reliably: the sender waits for an ACK. If no ACK is received, the update is retransmitted (up to 16 times by default). After initial exchange, only incremental updates are sent when a route changes.
DUAL Algorithm: EIGRP uses DUAL to select routes. For each destination, the router chooses a successor (the best path, with the lowest metric). It may also identify one or more feasible successors (backup paths that meet the feasibility condition: the reported distance from the neighbor is less than the feasible distance of the current successor). The feasibility condition guarantees loop-free alternate paths. If the successor fails and a feasible successor exists, EIGRP immediately uses the feasible successor without sending queries. If no feasible successor exists, EIGRP sends Queries to all neighbors to recompute.
Key States, Timers, and Defaults
Hello Interval: 5 seconds for links with bandwidth >= 1.544 Mbps; 60 seconds for links with bandwidth < 1.544 Mbps.
Hold Time: 15 seconds (3 x Hello) by default; can be changed manually.
Metric Calculation: Composite metric = (K1 * BW + (K2 * BW)/(256 - Load) + K3 * Delay) * (K5/(Reliability + K4)). Default K-values: K1=1, K2=0, K3=1, K4=0, K5=0. So metric = BW + Delay (scaled). BW = (10^7 / min_bandwidth_in_kbps) * 256. Delay = (sum_of_delays_in_tens_of_microseconds) * 256.
AD (Administrative Distance): Internal EIGRP = 90; External EIGRP = 170.
EIGRP Router ID: Highest IP on a loopback interface, else highest IP on an active physical interface.
IOS CLI Verification Commands with Real Example Output
After configuring EIGRP, use these commands to verify:
show ip eigrp neighborsSample output:
EIGRP-IPv4 Neighbors for AS(100)
H Address Interface Hold Uptime SRTT RTO Q Seq
(sec) (ms) Cnt Num
0 192.168.12.2 GigabitEthernet0/0 13 00:12:34 1 100 0 12H: Handle (neighbor index)
Address: Neighbor's IP
Interface: Local interface
Hold: Time until neighbor considered dead (seconds)
Uptime: Time since neighbor learned
SRTT: Smooth Round Trip Time (ms)
RTO: Retransmission Timeout (ms)
Q Cnt: Queue count (should be 0)
Seq Num: Sequence number of last update
show ip route eigrpSample output:
D 10.0.0.0/8 [90/2172416] via 192.168.12.2, 00:10:00, GigabitEthernet0/0D: EIGRP (internal)
[90/2172416]: AD/Metric
via: Next-hop
show ip protocolsShows EIGRP process information, including AS number, router ID, neighbors, and filters.
show ip eigrp topologyDisplays the EIGRP topology table with successors and feasible successors.
How EIGRP Interacts with Related Protocols
EIGRP can redistribute routes from other routing protocols (OSPF, RIP, static) using the redistribute command. It can also be used in conjunction with BGP for external routes. EIGRP supports both IPv4 and IPv6 (named mode). It uses the same DUAL algorithm for both address families. EIGRP is often used in enterprise networks as an IGP, while OSPF is more common in service provider environments. On the CCNA exam, you may compare EIGRP to OSPF in terms of metric calculation, convergence, and scalability.
Configure EIGRP on R1
Enter global configuration mode on R1 and start the EIGRP process with AS number 100. Then advertise the directly connected networks. Use the `network` command with the wildcard mask to include the subnet. For example: ``` R1(config)# router eigrp 100 R1(config-router)# network 192.168.12.0 0.0.0.3 R1(config-router)# network 10.1.1.0 0.0.0.3 ``` The `network` command tells EIGRP which interfaces to enable EIGRP on and which networks to advertise. The wildcard mask is the inverse of the subnet mask. EIGRP will send Hello packets out interfaces that match the network statement. Always use the exact subnet mask wildcard to avoid including unwanted interfaces.
Configure EIGRP on R2
On R2, configure EIGRP with the same AS number (100) and advertise its connected networks. Include the link between R1 and R2, and the link to the loopback network. ``` R2(config)# router eigrp 100 R2(config-router)# network 192.168.12.0 0.0.0.3 R2(config-router)# network 192.168.23.0 0.0.0.3 R2(config-router)# network 10.2.2.0 0.0.0.3 ``` Make sure the AS number matches exactly. If the AS numbers differ, neighbors will not form. Also, ensure that the interfaces are up/up and have IP addresses in the advertised subnets.
Configure EIGRP on R3
On R3, configure EIGRP with AS 100 and advertise its networks, including the link to R2 and any loopback networks. ``` R3(config)# router eigrp 100 R3(config-router)# network 192.168.23.0 0.0.0.3 R3(config-router)# network 10.3.3.0 0.0.0.3 ``` After configuration, EIGRP will start sending Hello packets. Verify neighbor relationships using `show ip eigrp neighbors` on each router. All three routers should see each other as neighbors if the configuration is correct.
Verify EIGRP Neighbors and Routes
On any router, run `show ip eigrp neighbors` to confirm that all expected neighbors are present. The output should show each neighbor with a Hold time and Uptime. Then check the routing table with `show ip route eigrp` to see the EIGRP-learned routes. For example, on R1 you should see a route to 10.3.3.0/24 via R2. Also use `show ip protocols` to verify the EIGRP process and router ID. If neighbors are not forming, check the AS number, interface IPs, and that interfaces are not passive. Use `debug eigrp packets` (with caution) to see Hello and Update packets.
Configure Passive Interface
To prevent EIGRP from sending Hello packets out a specific interface (e.g., a LAN interface that does not have other routers), use the `passive-interface` command. This stops the router from sending Hellos out that interface, but the network is still advertised. ``` R1(config-router)# passive-interface GigabitEthernet0/1 ``` This is commonly done on interfaces facing end hosts. On the exam, be aware that a passive interface will not form neighbor adjacencies. Use `show ip protocols` to verify which interfaces are passive.
Verify Unequal-Cost Load Balancing
EIGRP supports unequal-cost load balancing using the `variance` command. By default, EIGRP only does equal-cost load balancing (up to 4 paths, default maximum-paths). To enable unequal-cost, configure a variance multiplier. ``` R1(config-router)# variance 2 ``` This allows routes with a metric up to 2 times the best metric to be installed in the routing table. Verify with `show ip route eigrp`. For example, if the best metric to a network is 100, routes with metric up to 200 will be used. The traffic is distributed proportionally based on the metric. On the exam, know that the variance command affects multipath routing.
In enterprise networks, EIGRP is often deployed in medium-to-large organizations that use Cisco equipment exclusively. For example, a company with multiple branch offices connected via WAN links might use EIGRP as the IGP to dynamically route traffic between sites. The network engineer configures EIGRP on all routers, using a single AS number for the entire domain. They use passive interfaces on links to end-user VLANs to prevent unnecessary Hellos. The engineer also tunes the metric by adjusting the delay on certain links to influence path selection. For instance, a satellite link with high latency might have its delay artificially increased to discourage traffic from using it unless necessary. EIGRP's fast convergence is critical for real-time applications like VoIP. If a WAN link fails, EIGRP can fail over to a backup link within seconds, often without dropping calls, thanks to feasible successors. Another common scenario is using EIGRP stub routing at remote branches. A stub router advertises only a default route to the hub, reducing the size of the topology table and preventing query propagation. This is configured with the eigrp stub command. In production, misconfiguration can cause routing loops or black holes. For example, if the AS number is mismatched, neighbors will not form. If the network statement is too broad (e.g., using a wildcard mask that includes interfaces that should not run EIGRP), it can cause unintended neighbor relationships or route leaks. Also, forgetting to configure authentication can allow rogue routers to inject false routes. EIGRP authentication uses MD5 or SHA-256. Performance-wise, EIGRP scales well up to a few hundred routers, but in very large networks, OSPF is often preferred due to its hierarchical design. However, EIGRP's stub feature and route summarization help manage scale. In a multi-vendor environment, EIGRP cannot be used because it is Cisco-proprietary; OSPF or IS-IS would be required.
The CCNA 200-301 exam tests EIGRP configuration under objective 3.5: 'Configure and verify EIGRP (single AS)'. Focus on the following:
Neighbor Formation: Know the prerequisites for forming an EIGRP neighbor: same AS number, matching K-values (defaults), interfaces in the same subnet, and no ACL blocking EIGRP packets (multicast 224.0.0.10). A common wrong answer is that the router IDs must match – they do not; they only need to be unique. Candidates often choose 'Hello and Hold timers must match' – actually, they do not need to match; the Hold timer of the receiver determines when the neighbor is declared dead.
Metric Calculation: The exam may ask for the metric of a route. Remember the formula: metric = (10^7 / bandwidth) * 256 + (delay/10) * 256 (with default K-values). Bandwidth is the minimum bandwidth along the path in kbps. Delay is the sum of delays in tens of microseconds. For example, a path with bandwidth 1000 kbps and delay 2000 microseconds gives metric = (10000000/1000)*256 + (2000/10)*256 = 2560000 + 51200 = 2611200. A trap is using the wrong units (delay in microseconds vs tens of microseconds).
Verification Commands: Be able to interpret output of show ip eigrp neighbors, show ip route eigrp, and show ip protocols. For example, the 'Q Cnt' should be 0; if non-zero, there are unacknowledged packets. The 'SRTT' is used for retransmission.
Passive Interface: Know that passive-interface stops Hellos but still advertises the network. A common question: 'Which command prevents EIGRP from forming neighbors on an interface but still advertises the subnet?' Answer: passive-interface.
Variance: The variance command allows unequal-cost load balancing. The default is 1 (equal-cost only). A typical question: 'What is the effect of variance 2?' Answer: Routes with metric up to 2 times the best metric are installed.
DUAL: Understand the concepts of successor, feasible successor, and feasibility condition. A feasible successor must have a reported distance less than the feasible distance of the successor. On the exam, a scenario may ask which path becomes the successor when the current successor fails.
Elimination strategy: For scenario questions, first check AS number matching. Then check if interfaces are in the same subnet. Then verify that no passive interface blocks Hellos. If the question involves metric, calculate the bandwidth and delay values carefully.
EIGRP uses AS number to identify the routing domain; neighbors must have the same AS number.
Default Hello interval is 5 seconds on links >= 1.544 Mbps; Hold time is 15 seconds (3 x Hello).
EIGRP uses composite metric: (10^7/min_bandwidth_kbps + sum_delay_tens_of_microseconds) * 256.
Administrative distance: Internal EIGRP = 90, External EIGRP = 170.
Passive-interface stops Hello packets but still advertises the network.
Variance command enables unequal-cost load balancing; default variance is 1 (equal-cost only).
Feasible successor must have reported distance < feasible distance of successor.
These come up on the exam all the time. Here's how to tell them apart.
EIGRP
Cisco-proprietary
Composite metric (bandwidth, delay, load, reliability)
Fast convergence with DUAL and feasible successors
No area hierarchy (flat design)
Supports unequal-cost load balancing via variance
OSPF
Open standard (RFC 2328)
Cost metric (based on bandwidth reference)
Fast convergence with SPF and LSA flooding
Hierarchical design with areas (backbone area 0)
Only equal-cost load balancing
Mistake
EIGRP Hello and Hold timers must match between neighbors.
Correct
Hello and Hold timers do not need to match. The Hold timer of the receiving router determines when the neighbor is considered dead. Cisco recommends using consistent timers for stability, but it is not a requirement for neighbor formation.
Many candidates confuse this with OSPF, where Hello and Dead intervals must match.
Mistake
EIGRP automatically load-balances across unequal-cost paths.
Correct
By default, EIGRP only load-balances across equal-cost paths (up to 4). To enable unequal-cost load balancing, you must configure the `variance` command. Without it, only routes with the exact same metric are used.
The term 'hybrid' may lead candidates to think EIGRP automatically supports unequal-cost, but it requires explicit configuration.
Mistake
The network command in EIGRP enables the protocol on the interface matching the network address (classful).
Correct
The network command uses a wildcard mask to specify the exact subnet. If no wildcard mask is given, EIGRP uses the classful boundary. For example, `network 10.0.0.0` enables EIGRP on all interfaces with an IP starting with 10. This can cause unintended adjacencies.
Older IGRP used classful networks; candidates may forget to specify the wildcard mask for subnetted networks.
Mistake
EIGRP uses the Router ID to form neighbors; Router IDs must be unique and match.
Correct
Router IDs must be unique but do not need to match. The Router ID is used to identify the router in the topology table and for DUAL operations. Neighbor formation does not require matching Router IDs.
Candidates may confuse this with OSPF, where mismatched Router IDs can cause issues in some implementations, but EIGRP does not have that requirement.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
For two routers to become EIGRP neighbors, they must: (1) use the same Autonomous System (AS) number, (2) have matching K-values (defaults are K1=1, K2=0, K3=1, K4=0, K5=0), (3) be connected on interfaces in the same subnet, (4) have no ACL blocking EIGRP packets (multicast 224.0.0.10), and (5) not have the interface configured as passive. The Hello and Hold timers do not need to match, but mismatched timers can cause flapping. On the exam, if neighbors are not forming, check these conditions first.
With default K-values (K1=1, K2=0, K3=1, K4=0, K5=0), the metric simplifies to: metric = (bandwidth + delay) * 256. Bandwidth = (10^7 / minimum bandwidth along the path in kbps). Delay = (sum of delays in tens of microseconds). For example, if the minimum bandwidth is 1000 kbps and total delay is 2000 microseconds, metric = (10000000/1000 + 2000/10) * 256 = (10000 + 200) * 256 = 10200 * 256 = 2611200. On the exam, you may be asked to compute metric or compare routes based on metric. Remember that bandwidth is the bottleneck link, and delay is cumulative.
A successor is the next-hop router for the best path to a destination (the route with the lowest metric). A feasible successor is a backup next-hop that meets the feasibility condition: its reported distance (the metric from that neighbor to the destination) is less than the feasible distance (the current best metric) of the successor. If the successor fails, the feasible successor is used immediately without sending queries. If no feasible successor exists, EIGRP sends queries to recompute the route. On the exam, you may be asked to identify feasible successors from a topology table.
The `passive-interface` command under router configuration mode prevents EIGRP from sending Hello packets out the specified interface. This stops neighbor relationships from forming on that interface. However, the subnet configured on that interface is still advertised in EIGRP updates sent to other neighbors. This is typically used on interfaces that connect to end hosts or switches where no other EIGRP routers exist. It reduces unnecessary traffic and prevents accidental adjacencies. To verify, use `show ip protocols` to see which interfaces are passive.
Use the `variance` command under the EIGRP router configuration. The variance multiplier allows routes with a metric up to (variance * best metric) to be installed in the routing table. For example, `variance 2` allows routes with metric up to 2 times the best metric. By default, variance is 1 (only equal-cost paths). The router will then load-balance proportionally based on the metric values. Note that EIGRP also supports up to 4 equal-cost paths by default (configurable with `maximum-paths`).
The EIGRP stub feature is used to restrict a router from advertising routes learned from other neighbors, typically at a remote branch. A stub router only advertises connected and summary routes (or a default route) and does not participate in query propagation. This reduces the size of the topology table and speeds up convergence. Configure with `eigrp stub [receive-only | connected | static | summary]`. For example, `eigrp stub connected summary` advertises only connected and summary routes. On the exam, know that stub routers do not forward queries.
Use the following commands: `show ip eigrp neighbors` displays neighbor table with details like address, interface, hold time, uptime, and queue count. `show ip route eigrp` shows only EIGRP-learned routes in the routing table. `show ip protocols` shows EIGRP process information, including AS number, router ID, passive interfaces, and filters. `show ip eigrp topology` displays the topology table with successors and feasible successors. For troubleshooting, `debug eigrp packets` can show Hello and Update exchanges (use with caution in production).
You've just covered Lab: Configure EIGRP — now see how well it sticks with free CCNA 200-301 practice questions. Full explanations included, no account needed.
Done with this chapter?