【经验】如何使用自动化构造随机路由模型

本文中信而泰XINERTEL将为大家介绍如何使用自动化构造随机路由模型。

为什么要仿真随机路由？

路由器测试中，为了最大程度还原现网路由情况，评估路由器在现网环境下稳定工作各项指标，需要对导入路由进行离散仿真，目前路由仿真可分为导入路由与生成路由两种方式，导入路由需要现网路由表导入，本文讨论重点为生成路由方式，应用拓扑如下图所示：

自动化生成路由能解决什么问题？

使用用户界面生成路由时，可根据离散模型生成路由，但生成路由与现网路由相比，只注重路由段离散，未体现AsPath、Community等BGP路由参数离散，使用自动化生成路由可根据定义规则进行生成。

如何使用自动化生成随机路由

信而泰RENIX平台提供了python API接口，可使用python API进行路由灵活定义。假设路由需求如下：配置Port口1个，包含20个IBGP，每个IBGP通告10个路由段、共10wIPv4+10wIPv6路由，要求路由掩码随机选择，AsPath随机选择、Connmity随机选择。本文选择基础API使用信而泰API（renix_py_api、MiscLibrary），不另做定义，使用时需安装相关环境。代码解析如下：

导入相关库

import time

from renix_py_api.renix import *

from MiscLibrary.base import *

import logging

import random

import re

初始化Python环境及定义参

初始化Renix相关Python参数外，定义生成BGP路由的相关参数，其中包括IPv4/IPv6相关变化点路由数量、起始路由、掩码/前缀、AsPath、Community，设备各变化点取值范围。

api = MiscAPI()

    initialize(log=True, log_level=logging.INFO, log_handle=LogHandle.LOG_FILE)

    chassis_DY = "10.1.1.7"

    port_DY_1 = "//10.1.1.7/3/1"

    start_ip1 = "20.0.0.0"

    start_ipv61 = "2023::"

    BgpSessionCount = 20

    BgpRouteBlock = 10

    BgpRouteBlockv6 = 10

    ipv4routecount = 100000

    ipv6routecount = 100000

    MaskMin = 20

    MaskMax = 30

    PrefixMin = 80

    PrefixMax = 120

    AsPathMaxLength = 8

    CommunityMaxLength = 8

    Ipv4RoutePerSession = int(ipv4routecount / BgpSessionCount)

    ipv6PrefixPerSession = int(ipv6routecount / BgpSessionCount)

    Ipv4CountRandonMax = int(Ipv4RoutePerSession / BgpRouteBlock)

    Ipv4CountRandonMin = int(Ipv4CountRandonMax * 0.5)

    Ipv6CountRandonMax = int(ipv6PrefixPerSession / BgpRouteBlockv6)

    Ipv6CountRandonMin = int(Ipv6CountRandonMax * 0.5)

创建端口及映射机箱

如有对应仪表机框时，可按以下执行，如生成离线配置，可注释chassis.execute()和BringPortsOnlineCommand(PortList=[port_1.handle]).execute()语句。

    sys_entry = get_sys_entry()

    sys_entry.edit(ProductType=1)

    chassis = ConnectChassisCommand(chassis_DY)

    chassis.execute()

    port_1 = Port(upper=sys_entry, Location=port_DY_1, name='port_1')

    BringPortsOnlineCommand(PortList=[port_1.handle]).execute()

参数生成器定义

主要定义RouterId、IPv6RouterId、Mac、IPv4、IPv6生成器，接口相关参数均按偏移（Offset）变化。RouterId、IPv6RouterId、Mac均按递增1变化（ Offset=0，Step=1），IPv4按掩码24位递增1变化（ Offset=8，Step=1），IPv6按掩码80位递增1变化（ Offset=80，Step=1）

    GeneratorRouteridv4 = api.address_modifier(Start=r'192.168.0.1', Step=1, Count=1000, Offset=0)

    GeneratorRouteridv6 = api.address_modifier(Start=r'192:168::1', Step=1, Count=1000, Offset=0)

    GeneratorMacAddress = api.address_modifier(Start=r'00:10:94:00:00:01', Step=1, Count=1000, Offset=0)

    GeneratorIPv4Address = api.address_modifier(Start=r'10.0.0.2', Step=1, Count=1000, Offset=8)

    GeneratorIPv6Address = api.address_modifier(Start=r'2000::2', Step=1, Count=1000, Offset=80)

