gNOI系统服务
使用 gNOI System 服务在目标网络设备上执行系统操作，包括重新启动设备、升级软件和排除网络故障。
概述
gNOI System 服务提供 RPC，用于在网络设备上执行多种不同的系统操作，包括以下操作：
- 重新启动设备
- 执行 ping 和 traceroute 命令对网络进行故障排除
- 升级软件
- 执行路由引擎切换
原型定义文件位于 https://github.com/openconfig/gnoi/blob/master/system/system.proto。
注意：
如果发生系统故障，该 gnoi-system 进程将重新启动。要手动重新启动它，请使用命令 restart gnoi-system 。
网络设备配置
开始之前：
- 在网络设备上配置 gRPC 服务，如配置 gRPC 服务中所述。
- 配置网络管理系统以支持 gNOI 操作，如配置 gNOI 服务中所述。
使用 System 服务 RPC 不需要其他配置。
Ping 和 Traceroute
您可以在网络设备上执行 ping 和 traceroute 命令来排除网络上的问题。
| RPC | 描述 | 在版本中引入 |
|---|---|---|
Ping() |
对设备执行 Ping 操作。 默认数据包数：5 |
Junos OS 演化版 22.2R1 |
Traceroute() |
在目标设备上执行 traceroute 命令并流式传输结果。 默认跃点计数：30 |
Junos OS 演化版 22.2R1 |
示例：Ping
在此示例中，客户端执行 gnoi_ping_request.py Python 应用程序。应用程序将 Ping() RPC 发送到网络设备，然后网络设备对网络上的指定设备执行 ping 操作。
gnoi_ping_request.py应用程序导入grpc_channel模块以建立通道。配置 gNOI 服务中介绍了该grpc_channel模块。应用程序的参数存储在gnoi_ping_request_args.txt文件中。此处显示了应用程序和参数文件。
gnoi_ping_request.py
"""gRPC gNOI ping request utility.""" from __future__ import print_function import argparse import logging from getpass import getpass import system_pb2 import system_pb2_grpc from grpc_channel import grpc_authenticate_channel_mutual def get_args(parser): parser.add_argument('--server', dest='server', type=str, default='localhost', help='Server IP or name. Default is localhost') parser.add_argument('--port', dest='port', nargs='?', type=int, default=32767, help='The server port. Default is 32767') parser.add_argument('--client_key', dest='client_key', type=str, default='', help='Full path of the client private key. Default ""') parser.add_argument('--client_cert', dest='client_cert', type=str, default='', help='Full path of the client certificate. Default ""') parser.add_argument('--root_ca_cert', dest='root_ca_cert', required=True, type=str, help='Full path of the Root CA certificate.') parser.add_argument('--user_id', dest='user_id', required=True, type=str, help='User ID for RPC call credentials.') # Ping request arguments parser.add_argument('--destination', dest='destination', type=str, default=None, help='Destination IP. Default None') parser.add_argument('--source', dest='source', type=str, default=None, help='Source IP. Default None') parser.add_argument('--count', dest='count', type=int, default=None, help='Count of packets. Default None') parser.add_argument('--interval', dest='interval', type=int, default=None, help='Interval of packets in nanoseconds. Default None') parser.add_argument('--wait', dest='wait', type=int, default=None, help='Wait of packets in nanoseconds. Default None') parser.add_argument('--size', dest='size', type=int, default=None, help='Size of packets. Default None') parser.add_argument('--dnfragment', dest='dnfragment', type=int, default=0, help='Do not fragment. Default 0 (False)') parser.add_argument('--dnresolve', dest='dnresolve', type=int, default=0, help='Do not resolve. Default 0 (False)') parser.add_argument('--l3protocol', dest='l3protocol', type=int, default=None, help='L3 protocol (1=ipv4,2=ipv6). Default None') parser.add_argument('--timeout', dest='timeout', type=int, default=30, help='Timeout for ping. Default: 30 seconds') args = parser.parse_args() return args def send_rpc(channel, metadata, args): stub = system_pb2_grpc.SystemStub(channel) print("Executing GNOI::System::Ping Request RPC") req = system_pb2.PingRequest() if args.count != None: req.count = args.count if args.source != None: req.source = args.source if args.destination != None: req.destination = args.destination if args.interval != None: req.interval = args.interval if args.wait != None: req.wait = args.wait if args.size != None: req.size = args.size if args.dnfragment != 0: req.do_not_fragment = args.dnfragment if args.dnresolve != 0: req.do_not_resolve = args.dnresolve if args.l3protocol != None: req.l3protocol = args.l3protocol try: print("Ping Request Response starts\n") count = 1 for ping in stub.Ping(request=req, metadata=metadata, timeout=args.timeout): print("Response Source%s: %s " % (count, ping.source)) print("Time%s: %s" % (count, ping.time)) print("Sent%s: %s" % (count, ping.sent)) print("Receive%s: %s" % (count, ping.received)) print("Mintime%s: %s" % (count, ping.min_time)) print("Avgtime%s: %s" % (count, ping.avg_time)) print("Stddev%s: %s" % (count, ping.std_dev)) print("Bytes%s: %s" % (count, ping.bytes)) print("Sequence%s: %s" % (count, ping.sequence)) print("TTL%s: %s" % (count, ping.ttl)) count += 1 print("Ping Request Response ends\n") except Exception as e: logging.error('Error: %s', e) print(e) def main(): parser = argparse.ArgumentParser(fromfile_prefix_chars='@') args = get_args(parser) grpc_server_password = getpass("gRPC server password for executing RPCs: ") metadata = [('username', args.user_id), ('password', grpc_server_password)] try: # Establish grpc channel to network device channel = grpc_authenticate_channel_mutual( args.server, args.port, args.root_ca_cert, args.client_key, args.client_cert) response = send_rpc(channel, metadata, args) except Exception as e: logging.error('Received error: %s', e) print(e) if __name__ == '__main__': logging.basicConfig(filename='gnoi-testing.log', format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') main()
gnoi_ping_request_args.txt
--server=10.0.2.1 --port=32767 --root_ca_cert=/etc/pki/certs/serverRootCA.crt --client_key=/home/lab/certs/client.key --client_cert=/home/lab/certs/client.crt --user_id=gnoi-user --destination=10.0.3.1 --source=10.0.2.1 --count=5
执行应用
在客户端上，执行应用程序，该应用程序会提示服务器输入 RPC 调用凭据的密码。表示 PingResponse 设备发送了五个 ping。最终响应包括 ping 请求的汇总统计信息，其中显示设备发送了 5 个 ping，并收到了 5 个响应。
lab@gnoi-client:~/src/gnoi/proto$ python3 gnoi_ping_request.py @gnoi_ping_request_args.txt gRPC server password for executing RPCs: Creating channel Executing GNOI::System::Ping Request RPC Ping Request Response starts Response Source1: 10.0.3.1 Time1: 741000 Sent1: 0 Receive1: 0 Mintime1: 0 Avgtime1: 0 Stddev1: 0 Bytes1: 64 Sequence1: 1 TTL1: 59 Response Source2: 10.0.3.1 Time2: 734000 Sent2: 0 Receive2: 0 Mintime2: 0 Avgtime2: 0 Stddev2: 0 Bytes2: 64 Sequence2: 2 TTL2: 59 Response Source3: 10.0.3.1 Time3: 704000 Sent3: 0 Receive3: 0 Mintime3: 0 Avgtime3: 0 Stddev3: 0 Bytes3: 64 Sequence3: 3 TTL3: 59 Response Source4: 10.0.3.1 Time4: 767000 Sent4: 0 Receive4: 0 Mintime4: 0 Avgtime4: 0 Stddev4: 0 Bytes4: 64 Sequence4: 4 TTL4: 59 Response Source5: 10.0.3.1 Time5: 800000 Sent5: 0 Receive5: 0 Mintime5: 0 Avgtime5: 0 Stddev5: 0 Bytes5: 64 Sequence5: 5 TTL5: 59 Response Source6: 10.0.3.1 Time6: 4111000000 Sent6: 5 Receive6: 5 Mintime6: 704000 Avgtime6: 749000 Stddev6: 32000 Bytes6: 0 Sequence6: 0 TTL6: 0 Ping Request Response ends
重新启动设备
使用 System 服务 RPC 远程重新启动设备，检查重新启动的状态，并在需要时取消重新启动。可以在设备或特定子组件上执行这些 RPC。Junos 设备支持以下重新启动方法：
-
冷 （1）：适用于所有类型的重启。
-
POWERDOWN （2）：用于 FPC 和路由引擎（控制器卡）重新启动。
-
HALT （3）：用于主动控制处理器重新启动。
-
POWERUP （7）：用于 FPC 和路由引擎（控制器卡）重新启动。
从 Junos OS 演化版 25.2R1 开始，您可以在路由引擎组件上使用 POWERDOWN 和 POWERUP 选项。您只能关闭双路由引擎系统中的路由引擎，不能同时关闭两个路由引擎的电源。路由引擎将保持关闭状态，直到下次重新启动。
注意：
要关闭路由引擎的电源并在重新启动后仍保持状态，可以将 OpenConfig 路径/components/component/controller-card/config/power-admin-state/POWER_DISABLED设置为 。此状态更改在备份路由引擎上立即生效。主路由引擎状态仅在重新启动或切换后更改。
| RPC | 描述 | 在版本中引入 |
|---|---|---|
Reboot() |
重新启动目标。一次只能对目标执行一个重新启动请求。 您可以选择配置将来重新启动的延迟，单独重新启动子组件，并在重新启动时添加消息。延迟配置以纳秒为单位。 Junos 设备支持以下重新启动方法：
|
Junos OS 演化版 22.2R1 |
RebootStatus() |
返回重新启动的状态。 |
Junos OS 演化版 22.2R1 |
CancelReboot() |
取消挂起的重启请求。 |
Junos OS 演化版 22.2R1 |
示例：重新启动
在此示例中，客户端执行 gnoi_reboot_request.py Python 应用程序。应用程序发送重新启动请求，然后检查重新启动的状态。
该应用程序允许用户以秒为单位设置重新启动延迟。由于以 RebootRequest() 纳秒为单位解释延迟，因此应用程序将用户输入转换为请求的纳秒。在此示例中，客户端为重新启动操作指定了 60 秒的延迟。
gnoi_reboot_request.py应用程序导入grpc_channel模块以建立通道。配置 gNOI 服务中介绍了该grpc_channel模块。应用程序的参数存储在reboot_status_request_args.txt文件中。此处显示了应用程序和参数文件。
gnoi_reboot_status_request.py
"""gRPC gNOI reboot request and reboot status utility.""" from __future__ import print_function import argparse import logging from getpass import getpass import types_pb2 import system_pb2 import system_pb2_grpc from grpc_channel import grpc_authenticate_channel_mutual def get_args(parser): parser.add_argument('--server', dest='server', type=str, default='localhost', help='Server IP or name. Default is localhost') parser.add_argument('--port', dest='port', nargs='?', type=int, default=32767, help='The server port. Default is 32767') parser.add_argument('--client_key', dest='client_key', type=str, default='', help='Full path of the client private key. Default ""') parser.add_argument('--client_cert', dest='client_cert', type=str, default='', help='Full path of the client certificate. Default ""') parser.add_argument('--root_ca_cert', dest='root_ca_cert', required=True, type=str, help='Full path of the Root CA certificate.') parser.add_argument('--user_id', dest='user_id', required=True, type=str, help='User ID for RPC call credentials.') # Arguments for RebootRequest parser.add_argument('--method', dest='method', type=int, default=1, help='Reboot method. Valid value: 0 (UNKNOWN), 1 (COLD), 2 (POWERDOWN), 3 (HALT), 6 (reserved), 7 (POWERUP). Default 1') parser.add_argument('--delay', dest='delay', type=int, default=None, help='Delay in seconds before rebooting. Default 0') parser.add_argument('--message', dest='message', type=str, default=None, help='Message for rebooting.') parser.add_argument('--force', dest='force', type=int, default=None, help='Force reboot. Valid value 0|1. Default 0') parser.add_argument('--subcomponents', dest='subcomponents', type=str, default='', help='Subcomponents to reboot. Valid value re0,re1,fpc0,fpc8,etc. Default ""') args = parser.parse_args() return args def send_rpc(channel, metadata, args): # RebootRequest stub = system_pb2_grpc.SystemStub(channel) print("Executing GNOI::System::Reboot RPC") req = system_pb2.RebootRequest() # Add RebootRequest arguments req.method = args.method if args.delay != None: # gNOI delay is in nanoseconds. Convert from seconds to nanoseconds. req.delay = args.delay*(10**9) if args.message != None: req.message = args.message if args.force != None: req.force = args.force for subcomponent in args.subcomponents.split(","): if subcomponent == "": continue elem_key = {} elem_key["%s" % subcomponent] = subcomponent path_elem = [types_pb2.PathElem( name="%s" % subcomponent, key=elem_key)] path = types_pb2.Path(origin="origin", elem=path_elem) req.subcomponents.extend([path]) # RebootStatus print("Executing GNOI::System::Reboot Status RPC") req_status = system_pb2.RebootStatusRequest() try: reboot_response = stub.Reboot( request=req, metadata=metadata, timeout=60) status_response = stub.RebootStatus( request=req_status, metadata=metadata, timeout=60) print("Reboot status response received. %s" % status_response) except Exception as e: logging.error('Error: %s', e) print(e) else: logging.info('Received reboot status: %s', status_response) def main(): parser = argparse.ArgumentParser(fromfile_prefix_chars='@') args = get_args(parser) grpc_server_password = getpass("gRPC server password for executing RPCs: ") metadata = [('username', args.user_id), ('password', grpc_server_password)] try: # Establish grpc channel to network device channel = grpc_authenticate_channel_mutual( args.server, args.port, args.root_ca_cert, args.client_key, args.client_cert) send_rpc(channel, metadata, args) except Exception as e: print(e) logging.error('Received error: %s', e) if __name__ == '__main__': logging.basicConfig(filename='gnoi-testing.log', format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') main()
reboot_status_request_args.txt
--server=10.0.2.1 --port=32767 --root_ca_cert=/etc/pki/certs/serverRootCA.crt --client_key=/home/lab/certs/client.key --client_cert=/home/lab/certs/client.crt --user_id=gnoi-user --message="Testing gNOI reboot" --delay=60
执行应用
当客户端执行应用程序时，应用程序会提示服务器输入 RPC 调用凭据的密码。然后，应用程序会在延迟 60 秒后重新启动服务器，并返回适用的重新启动状态消息。下面 reason 设置的消息也会在服务器重新启动之前立即显示在服务器上。在此示例中，登录到服务器的任何用户都会在重新启动之前立即看到“正在测试 gNOI 重新启动”。
lab@gnoi-client:~/src/gnoi/proto$ python3 gnoi_reboot_status_request.py @reboot_status_request_args.txt gRPC server password for executing RPCs: Creating channel Executing GNOI::System::Reboot RPC Executing GNOI::System::Reboot Status RPC Reboot status response received! active: true wait: 59266969677 when: 1651788480000000000 reason: "Testing gNOI reboot" count: 5
升级软件
表 3 列出了支持软件升级的 系统 服务 RPC。
| RPC | 描述 | 在版本中引入 |
|---|---|---|
SetPackage() |
在目标设备上安装软件映像。 |
Junos OS 演化版 22.2R1 |
您可以使用 SetPackage() RPC 将软件映像复制到目标设备并进行安装。源软件映像必须驻留在本地网络管理系统上。如果文件复制操作成功，并且目标位置已存在同名文件，则将覆盖该文件。如果目标位置不存在或写入数据时出错，则 RPC 将返回错误。
默认情况下，SetPackage()不会重新启动设备和激活软件。您必须在消息中SetPackageRequest将该选项显式设置为 activate 1，才能激活新软件。如果激活软件，设备将重新启动并使用新的软件映像。如果未激活软件，则必须重新启动相关节点才能完成安装并激活新的软件映像。
示例：安装软件包
在此示例中，客户端执行 gnoi_system_set_package.py Python 应用程序，该应用程序执行以下操作：
- 将软件包从本地网络管理系统复制到网络设备。
- 在网络设备上安装软件包。
- 重新启动网络设备，从而激活新的软件映像。
应用程序使用适当的参数构造 SetPackageRequest 消息，以定义复制和安装操作的请求。然后，应用程序调用 SetPackage() RPC 将请求发送到网络设备。该 SetPackageRequest 消息包含以下组件：
- 包含软件映像的路径和文件信息的初始
Package消息。activate该参数设置为 1 （True） 以重新启动设备并激活软件。 - 不超过 64KB 的顺序消息中的软件映像文件内容流。
- 带有文件校验和的最后一条消息，用于验证文件内容的完整性。
gnoi_system_set_package.py应用程序导入grpc_channel模块以建立通道。配置 gNOI 服务中介绍了该grpc_channel模块。应用程序的参数存储在文件中args_system_set_package.txt。应用程序和参数文件如下：
gnoi_system_set_package.py
"""gRPC gNOI OS Upgrade Utility.""" from __future__ import print_function import argparse import hashlib import logging from functools import partial from getpass import getpass import system_pb2 import system_pb2_grpc from grpc_channel import grpc_authenticate_channel_mutual MAX_BYTES = 65536 def get_args(parser): parser.add_argument('--server', dest='server', type=str, default='localhost', help='Server IP or name. Default is localhost') parser.add_argument('--port', dest='port', nargs='?', type=int, default=32767, help='The server port. Default is 32767') parser.add_argument('--client_key', dest='client_key', type=str, default='', help='Full path of the client private key. Default ""') parser.add_argument('--client_cert', dest='client_cert', type=str, default='', help='Full path of the client certificate. Default ""') parser.add_argument('--root_ca_cert', dest='root_ca_cert', required=True, type=str, help='Full path of the Root CA certificate.') parser.add_argument('--user_id', dest='user_id', required=True, type=str, help='User ID for RPC call credentials.') parser.add_argument('--activate', dest='activate', type=int, default=0, help='Reboot and activate the package. Default: 0 (Do not reboot/activate). Valid value: 1 (Reboot/activate).') parser.add_argument('--filename', dest='filename', type=str, default='', help='Destination path and filename of the package. Default ""') parser.add_argument('--source_package', dest='source_package', type=str, default='', help='Full path of the source file to send. Default ""') parser.add_argument('--timeout', dest='timeout', type=int, default=None, help='Timeout in seconds.') parser.add_argument('--version', dest='version', type=str, default='', help='Version of the package. Default ""') args = parser.parse_args() return args def send_rpc(channel, metadata, args): stub = system_pb2_grpc.SystemStub(channel) print("Executing GNOI::System::SetPackage") # Create request # Add file information to request req = system_pb2.SetPackageRequest() req.package.activate = args.activate req.package.filename = args.filename it = [] it.append(req) # Prepare hash generator gen_hash = hashlib.sha256() # Read source package and add to request with open(args.source_package, "rb") as fd: # Read data in 64 KB chunks and calculate checksum and data messages for data in iter(partial(fd.read, MAX_BYTES), b''): req = system_pb2.SetPackageRequest() req.contents = data it.append(req) gen_hash.update(data) # Add checksum to request req = system_pb2.SetPackageRequest() req.hash.hash = gen_hash.hexdigest().encode() req.hash.method = 1 it.append(req) # Install the package try: logging.info('Installing package %s', args.source_package) print('SetPackage start.') response = stub.SetPackage( iter(it), metadata=metadata, timeout=args.timeout) print('SetPackage complete.') except Exception as e: logging.error('Software install error: %s', e) print(e) else: logging.info('SetPackage complete.') return response def main(): parser = argparse.ArgumentParser(fromfile_prefix_chars='@') args = get_args(parser) grpc_server_password = getpass("gRPC server password for executing RPCs: ") metadata = [('username', args.user_id), ('password', grpc_server_password)] try: # Establish grpc channel to network device channel = grpc_authenticate_channel_mutual( args.server, args.port, args.root_ca_cert, args.client_key, args.client_cert) response = send_rpc(channel, metadata, args) except Exception as e: logging.error('Error: %s', e) print(e) if __name__ == '__main__': logging.basicConfig(filename='gnoi-install.log', format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') main()
args_system_set_package.txt
--server=10.0.2.1 --port=32767 --root_ca_cert=/etc/pki/certs/serverRootCA.crt --client_key=/home/lab/certs/client.key --client_cert=/home/lab/certs/client.crt --user_id=gnoi-user --activate=1 --filename=/var/tmp/junos-evo-install-ptx-x86-64-22.2R1.13-EVO.iso --source_package=/home/lab/images/junos-evo-install-ptx-x86-64-22.2R1.13-EVO.iso --timeout=1800
执行应用
当客户端执行应用程序时，应用程序会将包从本地设备复制到网络设备，安装它，然后重新启动设备以完成安装。
lab@gnoi-client:~/src/gnoi/proto$ python3 gnoi_system_set_package.py @args_system_set_package.txt gRPC server password for executing RPCs: Creating channel Executing GNOI::System::SetPackage SetPackage start. SetPackage complete.
路由引擎切换
SwitchControlProcessor()您可以使用 RPC 执行路由引擎切换。
注意：
在两个路由引擎启动后，连续的路由引擎切换事件必须至少间隔 400 秒。
| RPC | 描述 | 在版本中引入 |
|---|---|---|
SwitchControlProcessor() |
从当前路由引擎切换到指定的路由引擎。如果当前路由引擎和指定的路由引擎相同，则为 NOOP。如果目标不存在，则 RPC 将返回错误。
注意：
Junos 设备不支持 |
Junos OS 演化版 22.2R1 |
示例：路由引擎切换
在此示例中，gNOI 客户端执行 gnoi_system_switch_control_processor.py 应用程序以执行路由引擎切换。客户端通过包含 control_processor 参数来指定哪个交换机控制处理器或路由引擎应为主路由引擎。如果目标路由引擎不存在，RPC 将返回 INVALID_ARGUMENT 错误。
应用程序导入grpc_channel模块以建立通道。配置 gNOI 服务中介绍了该grpc_channel模块。
gnoi_system_switch_control_processor.py
"""gNOI Routing Engine switchover request utility.""" from __future__ import print_function import argparse import logging from getpass import getpass import system_pb2 import system_pb2_grpc import types_pb2 from grpc_channel import grpc_authenticate_channel_mutual def get_args(parser): parser.add_argument('--server', dest='server', type=str, default='localhost', help='Server IP or name. Default is localhost') parser.add_argument('--port', dest='port', nargs='?', type=int, default=32767, help='The server port. Default is 32767') parser.add_argument('--client_key', dest='client_key', type=str, default='', help='Full path of the client private key. Default ""') parser.add_argument('--client_cert', dest='client_cert', type=str, default='', help='Full path of the client certificate. Default ""') parser.add_argument('--root_ca_cert', dest='root_ca_cert', required=True, type=str, help='Full path of the Root CA certificate.') parser.add_argument('--user_id', dest='user_id', required=True, type=str, help='User ID for RPC call credentials.') parser.add_argument('--control_processor', dest='control_processor', type=str, default='re1', help='Control processor that will assume the role of primary. Default is re1. Valid values are re0,re1.') args = parser.parse_args() return args def send_rpc(channel, metadata, processor): stub = system_pb2_grpc.SystemStub(channel) print("Executing GNOI::System::SwitchControlProcessor") elem_key = {} elem_key["%s" % processor] = processor path_elem = [types_pb2.PathElem(name="%s" % processor, key=elem_key)] path = types_pb2.Path(origin="origin", elem=path_elem) req = system_pb2.SwitchControlProcessorRequest(control_processor=path) # Send the request try: response = stub.SwitchControlProcessor( req, metadata=metadata, timeout=60) print("SwitchControlProcessor response:\n", response) except Exception as e: logging.error('Switchover error: %s', e) print(e) else: logging.info('SwitchControlProcessor response:\n %s', response) return response def main(): parser = argparse.ArgumentParser() args = get_args(parser) grpc_server_password = getpass("gRPC server password for executing RPCs: ") metadata = [('username', args.user_id), ('password', grpc_server_password)] try: # Establish grpc channel to network device channel = grpc_authenticate_channel_mutual( args.server, args.port, args.root_ca_cert, args.client_key, args.client_cert) response = send_rpc(channel, metadata, args.control_processor) except Exception as e: logging.error('Received error: %s', e) print(e) if __name__ == '__main__': logging.basicConfig(filename='gnoi-testing.log', format='%(asctime)s %(levelname)-8s %(message)s', level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S') main()
执行应用
客户端执行应用程序并将参数设置为 control_processor ， re1 以便 re1 成为主路由引擎。
lab@gnoi-client:~/src/gnoi/proto$ python3 gnoi_system_switch_control_processor.py --server 10.0.2.1 --port 32767 --root_ca_cert /etc/pki/certs/serverRootCA.crt --client_key /home/lab/certs/client.key --client_cert /home/lab/certs/client.crt --user_id gnoi-user --control_processor re1 gRPC server password for executing RPCs: Creating channel Executing GNOI::System::SwitchControlProcessor SwitchControlProcessor response: version: "22.2R1.13-EVO" uptime: 1652478709000000000
执行操作后，re1 是目标设备上的主路由引擎。
{master}
lab@gnoi-server-re1>
变更历史表
是否支持某项功能取决于您使用的平台和版本。使用 功能资源管理器 确定您的平台是否支持某个功能。
发布
描述
25.2R1-EVO
从 Junos OS 演化版 25.2R1 开始，您可以使用 gNOI
System 服务 Reboot() RPC 为双路由引擎设备上的路由引擎（控制器卡）打开和关闭电源。