RIFT Overview and Set Up
SUMMARY Routing in Fat Tree (RIFT) is a zero OpEx routing protocol that you can use to route packets in variants of CLOS-based and fat tree network topologies. It is a hybrid of both link-state and distance-vector techniques, and provides several benefits for IP fabrics, such as ease of management, and adding resiliency to the network.
Understanding Junos Implementation of Routing in Fat Tree (RIFT) Protocol
- Benefits of RIFT Protocol
- RIFT Protocol Overview
- Impact of Junos Implementation of RIFT Protocol on Network Performance
- Unsupported Features with RIFT Protocol
Benefits of RIFT Protocol
The RIFT protocols is a zero OpEx routing protocol that enables:
Requires almost zero necessary configuration making IP fabrics simpler to manage.
Extensive tracing and logging capabilities allowing scaling advantage for IP fabrics.
Maximum utilization of paths without looping thereby adding resiliency in the IP fabric.
As a hybrid of the distance vector and link state protocols, the RIFT protocol inherits the advantages of both the protocol types, providing additional benefits such as:
Fastest possible convergence.
Auto-detection of topology.
Minimal routes on top-of-rack devices.
High degree of equal-cost multipath (ECMP).
RIFT Protocol Overview
With the increase in deployment of IP forwarding-based data centers in CLOS and fat-tree architectures (also called the spine and leaf model), interior gateway protocols (IGPs) and BGP are currently used to handle the necessary routing decisions. The approach used by these protocols relies on complex and highly expensive operational extensions that fail to meet the requirements of such IP fabrics. This is because the IGP and BGP protocols were originally built for generic and sparse network topologies. Routing in Fat Trees (RIFT) overcomes these issues and meets the needs of evolving IP fabrics.
The RIFT protocol is an open standard protocol. It is a hybrid version of a distance vector protocol that uses diffused computation toward the leafs, and a link state protocol that uses distributed computation and flooding toward the spines. In other words, with the RIFT protocol enabled, devices flood their link-state information in the northern direction, while every switch except the leafs generate a default route (under normal conditions), which is flooded in the southern direction.
The key features of the RIFT protocol:
Automatic construction of fat-tree topologies.
Automatic detection of miscabled links of the IP fabric.
Minimizes the amount of routing state information held at each level of the data center network.
Automatically minimizes the amount of flooding.
Automatic disaggregation of prefixes on link and node failures to prevent black-holing and suboptimal routing.
Allows non-ECMP forwarding.
Automatically rebalances traffic toward the spine based on the available bandwidth.
Synchronizes a limited key-value data-store that can be used after protocol convergence; for example, to bootstrap higher levels of functionality on nodes.
For more details, see Internet draft draft-ietf-rift-rift-09 (expires May 7, 2020) RIFT: Routing in Fat Trees.
Impact of Junos Implementation of RIFT Protocol on Network Performance
The integration of RIFT protocol into Junos OS has some impact on the route load and memory utilization for common datacenter architectures. This is because the RIFT protocol has the capability of consuming all available cores to improve protocol performance.
Dynamic configuration of RIFT is not fully supported. Configuration changes in the Junos OS CLI might restart the RIFT protocol causing the protocol to reconverge with resulting traffic loss.
Unsupported Features with RIFT Protocol
The Junos OS implementation of RIFT complies with the standards described in the RIFT Internet draft at https://datatracker.ietf.org/doc/draft-ietf-rift-rift/, but does not support the following features:
Logical systems
SNMP
In-service software upgrade (ISSU) and nonstop software upgrade
Graceful Routing Engine switchover (GRES)
Telemetry
The Junos OS implementation of RIFT does not implement:
Key-Value store
Horizontal links
Leaf-2-leaf support
Negative disaggregation
Mobility attributes on prefixes
Label binding on interfaces
Enabling the RIFT Protocol
The RIFT software package is a standalone package and the Juniper implementation of the protocol is executed in a modern memory and thread-safe programming language that is designed for optimal utilization of multi-core processor architectures.
The RIFT protocol initializes the associated RIFT processes,
and the zero-touch configuration default values are applied through
the configuration. It also automatically enables RIFT on all Ethernet
interfaces. The system-id
is automatically derived from
the system MAC address, and the level
is automatically
determined through the discovery portion of the protocol operation.
SUMMARY The RIFT protocol requires close to zero necessary
configuration. When you enable the RIFT protocol, it automatically
inherits the required configuration from the junos-rift
package defaults, making IP fabrics simpler to manage.
Before You Begin
You must download and install the RIFT software package on your device before you enable the protocol.
To install the RIFT protocol:
Download the special
junos-rift
package from the software package that is required to be run along with the baseline Junos OS software.Note:The baseline Junos OS software on which the
junos-rift
package is deployed must be 64-bit version only and starting from Junos OS Releases 19.4R1.While installing the
junos-rift
package, the devices must be cabled in a CLOS architecture.Because
junos-rift
is a separate package, it can be licensed separately from the Junos OS baseline package.Licensing of the
junos-rift
package is granted under the End User License Agreement with special emphasis on sections 15, 16 and 17.
From the software package, extract the
junos-rift
package and download it to the/var/tmp
directory on the host device.After you successfully download the software package, run the following command:
user@host> request system software add package-name
For example:
user@host> request system software add /var/tmp/junos-rift.tgz
To enable the RIFT protocol, you must activate the RIFT software
package on your device. You can activate RIFT either using the request rift package activate
command, or manually load and
combine the RIFT configuration from a specified file with the current
configuration in the CLI.
Enabling RIFT Using Activate Command
To activate the RIFT software package using the request rift package activate
command:
junos-rift
package, run the following command:user@host >request rift package activate
The activate command automatically commits the RIFT configuration.
Enabling RIFT Using Load Command
To load the RIFT configuration manually:
After you successfully install the
junos-rift
package, run the following command to load and combine the RIFT configuration from a specified file with the current configuration in the CLI:user@host# load merge /etc/config/junos-rift/package-defaults.conf user@host# load merge /etc/config/junos-rift/platform/platform-defaults.conf
Here, platform is the host device, and can be any one of the following values—mx, qfx, or vmx.
Commit the configuration.
user@host> commit
Enabling RIFT in CLOS-based Topology (ZTP Mode)
For activating the RIFT software package on a CLOS topology,
additional configuration is required. You must identify the nodes
that are the top-of-fabric in the topology, and configure all the
top-of-fabric devices to override the auto
level in the
default configuration.
To activate the RIFT software package in a CLOS-based topology:
Override the auto level in the default configuration, and optionally, specify the levels manually.
[edit protocols rift] user@host# set level top-of-fabric
Commit the additional configuration.
user@host> commit
Traceoptions for RIFT
Although enabling the RIFT protocol automatically inherits the necessary configuration, you can additionally configure minimal tracing as optional configuration.
To configure traceoptions for RIFT:
Specify the traceoptions and proxy-process parameters under the rift statement.
[edit protocols rift] user@host# set traceoptions file size size user@host# set traceoptions file files number user@host# set traceoptions level level user@host# set traceoptions flag flag user@host# set proxy-process traceoptions file size size user@host# set proxy-process traceoptions level level user@host# set proxy-process traceoptions file files number user@host# set proxy-process traceoptions flag flag
For example:
[edit protocols rift] user@host# set traceoptions file size 1000000 user@host# set traceoptions file files 4 user@host# set traceoptions level info user@host# set traceoptions flag node user@host# set proxy-process traceoptions file size 1000000 user@host# set proxy-process traceoptions level info user@host# set proxy-process traceoptions file files 4 user@host# set proxy-process traceoptions flag if-events
Verifying RIFT Configuration
You can verify the RIFT protocol configuration from the following hierarchy levels:
[groups rift-defaults]
[interfaces interface-range rift-interfaces]
[protocols rift]
[edit] user@host# show groups rift-defaults protocols { rift { node-id auto; level auto; lie-receive-address { family { inet 224.0.0.120; inet6 ff02::a1f7; } } interface <*> { lie-transmit-address { family { inet 224.0.0.120; inet6 ff02::a1f7; } } bfd-liveness-detection minimum-interval 1000; } } }
[edit] user@host# show interfaces interface-range rift-interfaces member ge-0/0/*; description "Match interfaces that RIFT could use.";
[edit] user@host# show protocols rift apply-groups rift-defaults; interface rift-interfaces;
You can also verify the RIFT configuration by viewing the defaults
applied from the junos-rift
package. To do this, run the show configuration protocols rift | display inherited
command.
For example:
user@host> show configuration protocols rift | display inherited ## ## 'auto' was inherited from group 'rift-defaults' ## node-id auto; level auto; ## ## 'lie-receive-address' was inherited from group 'rift-defaults' ## lie-receive-address { ## ## 'family' was inherited from group 'rift-defaults' ## family { ## ## '224.0.0.120' was inherited from group 'rift-defaults' ## inet 224.0.0.120; ## ## 'ff02::a1f7' was inherited from group 'rift-defaults' ## inet6 ff02::a1f7; } } interface ge-0/0/0.1 { ## ## 'lie-transmit-address' was inherited from group 'rift-defaults' ## lie-transmit-address { ## ## 'family' was inherited from group 'rift-defaults' ## family { ## ## '224.0.0.120' was inherited from group 'rift-defaults' ## inet 224.0.0.120; ## ## 'ff02::a1f7' was inherited from group 'rift-defaults' ## inet6 ff02::a1f7; } } ## ## 'bfd-liveness-detection' was inherited from group 'rift-defaults' ## ‘400’ was inherited from group 'rift-defaults' ## bfd-liveness-detection minimum-interval 400; }
Table 1 list the commands you can use to verify the RIFT protocol configuration and status.
Command |
Description |
|
Inspect the runtime state of the RIFT protocol. |
|
The RIFT protocol can be used in policies and commands where other protocols are accepted. |
|
View detailed RIFT-installed routes. |
|
Clear the RIFT database. |
|
Restart the RIFT protocol. |
For more information, see the FAQ file in the software package distribution.
Troubleshooting the RIFT Protocol
The RIFT protocol does not produce core files except in very extreme cases. It reports every failure by extensive logging and sometimes backtraces on exit. The RIFT process provides configurable tracing events that can be collected using traceoptions configuration.
To troubleshoot the RIFT implementation, see:
Forming Adjacency
Problem
RIFT adjacency flapping up and down, showing rejects with
Multiple Neighbors
orRemote Uses Our Own SystemID
errors.Solution
The RIFT protocol does not support more than two neighbors on an Ethernet link forming a point-to-point adjacency, or a node's own interfaces looped back. Check and correct the cabling.
Undefined Level
Problem
All the switches show undefined level and do not form three-way adjacencies, but link information elements (LIEs) are being sent and received.
Solution
There is a possibility that there is no top-of-fabric level configuration. All top-of-fabric devices must be configured with the top-of-fabric level to provide an anchor for ZTP.
Loopback Address
Problem
Not able to get loopback addresses to my nodes in RIFT.
Solution
To have all the loopback addresses in top-of-fabric, the simplest way is to configure a loopback address in every node necessary and redistribute it in the northbound direction into RIFT. The following configuration is required for doing this:
[edit policy-options] policy-statement lo0-rift { term 0 { from { protocol direct; route-filter loopback-address exact; } then accept; } term default { then reject; } }
[edit protocols rift] export { northbound { lo0-rift; } }
This configuration allows every leaf to ping the loopback address of all other nodes except the top-of-fabric devices.
If the top-of-fabric devices should also be reachable from the leaf devices, or vice-versa, the top-of-fabric loopback addresses need to be exposed to one level below (that is, southbound). The following configuration is required for doing this:
[edit protocols rift] export { southbound { lo0-rift; } }
Note:To enable the top-of-fabric addresses to be propagated to all the leaf nodes, configure the
allow-rift-routes
option under the[edit protocols rift export southbound]
hierarchy level.System Log Error Messages
The RIFT process generates system log messages to record errors related to the integration of the RIFT protocol into Junos OS. To interpret system log messages, refer to the following:
RIFT_PROXYD_ALREADY_RUNNING
—Another instance of the RIFT process is already running.RIFT_PROXYD_CONNECT_RIFT
—Attempts to connect to the local RIFT process failed.
For more information on system log error messages, see System Log Explorer.