advanced/p4-upf.rst - sdfabric-docs - Gitiles

 .. SPDX-FileCopyrightText: 2021 Open Networking Foundation <info@opennetworking.org>
 .. SPDX-License-Identifier: Apache-2.0

 .. _p4_upf:

 P4-based User Plane Function (P4-UPF)
 =====================================

 Overview
 --------

 SD-Fabric supports running a 4G/5G mobile core User Plane Function (UPF) as part
 of the switches packet processing pipeline. Like the rest of the pipeline, this
 is realized using P4 and for this reason we call this P4-UPF.

 P4-UPF is integrated with the ONF's SD-Core project. By default, SD-Core ships
 with BESS-UPF, a containerized UPF implementation, based on the Berkeley
 Software Switch (BESS).

 SD-Fabric can be used with BESS-UPF or any other UPF implementation that runs on
 servers. In this case, the fabric switches can provide routing of GTP-U packets
 to and from radio base station and servers. When P4-UPF is enabled, the same
 fabric switches perform GTP-U tunnel termination.

 .. image:: ../images/bess-p4-upf.png
     :width: 700px

 **Supported Features**

 SD-Fabric's P4-UPF implements a core set of features capable of supporting
 requirements for a broad range of enterprise use cases:

 * GTP-U tunnel encap/decap: including support for 5G extensions such as PDU
   Session Container carrying QoS Flow Information.
 * Accounting: we use switch counters to collect per-flow stats and support usage
   reporting and volume-based triggers.
 * Downlink buffering: when a user device radio goes idle (power-save mode) or
   during a handover, switches are updated to forward all downlink traffic for
   the specific device (UE) to DBUF, a K8s-managed buffering service running on
   servers. Then, when the device radio becomes ready to receive traffic,
   packets are drained from the software buffers back to the switch to be
   delivered to base stations.
 * QoS: support for enforcement of maximum bitrate (MBR), minimum guaranteed
   bitrate (GBR, via admission control), and prioritization using switch
   queues and scheduling policy.
 * Slicing: multiple logical UPFs can be instantiated on the same switch, each
   one with its own QoS model and isolation guarantees enforced at the hardware
   level using separate queues.

 **Distributed UPF**

 .. image:: ../images/upf-distributed.png
     :width: 700px

 In SD-Fabric we support different topologies to meet the requirements of
 different deployment sizes: from a single rack with just one leaf
 switch, or a paired-leaves for redundancy, to N x M leaf-spine fabric for multi-rack
 deployments. For this reason, P4-UPF is realized with a "distributed" data plane
 implementation where all leaf switches are programmed with the same UPF
 rules, such that any leaf can terminate any GTP-U tunnel. This provides several
 benefits:

 * Simplified deployment: base stations can be connected via any leaf switch.
 * Minimum latency: the UPF function is applied as soon as packets enter the
   fabric, without going through additional devices before reaching their final
   destination.
 * Fast failover: when using paired-leaves, if one switch fails, the other can
   immediately take over as it is already programmed with the same UPF state.
 * Fabric-wide slicing & QoS guarantees: packets are classified as soon as they
   hit the first leaf. We then use a custom DSCP-based marking to enforce the
   same QoS rules on all hops. In case of congestion, flows deemed high priority
   are treated as such by all switches.

 **Control Architecture and Integration with SD-Core**

 SD-Fabric's P4-UPF is integrated with the ONF SD-Core project to provide a
 high-performance 3GPP-compliant mobile core solution.

 The integration with SD-Core is achieved via an ONOS application called UP4,
 which is in charge of populating the UPF tables of the switch pipeline.

 .. image:: ../images/up4-arch.png
     :width: 600px

 The interface between the mobile core control plane and the UPF is defined by
 the 3GPP standard Packet Forwarding Control Protocol (PFCP). This is a complex
 protocol that can be difficult to understand, even though at its essence the
 rules that it installs are simple match-action rules. The implementation of such
 protocol, such as message parsing, state machines, and other bookkeeping can be
 common to many different UPF realizations. For this reason, SD-Fabric relies on
 an implementation of the PFCP protocol realized as an external microservice
 named “PFCP Agent”, which is provided by the SD-Core project.

 The UP4 App abstracts the whole fabric as one virtual big switch with UPF
 capabilities, we call this the One-Big-UPF abstraction. Such abstraction allows
 the upper layers to be independent of the underlying physical topology.
 Communication between the PFCP Agent and the UP4 App is done via P4Runtime. This
 is the same API that ONOS uses to communicate with the actual switches. However,
 in the former case, it is used between two control planes, the mobile core, and
 the SDN controller. By doing this, the deployment can be scaled up and down,
 adding or removing racks and switches, without changing the mobile core control
 plane, which instead is provided with the illusion of controlling just one
 switch.

 The One-Big-UPF abstraction abstraction is realized with a ``virtual-upf.p4``
 program that formalizes the forwarding model described by PFCP as a series of
 match-action tables. This program doesn't run on switches, but it's used as the
 schema to define the content of the P4Runtime messages between PFCP Agent and
 the UP4 App. On switches, we use a different program, fabric.p4, which
 implements tables similar to the virtual UPF but optimized to satisfy the
 resource constraints of Tofino, as well as tables for basic bridging, IP
 routing, ECMP, and more. The UP4 App implements a P4Runtime server, like if it
 were a switch, but instead it internally takes care of translating P4Runtime
 rules from ``virtual-upf.p4`` to rules for the multiple physical switches running
 fabric.p4, based on an up-to-date global view of the topology.

 Downlink Buffering (DBUF)
 -------------------------

 A UPF is required to buffer packets when UEs are in idle-mode or during
 handovers, this is usually called *downlink buffering*, as it applies only to
 the downlink direction of traffic. Most switches provide buffering capabilities
 to handle congestion, they cannot hold packets indefinitely. For this reason, we
 provide DBUF, a microservice
 responsible for providing the downlink buffering capabilities to P4-UPF.

 .. image:: ../images/dbuf.png
     :width: 400px

 When a UE goes idle and turns off its radio, or during handovers, the mobile
 core control plane uses PFCP to update the Forwarding Action Rules (FARs) for
 that UE to enter buffering* mode. When this happens, UP4 updates the switch rules to
 steer packets to DBUF using GTP-U tunnels.

 UP4 uses gRPC to communicate with DBUF. DBUF notifies UP4 about buffering
 events, which are relayed to the mobile core control plane as Downlink Data
 Notifications (DDN). When a UE becomes available again, UP4 triggers a buffer
 drain on DBUF and updates the switch rules to start sending traffic to the UE again.

 Deploying DBUF is optional (can be enabled in the SD-Fabric Helm Chart).
 DBUF feature requires SR-IOV and DHCP support on NICs and Kubernetes CNIs.

 ONOS Configuration
 ------------------

 The UPF configuration is split in two configurations, that can be provided
 independently to ONOS. Th first is used to configure the UP4 ONOS application
 and defines UPF-related information such as S1U Address, network devices
 implementing UPF etc. The second one, instead, is used to configure parameters
 related to the DBUF functionality.

 Here's a list of fields that you can configure via the UPF Network Configuration
 for UP4:

 * ``devices``: A list of devices IDs that implements the UPF data plane. This
   list must include all the leaf switches in the topology. The UPF state is
   replicated on all devices specified in this configuration field. The devices
   specified in this list must use a P4 pipeline implementing the UPF
   functionality. **Required**

 * ``s1uAddr``: **Deprecated**. Use ``n3Addr`` instead.

 * ``n3Addr``: The IP address of the N3 interface (equivalent to S1-U for 4G).
   It can be an arbitrary IP address. **Optional**
   (PFCP agent can insert interface table entry if not supplied)

 * ``uePools``: A list of subnets that are in use by the UEs. **Optional**
   (PFCP agent can insert interface table entry if not supplied)

 * ``sliceId``: Network slice ID used by mobile traffic. **Optional**
   Required only when either ``n3Addr`` or ``uePools`` is specified.

 * ``dbufDrainAddr``: The IP address of the UPF data plane interface that the
   DBUF service will drain packets towards. **Optional**

 * ``pscEncapEnabled``: Set whether the UPF should use GTP-U extension PDU
   Session Container when doing encapsulation of downlink packets. **Optional**
   (Should set to true for 5G)

 * ``defaultQfi``: The default QoS Flow Identifier to use when the PDU Session
   Container encapsulation is enabled. **Optional**

 Here is an example of netcfg JSON for UP4:

 .. code-block:: json

     {
         "apps": {
             "org.omecproject.up4": {
                 "up4": {
                   "devices": [
                     "device:leaf1",
                     "device:leaf2"
                   ],
                   "n3Addr": "10.32.11.126",
                   "uePools": [
                     "10.240.0.0/16"
                   ],
                   "sliceId": 0
                   "dbufDrainAddr": "10.32.11.126",
                   "pscEncapEnabled": false,
                   "defaultQfi": 0
                 }
             }
         }
     }

 The DBUF configuration block is all **Optional**, we can use UP4 without the
 downlink buffering functionality. Here's a list of fields that you can
 configure:

 * ``serviceAddr``: The address of the DBUF service management interface in the
   form IP:port. This address is used to communicate with the DBUF service via
   gRPC (for example, to trigger the drain operation, or receive notification for
   buffered packets).

 * ``dataplaneAddr``: The address of the DBUF service data plane interface in the
   form IP:port. Packets sent to this address by the UPF switches will be
   buffered by DBUF. The IP address must be a routable fabric address.

 Here is an example of netcfg for DBUF:

 .. code-block:: json

     {
         "apps": {
             "org.omecproject.up4": {
                 "dbuf": {
                     "serviceAddr": "10.76.28.72:10000",
                     "dataplaneAddr": "10.32.11.3:2152"
                 }
           }
         }
     }

 .. note::
     When deploying DBUF using the SD-Fabric Helm Chart you do **NOT** need to
     provide the ``"dbuf"`` part of the UP4 config. That will be pushed
     automatically by the DBUF Kubernetes pod.

 PFCP Agent Configuration
 ------------------------

 PFCP Agent can be deployed as part of the SD-Fabric Helm Chart.

 See the `SD-Fabric Helm Chart README <https://gerrit.opencord.org/plugins/gitiles/sdfabric-helm-charts/+/HEAD/sdfabric/README.md>`_ for more information on the configuration
 parameters used in SD-Fabric.
 See the `PFCP agent configuration guide <https://github.com/omec-project/upf/blob/master/docs/configuration_guide.md>` for other parameters provided by PFCP agent.
 Once deployed, use ``kubectl get services -n sdfabric`` to find out
 the exact UDP endpoint used to listen for PFCP connection requests.

 UP4 Troubleshooting
 -------------------

 See :ref:`troubleshooting_guide`.
	.. SPDX-FileCopyrightText: 2021 Open Networking Foundation <info@opennetworking.org>
	.. SPDX-License-Identifier: Apache-2.0

	.. _p4_upf:

	P4-based User Plane Function (P4-UPF)
	=====================================

	Overview
	--------

	SD-Fabric supports running a 4G/5G mobile core User Plane Function (UPF) as part
	of the switches packet processing pipeline. Like the rest of the pipeline, this
	is realized using P4 and for this reason we call this P4-UPF.

	P4-UPF is integrated with the ONF's SD-Core project. By default, SD-Core ships
	with BESS-UPF, a containerized UPF implementation, based on the Berkeley
	Software Switch (BESS).

	SD-Fabric can be used with BESS-UPF or any other UPF implementation that runs on
	servers. In this case, the fabric switches can provide routing of GTP-U packets
	to and from radio base station and servers. When P4-UPF is enabled, the same
	fabric switches perform GTP-U tunnel termination.

	.. image:: ../images/bess-p4-upf.png
	:width: 700px

	Supported Features

	SD-Fabric's P4-UPF implements a core set of features capable of supporting
	requirements for a broad range of enterprise use cases:

	* GTP-U tunnel encap/decap: including support for 5G extensions such as PDU
	Session Container carrying QoS Flow Information.
	* Accounting: we use switch counters to collect per-flow stats and support usage
	reporting and volume-based triggers.
	* Downlink buffering: when a user device radio goes idle (power-save mode) or
	during a handover, switches are updated to forward all downlink traffic for
	the specific device (UE) to DBUF, a K8s-managed buffering service running on
	servers. Then, when the device radio becomes ready to receive traffic,
	packets are drained from the software buffers back to the switch to be
	delivered to base stations.
	* QoS: support for enforcement of maximum bitrate (MBR), minimum guaranteed
	bitrate (GBR, via admission control), and prioritization using switch
	queues and scheduling policy.
	* Slicing: multiple logical UPFs can be instantiated on the same switch, each
	one with its own QoS model and isolation guarantees enforced at the hardware
	level using separate queues.

	Distributed UPF

	.. image:: ../images/upf-distributed.png
	:width: 700px

	In SD-Fabric we support different topologies to meet the requirements of
	different deployment sizes: from a single rack with just one leaf
	switch, or a paired-leaves for redundancy, to N x M leaf-spine fabric for multi-rack
	deployments. For this reason, P4-UPF is realized with a "distributed" data plane
	implementation where all leaf switches are programmed with the same UPF
	rules, such that any leaf can terminate any GTP-U tunnel. This provides several
	benefits:

	* Simplified deployment: base stations can be connected via any leaf switch.
	* Minimum latency: the UPF function is applied as soon as packets enter the
	fabric, without going through additional devices before reaching their final
	destination.
	* Fast failover: when using paired-leaves, if one switch fails, the other can
	immediately take over as it is already programmed with the same UPF state.
	* Fabric-wide slicing & QoS guarantees: packets are classified as soon as they
	hit the first leaf. We then use a custom DSCP-based marking to enforce the
	same QoS rules on all hops. In case of congestion, flows deemed high priority
	are treated as such by all switches.

	Control Architecture and Integration with SD-Core

	SD-Fabric's P4-UPF is integrated with the ONF SD-Core project to provide a
	high-performance 3GPP-compliant mobile core solution.

	The integration with SD-Core is achieved via an ONOS application called UP4,
	which is in charge of populating the UPF tables of the switch pipeline.

	.. image:: ../images/up4-arch.png
	:width: 600px

	The interface between the mobile core control plane and the UPF is defined by
	the 3GPP standard Packet Forwarding Control Protocol (PFCP). This is a complex
	protocol that can be difficult to understand, even though at its essence the
	rules that it installs are simple match-action rules. The implementation of such
	protocol, such as message parsing, state machines, and other bookkeeping can be
	common to many different UPF realizations. For this reason, SD-Fabric relies on
	an implementation of the PFCP protocol realized as an external microservice
	named “PFCP Agent”, which is provided by the SD-Core project.

	The UP4 App abstracts the whole fabric as one virtual big switch with UPF
	capabilities, we call this the One-Big-UPF abstraction. Such abstraction allows
	the upper layers to be independent of the underlying physical topology.
	Communication between the PFCP Agent and the UP4 App is done via P4Runtime. This
	is the same API that ONOS uses to communicate with the actual switches. However,
	in the former case, it is used between two control planes, the mobile core, and
	the SDN controller. By doing this, the deployment can be scaled up and down,
	adding or removing racks and switches, without changing the mobile core control
	plane, which instead is provided with the illusion of controlling just one
	switch.

	The One-Big-UPF abstraction abstraction is realized with a ``virtual-upf.p4``
	program that formalizes the forwarding model described by PFCP as a series of
	match-action tables. This program doesn't run on switches, but it's used as the
	schema to define the content of the P4Runtime messages between PFCP Agent and
	the UP4 App. On switches, we use a different program, fabric.p4, which
	implements tables similar to the virtual UPF but optimized to satisfy the
	resource constraints of Tofino, as well as tables for basic bridging, IP
	routing, ECMP, and more. The UP4 App implements a P4Runtime server, like if it
	were a switch, but instead it internally takes care of translating P4Runtime
	rules from ``virtual-upf.p4`` to rules for the multiple physical switches running
	fabric.p4, based on an up-to-date global view of the topology.

	Downlink Buffering (DBUF)
	-------------------------

	A UPF is required to buffer packets when UEs are in idle-mode or during
	handovers, this is usually called downlink buffering, as it applies only to
	the downlink direction of traffic. Most switches provide buffering capabilities
	to handle congestion, they cannot hold packets indefinitely. For this reason, we
	provide DBUF, a microservice
	responsible for providing the downlink buffering capabilities to P4-UPF.

	.. image:: ../images/dbuf.png
	:width: 400px

	When a UE goes idle and turns off its radio, or during handovers, the mobile
	core control plane uses PFCP to update the Forwarding Action Rules (FARs) for
	that UE to enter buffering* mode. When this happens, UP4 updates the switch rules to
	steer packets to DBUF using GTP-U tunnels.

	UP4 uses gRPC to communicate with DBUF. DBUF notifies UP4 about buffering
	events, which are relayed to the mobile core control plane as Downlink Data
	Notifications (DDN). When a UE becomes available again, UP4 triggers a buffer
	drain on DBUF and updates the switch rules to start sending traffic to the UE again.

	Deploying DBUF is optional (can be enabled in the SD-Fabric Helm Chart).
	DBUF feature requires SR-IOV and DHCP support on NICs and Kubernetes CNIs.

	ONOS Configuration
	------------------

	The UPF configuration is split in two configurations, that can be provided
	independently to ONOS. Th first is used to configure the UP4 ONOS application
	and defines UPF-related information such as S1U Address, network devices
	implementing UPF etc. The second one, instead, is used to configure parameters
	related to the DBUF functionality.

	Here's a list of fields that you can configure via the UPF Network Configuration
	for UP4:

	* ``devices``: A list of devices IDs that implements the UPF data plane. This
	list must include all the leaf switches in the topology. The UPF state is
	replicated on all devices specified in this configuration field. The devices
	specified in this list must use a P4 pipeline implementing the UPF
	functionality. Required

	* ``s1uAddr``: Deprecated. Use ``n3Addr`` instead.

	* ``n3Addr``: The IP address of the N3 interface (equivalent to S1-U for 4G).
	It can be an arbitrary IP address. Optional
	(PFCP agent can insert interface table entry if not supplied)

	* ``uePools``: A list of subnets that are in use by the UEs. Optional
	(PFCP agent can insert interface table entry if not supplied)

	* ``sliceId``: Network slice ID used by mobile traffic. Optional
	Required only when either ``n3Addr`` or ``uePools`` is specified.

	* ``dbufDrainAddr``: The IP address of the UPF data plane interface that the
	DBUF service will drain packets towards. Optional

	* ``pscEncapEnabled``: Set whether the UPF should use GTP-U extension PDU
	Session Container when doing encapsulation of downlink packets. Optional
	(Should set to true for 5G)

	* ``defaultQfi``: The default QoS Flow Identifier to use when the PDU Session
	Container encapsulation is enabled. Optional

	Here is an example of netcfg JSON for UP4:

	.. code-block:: json

	{
	"apps": {
	"org.omecproject.up4": {
	"up4": {
	"devices": [
	"device:leaf1",
	"device:leaf2"
	],
	"n3Addr": "10.32.11.126",
	"uePools": [
	"10.240.0.0/16"
	],
	"sliceId": 0
	"dbufDrainAddr": "10.32.11.126",
	"pscEncapEnabled": false,
	"defaultQfi": 0
	}
	}
	}
	}

	The DBUF configuration block is all Optional, we can use UP4 without the
	downlink buffering functionality. Here's a list of fields that you can
	configure:

	* ``serviceAddr``: The address of the DBUF service management interface in the
	form IP:port. This address is used to communicate with the DBUF service via
	gRPC (for example, to trigger the drain operation, or receive notification for
	buffered packets).

	* ``dataplaneAddr``: The address of the DBUF service data plane interface in the
	form IP:port. Packets sent to this address by the UPF switches will be
	buffered by DBUF. The IP address must be a routable fabric address.

	Here is an example of netcfg for DBUF:

	.. code-block:: json

	{
	"apps": {
	"org.omecproject.up4": {
	"dbuf": {
	"serviceAddr": "10.76.28.72:10000",
	"dataplaneAddr": "10.32.11.3:2152"
	}
	}
	}
	}

	.. note::
	When deploying DBUF using the SD-Fabric Helm Chart you do NOT need to
	provide the ``"dbuf"`` part of the UP4 config. That will be pushed
	automatically by the DBUF Kubernetes pod.

	PFCP Agent Configuration
	------------------------

	PFCP Agent can be deployed as part of the SD-Fabric Helm Chart.

	See the `SD-Fabric Helm Chart README <https://gerrit.opencord.org/plugins/gitiles/sdfabric-helm-charts/+/HEAD/sdfabric/README.md>`_ for more information on the configuration
	parameters used in SD-Fabric.
	See the `PFCP agent configuration guide <https://github.com/omec-project/upf/blob/master/docs/configuration_guide.md>` for other parameters provided by PFCP agent.
	Once deployed, use ``kubectl get services -n sdfabric`` to find out
	the exact UDP endpoint used to listen for PFCP connection requests.

	UP4 Troubleshooting
	-------------------

	See :ref:`troubleshooting_guide`.