Como usar RPCs e comandos de modo operacional em scripts de eventos
A maioria dos comandos de modo operacional Junos OS tem equivalentes XML. Os scripts de eventos podem executar esses comandos XML em um dispositivo local ou remoto usando o protocolo de chamada de procedimento remoto (RPC). Todos os comandos de modo operacional que têm equivalentes XML estão listados na Referência de Desenvolvedor Operacional de API Junos XML.
Os scripts SLAX e XSLT executam RPCs em um dispositivo local ou remoto usando as jcs:invoke() funções ou jcs:execute() extensão, respectivamente. Nos scripts Python, os RPCs são fáceis de executar usando APIs Junos PyEZ . Cada instância da classe Junos PyEZ Device tem uma rpc propriedade que permite que você execute qualquer RPC disponível através da API Junos XML. Após estabelecer uma sessão com um dispositivo local ou remoto, você pode executar o RPC anexando o nome do rpc método de propriedade e RPC à instância do dispositivo. O valor de devolução é um objeto XML a partir do primeiro elemento sob a <rpc-reply> tag.
O uso de RPCs e comandos de modo operacional em scripts de caso seja discutido com mais detalhes nas seguintes seções:
Execução de RPCs em um dispositivo local
Em um script de eventos SLAX ou XSLT, para executar um RPC no dispositivo local, incluir o RPC em uma declaração variável e chamar a jcs:invoke() função de extensão com a variável RPC como argumento. O trecho a seguir invoca um RPC no dispositivo local:
Sintaxe XSLT
<xsl:variable name="rpc"> <get-interface-information/> # Junos RPC for the show interfaces command </xsl:variable> <xsl:variable name="out" select="jcs:invoke($rpc)"/> ...
Sintaxe SLAX
var $rpc = <get-interface-information>; var $out = jcs:invoke($rpc);
Em um script de evento Python, para executar um RPC no dispositivo local, criar a Device instância usando uma lista de argumentos vazia e apensar a rpc propriedade e a lista de nomes e argumentos do método RPC para a instância do dispositivo.
Sintaxe Python
from jnpr.junos import Device
with Device() as jdev:
rsp = jdev.rpc.get_interface_information()
Quando você cria a Device instância usando uma lista de argumentos vazia para se conectar ao dispositivo local, o Junos OS usa os privilégios de acesso do usuário configurado no nível de [edit event-options event-script file filename python-script-user] hierarquia. Se a python-script-user declaração for omitida, o Junos OS usará os privilégios de acesso do usuário e grupo nobodygenéricos e desprivilegiados.
Execução de RPCs em um dispositivo remoto
Em um script de evento SLAX ou XSLT, para executar um RPC em um dispositivo remoto, primeiro inclua o RPC em uma declaração variável e crie uma alça de conexão usando a jcs:open() função de extensão com os argumentos necessários para se conectar ao dispositivo remoto. Em seguida, chame a jcs:execute() função de extensão e inclua a alça de conexão e a variável RPC como argumentos. Por exemplo:
Sintaxe XSLT
<xsl:variable name="rpc">
<get-interface-information/>
</xsl:variable>
<xsl:variable name="connection"
select="jcs:open('198.51.100.1', 'bsmith', 'test123')"/>
<xsl:variable name="out" select="jcs:execute($connection, $rpc)"/>
<xsl:value-of select="jcs:close($connection)"/>
...
Sintaxe SLAX
var $rpc = <get-interface-information>;
var $connection = jcs:open("198.51.100.1", "bsmith","test123");
var $out = jcs:execute($connection, $rpc);
expr jcs:close($connection);
...
Em um script de evento Python, para executar um RPC em um dispositivo remoto, crie primeiro uma instância de uso dos Device argumentos necessários para se conectar ao dispositivo remoto. Em seguida, execute o RPC anexando a rpc propriedade e a lista de nomes e argumentos do método RPC à instância do dispositivo.
Sintaxe Python
from jnpr.junos import Device
with Device(host='198.51.100.1', user='bsmith', passwd='test123') as jdev:
rsp = jdev.rpc.get_interface_information()
O Junos OS se conecta e executa operações no dispositivo remoto usando os privilégios de acesso do usuário especificados na Device() lista de argumentos, mesmo que um usuário diferente esteja configurado para a python-script-user declaração no nível de [edit event-options event-script file filename] hierarquia.
Para evitar adicionar os detalhes de conexão remota diretamente em um script de evento, você pode especificar detalhes de execução remota para cada script de evento que executa RPCs em um dispositivo remoto no nível de [edit event-options event-script file filename remote-execution] hierarquia. Recomendamos adicionar os detalhes de execução remota à configuração em vez de diretamente no script de eventos, porque todas as informações estão disponíveis em um único local, e a senha é criptografada na configuração.
Para cada dispositivo remoto onde um RPC é executado, configure o nome de host do dispositivo e o nome de usuário e senha correspondentes.
[edit event-options event-script file filename] remote-execution { remote-hostname { username username; passphrase passphrase; } }
Os nomes de host remotos e seu nome de usuário e senha correspondentes, além dos detalhes do evento, são passados como entrada para o script do evento quando são executados por uma política de eventos. Para obter mais informações sobre os detalhes encaminhados ao script do evento, consulte detalhes de evento de uso e execução remota em scripts de eventos.
Um script de evento faz referência aos detalhes de execução remota na lista de argumentos da função usada para criar a conexão com o host remoto. Uma vez estabelecida a conexão, o script pode executar RPCs nesse dispositivo.
Nos scripts de eventos Python, você faz referência aos detalhes de execução remota na lista de argumentos da instância Junos PyEZ Device() . O código a seguir itera dos detalhes de execução remota para todos os hosts configurados para esse script de evento e se conecta e executa o mesmo RPC em cada host.
Sintaxe Python
from junos import Junos_Remote_Execution_Details
from jnpr.junos import Device
def main()
for remote in Junos_Remote_Execution_Details():
hostname = remote.host
username = remote.user
passphrase = remote.passwd
with Device(host=hostname, user=username, passwd=passphrase) as jdev:
inv = jdev.rpc.get_interface_information()
#process RPC information...
if __name__ == "__main__":
main()
Em scripts SLAX ou XSLT, crie uma conexão com o host remoto usando a jcs:open() função e faça referência aos detalhes de execução remota na lista de argumentos. Por exemplo:
Sintaxe XSLT
<xsl:variable name="rpc"> <get-interface-information/> </xsl:variable> <xsl:for-each select="event-script-input/remote-execution-details"> <xsl:variable name="d" select="remote-execution-detail"/> <xsl:variable name="connection" select="jcs:open($d/remote-hostname,$d/username,$d/passphrase)"/> <xsl:variable name="out" select="jcs:execute($connection, $rpc)"/> <xsl:value-of select="jcs:close($connection)"/> ... </xsl:for-each>
Sintaxe SLAX
var $rpc = <get-interface-information>;
for-each (event-script-input/remote-execution-details) {
var $d = remote-execution-detail;
var $connection = jcs:open($d/remote-hostname,$d/username,$d/passphrase);
var $out = jcs:execute($connection, $rpc);
expr jcs:close($connection);
...
}
Para executar um RPC em um dispositivo remoto, uma sessão de SSH deve ser estabelecida. Para que o script estabeleça a conexão, você deve configurar as informações-chave do host SSH para o dispositivo remoto no dispositivo local onde o script será executado, ou as informações-chave do host SSH para o dispositivo remoto devem existir no arquivo de hosts conhecido do usuário que executa o script. Para cada dispositivo remoto onde o RPC é executado, configure as informações-chave do host SSH usando um dos seguintes métodos:
Para configurar hosts conhecidos de SSH no dispositivo local, inclua a
hostdeclaração e especifique as opções de nome de host e host para o dispositivo remoto no[edit security ssh-known-hosts]nível de hierarquia da configuração.Para recuperar manualmente as informações chave do host SSH, emita o comando do
set security ssh-known-hosts fetch-from-server hostnamemodo de configuração para instruir o Junos OS a se conectar ao dispositivo remoto e adicionar a chave.user@host# set security ssh-known-hosts fetch-from-server router2 The authenticity of host 'router2 (198.51.100.1)' can't be established. RSA key fingerprint is 30:18:99:7a:3c:ed:40:04:0f:fd:c1:57:7e:6b:f3:90. Are you sure you want to continue connecting (yes/no)? yes Warning: Permanently added 'router2,198.51.100.1' (RSA) to the list of known hosts.
Para importar manualmente as informações-chave do host SSH de um arquivo, use o comando de
set security ssh-known- hosts load-key-file filenamemodo de configuração e especifique o arquivo de hosts conhecidos.user@host# set security ssh-known-hosts load-key-file /var/tmp/known_hosts Import SSH host keys from trusted source /var/tmp/known_hosts ? [yes,no] (no) yes
Como alternativa, o usuário que executa o script pode fazer login no dispositivo local, SSH para o dispositivo remoto e, em seguida, aceitar manualmente a chave do host, que é adicionada ao arquivo de hosts conhecido do usuário. No exemplo a seguir, a raiz está logada no roteador1. Para executar um RPC remoto no roteador2, a raiz adiciona a chave host do roteador2, emitindo o comando do
ssh router2modo operacional e aceitando manualmente a chave.root@router1> ssh router2 The authenticity of host 'router2 (198.51.100.1)' can't be established. RSA key fingerprint is 30:18:99:7a:3c:ed:40:04:0f:fd:c1:57:7e:6b:f3:90. Are you sure you want to continue connecting (yes/no)? yes Warning: Permanently added 'router2,198.51.100.1' (RSA) to the list of known hosts.
Depois de configurar a chave de host SSH necessária e obter uma alça de conexão com o dispositivo remoto, o script de evento pode executar RPCs com a jcs:execute() função de extensão naquele dispositivo remoto.
Exibindo as tags RPC para um comando
Você pode exibir as tags RPC XML para comandos de modo operacional na CLI do dispositivo. Para exibir as etiquetas RPC XML para um comando, entre display xml rpc após o símbolo do pipe (|).
O exemplo a seguir exibe as tags RPC para o show route comando:
user@host> show route | display xml rpc
<rpc-reply xmlns:junos="http://xml.juniper.net/junos/10.1I0/junos">
<rpc>
<get-route-information>
</get-route-information>
</rpc>
<cli>
<banner></banner>
</cli>
</rpc-reply>
Os scripts SLAX e XSLT podem executar RPCs usando as tags RPC XML. Os scripts Python devem converter as tags RPC e as opções de comando em um formato adequado para Python. Para obter mais informações sobre o uso do Junos PyEZ para executar RPCs e sobre o mapeamento das tags RPC ao método Python correspondente e aos argumentos do método, consulte o uso do Junos PyEZ para executar RPCs em dispositivos que executam o Junos OS.
Usando comandos de modo operacional em scripts de eventos
Alguns comandos de modo operacional não têm equivalentes XML. Os scripts SLAX e XSLT podem executar comandos que não têm equivalente XML usando o <command> elemento. Os scripts Python podem executar esses comandos usando o método Junos PyEZ cli() definido na Device classe.
Se um comando não estiver listado no Junos XML API Operational Developer Reference, o comando não tem um equivalente XML. Outra maneira de determinar se um comando tem um equivalente XML é emitir o comando seguido pelo | display xml comando.
user@host> operational-mode-command | display xml
Se a saída incluir apenas elementos de tag como <output>, <cli>e <banner>, o comando pode não ter um equivalente XML. No exemplo a seguir, a saída indica que o show host comando não tem equivalente XML:
user@host> show host hostname | display xml <rpc-reply xmlns:junos="http://xml.juniper.net/junos/10.0R1/junos"> <output> ... </output> <cli> <banner></banner> </cli> </rpc-reply>
Para alguns comandos que têm um equivalente XML, a saída do comando encanado | display xml não inclui elementos de tag que <output>não sejam , <cli>e <banner> apenas porque o recurso relevante não está configurado. Por exemplo, o show services cos statistics forwarding-class comando tem um equivalente XML que devolve a <service-cos-forwarding-class-statistics> saída na tag de resposta, mas se a configuração não incluir nenhuma declaração no nível de [edit class-of-service] hierarquia, então não há dados reais para o show services cos statistics forwarding-class | display xml comando exibir. A saída é semelhante a esta:
user@host> show services cos statistics forwarding-class | display xml <rpc-reply xmlns:junos="http://xml.juniper.net/junos/8.3I0/junos"> <cli> <banner></banner> </cli> </rpc-reply>
Por isso, as informações na referência de desenvolvedor operacional de API Junos XML geralmente são mais confiáveis.
Scripts de eventos SLAX e XSLT podem executar comandos que não têm equivalente XML. Use os <command>elementos <xsl:value-of>e <output> os elementos do script, conforme mostrado no seguinte trecho de código. Este trecho é expandido e totalmente descrito em Exemplo: Exibir informações de nome de host DNS usando um script de operação.
<xsl:variable name="query">
<command>
<xsl:value-of select="concat('show host ', $hostname)"/>
</command>
</xsl:variable>
<xsl:variable name="result" select="jcs:invoke($query)"/>
<xsl:variable name="host" select="$result"/>
<output>
<xsl:value-of select="concat('Name: ', $host)"/>
</output>
...
Os scripts de eventos Python podem executar comandos que não têm equivalente XML usando APIs Junos PyEZ. O cli() método definido na Device classe executa um comando de modo operacional e devolve a saída em formato de texto. Por exemplo:
from jnpr.junos import Device
def main():
with Device() as jdev:
res = jdev.cli('show host hostname', warning=False)
print (res)
if __name__ == "__main__":
main()
Você também pode especificar format='xml' a devolução da saída formatada como elementos Junos OS XML. Para obter mais informações sobre o método Junos PyEZ cli , consulte http://junos-pyez.readthedocs.org/en/latest/_modules/jnpr/junos/device.html#Device.cli .