| Internet-Draft | SRv6 SFC Deployment | November 2026 |
| Ye & Lin | Expires 19 May 2027 | [Page] |
This document outlines the critical factors for deploying Service Function Chaining (SFC) using Segment Routing over IPv6 (SRv6). It addresses deployment architectures, including both SRv6-aware and SRv6-unaware scenarios, and details the end-to-end provisioning lifecycle. Furthermore, it proposes reliability mechanisms and provides strategic recommendations for network operators transitioning from legacy NSH-based SFC to a modern, scalable SRv6 framework.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Service Function Chaining (SFC) [RFC7665] is a network architecture that orchestrates traffic through a sequence of service functions—such as firewalls, load balancers, and deep packet inspection (DPI)—to form a logical processing chain. While traditional networks rely on scattered physical or virtual appliances, SFC leverages standardized mechanisms to dynamically steer traffic, significantly enhancing network flexibility and automation.¶
Historically, the Network Service Header (NSH) defined in [RFC8300] has been the primary encapsulation protocol for SFC. However, widespread adoption of NSH faces three significant challenges:¶
Compatibility: Mainstream hardware switches and operating systems often lack native support for NSH, making deployment more demanding in existing networks.¶
Scalability: Per-flow state must be maintained on every Service Function Forwarder (SFF) and Service Function (SF) along the Service Function Path (SFP), creating a management bottleneck as the network scales.¶
Fragmentation: NSH often relies on overlay tunneling (e.g., VXLAN/GRE). This additional layer complicates the integration between the Overlay and Underlay networks.¶
Segment Routing over IPv6 (SRv6) [RFC8986] offers a robust alternative for SFC. By leveraging IPv6 extension headers, SRv6 enables source-based routing where the path is encoded directly into the packet. This eliminates the need for complex state maintenance on intermediate nodes and provides end-to-end programmability.¶
This document focuses on the practical deployment of SRv6 SFC, moving beyond theoretical definitions to provide a comprehensive guide covering architectural choices, operational workflow, reliability, and best practices. It offers recommendations on how to deploy in environments with native SRv6 support versus those requiring legacy compatibility, presents a step-by-step lifecycle from business request to service decommissioning, describes mechanisms to ensure high availability during failures, and provides strategic recommendations for network planners and operators.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
SF (Service Function): A network function that performs specific operations on traffic (e.g., firewall, NAT).¶
SFC (Service Function Chaining): The process of steering traffic through an ordered sequence of service functions.¶
SFC Proxy: A functional entity that translates between SRv6 and non-SRv6 protocols (e.g., stripping NSH or raw IP) to enable legacy SFs to participate in an SRv6 chain.¶
SRv6 (Segment Routing over IPv6): A source-routing technology that uses IPv6 extension headers to encode paths.¶
SFF (Service Function Forwarder): The node responsible for steering traffic to the appropriate SF and maintaining the chain logic.¶
SID (Segment Identifier): An IPv6 address used in SRv6 to identify a specific segment or instruction.¶
SRH (Segment Routing Header): The IPv6 extension header carrying the segment list.¶
SRv6-Aware SF: An SF capable of natively processing SRv6 packets (parsing SRH).¶
SRv6-Unaware SF: An SF that cannot process SRv6 packets and requires a proxy or decapsulation.¶
This section provides guidance on selecting between the SRv6-aware and SRv6-unaware SFC architectures, based on an assessment of their characteristics, advantages, and applicability, and further identifies the deployment considerations associated with each model.¶
Both architectures are built on the following core components:¶
Classifier: The entry point of the SFC that identifies and classifies traffic flows based on policies (e.g., 5-tuple) and inserts the initial SRH with the ordered SID list.¶
SFF: The core forwarding element that forwards received SRv6 packets to the next hop based on the active SID, and handles the returned traffic from the SF.¶
SF: The actual application node (e.g., Firewall) that executes the business logic.¶
SFC Proxy (required only in Unaware Mode): It maintains a mapping table between SRH context and the virtual interface to the SF, strips the SRH before forwarding the payload to the SF, and re-encapsulates the returned packet with the correct SRH to continue the chain.¶
In SRv6-aware model, all Service Functions in the chain natively support SRv6. Accordingly, no SFC Proxy is needed, and SRv6 packets are forwarded directly between SFFs and SFs.¶
Characteristics: In SRv6-aware SFC, no SFC Proxy is required. The SFF forwards SRv6 packets directly to the SF. The SF parses the SRH, executes its service logic, updates the SRH (if necessary), and forwards it back to the SFF or to the next hop.¶
Advantages: SRv6-aware SFC provides the lowest latency, the simplest control plane, and the highest efficiency.¶
Applicability: SRv6-aware SFC is suited to new deployments, or to networks in which all SFs have been upgraded to support SRv6.¶
In the SRv6-unaware model, some SFs in the network do not support SRv6. An SFC Proxy is therefore deployed in front of each SRv6-unaware SF to bridge SRv6 and the SF's native packet format. The SRv6 proxy caches the mapping relationship between the SRH and the virtual interface to the SF, which is used to recover SRv6 packets based on the virtual interface when packets return from the SF. SRv6-unaware SFC is designed for networks containing legacy SFs that do not support SRv6.¶
Characteristics: An SFC Proxy is deployed immediately adjacent to the SRv6-Unaware SF. The Proxy acts as a translator, converting SRv6 packets to a format the SF can understand (e.g., raw IPv4/IPv6 or NSH) and converting returned packets back.¶
Advantages: SRv6-unaware SFC enables the integration of legacy infrastructure without immediate hardware replacement.¶
Applicability: SRv6-unaware SFC is suited to incremental upgrades in which replacing all SFs is not feasible.¶
SRv6 unaware
+-------+
| SF 1 |
| |
+---+---+
|
| SRv6 aware
+---+---+ +-------+
| SFC | | SF 2 |
| Proxy | | |
+---+---+ +---+---+
| |
| |
+--------+ +---+---+ +---+---+
Source ---+ Classi +---+ SFF 1 +----+ SFF 2 +---- Destination
| fier | | | | |
+--------+ +-------+ +-------+
A proxy may be co-located with the SF or SFF, or deployed on another compute node or device. Several proxy behaviors are defined in [I-D.draft-ietf-spring-srv6-service-programming-00], and the choice among them is driven by the SF’s capabilities and the constraints each behavior imposes.¶
Static SR Proxy SFC The static proxy removes the SR information before forwarding traffic to the SF, and re-attaches cached SR information to returned traffic based on the receiving interface.The cached SR information is manually configured and bound to a single SID list.¶
This behavior is suitable for small, stable SFC with infrequent policy changes, because each static proxy segment is bound to one SID list and each receiving interface to one proxy segment.¶
Dynamic SR Proxy SFC The dynamic proxy has the ability to learn the SRv6 information from incoming traffic and caches it locally, removing the need for manual CACHE configuration. The cache entry is mapped to the receiving interface (IFACE-IN), so each interface effectively serves one SR service policy; sharing an interface across multiple policies requires careful planning.¶
This behavior is suitable SFCs whose path change frequently.¶
Masquerading SR Proxy SFC: The masquerading proxy forwards the SRv6 packet to the SF without stripping the SRH, but instead sets the destination address to the final SID in the SRH. The SF is expected to process IPv6 packets but not inspect the SRH.¶
This behavior suits services that only inspect, drop, or perform limited modifications, such as IDS, DPI, and non-NAT firewalls. Services that terminate transport connections or generate new packets require the Caching flavor, and NAT services require the Destination NAT flavor. A masquerading proxy segment must not be the last segment in an SR service policy, since replacing the destination would serve no purpose when no further SID remains. Beyond this placement constraint, a masquerading segment can be reused across multiple SRv6 policies, and one interfaces can be bound to multiple masquerading proxy segments.¶
Deploying SRv6 SFC follows a structured lifecycle comprising six key stages:¶
1.Service Request¶
Purpose: Translate a business requirement into a defined SFC and its associated Service Level Agreements (SLAs).¶
The process begins with a business requirement. Stakeholders define the desired SFC (e.g., "All Web traffic must traverse Firewall -> WAF -> Load Balancer") and specify SLAs for latency, bandwidth, and availability.¶
2.Node Deployment¶
Purpose: Deploy or activate the required network elements and establish underlay connectivity before SFC logic is applied.¶
Physical or virtual network elements (Classifiers, SFFs, SFs, and Proxies) are deployed or activated. The underlay network is configured (IPv6 addressing, IGP/BGP routing) to ensure basic connectivity between all nodes.¶
3.SID Allocation¶
Purpose: Assign SIDs to each SF and Proxy, and generate the segment list that defines the traversal order.¶
One or more SIDs are allocated to each SF and Proxy, and the SIDs assigned to one node must not duplicate those assigned to any others. Allocation may be:¶
Static Allocation: SIDs are manually configured for stable, small-scale chains.¶
Dynamic Allocation: A controller assigns SIDs on demand based on real-time resource availability.¶
A complete segment List is then generated, defining the exact traversal order of the SFC.¶
4.Configuration Delivery¶
Purpose: Push configuration to the data plane and verify that the policies, segment lists or rules, where present on each node, are consistent with the intended service requirement.¶
The control plane (SDN Controller or Orchestrator) pushes the configuration to the data plane:¶
The Classifier receives the policy and the initial Segment List.¶
SFFs receive instructions on how to forward traffic to specific SIDs and handle return traffic.¶
Proxies, if applicable, are configured with the mapping rules between SIDs and local interfaces.¶
After the configuration is delivered, verification confirms that all nodes have consistent views of the chain.¶
5.Network Monitoring¶
Purpose: Continuously verify SFC health and SLA compliance once the SFC is active.¶
Continuous monitoring covers:¶
Connectivity: The link between SFF and SF/Proxy is monitored through mechanisms such as Bidirectional Forwarding Detection (BFD).¶
Performance: Metrics such as latency, jitter, and packet loss are tracked to ensure SLA compliance.¶
State Validation: The system verifies that packets are traversing the SFC in the correct order.¶
6.Service Modification and Teardown¶
Purpose: Adjust the SFC as business requirements evolve and release resources when a service is retired.¶
Modification: Adding new SFs, changing the order, or updating policies triggers a recalculation of the Segment List and a configuration update.¶
Teardown: When a service is retired, resources (SIDs, mappings) are released, and configurations are removed to prevent residual state.¶
During deployment, support for multi-tenancy must be considered.¶
One approach is for the Service Function (SF) to assign different SRv6 SIDs for each tenant, with the Classifier encapsulating distinct SRv6 SID sequences per tenant. This method allows the SF to identify the tenant based on the SRv6 SID, offering simple implementation. However, its drawback is that assigning individual SRv6 SIDs for each tenant consumes significant SID resources, which must be evaluated against the number of tenants.¶
An alternative approach is to carry tenant information within the service packet itself. This avoids the need to allocate separate SRv6 SIDs per tenant but results in a more complex system implementation.¶
For instance, as in shown in Figure 3, the traffic of tenant A enters vFW through a 3-layer sub-interface with VLAN ‘a’, while tenant B’ s traffic enters through that of VLAN ’b’. With the existence of VLANs and VPN instances, vFW would be able to figure out tenants and select their exclusive vsys instances to supply service. For example, the traffic of tenant A with destined for address X would be dropped by vsys1 instance on vFW, while tenant B’s traffic with destination address Y will be dropped by vsys2 instance.¶
+------+
|vsys1 |vFW
-+vsys2 |
/ |... |
/ +------+
/
/ +------+
/ |vsys1 |vIPS
+--+ +----+ |vsys2 |
|GW+---+TOR1+------|... |
+--+ +----+ | |
\ +------+
\
\
\ +------+
\ |vsys1 |vAV
-+vsys2 |
|... |
| |
+------+
[I-D.draft-lin-spring-srv6-aware-context-indicator-08] describes how to use SRv6 SIDs as context indicator for SR-aware services.¶
This section discusses the the reliability and fault detection mechanisms for SRv6 SFC deployment, along with the considerations for selection.¶
In SRv6 SFC deployment, service continuity can be affected by three types of failure: an SFF failure, an SF failure, and links failure between the SFF and the SF. Any of these failures can cause packets to be dropped if no protection is deployed, since the packets can no longer be forwarded along the intended logical order or processed by the intended SF.¶
To enhance the reliability of the SRv6 SFC, protection mechanisms can be deployed, individually or in combination:¶
SF redundancy at a single SFF: A primary SF and a backup SF, or a cluster of SFs, are deployed for the same service and connected to the same SFF. When the primary SF becomes unreachable, traffic is switched to the backup SF; when an SF in the cluster becomes unreachable, traffic is switched to another SF in the cluster. This mode protects against SF failure and SFF-SF link failure, and preserves the SF capability for the service through the backup or another SF in the cluster.¶
SFF redundancy: The SF is dual-homed to a primary SFF and a backup SFF. When the primary SFF fails, or when it detects that the SF or proxy is unreachable, traffic is switched to the backup SFF. The number of backup SFFs may be increased according to service importance and cost considerations. This mode protects against SFF failure and SFF-SF link failure.¶
SF redundancy across SFFs: A primary SF and a backup SF are connected to a primary SFF and a backup SFF, respectively. When the primary SFF fails, or when it detects that the SF or proxy is unreachable (including SF or proxy failure and SFF-SF link failure), traffic is switched to the backup SFF and forwarded to the backup SF. This mode protects against SFF failure, SF failure and SFF-SF link failure.¶
SFF bypass: When the SFF detects all SFs providing the same service are down or unreachable, traffic bypasses the failed service node and is forwarded to the downstream node in the chain. This mode preserve connectivity for the remaining services, but the processing of the skipped SF is lost, which may be unacceptable for security-critical SFC. This mode is, strictly, not a redundancy mechanism.¶
Hybrid protection: When multiple modes are deployed, SF redundancy at a single SFF is attempted first, followed by SFF redundancy and then SF redundancy across SFFs, bypass is used only if all these redundancy mechanisms fail. This provides both multiple SF-level redundancy and a last-resort path, at the cost of more complex configuration and state maintenance.¶
The table Table 1 summarizes the characteristics of these mechanisms and the failures they can handle.¶
| Protection Mode | SFF Failure | SF Failure | SFF-SF Link Failure | Deployment Characteristics |
|---|---|---|---|---|
| SF redundancy at a single SFF | × | √ | √ | primary&backup SF or SF cluster connected to same SFF |
| SFS redundancy | √ | √ | × | one SF dual-homed to primary&backup SFF |
| SF redundancy across SFFs | √ | √ | √ | primary&backup SF connected to primary&backup SFF, respectively |
| SFF Bypass |
/ Only ensuring remaining services can still be completed when the current SF fails |
No backup SF or SFF required | ||
| Hybrid Protection | Depending on the combination | Depending on the combination | ||
Fast fault detection determines how quickly protection mechanisms can be triggered when an SF becomes unreachable. It is therefore required between the SFF and the SF, or between the SFF and the SFC Proxy, so that dual-homing or bypass protection can be activated promptly.¶
BFD is a typical choice for this purpose. The selection of the detection method should consider the required fault response time and the deployment cost.¶
Based on the architectural and lifecycle analysis above, the following recommendations are provided for SRv6 SFC deployment:¶
1.Prioritize stateless architectures for greenfield deployments.¶
For greenfield deployments, adopt Stateless SRv6 SFC exclusively. Avoiding NSH and stateful proxies reduces complexity and maximizes performance.¶
2.Use proxies strategically for brownfield upgrades.¶
For brownfield upgrades, deploy SFC Proxies to integrate legacy SFs. This enables a phased migration in which SFs can be upgraded to SRv6-aware over time without disrupting existing services.¶
3.Plan resources for multi-tenant deployments.¶
When supporting multiple tenants, evaluate the trade-off between SID consumption and implementation complexity:¶
For small-scale multi-tenancy, assigning an unique SID per tenant is straightforward.¶
For large-scale environments, consider embedding tenant identifiers within the packet payload to conserve the SID space, accepting the increased software complexity.¶
4.Apply tiered high availability.¶
Not all services require the same level of redundancy. Protection should be selected according to service importance:¶
For critical services, redundancy MUST be implemented to avoid service interruption and achieve zero downtime. At a minimum, one protection mechanism must be selected; where conditions permit, hybrid protection SHOULD be implemented to handle SF failure, SFF failure and SFF-SF link failure, with bypass protection as a last resort.¶
For standard services, where temporary loss of specific services or performance degradation, bypass protection MAY be used to ensure the remaining services could be performed when a SF node fails.¶
5.Automate the deployment lifecycle.¶
Manual configuration of SRv6 SFC is error-prone and unscalable. Operators MUST implement SDN controllers or orchestration platforms to automate the lifecycle stages from SID allocation to configuration delivery.¶
6.Protect SRH integrity.¶
SRH headers should be protected against tampering and validation mechanisms should be implemented to prevent unauthorized modification of the segment list, which could redirect traffic to malicious nodes.¶
This document has no IANA actions.¶