接口生成interface&BgpSession

接口生成时，主要变化点为RouterId、IPv6RouterId、Mac、IPV4、IPv6、IPv4GW、IPv6GW变化，接口数量与BGPSessionCount一一对应，注意单接口下生成多个interface时，启用子接口模式，对应仪表变化则为Vlan变化实现代码参数以下,相关生成器定义已在上文讨论，本循环使用api.generator_next()生成对连接变化点。

for x in range(BgpSessionCount):

#Interface生成部分代码

        Routeridv4 = api.generator_next(GeneratorRouteridv4)

        Routeridv6 = api.generator_next(GeneratorRouteridv6)

        MacAddr = api.generator_next(GeneratorMacAddress)

        IPv4Addr = api.generator_next(GeneratorIPv4Address)

        IPv6Addr = api.generator_next(GeneratorIPv6Address)

        IPv4GWAddr = api.ipv4_address_hopping(IPv4Addr, Mask=32, Type='decrement', Step=1)

        IPv6GWAddr = api.ipv6_address_hopping(IPv6Addr, Mask=128, Type='decrement', Step=1)

        interface = Interface(upper=port_1, RouterId = Routeridv4, Ipv6RouterId = Routeridv6)

        Interface_temp = "Interface_" + str(x+1)

        build_Dual = BuildInterfaceCommand(InterfaceList=Interface_temp, NetworkLayers=['eth', 'vlan'], TopLayers=['ipv4', 'ipv6'])

        build_Dual.execute()

        eth_layer = interface.get_children('EthIILayer')[0]

        eth_layer.edit(Address = MacAddr)

        vlan_layer = interface.get_children('VlanLayer')[0]

        vlan_layer.edit(VlanId = x+1 )

        ipv4_layer = interface.get_children('Ipv4Layer')[0]

        ipv4_layer.edit(Address = IPv4Addr , Gateway=IPv4GWAddr)

        ipv6_layer = interface.get_children('Ipv6Layer')[0]

        ipv6_layer.edit(Address = IPv6Addr , Gateway=IPv6GWAddr)

生成Interface效果下图所示：

BepSession生成

由于BgpSession与interface存在一一对应关系，所以可在同一个循环下生成BgpSession并绑定Interface。以下代码以上部分代码同处一个循环（for x in range(BgpSessionCount):）。

for x in range(BgpSessionCount):

...

        BgpSession = BgpProtocolConfig(upper=port_1)

        BgpSession.edit(AsNumber=65000)

        BgpSession.edit(DutAsNumber=65000)

        BgpSession.edit(UseGatewayAsDutIp=False)

        BgpSession.edit(DutIpv4Address=IPv4GWAddr)

        BgpSession.edit(DutIpv6Address=IPv6GWAddr)

        select_interface = SelectInterfaceCommand(ProtocolList=[BgpSession.handle], InterfaceList=[interface.handle])

        select_interface.execute()

生成Bgp效果下图所示：

IPv4路由生成

为每个BgpSession生成若干条RouteBlock，所以可在同一个循环下生成RouteBlock并绑定BgpSession。以下代码以上部分代码同处一个循环（for x in range(BgpSessionCount):），每个BgpSession生成的RouteBlock数量由BgpRouteBlock决定并循环执行，相关变化点包括路由数量、起始路由、掩码、AsPath、AsPath跳变长度、每个路由组AsPath数量、Community、Community跳变长度、每个路由组Community数量，其中路由数量、掩码、AsPath、Community为Random值，起始路由、AsPath跳变长度、每个路由组AsPath数量、Community跳变长度、每个路由组Community数量为对应变化：

起始路由:第1条路由填入定义的起始路由，2~n条按上一条路由的起始路由、路由数量、掩码生成对应的起始路由，每条路由组路由数量、掩码均使用random.randint生成随机数。

AsPath：按约定的最大AsPath长度生成随机长度，并根据长度生成对应随机AsPath，AsPath跳变长度均为1:1，AsPath跳变长度根据路由数量取值

