Skip to content

Address Families SRv6 and MUP

Jump to bottom
Thomas Mangin edited this page Mar 25, 2026 · 3 revisions

SRv6 and Mobile User Plane (MUP)

Segment Routing over IPv6 (SRv6) and Mobile User Plane (MUP) enable advanced traffic engineering and 5G mobile network integration using IPv6-based segment routing.

Table of Contents

Overview

What is SRv6?

Segment Routing over IPv6 (SRv6) is a source routing paradigm that leverages IPv6 as the underlying data plane. It allows network operators to encode a packet's path as a list of IPv6 addresses (segments) in the IPv6 extension header.

Key characteristics:

  • Uses IPv6 addresses to represent network segments
  • Encodes forwarding instructions in the packet header
  • Provides fine-grained traffic engineering without per-flow state in the network core
  • Supports service chaining and network programming

What is MUP?

Mobile User Plane (MUP) extends SRv6 to support 5G mobile networks by providing segment routing for mobile user plane traffic. It enables:

  • Integration of 5G User Plane Functions (UPF) with SRv6
  • Mobile session anchoring and mobility
  • Service function chaining for mobile traffic
  • Efficient mobile backhaul and fronthaul

RFCs and Standards

  • RFC 8986: SRv6 Network Programming
  • RFC 9514: Border Gateway Protocol - Link State (BGP-LS) Extensions for Segment Routing BGP Egress Peer Engineering
  • draft-ietf-dmm-srv6-mobile-uplane: SRv6 for Mobile User Plane (work in progress)

ExaBGP Support

ExaBGP supports SRv6 and MUP through:

  • BGP SAFI 73 (SR Policy)
  • SRv6 SID (Segment Identifier) advertisement
  • MUP-specific NLRI encoding
  • Integration with SDN controllers and orchestration systems

Important: ExaBGP announces SRv6/MUP routes via BGP but does NOT install them into the kernel routing table or perform packet forwarding. Your external application must handle route installation and traffic steering.

SRv6 Basics

Segment Routing Architecture

SRv6 uses three key components:

  1. Segment Identifier (SID): An IPv6 address representing a network function or path segment
  2. Segment List: An ordered list of SIDs encoding the packet's path
  3. Segment Routing Header (SRH): An IPv6 extension header carrying the segment list

SID Types

Common SRv6 SID types:

SID Type Description Example Use
End Endpoint function Node segment
End.X Endpoint with cross-connect Adjacency segment
End.DT4/DT6 Decapsulation and IPv4/IPv6 table lookup VPN termination
End.DX4/DX6 Decapsulation and IPv4/IPv6 cross-connect L3VPN PE
End.T Transit behavior with table lookup VRF routing
End.B6.Encaps Binding SID with encapsulation SR policy head-end

SRv6 vs SR-MPLS

Feature SRv6 SR-MPLS
Data plane IPv6 MPLS
Segment encoding IPv6 addresses MPLS labels
Header SRH (IPv6 extension) MPLS label stack
Address space 128-bit IPv6 20-bit MPLS label
Network programming Rich (End, End.X, End.DT, etc.) Limited (PHP, UHP)
Deployment IPv6 infrastructure required MPLS infrastructure required

Mobile User Plane (MUP)

5G Network Architecture

MUP integrates SRv6 with 5G mobile networks:

[UE] <---> [gNB] <---> [5G Core Network]
              |              |
              +---[UPF]------+
                    |
                  [SRv6 Network]
                    |
                [Data Network]

Components:

  • UE: User Equipment (mobile device)
  • gNB: 5G base station
  • UPF: User Plane Function (packet processing)
  • SRv6 Network: Transport network using segment routing

MUP Use Cases

  1. Mobile Session Anchoring: Anchor mobile sessions at specific UPF nodes
  2. Session Mobility: Seamlessly move sessions between UPFs
  3. Service Function Chaining: Insert security, NAT, or firewall functions
  4. Multi-Access Edge Computing (MEC): Route traffic to edge compute resources
  5. Network Slicing: Isolate traffic for different service types (eMBB, URLLC, mMTC)

