Crie scripts de ação para RPCs YANG em dispositivos Junos
Você pode adicionar modelos de dados YANG que definem chamadas de procedimento remoto (RPCs) personalizadas em dispositivos Junos suportados. Quando você adiciona um RPC YANG não nativo a um dispositivo, você também deve fornecer um script de ação que serve como manipulador do RPC. A definição de RPC faz referência ao script de ação, que é invocado quando o RPC é executado. O script de ação executa as operações e recupera as informações exigidas pelo RPC e devolve todos os elementos de saída XML necessários conforme definido na declaração RPC output .
Scripts de ação podem ser escritos em Stylesheet Language Alternative SyntaX (SLAX) ou Python. Os scripts de ação SLAX são semelhantes aos scripts de operação SLAX e podem executar qualquer função disponível através dos RPCs suportados pelo protocolo de gerenciamento Junos XML e pela API Junos XML. Os scripts de ação python podem aproveitar todos os recursos e construções na linguagem Python, o que oferece maior flexibilidade sobre scripts SLAX. Além disso, os scripts de ação Python oferecem suporte a APIs Junos PyEZ , que facilitam a execução de RPCs e a execução de tarefas operacionais e de configuração em dispositivos Junos. Os scripts Python também podem aproveitar a biblioteca, o que simplifica o lxml manuseio do XPath. Além disso, a partir do Junos OS Release 19.3R1, os dispositivos que executam o Junos OS com suporte freeBSD atualizado usando IPv6 em scripts de ação Python.
Este tópico discute como criar um script de ação, incluindo como analisar os argumentos de entrada RPC, acessar dados operacionais e de configuração no script, emitir a saída XML e validar e carregar o script em um dispositivo.
Plate de script de ação
Plate de script SLAX
Os scripts de ação SLAX devem incluir a placa de serviço necessária para funcionalidades básicas de script, bem como qualquer funcionalidade opcional usada dentro do script, como as funções de extensão do Junos OS e modelos nomeados. Além disso, o script deve declarar todos os parâmetros de entrada RPC usando a param declaração. O script de ação SLAX é o seguinte:
version 1.0;
ns junos = "http://xml.juniper.net/junos/*/junos";
ns xnm = "http://xml.juniper.net/xnm/1.1/xnm";
ns jcs = "http://xml.juniper.net/junos/commit-scripts/1.0";
import "/var/db/scripts/import/junos.xsl";
param $input-param1;
param $input-param2;
match / {
<action-script-results> {
/* insert your code here */
}
}
Python Script Boilerplate
Os scripts de ação python devem incluir uma linha de diretiva de intérprete que especifica a versão Python usada para executar o script. A Tabela 1 descreve as linhas de diretiva do intérprete que você pode usar nas diferentes versões.
| as linhas de diretiva | Python Version | Interpreter|
|---|---|---|
| Python 3 |
|
Junos OS Release 20.2R1 e posterior Junos OS Evolved Release 21.1R1 e posterior |
| Python 2.7 |
|
Junos OS Release 20.1 e anterior Junos OS Evolved Release 22.2 e anterior |
A partir do Junos OS Release 20.2R1 e do Junos OS Evolved Release 22.3R1, o dispositivo usa Python 3 para executar scripts de ação e tradução YANG. Em versões anteriores, o Junos OS só usa Python 2.7 para executar esses scripts, e o Junos OS Evolved usa Python 2.7 por padrão para executar os scripts.
Além disso, os scripts de ação python devem importar quaisquer bibliotecas, módulos ou objetos que sejam usados no script. Por exemplo, além das bibliotecas Python padrão, os scripts de ação python podem importar os seguintes:
-
jcsbiblioteca — permite que o script use funções de extensão do Junos OS e a funcionalidade de modelo indicada pelo Junos OS no script. -
jnpr.junosmódulo e aulas — permite que o script use o Junos PyEZ. -
lxmlbiblioteca — simplifica o manuseio do XPath.
Por exemplo:
#!/usr/bin/python3 import jcs from jnpr.junos import Device from lxml import etree
Analisando os argumentos de entrada de RPC
- Visão geral do argumento de entrada
- Argumentos de entrada de script SLAX
- Argumentos de entrada de script Python
Visão geral do argumento de entrada
Um RPC pode definir parâmetros de entrada usando a declaração opcional input . Quando você executa um RPC e fornece argumentos de entrada, o Junos OS invoca o script de ação do RPC e passa esses argumentos para o script. Em um script de ação Python ou SLAX, você pode acessar os argumentos de entrada RPC da mesma maneira que acessaria argumentos de linha de comando para um script Python normal ou um script operacional Junos OS SLAX, respectivamente.
Considere a declaração a seguir input para o get-host-status RPC:
rpc get-host-status {
description "RPC example to retrieve host status";
junos:command "show host-status" {
junos:action-execute {
junos:script "rpc-host-status.py";
}
}
input {
leaf hostip {
description "IP address of the target host";
type string;
}
leaf level {
type enumeration {
enum brief {
description "Display brief output";
}
enum detail {
description "Display detailed output";
}
}
}
leaf test {
description "empty argument";
type empty;
}
}
...
O RPC pode ser executado na CLI ou por meio de uma sessão de protocolo NETCONF ou Junos XML. Por exemplo, você pode executar o seguinte comando na CLI:
user@host> show host-status hostip 198.51.100.1 level detail test
Da mesma forma, você pode executar o seguinte RPC em uma sessão remota:
<rpc>
<get-host-status>
<hostip>198.51.100.1</hostip>
<level>detail</level>
<test/>
</get-host-status>
</rpc>
Quando você executa o comando ou RPC, o dispositivo invoca o script de ação e passa nos argumentos. As seções a seguir discutem como processar os argumentos no script de ação SLAX ou Python.
A partir do Junos OS Release 19.2R1, os RPCs YANG personalizados oferecem suporte a parâmetros de entrada do tipo empty ao executar o comando do RPC no Junos OS CLI, e o valor passado para o script de ação é o nome do parâmetro. Em versões anteriores, parâmetros de entrada do tipo empty só são suportados ao executar o RPC em uma sessão de protocolo NETCONF ou Junos XML, e o valor passado para o script de ação é a cadeia 'none'.
Argumentos de entrada de script SLAX
Nos scripts de ação SLAX, você deve declarar parâmetros de entrada usando a param declaração. Os nomes dos parâmetros devem ser idênticos aos nomes de parâmetros definidos no módulo YANG.
Quando invocado, o script atribui o valor de cada argumento ao parâmetro correspondente, que você pode então fazer referência ao script. Você deve incluir o símbolo do sinal de dólar ($) tanto quando você declara o parâmetro quanto quando acessa seu valor. Se um parâmetro for tipo empty, o nome do parâmetro é passado como seu valor.
param $hostip; param $level; param $test;
Para obter mais informações sobre parâmetros SLAX, consulte a visão geral dos parâmetros SLAX no Guia do usuário de scripts de automação.
Argumentos de entrada de script Python
Para scripts de ação python, os argumentos são passados para o script da seguinte forma:
-
O primeiro argumento é sempre o caminho do arquivo do script de ação.
-
Os próximos argumentos da lista são o nome e o valor para cada parâmetro de entrada fornecido pelo usuário.
O nome do argumento é passado da seguinte forma:
-
No Junos OS Release 21.1 e anterior, o dispositivo passa em nome do argumento.
-
No Junos OS Release 21.2R1 e posterior, o dispositivo prefixa um único hífen (-) a nomes de argumentos de um único personagem e prefixa dois hífens (--) em nomes de argumentos de vários caracteres.
Nota:Quando você executa o comando do RPC na CLI, os argumentos são passados para o script na ordem dada na linha de comando. Em uma sessão de protocolo NETCONF ou Junos XML, a ordem dos argumentos no XML é arbitrária, de modo que os argumentos são passados para o script na ordem em que são declarados na declaração do RPC
input. -
-
Os dois últimos argumentos da lista, fornecidos pelo sistema e não pelo usuário, são
'rpc_name'e o nome do RPC.
As seções a seguir discutem como lidar com os argumentos que são passados para scripts de ação Python nas diferentes versões.
Scripts de ação python (21.2R1 ou posterior)
A partir do Junos OS Release 21.2R1 e junos OS Evolved Release 21.2R1, quando o dispositivo passa os nomes dos argumentos de entrada para o script de ação Python, ele prefixa um único hífen (-) para nomes de argumentos de um único personagem e prefixa dois hífens (--) para nomes de argumentos de vários caracteres. Isso permite que você use bibliotecas padrão de análise de linha de comando para lidar com os argumentos.
Para o exemplo anterior do RPC YANG, a lista de argumentos de entrada do script de sys.argv ação é:
['/var/db/scripts/action/rpc-host-status.py', '--hostip', '198.51.100.1', '--level', 'detail', '--test', 'test', '--rpc_name', 'get-host-status']
O código Python da amostra a seguir usa a argparse biblioteca para lidar com os argumentos. Nesse caso, o parser também deve explicar o rpc_name argumento de que o sistema passa para o script.
#!/usr/bin/python3
import argparse
parser = argparse.ArgumentParser(description='This is a demo script.')
parser.add_argument('--hostip', required=True)
parser.add_argument('--level', required=False, default='brief')
parser.add_argument('--test', required=False)
parser.add_argument('--rpc_name', required=True)
args = parser.parse_args()
# access argument values by using args.hostip, args.level, and args.test
Scripts de ação python (21.1 e anteriores)
No Junos OS Release 21.1 e anterior, o dispositivo passa os nomes dos argumentos de entrada para o script de ação Python exatamente como são dados no comando ou RPC. Você pode acessar os argumentos de entrada por meio da sys.argv lista.
Para o exemplo anterior do RPC YANG, a lista de argumentos de entrada do script de sys.argv ação é:
['/var/db/scripts/action/rpc-host-status.py', 'hostip', '198.51.100.1', 'level', 'detail', 'test', 'test', 'rpc_name', 'get-host-status']
A amostra a seguir do código Python demonstra uma maneira de extrair o valor de cada argumento da sys.arv lista para o exemplo de RPC. O exemplo primeiro define um dicionário contendo os possíveis nomes de argumentos como chaves e um valor padrão para cada argumento. Em seguida, o código verifica cada chave da sys.argv lista e recupera o índice do nome do argumento na lista, se estiver presente. O código então extrai o valor do argumento na posição de índice adjacente e o armazena no dicionário para obter a chave apropriada. Esse método garante que, se os argumentos forem passados para o script em uma ordem diferente durante a execução, o valor correto será recuperado para um determinado argumento.
import sys
# Define default values for arguments
args = {'hostip': None, 'level': 'brief', 'test': None}
# Retrieve user input and store the values in the args dictionary
for arg in args.keys():
if arg in sys.argv:
index = sys.argv.index(arg)
args[arg] = sys.argv[index+1]
Recuperação de dados operacionais e de configuração
Os scripts de ação podem recuperar dados operacionais e de configuração de um dispositivo que executa o Junos OS e, em seguida, analisar os dados para obter as informações necessárias. Os scripts de ação SLAX podem recuperar informações do dispositivo executando RPCs com o suporte do protocolo de gerenciamento Junos XML e da API Junos XML. Os scripts de ação python podem recuperar informações operacionais e de configuração usando APIs Junos PyEZ ou usando os cli -c 'command' comandos de CLI para executar no script de ação como você faria a partir da shell. Para recuperar informações operacionais com o cli -c método, inclua o comando operacional desejado. Para recuperar informações de configuração, use o show configuration comando.
O trecho SLAX a seguir executa o show interfaces comando no dispositivo local usando a tag de solicitação equivalente <get-interface-information> :
var $rpc = <get-interface-information>; var $out = jcs:invoke($rpc); /* parse for relevant information and return as XML tree for RPC output */
O código Python a seguir usa o Junos PyEZ para executar o get_interface_information RPC, que é equivalente ao show interfaces comando CLI:
#!/usr/bin/python3
from jnpr.junos import Device
from lxml import etree
with Device() as dev:
res = dev.rpc.get_interface_information()
# parse for relevant information and return as XML tree for RPC output
Para obter informações sobre como usar o Junos PyEZ para executar RPCs em dispositivos que executam o Junos OS, consulte o Uso do Junos PyEZ para executar RPCs em dispositivos que executam o Junos OS.
O código Python a seguir executa o show interfaces | display xml comando e converte a saída de string em uma árvore XML que pode ser analisada para os dados necessários usando construções XPath:
#!/usr/bin/python3 import subprocess from lxml import etree cmd = ['cli', '-c', 'show interfaces | display xml'] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) tmp = proc.stdout.read() root = etree.fromstring(tmp.strip()) # parse for relevant information and return as XML tree for RPC output
Emitindo a saída RPC XML
Um RPC pode definir elementos de saída usando a declaração opcional output . O script de ação deve definir e emitir quaisquer elementos XML necessários para a saída RPC. A hierarquia XML emitida pelo script deve refletir a árvore definida pelos contêineres e declarações da folha na definição da declaração RPC output . Para devolver a saída XML, o script de ação deve emitir a hierarquia de saída de RPC e apenas a hierarquia de saída. Os scripts SLAX devem usar a copy-of declaração para emitir o XML, e os scripts Python podem usar print declarações.
Por exemplo, considere a seguinte declaração de RPC output YANG:
output {
container host-status-information {
container host-status-info {
leaf host {
type string;
description "Host IP";
}
leaf status {
type string;
description "Host status";
}
leaf date {
type string;
description "Date and time";
}
}
}
}
O script de ação deve gerar e emitir a saída XML correspondente, por exemplo:
<host-status-information>
<host-status-info>
<host>198.51.100.1</host>
<status>Active</status>
<date>2016-10-10</date>
</host-status-info>
<host-status-info>
<host>198.51.100.2</host>
<status>Inactive</status>
<date>2016-10-10</date>
</host-status-info>
</host-status-information>
Após recuperar os valores dos elementos de saída necessários, um script Python pode emitir a hierarquia de saída XML usando o seguinte código:
from lxml import etree
...
xml = '''
<host-status-information>
<host-status-info>
<host>{0}</host>
<status>{1}</status>
<date>{2}</date>
</host-status-info>
</host-status-information>
'''.format(hostip, pingstatus, now)
tree = etree.fromstring(xml)
print (etree.tostring(tree))
Da mesma forma, um script de ação SLAX pode usar o seguinte:
var $node = {
<host-status-information> {
<host-status-info> {
<host> $ip;
<status> $pingstatus;
<date> $date;
}
}
}
copy-of $node;
Scripts de ação de validação e carregamento em um dispositivo
Em sua definição de RPC YANG, você especifica o script de ação do RPC, incluindo as junos:command declarações e junos:action-execute o junos:script subestadual, que leva o nome de arquivo do script de ação como seu valor. Você deve definir um único script de ação para cada RPC. Por exemplo:
rpc rpc-name {
...
junos:command "show sw-info" {
junos:action-execute {
junos:script "sw-info.py";
}
}
...
}
A partir do Junos OS Release 17.3, a action-execute declaração é um eufemismo para command. Em versões anteriores, as declarações e command declarações action-execute são colocadas no mesmo nível, e a command declaração é opcional.
Os módulos YANG que definem RPCs para dispositivos que executam o Junos OS devem importar o módulo de extensões DDL Junos OS.
Os scripts de ação python devem atender aos seguintes requisitos antes que você possa executar os scripts em dispositivos que executam o Junos OS.
-
O proprietário do arquivo é uma raiz ou um usuário na aula de login do Junos OS
super-user. -
Apenas o proprietário do arquivo tem permissão de gravação para o arquivo.
-
O script inclui uma linha de diretiva de intérprete, conforme descrito em Action Script Boilerplate.
-
A
language pythondeclaração oulanguage python3declaração está configurada no nível de[edit system scripts]hierarquia para permitir a execução de scripts Python não assinados.
A partir do Junos OS Release 20.2R1 e do Junos OS Evolved Release 22.3R1, o dispositivo usa Python 3 para executar scripts de ação e tradução YANG. Em versões anteriores, o Junos OS só usa Python 2.7 para executar esses scripts, e o Junos OS Evolved usa Python 2.7 por padrão para executar os scripts.
Os usuários só podem executar scripts Python não assinados em dispositivos que executam o Junos OS quando as permissões de arquivo do script incluem permissão de leitura para a primeira classe em que o usuário se enquadra, na ordem do usuário, grupo ou outros.
Você pode validar a sintaxe de um script de ação na CLI emitindo o request system yang validate action-script comando e fornecendo o caminho para o script. Por exemplo:
user@host> request system yang validate action-script /var/tmp/sw-info.py Scripts syntax validation : START Scripts syntax validation : SUCCESS
Para usar um script de ação, você deve carregá-lo no dispositivo com o módulo YANG que contém o RPC correspondente. Você usa os request system yang add ou request system yang update comandos para adicionar módulos YANG e seus scripts de ação associados a um pacote YANG novo ou existente no dispositivo. Depois de adicionar os módulos e scripts de ação ao dispositivo, você pode executar seus RPCs personalizados. Quando você executa um RPC, o dispositivo invoca o script mencionado.
Scripts de ação de resolução de problemas
Por padrão, scripts de ação registram mensagens de rastreamento informativas quando o script é executado. Você pode visualizar as mensagens de rastreamento para verificar se o RPC invocou o script e que o script foi executado corretamente. Se o script falhar por algum motivo, os erros serão registrados no arquivo de rastreamento.
Junos OS
Para ver o script de ação rastrear mensagens nos dispositivos Junos OS em execução, veja o conteúdo do arquivo action.log trace.
user@host> show log action.log
Junos OS Evolved
Para ver o script de ação rastrear mensagens em dispositivos Junos OS Evolved, veja as mensagens de rastreamento de aplicativos cscript, que incluem dados de rastreamento para todos os tipos de script.
user@host> show trace application cscript
empty ao executar o comando do RPC no Junos OS CLI, e o valor passado para o script de ação é o nome do parâmetro.
action-execute declaração é um eufemismo para
command.