이 페이지의 내용
gNOI 시스템 서비스
요약 gNOI System 서비스를 사용하여 대상 네트워크 디바이스에서 디바이스 재부팅, 소프트웨어 업그레이드, 네트워크 문제 해결 등의 시스템 작업을 수행할 수 있습니다.
개요
gNOI System 서비스는 다음 작업을 포함하여 네트워크 디바이스에서 다양한 시스템 작업을 수행할 수 있는 RPC를 제공합니다.
- 장치 재부팅
- ping 및 traceroute 명령을 실행하여 네트워크 문제 해결
- 소프트웨어 업그레이드
- 라우팅 엔진 전환 수행
proto 정의 파일은 https://github.com/openconfig/gnoi/blob/master/system/system.proto 에 있습니다.
참고:
gnoi-system 시스템 오류가 발생할 경우 프로세스가 다시 시작됩니다. 수동으로 다시 시작하려면 명령을 사용합니다restart gnoi-system.
네트워크 디바이스 구성
시작하기 전에:
- gRPC 서비스 구성에 설명된 대로 네트워크 디바이스에서 gRPC 서비스를 구성합니다.
- gNOI 서비스 구성에 설명된 대로 gNOI 작업을 지원하도록 네트워크 관리 시스템을 구성합니다.
서비스 RPC를 System 사용하기 위해 추가 구성이 필요하지 않습니다.
핑 및 경로 추적
네트워크 디바이스에서 ping 및 traceroute 명령을 실행하여 네트워크 문제를 해결할 수 있습니다.
| 릴리스에 도입된 | RPC | 설명 |
|---|---|---|
Ping() |
장치를 ping합니다. RPC는 기본 패킷 수: 5 |
진화한 Junos OS 22.2R1 |
Traceroute() |
대상 디바이스에서 traceroute 명령을 실행하고 결과를 다시 스트리밍합니다. 기본 홉 수: 30 |
진화한 Junos OS 22.2R1 |
예: Ping
이 예제에서 클라이언트는 Python 응용 프로그램을 gnoi_ping_request.py 실행합니다. 애플리케이션은 RPC를 Ping() 네트워크 디바이스로 전송한 다음, 네트워크에서 지정된 디바이스를 ping합니다.
응용 프로그램은 gnoi_ping_request.py 채널을 설정하기 위해 모듈을 가져옵니다 grpc_channel . 이 grpc_channel 모듈은 gNOI 서비스 구성에 설명되어 있습니다. 응용 프로그램의 인수는 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=50051,
help='The server port. Default is 50051')
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=50051 --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 디바이스가 5개의 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
장치 재부팅
서비스 RPC를 System 사용하여 디바이스를 원격으로 재부팅하고, 재부팅 상태를 확인하고, 필요한 경우 재부팅을 취소합니다. 디바이스 또는 특정 하위 구성 요소에서 이러한 RPC를 실행할 수 있습니다. Junos 디바이스는 다음과 같은 재부팅 방법을 지원합니다.
COLD(1): 모든 유형의 재부팅에 사용할 수 있습니다.
POWERDOWN (2): FPC 재부팅에 사용합니다.
HALT (3): 활성 제어 프로세서 재부팅에 사용합니다.
POWERUP (7): FPC 재부팅에 사용합니다.
| 릴리스에 도입된 | RPC | 설명 |
|---|---|---|
Reboot() |
대상을 재부팅합니다. 대상에서 한 번에 하나의 재부팅 요청만 실행할 수 있습니다. 선택적으로 나중에 재부팅하도록 지연을 구성하고, 하위 구성 요소를 개별적으로 재부팅하고, 재부팅이 시작될 때 메시지를 추가할 수 있습니다. 지연은 나노초 단위로 구성됩니다. Junos 디바이스는 다음과 같은 재부팅 방법을 지원합니다.
|
진화한 Junos OS 22.2R1 |
RebootStatus() |
재부팅 상태를 반환합니다. | 진화한 Junos OS 22.2R1 |
CancelReboot() |
보류 중인 재부팅 요청을 취소합니다. | 진화한 Junos OS 22.2R1 |
예: 재부팅
이 예제에서 클라이언트는 Python 응용 프로그램을 gnoi_reboot_request.py 실행합니다. 애플리케이션은 재부팅 요청을 보낸 다음 재부팅 상태를 확인합니다.
이 애플리케이션을 통해 사용자는 재부팅 지연을 초 단위로 설정할 수 있습니다. RebootRequest() 은(는) 지연을 나노초 단위로 해석하므로 애플리케이션은 요청에 대한 사용자 입력을 나노초로 변환합니다. 이 예에서 클라이언트는 재부팅 작업에 대해 60초 지연을 지정합니다.
응용 프로그램은 gnoi_reboot_request.py 채널을 설정하기 위해 모듈을 가져옵니다 grpc_channel . 이 grpc_channel 모듈은 gNOI 서비스 구성에 설명되어 있습니다. 응용 프로그램의 인수는 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=50051,
help='The server port. Default is 50051')
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=50051 --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 |
RPC를 SetPackage() 사용하여 소프트웨어 이미지를 대상 디바이스에 복사하고 설치할 수 있습니다. 소스 소프트웨어 이미지는 로컬 네트워크 관리 시스템에 상주해야 합니다. 파일 복사 작업이 성공하고 대상 위치에 동일한 이름의 파일이 이미 있는 경우 파일을 덮어씁니다. RPC는 대상 위치가 없거나 데이터 쓰기 오류가 있는 경우 오류를 반환합니다.
기본적으로 은SetPackage()(는) 디바이스를 재부팅하고 소프트웨어를 활성화하지 않습니다. 새 소프트웨어를 활성화하려면 메시지에서 SetPackageRequest 옵션을 명시적으로 1로 설정해야 activate 합니다. 소프트웨어를 활성화하면 디바이스가 재부팅되고 새 소프트웨어 이미지가 사용됩니다. 소프트웨어를 활성화하지 않은 경우 관련 노드를 재부팅하여 설치를 완료하고 새 소프트웨어 이미지를 활성화해야 합니다.
예제: 소프트웨어 패키지 설치
이 예제에서 클라이언트는 다음 작업을 수행하는 Python 응용 프로그램을 실행합니다 gnoi_system_set_package.py .
- 소프트웨어 패키지를 로컬 네트워크 관리 시스템에서 네트워크 디바이스로 복사합니다.
- 네트워크 장치에 패키지를 설치합니다.
- 네트워크 디바이스를 재부팅하여 새 소프트웨어 이미지를 활성화합니다.
응용 프로그램은 적절한 매개 변수를 사용하여 메시지를 구성 SetPackageRequest 하여 복사 및 설치 작업에 대한 요청을 정의합니다. 그런 다음 애플리케이션은 RPC를 SetPackage() 호출하여 네트워크 디바이스에 요청을 보냅니다. 메시지에는 SetPackageRequest 다음 구성 요소가 포함되어 있습니다.
- 소프트웨어 이미지의 경로 및 파일 정보가 들어 있는 초기
Package메시지입니다. 인수는activate장치를 재부팅하고 소프트웨어를 활성화하기 위해 1(True)로 설정됩니다. - 64KB를 초과하지 않는 순차적 메시지의 소프트웨어 이미지 파일 콘텐츠 스트림입니다.
- 파일 내용의 무결성을 확인하기 위한 파일 체크섬이 포함된 최종 메시지입니다.
응용 프로그램은 gnoi_system_set_package.py 채널을 설정하기 위해 모듈을 가져옵니다 grpc_channel . 이 grpc_channel 모듈은 gNOI 서비스 구성에 설명되어 있습니다. 응용 프로그램의 인수는 파일에 저장됩니다 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=50051,
help='The server port. Default is 50051')
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=50051 --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.
라우팅 엔진 스위치오버
RPC를 SwitchControlProcessor() 사용하여 라우팅 엔진 전환을 수행할 수 있습니다.
참고:
연속적인 라우팅 엔진 전환 이벤트는 두 라우팅 엔진이 모두 등장한 후 최소 400초 간격으로 발생해야 합니다.
| 릴리스에 도입된 | RPC | 설명 |
|---|---|---|
SwitchControlProcessor() |
현재 라우팅 엔진에서 지정된 라우팅 엔진으로 전환합니다. 현재 라우팅 엔진과 지정된 라우팅 엔진이 동일하면 NOOP입니다. 대상이 없으면 RPC에서 오류를 반환합니다.
참고:
Junos 디바이스는 를 지원하지 |
진화한 Junos OS 22.2R1 |
예: 라우팅 엔진 스위치오버
이 예에서 gNOI 클라이언트는 라우팅 엔진 전환을 gnoi_system_switch_control_processor.py 수행하기 위해 애플리케이션을 실행합니다. 클라이언트는 인수를 포함하여 control_processor 어떤 스위치 제어 프로세서 또는 라우팅 엔진이 기본 라우팅 엔진이 되어야 하는지 지정합니다. 대상 라우팅 엔진이 존재하지 않는 경우, RPC는 INVALID_ARGUMENT 오류를 반환합니다.
응용 프로그램은 채널을 설정하기 위해 모듈을 가져옵니다 grpc_channel . 이 grpc_channel 모듈은 gNOI 서비스 구성에 설명되어 있습니다.
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=50051,
help='The server port. Default is 50051')
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 50051 --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>