MUP SID Types

Mobile User Plane specific SIDs:

  • End.M.GTP4.E: GTPv1-U encapsulation for IPv4
  • End.M.GTP6.E: GTPv1-U encapsulation for IPv6
  • End.M.GTP4.D: GTPv1-U decapsulation for IPv4
  • End.M.GTP6.D: GTPv1-U decapsulation for IPv6

Use Cases

1. 5G Mobile Backhaul/Fronthaul

Use SRv6 to transport mobile traffic between radio access network and core:

[gNB] --SRv6--> [UPF] --SRv6--> [5G Core]

Benefits:

  • No MPLS required
  • Simplified network operations
  • Fine-grained traffic steering
  • Support for network slicing

2. Mobile Edge Computing

Route mobile user traffic to edge compute nodes:

[UE] --> [gNB] --> [UPF] --SRv6--> [MEC Node] --> [Application]

Benefits:

  • Low latency for edge applications
  • Dynamic traffic steering based on user location
  • Service chaining for security/optimization

3. Network Slicing

Isolate different service types using SRv6:

[eMBB Traffic] --SRv6 Path 1--> [High Bandwidth Path]
[URLLC Traffic] --SRv6 Path 2--> [Low Latency Path]
[mMTC Traffic] --SRv6 Path 3--> [IoT Backend]

Benefits:

  • Service-level isolation
  • Different QoS per slice
  • Flexible resource allocation

4. Cross-Domain Traffic Engineering

Steer mobile traffic across multiple network domains:

[Mobile Network] --SRv6--> [Transit Network] --SRv6--> [Data Center]

Benefits:

  • End-to-end path control
  • Multi-domain visibility
  • SLA enforcement

Configuration

Basic SRv6 Neighbor

neighbor 2001:db8::1 {
    router-id 10.0.0.1;
    local-address 2001:db8::2;
    local-as 65001;
    peer-as 65002;

    family {
        ipv6 sr-policy;
    }
}

SRv6 with Multiple Address Families

neighbor 2001:db8::1 {
    router-id 10.0.0.1;
    local-address 2001:db8::2;
    local-as 65001;
    peer-as 65002;

    family {
        ipv4 unicast;
        ipv6 unicast;
        ipv6 sr-policy;
    }
}

MUP-Enabled Configuration

neighbor 2001:db8:5g::1 {
    router-id 10.0.0.1;
    local-address 2001:db8:5g::2;
    local-as 65001;
    peer-as 65001;  # iBGP for 5G network

    family {
        ipv6 sr-policy;
    }

    # Enable extended community support for MUP
    capability {
        extended-community;
    }
}

API Integration

Announcing SRv6 Routes (Text API)

# Announce SRv6 route with segment list
echo "announce route 2001:db8:1::/64 next-hop 2001:db8::1 \
  attribute [ 0x28 0x0c 0x00 0x00 0x00 0x01 \
    0x20 0x01 0x0d 0xb8 0x00 0x01 0x00 0x00 \
    0x20 0x01 0x0d 0xb8 0x00 0x02 0x00 0x00 ]"

Announcing SRv6 Routes (JSON API)

{
  "exabgp": "4.0",
  "time": 1699564800,
  "neighbor": {
    "address": {
      "local": "2001:db8::2",
      "peer": "2001:db8::1"
    },
    "asn": {
      "local": 65001,
      "peer": 65002
    },
    "message": {
      "update": {
        "announce": {
          "ipv6 sr-policy": {
            "2001:db8::1": [
              {
                "nlri": "2001:db8:1::/64",
                "segment-list": [
                  "2001:db8:100::1",
                  "2001:db8:200::1",
                  "2001:db8:300::1"
                ]
              }
            ]
          }
        }
      }
    }
  }
}