Community：变化与AsPath类似。

具体实现代码如下：

for x in range(BgpSessionCount):

...

        FirstRoute = start_ip1

        Ipv4RouteCount = 0

        for y in range(BgpRouteBlock):

            mask = random.randint(MaskMin, MaskMax)

            if y == BgpRouteBlock-1:

                RouteCount = Ipv4RoutePerSession - Ipv4RouteCount

            else:

                RouteCount = random.randint(Ipv4CountRandonMin, Ipv4CountRandonMax)

            Ipv4RouteCount = Ipv4RouteCount+RouteCount

            offset = 32 - mask

            if x == 0 and y == 0:

                BgpRoute = BgpIpv4RoutepoolConfig(upper=BgpSession)

                BgpRoute.get()

                BgpRoute.edit(FirstRoute=FirstRoute)

                BgpRoute.edit(PrefixLength=mask)

                BgpRoute.edit(RouteCount=RouteCount)

                GeneratorIPv4Route = api.address_modifier(Start=FirstRoute, Step=RouteCount, Offset=offset, Count=1000)

                IPv4Route = api.generator_next(GeneratorIPv4Route)

                IPv4Route = api.generator_next(GeneratorIPv4Route)

            else:

                BgpRoute = BgpIpv4RoutepoolConfig(upper=BgpSession)

                BgpRoute.get()

                BgpRoute.edit(FirstRoute=IPv4Route)

                BgpRoute.edit(PrefixLength=mask)

                BgpRoute.edit(RouteCount=RouteCount)

                Start = IPv4Route

                GeneratorIPv4Route = api.address_modifier(Start=Start, Step=RouteCount, Offset=offset, Count=1000)

                IPv4Route = api.generator_next(GeneratorIPv4Route)

                IPv4Route = api.generator_next(GeneratorIPv4Route)

            as_path_length = random.randint(2, AsPathMaxLength)

            community_length = random.randint(2, CommunityMaxLength)

            as_path_list = list()

            community_list = list()

            AsPathIncrement_list = list()

            as_path_tem = str()

            community_tem = str()

            communityIncrement_list = list()

            for z in range(as_path_length):

                as_path = random.randint(300, 64000)

                as_path_list.append(as_path)

            for z in range(community_length):

                community1 = random.randint(1, 65535)

                community2 = random.randint(1, 65535)

                community = str(community1) + ':' + str(community2)

                community_list.append(community)

            for i in range(len(community_list) - 1):

                community = community_list[i]

                community_tem += community

                community_tem += ','

            community_tem += str(community_list[-1])

            AsPathPerBlockCount = int(RouteCount / 6.5)

            for z in range(len(as_path_list)):

                AsPathIncrement_list.append(1)

            for z in range(len(community_list)):

                Temp = str(1) + ':' + str(1)

                communityIncrement_list.append(Temp)

            BgpRoute.edit(AsPath=as_path_list)

            BgpRoute.edit(AsPathIncrement=AsPathIncrement_list)

            BgpRoute.edit(AsPathPerBlockCount=AsPathPerBlockCount)

            BgpRoute.edit(Community=community_tem)

            BgpRoute.edit(CommunityIncrement=communityIncrement_list)

            BgpRoute.edit(CommunityPerBlockCount=AsPathPerBlockCount)

生成IPv4路由BgpRouteBlock效果图如下所示：

IPv6路由生成

IPv6路由生成方法与IPv4一致，实现参考上文代码。

生成IPv6 BgpRouteBlock效果图如下所示：

保存Renix平台对应XCFG

执行以上代循环代码后，用以下代码生成对应配置，其中ProductType=1代表Daryu系列产品。

    save_case = SaveTestCaseCommand(TestCase='D:\bgp_random.xcfg', ProductType=1)

    save_case.execute()

适用产品—DarYu-X系列
DarYu-X系列高性能网络测试仪是信而泰推出的面向高端路由器等高端数通设备的测试产品，具有高性能、高密度、高速率等特点，配置信而泰基于PCT架构的新一代测试软件RENIX和X系列测试模块，可为提供路由器组网测试解决方案，为建立一张高SLA保证、确定性时延、业务感知、灵活业务路径调优的下一代网络保驾护航。