Configurar serviços gNOI
Configure o sistema de gerenciamento de rede remoto como um cliente gRPC que pode executar operações gNOI em dispositivos de rede.
A interface de operações de rede gRPC (gNOI) usa a estrutura de chamada de procedimento remoto gRPC (gRPC) para realizar operações em um dispositivo de rede. O sistema de gerenciamento de rede deve ter a pilha gRPC instalada.
O OpenConfig define arquivos de protodefinição para serviços gNOI . Os arquivos de protodefinição definem as operações (RPCs) e as estruturas de dados (mensagens) para um determinado serviço. As definições são independentes de linguagem. O gRPC é compatível com o uso de muitas linguagens diferentes para executar operações de serviço. Você deve compilar os arquivos de protodefinição para o idioma de sua escolha. Em seguida, você cria aplicativos que usam os objetos (classes, funções, métodos, etc.) nos arquivos compilados para se conectar ao servidor gRPC no dispositivo de rede e executar as operações desejadas.
Para obter informações sobre como usar o gRPC com as diferentes linguagens compatíveis, consulte a documentação do gRPC. As seções a seguir fornecem comandos de exemplo para configurar um cliente gRPC e baixar e compilar os arquivos de definição de proto gNOI para Python. Você deve usar os comandos apropriados para o sistema operacional, o ambiente e a linguagem gRPC de sua escolha.
Antes de começar:
- Configure o servidor gRPC conforme descrito em Configurar serviços gRPC.
Configurar o cliente gRPC
O gNOI usa a estrutura gRPC para realizar operações em um dispositivo de rede. O gRPC é compatível com o uso de muitas linguagens diferentes. Antes de realizar operações gNOI usando a linguagem de sua escolha, você deve instalar a pilha gRPC no sistema de gerenciamento de rede.
Por exemplo, para instalar a pilha gRPC para Python em um sistema de gerenciamento de rede que executa o Ubuntu 20.04 LTS (use sudo quando apropriado):
Compilar os arquivos Proto Definiton
O gRPC é compatível com o uso de vários idiomas. Para realizar operações gRPC em dispositivos de rede, você deve compilar os respectivos arquivos de proto definição e quaisquer arquivos dependentes para a linguagem de sua escolha. O OpenConfig fornece os arquivos de protodefinição necessários no repositório GitHub do OpenConfig. Você usa o compilador de buffer de protocolo (protoc ou aplicativo equivalente) para compilar os .proto arquivos.
Para essa configuração, executamos um script que copia todos os arquivos desejados e dependentes .proto em um diretório, atualiza os arquivos para usar instruções de importação relativas e, em seguida, compila os arquivos.
Para baixar e compilar os arquivos de proto definition gNOI para Python:
Criar aplicativos gNOI
Depois de compilar os arquivos de protodefinição, você cria aplicativos que usam os objetos nos arquivos compilados. Os aplicativos se conectam ao servidor gRPC no dispositivo de rede e executam as operações desejadas. Esta seção fornece dois módulos Python de exemplo, que são descritos em suas respectivas seções.
grpc_channel.py
O grpc_channel.py módulo Python fornece funções de exemplo que criam um canal gRPC usando os argumentos fornecidos para o método de autenticação selecionado, somente servidor ou mútuo.
import grpc
from os.path import isfile
def grpc_authenticate_channel_mutual(server, port, root_ca_cert="", client_key="", client_cert=""):
if not isfile(root_ca_cert):
raise Exception("Error: root_ca_cert file does not exist")
if (client_key == "") or (not isfile(client_key)):
raise Exception(
"Error: client_key option is missing or target file does not exist")
elif (client_cert == "") or (not isfile(client_cert)):
raise Exception(
"Error: client_cert option is empty or target file does not exist")
print("Creating channel")
creds = grpc.ssl_channel_credentials(open(root_ca_cert, 'rb').read(),
open(client_key, 'rb').read(),
open(client_cert, 'rb').read())
channel = grpc.secure_channel('%s:%s' % (server, port), creds)
return channel
def grpc_authenticate_channel_server_only(server, port, root_ca_cert=""):
if isfile(root_ca_cert):
print("Creating channel")
creds = grpc.ssl_channel_credentials(open(root_ca_cert, 'rb').read(),
None,
None)
channel = grpc.secure_channel('%s:%s' % (server, port), creds)
return channel
else:
raise Exception("root_ca_cert file does not exist")
gnoi_connect_cert_auth_mutual.py
O gnoi_connect_cert_auth_mutual.py aplicativo Python estabelece um canal gRPC com o servidor gRPC fornecido e executa uma operação de serviço gNOI System simples. O usuário fornece as informações necessárias de conexão e autenticação mútua como entrada para o aplicativo. O aplicativo invoca a função apropriada no grpc_channel.py módulo para estabelecer o canal gRPC entre o cliente e o servidor. Se o aplicativo estabelecer com êxito um canal gRPC, ele executará um RPC de serviço do sistema simples para recuperar a hora do dispositivo de rede.
"""gRPC gNOI Time 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.')
args = parser.parse_args()
return args
def send_rpc(channel, metadata):
stub = system_pb2_grpc.SystemStub(channel)
print("Executing GNOI::System::Time RPC")
req = system_pb2.TimeRequest()
try:
response = stub.Time(request=req, metadata=metadata, timeout=60)
except Exception as e:
logging.error('Error executing RPC: %s', e)
print(e)
else:
logging.info('Received message: %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)
print("Response received: time since last epoch in nanoseconds is ", str(response))
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()
Executar o aplicativo
Depois de criar aplicativos para executar operações de serviço gNOI, você executa os aplicativos e fornece todos os argumentos necessários. O exemplo a seguir usa os scripts fornecidos na seção anterior para se conectar ao servidor gRPC no dispositivo de rede e solicitar a hora. O servidor gRPC é configurado para exigir e verificar o certificado do cliente.
-
Para autenticação mútua, o cliente fornece sua própria chave e certificado de chave pública X.509 no formato PEM, além do endereço IP do servidor, da porta gRPC e do certificado de CA raiz. O cliente também fornece as credenciais para chamadas RPC: o
user_idargumento fornece o nome de usuário e o aplicativo solicita a senha do usuário.lab@gnoi-client:~/src/proto$ python3 gnoi_connect_cert_auth_mutual.py --server 10.53.52.169 --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 gRPC server password for executing RPCs: Creating channel Executing GNOI::System::Time RPC Response received: time since last epoch in nanoseconds is time: 1650061065769701762