Configure serviços gNOI
RESUMO Configure o sistema de gerenciamento de rede remoto como um cliente gRPC que pode executar operações de gNOI em dispositivos de rede.
A interface de operações de rede (gNOI) gRPC usa a estrutura de chamada de procedimento remoto (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 proto-definição para serviços gNOI . Os arquivos proto-definição definem as operações (RPCs) e as estruturas de dados (mensagens) para um determinado serviço. As definições são agnósticas da linguagem. O gRPC oferece suporte usando muitos idiomas diferentes para executar operações de serviço. Você deve compilar os arquivos proto-definição para o seu idioma de 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 o uso do gRPC com os diferentes idiomas compatíveis, consulte a documentação do gRPC. As seções a seguir fornecem comandos de amostra para configurar um cliente gRPC e baixar e compilar os arquivos de proto definição de gNOI para Python. Você deve usar os comandos apropriados para o seu sistema operacional, ambiente e linguagem de escolha gRPC.
Antes de configurar o cliente gRPC, configure o servidor gRPC conforme definido em Configurar serviços gRPC.
Configure o cliente gRPC
A gNOI usa a estrutura gRPC para realizar operações em um dispositivo de rede. o gRPC oferece suporte a vários idiomas diferentes. Antes de realizar operações de gNOI usando seu idioma de 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 oferece suporte a muitos idiomas. Para realizar operações de gRPC em dispositivos de rede, você deve compilar os respectivos arquivos proto-definição para o seu idioma de escolha. O OpenConfig fornece os arquivos protode definição necessários no repositório OpenConfig GitHub. 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 .proto em um diretório, atualiza os arquivos para usar declarações relativas de importação e, em seguida, compila os arquivos.
Para baixar e compilar os arquivos de protode definição de gNOI para Python:
Criar aplicativos gNOI
Depois de compilar os arquivos proto-definiçã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 amostra, que são descritos em suas respectivas seções.
grpc_channel.py
O grpc_channel.py módulo Python oferece funções de amostra que criam um canal gRPC usando os argumentos fornecidos para o método selecionado de autenticação, somente de 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 e executa uma simples operação de serviço gNOI System . 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 sucesso um canal gRPC, ele executará um RPC de serviço de sistema simples para recuperar o tempo 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=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.')
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()
Execute o aplicativo
Depois de criar aplicativos para executar operações de serviço gNOI, você executa os aplicativos e fornece quaisquer 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 o tempo. O servidor gRPC está configurado para exigir e verificar o certificado do cliente.
-
Para autenticação mútua, o cliente oferece sua própria chave e certificado de chave pública X.509 no formato PEM, além do endereço IP do servidor, porta gRPC e certificado de CA raiz. O cliente também fornece as credenciais para chamadas de 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 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 gRPC server password for executing RPCs: Creating channel Executing GNOI::System::Time RPC Response received: time since last epoch in nanoseconds is time: 1650061065769701762