Advanced Routing and Traffic Engineering Questions

Advanced routing protocols, algorithms, and real world deployment practices for large scale and multi domain networks. Topics include deep Border Gateway Protocol knowledge such as path selection, attribute handling including weight, local preference, AS path manipulation, multi exit discriminators, communities, route filtering, route aggregation, and mitigation of route hijacking. Also covers advanced aspects of interior protocols such as Open Shortest Path First and IS IS including area design, adjacency and LSA or link state behavior, convergence optimization, and comparison of link state versus other approaches. Traffic engineering topics include load balancing, multi path routing, MPLS fundamentals and label switching, segment routing principles, and using routing and BGP for traffic engineering across internet exchanges and multi carrier environments. Practical skills include designing redundancy, scaling routing control planes, route policy design, and troubleshooting complex inter domain routing behaviors.

MediumTechnical

63 practiced

Write a Python 3 script (maximum 50 lines) that reads from stdin simplified BGP entries where each line is: 'prefix local_pref as_path origin' (space-separated). Example: '203.0.113.0/24 100 65001 65002 65003 i'. For each unique prefix, output the best path according to: highest local_pref, then shortest AS path length, then origin preference (i < e < ?), then lexicographically smallest AS path string as final tie-breaker. Focus on correct selection logic and readable code.

Sample Answer

**Approach**

- Parse each stdin line into prefix, local_pref, as_path, origin.- For each prefix keep the candidate with the best key: 1. higher local_pref 2. shorter AS path length 3. origin rank (i < e < ?) 4. lexicographically smallest AS path string as final tie-breaker- Emit the stored best lines.

**Code (<=50 lines)**

python3

#!/usr/bin/env python3
import sys

origin_rank = {'i': 0, 'e': 1, '?': 2}

best = {}  # prefix -> (key, original_line)

for line in sys.stdin:
    line = line.strip()
    if not line:
        continue
    parts = line.split()
    # Expect: prefix local_pref as_path... origin (origin last token)
    if len(parts) < 4:
        continue
    prefix = parts[0]
    try:
        lp = int(parts[1])
    except ValueError:
        continue
    origin = parts[-1]
    as_path_tokens = parts[2:-1]
    as_path_len = len(as_path_tokens)
    as_path_str = ' '.join(as_path_tokens)
    o_rank = origin_rank.get(origin, 3)
    # key: prefer higher local_pref -> use negative for min compare
    key = (-lp, as_path_len, o_rank, as_path_str)
    if prefix not in best or key < best[prefix][0]:
        best[prefix] = (key, line)

# Output best lines in stable order (sorted by prefix)
for prefix in sorted(best):
    print(best[prefix][1])

**Notes**- Time: O(n log p) due to final sort (n lines, p prefixes). Space: O(p).- Handles missing/invalid lines gracefully. Origin unknown ranks lowest.

MediumTechnical

37 practiced

You need consistent per-flow ECMP hashing across a heterogeneous vendor leaf-spine (different default hash seeds and field selection). Describe strategies to achieve consistent hashing across platforms, how to validate with packet captures or telemetry, and how to handle flows that fragment or exceed MTU which may cause reordering.

Sample Answer

**Approach / strategies**

- Standardize hashing where possible - Configure all vendors to use the same hash fields (prefer 5-tuple: src/dst IP, src/dst port, protocol) and same L4 preference. Many vendors let you choose L3+L4 hashing—use that. - Align hash seeds/algorithms: set vendor CLI options for consistent seed or enable vendor “consistent-hash” modes. If vendor A cannot change seed, use an intermediate device (or traffic-policy) to normalize (e.g., rewrite ports via NAT or use tunnel encapsulation with uniform inner headers).

- Alternatives when config parity isn’t possible - Use symmetric hashing (flow key independent of direction) so return path matches forward path. - Use ECMP with fewer equally-performing paths (reduce path count) or use deterministic hashing via programmable switches (P4/SONiC) to implement a custom hash. - For tunnels, hash on inner headers consistently across platforms.

**Validation (packet captures & telemetry)**

- Capture and correlate: - Capture at leaf ingress and at spine egress for same flows; include timestamps and interfaces. - Use tshark to extract 5-tuple and compute hash-like identifier:

bash

tshark -r capture.pcap -T fields -e frame.time_epoch -e ip.src -e ip.dst -e tcp.srcport -e tcp.dstport -e ip.proto

Compare tuples and timestamps to see path selection.- Use device telemetry: - sFlow/IPFIX: export flow records with hash or path index fields; compare hashes across devices. - CLI show commands: many platforms expose “flow-hash” or “ecmp-hash” per flow—collect and compare.- Correlate using timestamps and a unique 5-tuple to confirm consistent next-hop selection.

**Handling fragmented / MTU-exceeding flows**

- Avoid fragmentation: - Enforce Path MTU discovery (ensure DF bit behavior) and tune TCP MSS on edge devices (e.g., reduce MSS on TCP SYN to avoid in-path fragmentation). - Turn off IP fragmentation by policy and drop or signal PMTUD instead of fragmenting in network.- If fragmentation occurs: - Hashing on fragments: many platforms hash only on first fragment (contains 5-tuple). Ensure fragments preserve original header in first fragment; later fragments may lack L4 ports and can be mis-hashed -> they should be pinned to same path by enabling “consistent-flow-pin” or reassembly before ECMP where supported. - Disable features that alter packets in-flight (TSO/GSO/TSO interactions) or ensure NIC offloads are accounted for in captures.- Operational mitigation: - Pin large flows (elephant flows) via policy-based routing or flow-tracking to a single path. - Monitor for reordering metrics and add sequence checks in telemetry; if reordering observed, reduce ECMP width or force per-flow pinning.

**Why this works**- Aligning fields and seeds ensures deterministic mapping from flow key -> path across vendors. Validation with packet captures + sFlow/IPFIX gives ground truth. Preventing fragmentation or ensuring fragments are hashed/pinned avoids reordering that breaks higher-layer protocols.

EasyTechnical

66 practiced

Define ECMP and explain the difference between per-packet and per-flow load balancing. Describe how hashing decisions are typically made (which header fields are used), common operational problems such as flow skew or reordering, and give examples of topologies and traffic types where ECMP is recommended or not recommended.

EasyTechnical

45 practiced

List and explain the key differences between iBGP and eBGP behaviors: AS path modification, next-hop behavior, TTL/multihop requirements, default administrative distance, and typical session use-cases. Provide a brief scenario where an iBGP next-hop causes an unexpected forwarding failure and how you would fix it.

EasyTechnical

35 practiced

Describe RPKI (Resource Public Key Infrastructure) and origin validation at a high level. Explain how ROAs are created and published, what a router's origin validation result (valid/invalid/not-found) means, and operational caveats such as ROA coverage limitations, propagation delay, and the risk of rejecting 'invalid' routes during ROA misconfiguration.

Unlock Full Question Bank

Get access to hundreds of Advanced Routing and Traffic Engineering interview questions and detailed answers.

Join thousands of developers preparing for their dream job.