Python Example: SRv6 Route Injection

#!/usr/bin/env python3
import sys
import json

def announce_srv6_route(prefix, next_hop, segment_list):
    """Announce SRv6 route with segment list"""
    announcement = {
        "exabgp": "4.0",
        "time": 1699564800,
        "neighbor": {
            "message": {
                "update": {
                    "announce": {
                        "ipv6 sr-policy": {
                            next_hop: [{
                                "nlri": prefix,
                                "segment-list": segment_list
                            }]
                        }
                    }
                }
            }
        }
    }

    print(json.dumps(announcement), flush=True)

# Example: Announce route with SRv6 segment list
announce_srv6_route(
    prefix="2001:db8:1::/64",
    next_hop="2001:db8::1",
    segment_list=[
        "2001:db8:100::1",  # Segment 1
        "2001:db8:200::1",  # Segment 2
        "2001:db8:300::1"   # Segment 3
    ]
)

# Keep process running
while True:
    line = sys.stdin.readline().strip()
    if not line:
        break

MUP Route Example

#!/usr/bin/env python3
import sys

def announce_mup_route(mobile_prefix, upf_sid):
    """Announce MUP route for mobile user plane"""
    # Text API format for MUP
    announcement = f"announce route {mobile_prefix} " \
                   f"next-hop {upf_sid} " \
                   f"attribute [ 0x28 ... ]"  # MUP-specific attributes

    print(announcement, flush=True)

# Example: Announce mobile session route
announce_mup_route(
    mobile_prefix="10.1.1.0/24",  # Mobile subscriber prefix
    upf_sid="2001:db8:5g:upf1::"  # UPF SID
)

while True:
    line = sys.stdin.readline().strip()
    if not line:
        break

Examples

Example 1: Basic SRv6 Traffic Engineering

Steer traffic through specific network path using SRv6:

Configuration (/etc/exabgp/srv6-basic.conf):

process announce-routes {
    run python3 /etc/exabgp/srv6-announce.py;
    encoder json;
}

neighbor 2001:db8::1 {
    router-id 10.0.0.1;
    local-address 2001:db8::2;
    local-as 65001;
    peer-as 65002;

    family {
        ipv6 sr-policy;
    }

    api {
        processes [ announce-routes ];
    }
}

API Program (/etc/exabgp/srv6-announce.py):

#!/usr/bin/env python3
import sys
import time

# Announce route with SRv6 path
print('announce route 2001:db8:1::/64 next-hop 2001:db8::1 '
      'attribute [ 0x28 0x0c 0x00 0x00 0x00 0x01 '
      '0x20 0x01 0x0d 0xb8 0x01 0x00 0x00 0x00 '
      '0x20 0x01 0x0d 0xb8 0x02 0x00 0x00 0x00 ]', flush=True)

# Keep running
while True:
    time.sleep(60)

Example 2: 5G MUP Integration

Integrate ExaBGP with 5G User Plane Function:

Configuration (/etc/exabgp/mup-5g.conf):

process mup-controller {
    run python3 /etc/exabgp/mup-controller.py;
    encoder json;
}

neighbor 2001:db8:5g::1 {
    router-id 10.0.0.1;
    local-address 2001:db8:5g::2;
    local-as 65001;
    peer-as 65001;

    family {
        ipv6 sr-policy;
    }

    capability {
        extended-community;
    }

    api {
        processes [ mup-controller ];
    }
}

API Program (/etc/exabgp/mup-controller.py):

#!/usr/bin/env python3
import sys
import json

def announce_mobile_session(subscriber_ip, upf_sid):
    """Announce mobile user session to network"""
    announcement = f"announce route {subscriber_ip}/32 " \
                   f"next-hop {upf_sid}"
    print(announcement, flush=True)

def handle_session_setup(ue_ip):
    """Handle new mobile session setup"""
    # Select UPF based on location/load
    upf_sid = "2001:db8:5g:upf1::"
    announce_mobile_session(ue_ip, upf_sid)

