Back to Dashboard
Module 23
Advanced STP Features
← Previous Module
Next Module →
# 📘 CCNA 200-301 - Video 23: Advanced STP Features ## Deep Study Notes --- ## 📌 Learning Objectives By the end of this video, you should understand: - PortFast and its purpose - BPDU Guard and BPDU Filter - UplinkFast and its operation - BackboneFast and its operation - Loop Guard and Root Guard - When and how to use each feature --- ## 🧠 Core Concepts ### 1. STP Limitations **Standard STP Convergence Time:** 30-50 seconds | State | Duration | |-------|----------| | Blocking → Listening | 20 sec (Max Age) | | Listening → Learning | 15 sec (Forward Delay) | | Learning → Forwarding | 15 sec (Forward Delay) | | **Total** | **50 seconds** | **Problem:** When a device connects to a switch port (like a PC), it takes 30-50 seconds to start forwarding traffic. Users experience delays every time they connect. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ STANDARD STP DELAY ON ACCESS PORT │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ PC connects to switch port │ │ │ │ │ ▼ │ │ Port enters BLOCKING (20 sec) │ │ │ │ │ ▼ │ │ Port enters LISTENING (15 sec) │ │ │ │ │ ▼ │ │ Port enters LEARNING (15 sec) │ │ │ │ │ ▼ │ │ Port enters FORWARDING (after 50 seconds) │ │ │ │ │ ▼ │ │ User can finally use network! │ │ │ │ PROBLEM: 50 seconds is too long for end users! │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ### 2. PortFast **Definition:** PortFast is a Cisco feature that immediately transitions an access port from blocking to forwarding state, bypassing the listening and learning states. **Analogy:** PortFast is like a dedicated express lane at an airport. Regular passengers wait in line (STP states), but VIPs (end devices) go straight through. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ PORTFAST │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ WITHOUT PORTFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PC Connected → Blocking (20s) → Listening (15s) → Learning (15s) │ │ │ │ → Forwarding (after 50s) │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ WITH PORTFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PC Connected → Forwarding (immediately) │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ WHEN TO USE: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ ✓ Access ports connected to end devices (PCs, printers, servers) │ │ │ │ ✓ Ports that will NEVER connect to switches │ │ │ │ ✗ Trunk ports (can cause loops) │ │ │ │ ✗ Ports connected to other switches │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **PortFast Configuration:** ```cisco ! Configure PortFast on a single interface Switch(config)# interface fastEthernet 0/1 Switch(config-if)# spanning-tree portfast ! Configure PortFast globally (applies to all access ports) Switch(config)# spanning-tree portfast default ! Verify PortFast Switch# show spanning-tree interface fastEthernet 0/1 ! Example output: ! Interface Fa0/1 (port 1) in Spanning tree 1 is FORWARDING ! Port path cost 19, Port priority 128, Port Identifier 128.1. ! Designated root has priority 32768, address 001a.2b3c.4d5e ! Designated bridge has priority 32768, address 001a.2b3c.4d5e ! Designated port id is 128.1, designated path cost 0 ! Timers: message age 0, forward delay 0, hold 0 ! Number of transitions to forwarding state: 1 ! BPDU sent 0, received 0 ! The port is in the portfast mode ``` --- ### 3. BPDU Guard **Definition:** BPDU Guard is a security feature that disables (errdisable) a port if a BPDU is received on a PortFast-enabled port. **Purpose:** Prevents loops by ensuring that no switch is accidentally connected to a port that is supposed to be for end devices only. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ BPDU GUARD │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ NORMAL OPERATION (End Device Connected): │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ PC connected → PortFast enabled → No BPDU received → Port stays up │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ IF SWITCH ACCIDENTALLY CONNECTED: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ Switch connected → PortFast enabled → BPDU received │ │ │ │ → BPDU Guard triggers → Port goes into errdisable state │ │ │ │ → Loop prevented! │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **BPDU Guard Configuration:** ```cisco ! Configure BPDU Guard on a single interface Switch(config)# interface fastEthernet 0/1 Switch(config-if)# spanning-tree bpduguard enable ! Configure BPDU Guard globally (applies to all PortFast ports) Switch(config)# spanning-tree portfast bpduguard default ! Recover from errdisable state Switch# show interfaces status | include errdisable Switch# errdisable recovery cause bpduguard Switch# errdisable recovery interval 300 ! Auto-recover after 300 seconds ! Manual recovery Switch(config)# interface fastEthernet 0/1 Switch(config-if)# shutdown Switch(config-if)# no shutdown ``` **BPDU Guard vs. PortFast Relationship:** | PortFast | BPDU Guard | Result | |----------|------------|--------| | Disabled | Disabled | Normal STP operation | | Enabled | Disabled | PortFast active, BPDUs ignored | | Enabled | Enabled | PortFast active, port errdisables if BPDU received | --- ### 4. BPDU Filter **Definition:** BPDU Filter prevents the switch from sending or receiving BPDUs on a port. **Analogy:** BPDU Filter is like putting a soundproof wall around the port. No STP messages can get in or out. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ BPDU FILTER │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ Global BPDU Filter: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ • Applies to all PortFast ports │ │ │ │ • Prevents BPDU transmission AND reception │ │ │ │ • DANGEROUS: Can create loops! │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ Interface BPDU Filter: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ • Applies to specific interface │ │ │ │ • Same behavior - no BPDUs sent or received │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ WARNING: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ BPDU Filter is DANGEROUS! │ │ │ │ • If a switch is connected, loops can form │ │ │ │ • No STP protection │ │ │ │ • Use BPDU Guard instead unless you have a specific reason │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **BPDU Filter Configuration:** ```cisco ! Interface-level BPDU Filter Switch(config)# interface fastEthernet 0/1 Switch(config-if)# spanning-tree bpdufilter enable ! Global BPDU Filter (applies to all PortFast ports) Switch(config)# spanning-tree portfast bpdufilter default ! Verify Switch# show spanning-tree interface fastEthernet 0/1 detail ``` --- ### 5. UplinkFast **Definition:** UplinkFast is a Cisco proprietary feature that accelerates the failover time for a switch that has lost its root port. **Use Case:** Access layer switches with redundant uplinks to distribution switches. **Analogy:** UplinkFast is like having a backup generator that automatically starts when the main power fails. It takes only seconds instead of minutes. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ UPLINKFAST │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ WITHOUT UPLINKFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ Root Bridge │ │ │ │ (Distribution) │ │ │ │ ▲ ▲ │ │ │ │ │ │ │ │ │ │ Primary│ │Backup │ │ │ │ │ │ │ │ │ │ ┌────┴────┴────┐ │ │ │ │ │ Access Switch│ │ │ │ │ │ RP (Active) │ │ │ │ │ │ AP (Blocked) │ │ │ │ │ └──────────────┘ │ │ │ │ │ │ │ │ Primary fails → STP reconvergence: 30-50 seconds │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ WITH UPLINKFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ Root Bridge │ │ │ │ (Distribution) │ │ │ │ ▲ ▲ │ │ │ │ │ │ │ │ │ │ Primary│ │Backup │ │ │ │ │ │ │ │ │ │ ┌────┴────┴────┐ │ │ │ │ │ Access Switch│ │ │ │ │ │ RP (Active) │ │ │ │ │ │ AP (Blocked) │ │ │ │ │ └──────────────┘ │ │ │ │ │ │ │ │ Primary fails → UplinkFast: 2-4 seconds │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **How UplinkFast Works:** 1. Switch detects root port failure 2. Switch immediately unblocks the alternate port 3. Switch preloads MAC addresses to the alternate port 4. New root port becomes active in seconds (not 30-50 seconds) **UplinkFast Configuration:** ```cisco ! Enable UplinkFast globally Switch(config)# spanning-tree uplinkfast ! UplinkFast with rate (skips max age) Switch(config)# spanning-tree uplinkfast max-update-rate 200 ! Verify Switch# show spanning-tree summary | include UplinkFast ! Output: UplinkFast is enabled ``` **UplinkFast Effects:** - Increases bridge priority to 49152 (to prevent becoming root) - Automatically sets all ports to PortFast for faster recovery - Only works on switches with at least one blocked port --- ### 6. BackboneFast **Definition:** BackboneFast is a Cisco proprietary feature that accelerates STP convergence when a switch loses connectivity to the root bridge. **Use Case:** Core and distribution switches in a hierarchical network. **Analogy:** BackboneFast is like having a bypass route when the main highway is closed. Traffic finds an alternative path quickly. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ BACKBONEFAST │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ WITHOUT BACKBONEFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Root Bridge ─── Switch A ─── Switch B │ │ │ │ │ │ │ │ │ │ └──────┬─────┘ │ │ │ │ │ │ │ │ │ Switch C │ │ │ │ │ │ │ │ If link Root → Switch A fails: │ │ │ │ • Switch A must wait for Max Age (20 sec) before re-electing │ │ │ │ • Total convergence: 50 seconds │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ WITH BACKBONEFAST: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Root Bridge ─── Switch A ─── Switch B │ │ │ │ │ │ │ │ │ │ └──────┬─────┘ │ │ │ │ │ │ │ │ │ Switch C │ │ │ │ │ │ │ │ If link Root → Switch A fails: │ │ │ │ • Switch A receives RLQ (Root Link Query) from Switch B │ │ │ │ • Switch A determines root is unreachable via BPDU │ │ │ │ • Switch A starts alternative path immediately │ │ │ │ • Total convergence: < 10 seconds │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **How BackboneFast Works:** 1. Switch detects potential root path failure (receives inferior BPDU) 2. Switch sends RLQ (Root Link Query) to neighbors 3. If root is unreachable, switch bypasses Max Age timer 4. Switch immediately transitions to new root path **BackboneFast Configuration:** ```cisco ! Enable BackboneFast globally (must be enabled on all switches) Switch(config)# spanning-tree backbonefast ! Verify Switch# show spanning-tree summary | include BackboneFast ! Output: BackboneFast is enabled ``` --- ### 7. Root Guard **Definition:** Root Guard prevents a port from becoming a root port. If a BPDU with a better bridge ID is received, the port is placed in root-inconsistent state. **Purpose:** Ensures that the designated root bridge remains the root, preventing rogue switches from taking over. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ROOT GUARD │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ NORMAL OPERATION: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Root Bridge (Desired) Switch A (Root Guard enabled) │ │ │ │ ▲ │ │ │ │ │ │ │ │ │ │ │ Superior BPDU (good) │ │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ Rogue Switch │ │ │ │ (trying to become root) │ │ │ │ │ │ │ │ If rogue switch sends superior BPDU: │ │ │ │ • Port goes into root-inconsistent (blocked) │ │ │ │ • Root remains the desired root │ │ │ │ • Network stability maintained │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **Root Guard Configuration:** ```cisco ! Configure Root Guard on interface Switch(config)# interface gigabitEthernet 0/1 Switch(config-if)# spanning-tree guard root ! Verify Switch# show spanning-tree interface gigabitEthernet 0/1 detail ! Look for: "Root Guard is enabled on the port" ! Check root-inconsistent ports Switch# show spanning-tree inconsistentports ``` **Root Guard vs. BPDU Guard:** | Feature | Root Guard | BPDU Guard | |---------|------------|------------| | **Purpose** | Prevent port from becoming root | Prevent loops on access ports | | **Trigger** | Superior BPDU received | Any BPDU received | | **Action** | Root-inconsistent (blocked) | Errdisable | | **Port Type** | Typically trunk ports | Access ports with PortFast | | **Recovery** | Automatic when BPDU stops | Manual or errdisable recovery | --- ### 8. Loop Guard **Definition:** Loop Guard prevents alternate or root ports from transitioning to forwarding if BPDUs are no longer received. **Purpose:** Prevents loops caused by unidirectional link failures. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ LOOP GUARD │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ PROBLEM: Unidirectional Link Failure │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Switch A ────────────────────── Switch B │ │ │ │ (BPDUs can't reach A) │ │ │ │ │ │ │ │ Switch A stops receiving BPDUs, thinks it's root, │ │ │ │ starts forwarding on blocked port → LOOP! │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ SOLUTION: Loop Guard │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ • Port that stops receiving BPDUs stays in blocking state │ │ │ │ • Prevents transition to forwarding │ │ │ │ • Port recovers when BPDUs resume │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` **Loop Guard Configuration:** ```cisco ! Configure Loop Guard globally (applies to all ports) Switch(config)# spanning-tree loopguard default ! Configure Loop Guard on interface Switch(config)# interface gigabitEthernet 0/1 Switch(config-if)# spanning-tree guard loop ! Verify Switch# show spanning-tree interface gigabitEthernet 0/1 detail ! Look for: "Loop Guard is enabled on the port" ``` --- ### 9. Feature Comparison | Feature | Purpose | Configuration | Port Type | Recovery | |---------|---------|---------------|-----------|----------| | **PortFast** | Immediate forwarding on access ports | `spanning-tree portfast` | Access | N/A | | **BPDU Guard** | Disable port if BPDU received | `spanning-tree bpduguard enable` | Access | Errdisable recovery | | **BPDU Filter** | Suppress BPDUs (dangerous) | `spanning-tree bpdufilter enable` | Any | N/A | | **UplinkFast** | Faster failover for access switches | `spanning-tree uplinkfast` | Global | N/A | | **BackboneFast** | Faster convergence in backbone | `spanning-tree backbonefast` | Global | N/A | | **Root Guard** | Prevent port from becoming root | `spanning-tree guard root` | Trunk | Automatic | | **Loop Guard** | Prevent loops from unidirectional links | `spanning-tree guard loop` | Any | Automatic | --- ### 10. Feature Summary Diagram ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ STP FEATURES SUMMARY │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ ACCESS LAYER FEATURES: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ End Device (PC) ──── Access Port │ │ │ │ ├── PortFast (immediate forwarding) │ │ │ │ └── BPDU Guard (if BPDU, errdisable) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ DISTRIBUTION/ACCESS (Uplink) FEATURES: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Distribution Switch ◄──── Uplink ──── Access Switch │ │ │ │ └── UplinkFast (fast failover) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ CORE/DISTRIBUTION FEATURES: │ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │ │ │ │ │ │ Root Bridge ◄──── Trunk ──── Switch │ │ │ │ ├── Root Guard (prevent rogue root) │ │ │ │ └── BackboneFast (fast convergence) │ │ │ │ │ │ │ │ Switch to Switch Links: │ │ │ │ └── Loop Guard (prevent unidirectional loops) │ │ │ │ │ │ │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 🔧 Complete Configuration Examples ### Lab 1: PortFast with BPDU Guard ```cisco ! Configure access port with PortFast and BPDU Guard Switch(config)# interface fastEthernet 0/1 Switch(config-if)# switchport mode access Switch(config-if)# switchport access vlan 10 Switch(config-if)# spanning-tree portfast Switch(config-if)# spanning-tree bpduguard enable ! Global configuration (recommended) Switch(config)# spanning-tree portfast default Switch(config)# spanning-tree portfast bpduguard default ! Verify Switch# show spanning-tree interface fastEthernet 0/1 detail ``` ### Lab 2: UplinkFast Configuration ```cisco ! Enable UplinkFast on access switch Switch(config)# spanning-tree uplinkfast ! Optional: Configure max-update-rate Switch(config)# spanning-tree uplinkfast max-update-rate 200 ! Verify Switch# show spanning-tree summary Switch# show spanning-tree uplinkfast ``` ### Lab 3: Root Guard Configuration ```cisco ! Configure Root Guard on ports connected to distribution/access switches Switch(config)# interface range gigabitEthernet 0/1-2 Switch(config-if-range)# spanning-tree guard root ! Verify Switch# show spanning-tree interface gigabitEthernet 0/1 detail Switch# show spanning-tree inconsistentports ``` ### Lab 4: Loop Guard Configuration ```cisco ! Configure Loop Guard globally Switch(config)# spanning-tree loopguard default ! Or per interface Switch(config)# interface gigabitEthernet 0/3 Switch(config-if)# spanning-tree guard loop ! Verify Switch# show spanning-tree interface gigabitEthernet 0/3 detail ``` --- ## ✅ Exam Tips (For CCNA 200-301) | Topic | What Cisco Tests | |-------|------------------| | **PortFast** | Use on access ports; bypasses STP states | | **BPDU Guard** | Use with PortFast; errdisables port if BPDU received | | **UplinkFast** | Access switch feature; fast failover for uplinks | | **BackboneFast** | Distribution/core feature; fast convergence for root path failures | | **Root Guard** | Prevents port from becoming root; forces root-inconsistent | | **Loop Guard** | Prevents loops from unidirectional links | ### Common Exam Scenarios: **Scenario 1:** "A user complains that it takes 30 seconds to get network connectivity after plugging in a laptop. What feature should be configured?" - **Answer:** PortFast on the access port **Scenario 2:** "An access switch has two uplinks to distribution switches. One uplink is blocked by STP. What feature will provide faster failover?" - **Answer:** UplinkFast **Scenario 3:** "A switch receives BPDU on a PortFast-enabled port with BPDU Guard. What happens?" - **Answer:** The port goes into errdisable state ### Mnemonics: **STP Features:** **"PURLB" - PortFast, UplinkFast, Root Guard, Loop Guard, BackboneFast** **When to use BPDU Guard:** **"Guard the PortFast"** - Always use BPDU Guard on PortFast ports **Root Guard Placement:** **"Guard the Roots"** - Configure Root Guard on ports that should NOT become root ports --- ## 📝 Summary (1-Minute Revision) ``` ADVANCED STP FEATURES: PORTFAST: ├── Purpose: Immediate forwarding on access ports ├── Use: End devices (PCs, printers) ├── Configuration: spanning-tree portfast └── Risk: Can cause loops if connected to switch BPDU GUARD: ├── Purpose: Disable port if BPDU received ├── Use: With PortFast on access ports ├── Configuration: spanning-tree bpduguard enable └── Action: Errdisable state BPDU FILTER: ├── Purpose: Suppress BPDUs (DANGEROUS) ├── Use: Rarely; only with specific requirements ├── Configuration: spanning-tree bpdufilter enable └── Risk: Can create loops UPLINKFAST: ├── Purpose: Fast failover for access switches ├── Use: Access layer with redundant uplinks ├── Configuration: spanning-tree uplinkfast └── Convergence: 2-4 seconds BACKBONEFAST: ├── Purpose: Fast convergence for root path failures ├── Use: Core/distribution layer ├── Configuration: spanning-tree backbonefast └── Convergence: < 10 seconds ROOT GUARD: ├── Purpose: Prevent port from becoming root ├── Use: Ports that should not become root ├── Configuration: spanning-tree guard root └── Action: Root-inconsistent (blocked) LOOP GUARD: ├── Purpose: Prevent loops from unidirectional links ├── Use: Ports with potential for unidirectional failures ├── Configuration: spanning-tree guard loop └── Action: Blocked until BPDUs resume VERIFICATION: ├── show spanning-tree interface [int] detail ├── show spanning-tree inconsistentports ├── show spanning-tree summary └── show errdisable recovery ``` --- ## 🧪 Practice Questions **1. Which feature immediately transitions an access port to forwarding state?** - A) UplinkFast - B) BackboneFast - C) PortFast - D) Root Guard <details> <summary>Answer</summary> <b>C) PortFast</b> - PortFast bypasses STP states and immediately forwards traffic on access ports. </details> **2. What happens when BPDU Guard is enabled on a PortFast port that receives a BPDU?** - A) Port becomes root port - B) Port goes into errdisable state - C) Port becomes designated port - D) Port ignores the BPDU <details> <summary>Answer</summary> <b>B) Port goes into errdisable state</b> - BPDU Guard disables the port to prevent loops. </details> **3. Which feature accelerates STP convergence on an access switch with redundant uplinks?** - A) PortFast - B) UplinkFast - C) BackboneFast - D) Loop Guard <details> <summary>Answer</summary> <b>B) UplinkFast</b> - UplinkFast provides fast failover for access switches with redundant uplinks. </details> **4. Which feature prevents a switch from becoming the root bridge?** - A) BPDU Guard - B) Root Guard - C) Loop Guard - D) UplinkFast <details> <summary>Answer</summary> <b>B) Root Guard</b> - Root Guard prevents a port from becoming a root port. </details> **5. Which feature prevents loops caused by unidirectional link failures?** - A) PortFast - B) BPDU Guard - C) Loop Guard - D) BackboneFast <details> <summary>Answer</summary> <b>C) Loop Guard</b> - Loop Guard prevents ports from transitioning to forwarding when BPDUs stop. </details> **6. Which command enables PortFast on an interface?** - A) `spanning-tree portfast` - B) `spanning-tree fast` - C) `portfast enable` - D) `stp portfast` <details> <summary>Answer</summary> <b>A) `spanning-tree portfast`</b> - This is the correct command to enable PortFast. </details> **7. What is the default recovery time for errdisable ports?** - A) 30 seconds - B) 60 seconds - C) 300 seconds - D) No auto-recovery <details> <summary>Answer</summary> <b>D) No auto-recovery</b> - Auto-recovery must be configured with `errdisable recovery`. </details> **8. Which feature should be enabled on all access ports connecting end devices? (Select two)** - A) PortFast - B) UplinkFast - C) BPDU Guard - D) BackboneFast <details> <summary>Answer</summary> <b>A and C</b> - PortFast and BPDU Guard are recommended on access ports for faster connectivity and security. </details> **9. What is the purpose of BackboneFast?** - A) Fast failover for access switches - B) Fast convergence when root path fails - C) Immediate forwarding on access ports - D) Prevent loops from unidirectional links <details> <summary>Answer</summary> <b>B) Fast convergence when root path fails</b> - BackboneFast accelerates convergence when switches lose connectivity to root. </details> **10. A port with Root Guard receives a superior BPDU. What state does it enter?** - A) Forwarding - B) Listening - C) Root-inconsistent - D) Errdisable <details> <summary>Answer</summary> <b>C) Root-inconsistent</b> - Root Guard puts the port in root-inconsistent (blocked) state. </details> **11. Which feature is considered dangerous because it can create loops?** - A) PortFast - B) BPDU Guard - C) BPDU Filter - D) Loop Guard <details> <summary>Answer</summary> <b>C) BPDU Filter</b> - BPDU Filter suppresses BPDUs and can cause loops if a switch is connected. </details> **12. What is the convergence time for UplinkFast?** - A) 2-4 seconds - B) 15 seconds - C) 30 seconds - D) 50 seconds <details> <summary>Answer</summary> <b>A) 2-4 seconds</b> - UplinkFast provides fast failover in approximately 2-4 seconds. </details> --- ## 📌 Next Steps After completing Video 23, you should be ready for: - **Video 24:** Multiple Spanning Tree (MST) **Lab Practice:** 1. Configure PortFast on access ports and verify with `show spanning-tree interface` 2. Configure BPDU Guard and test by connecting a switch 3. Configure UplinkFast on an access switch with redundant uplinks 4. Configure Root Guard on distribution switch ports 5. Configure Loop Guard on switch-to-switch links 6. Verify all features with appropriate show commands **Ready for Video 24?** Share the link or say "next" and I'll continue with Multiple Spanning Tree (MST). I'll continue with **Video 24: Multiple Spanning Tree (MST)** based on the standard CCNA 200-301 curriculum. ---