# Example: Setup sessions
handle_session_setup("10.1.1.100")
handle_session_setup("10.1.1.101")

# Monitor for session changes
while True:
    line = sys.stdin.readline().strip()
    if not line:
        break

    # Parse JSON updates from ExaBGP
    try:
        data = json.loads(line)
        # Handle session mobility, updates, etc.
    except:
        pass

Example 3: Network Slicing with SRv6

Implement network slicing for different traffic types:

#!/usr/bin/env python3
import sys

# Define SRv6 paths for different slices
SLICES = {
    'eMBB': {  # Enhanced Mobile Broadband
        'sid_list': ['2001:db8:100::1', '2001:db8:200::1'],
        'qos': 'high-bandwidth'
    },
    'URLLC': {  # Ultra-Reliable Low-Latency
        'sid_list': ['2001:db8:150::1'],  # Direct path
        'qos': 'low-latency'
    },
    'mMTC': {  # Massive Machine-Type Communications
        'sid_list': ['2001:db8:100::1', '2001:db8:300::1'],
        'qos': 'iot'
    }
}

def announce_slice_route(prefix, slice_type):
    """Announce route with slice-specific SRv6 path"""
    slice_config = SLICES.get(slice_type)
    if not slice_config:
        return

    sid_list = slice_config['sid_list']
    next_hop = sid_list[0]

    print(f"announce route {prefix} next-hop {next_hop}", flush=True)

# Setup slices
announce_slice_route("2001:db8:embb::/48", "eMBB")
announce_slice_route("2001:db8:urllc::/48", "URLLC")
announce_slice_route("2001:db8:iot::/48", "mMTC")

while True:
    line = sys.stdin.readline().strip()
    if not line:
        break

Troubleshooting

Common Issues

1. SRv6 Capability Not Negotiated

Problem: BGP session established but SRv6 routes not exchanged

Solution:

# Check BGP capabilities
exabgp-cli show neighbor summary

# Verify family configuration
grep "sr-policy" /etc/exabgp/*.conf

# Check peer supports SRv6
tcpdump -i eth0 -vv tcp port 179

2. Invalid Segment List

Problem: SRv6 routes rejected by peer

Debugging:

# Enable debug logging
env exabgp.log.level=DEBUG exabgp /etc/exabgp/srv6.conf

# Check for malformed SID encoding
# SIDs must be valid IPv6 addresses

Solution:

  • Ensure all SIDs are valid IPv6 addresses
  • Check SID format matches peer expectations
  • Verify segment list order (must be traversable)

3. MUP Routes Not Working

Problem: Mobile user plane traffic not routed correctly

Debugging:

# Check if extended communities are enabled
grep "extended-community" /etc/exabgp/*.conf

# Verify MUP-specific attributes
exabgp-cli show neighbor received-routes

Solution:

  • Enable extended community capability
  • Verify UPF SIDs are reachable
  • Check GTP tunnel endpoints

Debug Commands

# Show SRv6 routes received from peer
exabgp-cli show neighbor 2001:db8::1 received-routes

# Show SRv6 routes announced to peer
exabgp-cli show neighbor 2001:db8::1 advertised-routes

# Debug mode for SRv6 processing
env exabgp.log.level=DEBUG \
    exabgp.log.routes=true \
    exabgp /etc/exabgp/srv6.conf

Validation

Verify SRv6/MUP deployment:

# On ExaBGP host - check BGP session
exabgp-cli show neighbor summary

# On router - check SRv6 routes received
# Cisco IOS-XR
show bgp ipv6 sr-policy

# Nokia SR OS
show router bgp routes sr-policy

# Juniper
show route protocol bgp table inet6.3

See Also

Address Families

Use Cases

Configuration

API

Reference

Home

Getting Started

Configuration

API

Address Families

Features

Use Cases

Tools

Operations

Reference

Integration

Migration

Community

External

Clone this wiki locally