Cisco ha traducido este documento combinando la traducción automática y los recursos humanos a fin de ofrecer a nuestros usuarios en todo el mundo contenido en su propio idioma. Tenga en cuenta que incluso la mejor traducción automática podría no ser tan precisa como la proporcionada por un traductor profesional. Cisco Systems, Inc. no asume ninguna responsabilidad por la precisión de estas traducciones y recomienda remitirse siempre al documento original escrito en inglés (insertar vínculo URL).
No hay requisitos específicos para este documento.
La información que contiene este documento se basa en las siguientes versiones de software y hardware.
switch(config)# feature nxsdk
switch(config)# feature bash-shell
switch(config)# run bash
bash-4.2$ vi /isan/bin/nxsdk-app.py
Note: La mejor práctica es crear los ficheros de Python en el directorio de /isan/bin/. Los permisos de la ejecución de la necesidad de los ficheros de Python para ejecutarse - no coloque los ficheros de Python en el directorio de /bootflash o ninguno de sus sub-directórios.
Note: No se requiere crear y corregir los ficheros de Python con NX-OS. El desarrollador puede crear la aplicación usando su entorno local y transferir los ficheros completados al dispositivo usando un File Transfer Protocol de su opción. Sin embargo, puede ser que sea más eficiente para que el desarrollador ponga a punto y resuelva problemas su script usando las utilidades NX-OS.
función del sdkThread
Note: A partir de NX-SDK v1.5.0, un tercer parámetro boleano se puede pasar en el método NxSdk.getSdkInst, que los permisos avanzaron las excepciones cuando es verdad y las neutralizaciones avanzó las excepciones cuando es falso. Este método se documenta aquí.
Algunos métodos de uso general incluyen:
Note: Los formatos de datos R_JSON y R_XML trabajan solamente si el comando utiliza la salida en esos formatos. En NX-OS, usted puede verificar si un comando utilice la salida en un formato de datos determinado transmitiendo la salida al formato de datos pedido. Si el comando transmitido vuelve la salida significativa, después se utiliza ese formato de datos. Por ejemplo, si usted funciona con la direccionamiento-tabla del mac de la demostración dinámica | el json en NX-OS vuelve la salida JSON, después el formato de datos R_JSON se utiliza en NX-SDK también.
Algunos métodos opcionales que pueden ser útiles son:
N9K-C93180LC-EX# show Tra?
track Tracking information
Transceiver_DOM.py Returns all interfaces with DOM-capable transceivers inserted
En una aplicación de Python con el uso de NX-SDK, crean y se definen a los comandos CLI de encargo dentro de la función del sdkThread. Hay dos tipos de comandos: Comandos show, y comandos config.
Estos dos métodos permiten la creación de los comandos show y de los comandos config respectivamente:
Note: Este comando es subclase de cliP.newCliCmd (“cmd_type”, “cmd_name”, el “sintaxis”) donde está CONF_CMD o SHOW_CMD el cmd_type (dependiendo del tipo de comando que es configurado), el cmd_name es un nombre único para el comando internal a la aplicación de la aduana NX-SDK, y syntaxdescribes qué palabras claves y parámetros se pueden utilizar en el comando. Debido a esto, el APIDOCUMENTATION para este comando pudo ser más útil para la referencia.
Note: Este comando es subclase de cliP.newCliCmd (“cmd_type”, “cmd_name”, el “sintaxis”) donde está CONF_CMD o SHOW_CMD el cmd_type (depende del tipo de comando se configure que), el cmd_name es un nombre único para el comando internal a la aplicación de la aduana NX-SDK, y syntaxdescribes qué palabras claves y parámetros se pueden utilizar en el comando. Debido a esto, el APIDOCUMENTATION para este comando pudo ser más útil para la referencia.
Ambos tipos de comandos tienen dos diversos componentes: Parámetros y palabras claves:
1. Los parámetros son valores usados para cambiar los resultados del comando. Por ejemplo, en el comando show ip route 192.168.1.0, hay una palabra clave de la ruta seguida por un parámetro que valide una dirección IP, que especifica que solamente las rutas que incluyen la dirección IP proporcionada deben ser mostradas.
2. Las palabras claves cambian los resultados del comando con su presencia solamente. Por ejemplo, en la direccionamiento-tabla del comando show mac dinámica, hay una palabra clave dinámica, que especifica que solamente las direcciones MAC dinámico-doctas deben ser visualizadas.
Ambos componentes se definen en el sintaxis de un comando NX-SDK cuando se crea. Los métodos para el objeto de NxCliCmd existen para modificar la puesta en práctica específica ambos los componentes.
Para ver los ejemplos de código de los componentes del comando de uso frecuente, vea la sección de encargo de los ejemplos del comando CLI de este documento.
Después de que hayan creado a los comandos CLI de encargo, un objeto de la clase del pyCmdHandler descrita más adelante en este documento necesita ser creado y ser fijado como el objeto del programa piloto de la devolución de llamada de CLI para el objeto de NxCliParser. Se demuestra esto como sigue:
cmd_handler = pyCmdHandler()
cliP.setCmdHandler(cmd_handler)
Entonces, el objeto de NxCliParser necesita ser agregado al árbol del analizador de sintaxis NX-OS CLI de modo que los comandos CLI de encargo sean visibles al usuario. Esto se hace con el comando cliP.addToParseTree (), adonde los cliPis el objeto de NxCliParser volvieron por el método sdk.getCliParser ().
ejemplo de la función del sdkThread
Aquí está un ejemplo de una función típica del sdkThread con el uso de las funciones explicadas previamente. Esta función (entre otros dentro de una aplicación típica de la aduana NX-SDK Python) utiliza las variables globales, que se ejemplifican en la ejecución del script.
cliP = "" sdk = "" event_hdlr = "" tmsg = "" def sdkThread(): global cliP, sdk, event_hdlr, tmsg sdk = nx_sdk_py.NxSdk.getSdkInst(len(sys.argv), sys.argv) if not sdk: return sdk.setAppDesc("Returns all interfaces with DOM-capable transceivers inserted") tmsg = sdk.getTracer() tmsg.event("[{}] Started service".format(sdk.getAppName())) cliP = sdk.getCliParser() nxcmd = cliP.newShowCmd("show_port_bw_util_cmd", "port bw utilization [<port>]") nxcmd.updateKeyword("port", "Port Information") nxcmd.updateKeyword("bw", "Port Bandwidth Information") nxcmd.updateKeyword("utilization", "Port BW utilization in (%)") nxcmd.updateParam("<port>", "Optional Filter Port Ex) Ethernet1/1", nx_sdk_py.P_INTERFACE) nxcmd1 = cliP.newConfigCmd("port_bw_threshold_cmd", "port bw threshold <threshold>") nxcmd1.updateKeyword("threshold", "Port BW Threshold in (%)") int_attr = nx_sdk_py.cli_param_type_integer_attr() int_attr.min_val = 1; int_attr.max_val = 100; nxcmd1.updateParam("<threshold>", "Threshold Limit. Default 50%", nx_sdk_py.P_INTEGER, int_attr, len(int_attr)) mycmd = pyCmdHandler() cliP.setCmdHandler(mycmd) cliP.addToParseTree() sdk.startEventLoop() # If sdk.stopEventLoop() is called or application is removed from VSH... tmsg.event("Service Quitting...!") nx_sdk_py.NxSdk.__swig_destroy__(sdk)
La clase del pyCmdHandler se hereda de la clase de NxCmdHandler dentro de la biblioteca nx_sdk_py. El método del postCliCb (uno mismo, clicmd) definido dentro de la clase del pyCmdHandler se llama siempre que los comandos CLI que originan de una aplicación NX-SDK. Así, el método del postCliCb (uno mismo, clicmd) es donde usted define cómo los comandos CLI de encargo definidos dentro de la función del sdkThread se comportan en el dispositivo.
La función del postCliCb (uno mismo, clicmd) vuelve un valor booleano. Si es verdad se vuelve, después se supone que el comando se ha ejecutado con éxito. Falso debe ser vuelto si el comando no ejecutó con éxito por cualquier motivo.
El parámetro del clicmd utiliza el nombre único que fue definido para el comando cuando fue creado en la función del sdkThread. Por ejemplo, si usted crea un nuevo comando show con un nombre único del show_xcvr_dom, después es recomendado para referir a este comando por el mismo nombre en la función del postCliCb (uno mismo, clicmd) después de que usted haya controlado para ver si el nombre del argumento del clicmd contiene el show_xcvr_dom. Se demuestra aquí:
def sdkThread(): <snip> sh_xcvr_dom = cliP.newShowCmd("show_xcvr_dom", "dom") sh_xcvr_dom.updateKeyword("dom", "Show all interfaces with transceivers that are DOM-capable") </snip> class pyCmdHandler(nx_sdk_py.NxCmdHandler): def postCliCb(self, clicmd): if "show_xcvr_dom" in clicmd.getCmdName(): get_dom_capable_interfaces()
Si se crea un comando que utiliza los parámetros, después usted necesitará muy probablemente utilizar esos parámetros en algún momento de la función del postCliCb (uno mismo, clicmd). Esto se puede hacer con el clicmd.getParamValue (“método del <parameter>"), donde está el nombre el <parameter> del comando parameter que usted desea conseguir el valor de incluido por las paréntesis angulares (<>). Este método se documenta aquí. Sin embargo, el valor devuelto por esta función necesita ser convertido al tipo que usted necesita. Esto se puede hacer con estos métodos:
La función del postCliCb (uno mismo, clicmd) (o cualquier funciones subsiguientes) también será típicamente donde imprimen a la salida del comando show a la consola. Esto se hace con el método clicmd.printConsole ().
Note: Si la aplicación encuentra un error, una excepción no administrada, o de otra manera repentinamente las salidas, después la salida de la función clicmd.printConsole () no será visualizada en absoluto. Por este motivo, la mejor práctica cuando usted pone a punto su aplicación de Python está a cualquier mensajes de la depuración del registro al Syslog con el uso de un objeto de NxTrace vuelto por el método sdk.getTracer (), o a las declaraciones de la impresión del uso y ejecuta la aplicación vía el binario de /isan/bin/python del shell del golpe.
ejemplo de la clase del pyCmdHandler
El código siguiente sirve como primer medio para la clase del pyCmdHandler descrita arriba. Este código se toma del fichero ip_move.py en la aplicación del IP-movimiento NX-SDK disponible aquí. El propósito de esta aplicación es seguir el movimiento de una dirección IP definida por el usario a través de los interfaces de un dispositivo del nexo. Para hacer esto, el código encuentra la dirección MAC de la dirección IP entrada con el parámetro del <ip> dentro del caché ARP del dispositivo, después verifica qué VLA N que la dirección MAC reside al usar la tabla de la dirección MAC del dispositivo. Usando este MAC y VLA N, el comando vlan del <vlan> l2fm l2dbg de la demostración del macdb del sistema del <mac> interno del direccionamiento visualiza una lista de índices de interfaz de SNMP a los cuales esta combinación se ha asociado recientemente. El código entonces utiliza el comando SNMP-ifindex del interfaz de la demostración de traducir los índices de interfaz de SNMP recientes a los nombres humano-legibles del interfaz.
class pyCmdHandler(nx_sdk_py.NxCmdHandler): def postCliCb(self, clicmd): global cli_parser if "show_ip_movement" in clicmd.getCmdName(): target_ip = nx_sdk_py.void_to_string(clicmd.getParamValue("<ip>")) target_mac = get_mac_from_arp(cli_parser, clicmd, target_ip) mac_vlan = "" if target_mac: mac_vlan = get_vlan_from_cam(cli_parser, clicmd, target_mac) if mac_vlan: find_mac_movement(cli_parser, clicmd, target_mac, mac_vlan) else: print("No entires in MAC address table") clicmd.printConsole("No entries in MAC address table for {}".format(target_mac)) else: clicmd.printConsole("No entries in ARP table for {}".format(target_ip)) return True def get_mac_from_arp(cli_parser, clicmd, target_ip): exec_cmd = "show ip arp {}".format(target_ip) arp_cmd = cli_parser.execShowCmd(exec_cmd, nx_sdk_py.R_JSON) if arp_cmd: try: arp_json = json.loads(arp_cmd) except ValueError as exc: return None count = int(arp_json["TABLE_vrf"]["ROW_vrf"]["cnt-total"]) if count: intf = arp_json["TABLE_vrf"]["ROW_vrf"]["TABLE_adj"]["ROW_adj"] if intf.get("ip-addr-out") == target_ip: target_mac = intf["mac"] clicmd.printConsole("{} is currently present in ARP table, MAC address {}\n".format(target_ip, target_mac)) return target_mac else: return None else: return None else: return None def get_vlan_from_cam(cli_parser, clicmd, target_mac): exec_cmd = "show mac address-table address {}".format(target_mac) mac_cmd = cli_parser.execShowCmd(exec_cmd, nx_sdk_py.R_JSON) if mac_cmd: try: cam_json = json.loads(mac_cmd) except ValueError as exc: return None mac_entry = cam_json["TABLE_mac_address"]["ROW_mac_address"] if mac_entry: if mac_entry["disp_mac_addr"] == target_mac: egress_intf = mac_entry["disp_port"] mac_vlan = mac_entry["disp_vlan"] clicmd.printConsole("{} is currently present in MAC address table on interface {}, VLAN {}\n".format(target_mac, egress_intf, mac_vlan)) return mac_vlan else: return None else: return None else: return None def find_mac_movement(cli_parser, clicmd, target_mac, mac_vlan): exec_cmd = "show system internal l2fm l2dbg macdb address {} vlan {}".format(target_mac, mac_vlan) l2fm_cmd = cli_parser.execShowCmd(exec_cmd) if l2fm_cmd: event_re = re.compile(r"^\s+(\w{3}) (\w{3}) (\d+) (\d{2}):(\d{2}):(\d{2}) (\d{4}) (0x\S{8}) (\d+)\s+(\S+) (\d+)\s+(\d+)\s+(\d+)") unique_interfaces = [] l2fm_events = l2fm_cmd.splitlines() for line in l2fm_events: res = re.search(event_re, line) if res: day_name = res.group(1) month = res.group(2) day = res.group(3) hour = res.group(4) minute = res.group(5) second = res.group(6) year = res.group(7) if_index = res.group(8) db = res.group(9) event = res.group(10) src=res.group(11) slot = res.group(12) fe = res.group(13) if "MAC_NOTIF_AM_MOVE" in event: timestamp = "{} {} {} {}:{}:{} {}".format(day_name, month, day, hour, minute, second, year) intf_dict = {"if_index": if_index, "timestamp": timestamp} unique_interfaces.append(intf_dict) if not unique_interfaces: clicmd.printConsole("No entries for {} in L2FM L2DBG\n".format(target_mac)) if len(unique_interfaces) == 1: clicmd.printConsole("{} has not been moving between interfaces\n".format(target_mac)) if len(unique_interfaces) > 1: clicmd.printConsole("{} has been moving between the following interfaces, from most recent to least recent:\n".format(target_mac)) unique_interfaces = get_snmp_intf_index(unique_interfaces) clicmd.printConsole("\t{} - {} (Current interface)\n".format(unique_interfaces[-1]["timestamp"], unique_interfaces[-1]["intf_name"])) for intf in unique_interfaces[-2::-1]: clicmd.printConsole("\t{} - {}\n".format(intf["timestamp"], intf["intf_name"]))
def get_snmp_intf_index(if_index_dict_list): global cli_parser snmp_ifindex = cli_parser.execShowCmd("show interface snmp-ifindex", nx_sdk_py.R_JSON) snmp_ifindex_json = json.loads(snmp_ifindex) snmp_ifindex_list = snmp_ifindex_json["TABLE_interface"]["ROW_interface"] for index_dict in if_index_dict_list: index = index_dict["if_index"] for ifindex_json in snmp_ifindex_list: if index == ifindex_json["snmp-ifindex"]: index_dict["intf_name"] = ifindex_json["interface"] return if_index_dict_list
Esta sección muestra algunos ejemplos del parámetro del sintaxis usado cuando usted crea los comandos CLI de encargo con el cliP.newShowCmd () o los métodos cliP.newConfigCmd (), donde está el objeto el clip de NxCliParser vuelto por el método sdk.getCliParser ().
Note: La ayuda para el sintaxis con la apertura y paréntesis cerrados (“(” y ")”) se introduce en NX-SDK v1.5.0, incluido en la versión NX-OS 7.0(3)I7(3). Se asume que el usuario utiliza NX-SDK v1.5.0 cuando él sigue ninguno de estos ejemplos dados que incluyan el sintaxis que utiliza la apertura y paréntesis cerrados.
Este comando show toma un solo mac de la palabra clave y agrega una cadena de demostraciones toda del ayudante las direcciones MAC misprogrammed en este dispositivo a la palabra clave.
nx_cmd = cliP.newShowCmd("show_misprogrammed", "mac")
nx_cmd.updateKeyword("mac", "Shows all misprogrammed MAC addresses on this device")
Este comando show toma un <mac> del único parámetro. Las paréntesis angulares de cerco alrededor del mac de la palabra significan que esto es un parámetro. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP.
nx_cmd = cliP.newShowCmd("show_misprogrammed_mac", "<mac>")
nx_cmd.updateParam("<mac>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
Este comando show puede tomar opcionalmente un solo [mac] de la palabra clave. Los corchetes de cerco alrededor del mac de la palabra significan que esta palabra clave es opcional. Una cadena de demostraciones toda del ayudante las direcciones MAC misprogrammed en este dispositivo se agrega a la palabra clave.
nx_cmd = cliP.newShowCmd( "show_misprogrammed_mac" , "[mac]" )
nx_cmd.updateKeyword( "mac" , "Shows all misprogrammed MAC addresses on this device" )
Este comando show puede tomar opcionalmente un [<mac>] del único parámetro. Los corchetes de cerco alrededor de la palabra < mac > significan que este parámetro es opcional. Las paréntesis angulares de cerco alrededor del mac de la palabra significan que esto es un parámetro. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP.
nx_cmd = cliP.newShowCmd("show_misprogrammed_mac", "[<mac>]")
nx_cmd.updateParam("<mac>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
Este comando show toma un solo mac de la palabra clave seguido inmediatamente por el parámetro < MAC address >. Las paréntesis angulares de cerco alrededor del MAC address de la palabra significan que esto es un parámetro. Una cadena del ayudante de la dirección MAC del control para el error de programación se agrega a la palabra clave. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP.
nx_cmd = cliP.newShowCmd("show_misprogrammed", "mac <mac-address>")
nx_cmd.updateKeyword("mac", "Check MAC address for misprogramming")
nx_cmd.updateParam("<mac-address>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
Este comando show puede tomar una de dos palabras claves, que tienen dos diversos parámetros que los siguen. El primer mac de la palabra clave tiene un parámetro del < MAC address >, y el segundo IP de la palabra clave tiene un parámetro de <ip address>. Las paréntesis angulares de cerco alrededor de las palabras MAC address e IP address significan que son parámetros. Una cadena del ayudante de la dirección MAC del control para el error de programación se agrega a la palabra clave del mac. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro del < MAC address >. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro del < MAC address > como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP. Una cadena del ayudante de la dirección IP del control para misprograming se agrega a la palabra clave IP. Una cadena del ayudante de la dirección IP a controlar para saber si hay error de programación se agrega <ip address> al parámetro. . El parámetro nx_sdk_py P_IP_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo <ip address> del parámetro como dirección IP, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP.
nx_cmd = cliP.newShowCmd("show_misprogrammed", "(mac <mac-address> | ip <ip-address>)")
nx_cmd.updateKeyword("mac", "Check MAC address for misprogramming")
nx_cmd.updateParam("<mac-address>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
nx_cmd.updateKeyword("ip", "Check IP address for misprogramming")
nx_cmd.updateParam("<ip-address>", "IP address to check for misprogramming", nx_sdk_py.P_IP_ADDR)
Este comando show puede tomar una de dos palabras claves, que tienen dos diversos parámetros que los siguen. El primer mac de la palabra clave tiene un parámetro del < MAC address >, y el segundo IP de la palabra clave tiene un parámetro de <ip address>. Las paréntesis angulares de cerco alrededor de las palabras MAC address e IP address significan que son parámetros. Una cadena del ayudante de la dirección MAC del control para el error de programación se agrega a la palabra clave del mac. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro del < MAC address >. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro del < MAC address > como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP. Una cadena del ayudante de la dirección IP del control para misprograming se agrega a la palabra clave IP. Una cadena del ayudante de la dirección IP a controlar para saber si hay error de programación se agrega <ip address> al parámetro. . El parámetro nx_sdk_py P_IP_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo <ip address> del parámetro como dirección IP, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP. Este comando show pudo tomar opcionalmente un [clear] de la palabra clave. Un ayudante que la cadena borra los direccionamientos detectados para misprogrammed se agrega a esta palabra clave optativa.
nx_cmd = cliP.newShowCmd("show_misprogrammed", "(mac <mac-address> | ip <ip-address>) [clear]")
nx_cmd.updateKeyword("mac", "Check MAC address for misprogramming")
nx_cmd.updateParam("<mac-address>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
nx_cmd.updateKeyword("ip", "Check IP address for misprogramming")
nx_cmd.updateParam("<ip-address>", "IP address to check for misprogramming", nx_sdk_py.P_IP_ADDR)
nx_cmd.updateKeyword("clear", "Clears addresses detected to be misprogrammed")
Este comando show puede tomar una de dos palabras claves, que tienen dos diversos parámetros que los siguen. El primer mac de la palabra clave tiene un parámetro del < MAC address >, y el segundo IP de la palabra clave tiene un parámetro de <ip address>. Las paréntesis angulares de cerco alrededor de las palabras MAC address e IP address significan que son parámetros. Una cadena del ayudante de la dirección MAC del control para los misprogrammingis agregados a la palabra clave del mac. Una cadena del ayudante de la dirección MAC a controlar para saber si hay error de programación se agrega al parámetro del < MAC address >. . El parámetro nx_sdk_py P_MAC_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo del parámetro del < MAC address > como dirección MAC, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP. Una cadena del ayudante de la dirección IP del control para misprograming se agrega a la palabra clave IP. Una cadena del ayudante de la dirección IP a controlar para saber si hay error de programación se agrega <ip address> al parámetro. . El parámetro nx_sdk_py P_IP_ADDR en el método nx_cmd.updateParam () se utiliza para definir el tipo <ip address> del parámetro como dirección IP, que previene la entrada del usuario final de otro tipo, tal como una cadena, un número entero, o una dirección IP. Este comando show pudo tomar opcionalmente un [<module>] del parámetro. Los direccionamientos claros de una cadena del ayudante solamente en el módulo especificado se agregan a este parámetro optativo.
nx_cmd = cliP.newShowCmd("show_misprogrammed", "(mac <mac-address> | ip <ip-address>) [<module>]")
nx_cmd.updateKeyword("mac", "Check MAC address for misprogramming")
nx_cmd.updateParam("<mac-address>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR)
nx_cmd.updateKeyword("ip", "Check IP address for misprogramming")
nx_cmd.updateParam("<ip-address>", "IP address to check for misprogramming", nx_sdk_py.P_IP_ADDR)
nx_cmd.updateParam("<module>", "Clears addresses detected to be misprogrammed", nx_sdk_py.P_INTEGER)
Una vez que se ha creado una aplicación NX-SDK Python, necesitará a menudo ser puesta a punto. NX-SDK le informa en caso de que haya cualquier error de sintaxis en su código, pero porque la biblioteca de Python NX-SDK utiliza el TRAGO para traducir las bibliotecas del C++ a las bibliotecas de Python, cualquier excepciones encontradas a la hora del resultado de la ejecución de códigos en un vaciado de memoria de la aplicación similar a esto:
terminate called after throwing an instance of 'Swig::DirectorMethodException'
what(): SWIG director method error. Error detected when calling 'NxCmdHandler.postCliCb'
Aborted (core dumped)
Debido a la naturaleza ambigua de este mensaje de error, la mejor práctica de poner a punto las aplicaciones de Python es registrar los mensajes de la depuración al Syslog con el uso de un objeto de NxTrace vuelto por el método sdk.getTracer (). Se demuestra esto como sigue:
#! /isan/bin/python tracer = 0 def evt_thread(): <snip> tracer = sdk.getTracer() tracer.event("[NXSDK-APP][INFO] Started service") <snip> class pyCmdHandler(nx_sdk_py.NxCmdHandler): def postCliCb(self, clicmd): global tracer tracer.event("[NXSDK-APP][DEBUG] Received command: {}".format(clicmd)) if "show_test_command" in clicmd.getCmdName(): tracer.event("[NXSDK-APP][DEBUG] `show_test_command` recognized")
Si registra la depuración los mensajes al Syslog no es una opción, un método alternativo es utilizar las declaraciones de la impresión y ejecutar la aplicación vía el binario de /isan/bin/python del shell del golpe. Sin embargo, la salida de estas declaraciones de la impresión será solamente visible cuando está ejecutada de este modo - ejecutar la aplicación a través del shell VSH no produce ninguna salida. Un ejemplo de utilizar las declaraciones de la impresión se muestra aquí:
#! /isan/bin/python tracer = 0 def evt_thread(): <snip> print("[NXSDK-APP][INFO] Started service") <snip> class pyCmdHandler(nx_sdk_py.NxCmdHandler): def postCliCb(self, clicmd): print("[NXSDK-APP][DEBUG] Received command: {}".format(clicmd)) if "show_test_command" in clicmd.getCmdName(): print("[NXSDK-APP][DEBUG] `show_test_command` recognized")
Una vez que una aplicación de Python se ha probado completamente en el shell del golpe y está lista para el despliegue, la aplicación se debe instalar en la producción con VSH. Esto permite que la aplicación persista cuando las recargas del dispositivo o cuando el intercambio del sistema ocurre en un decorado del Supervisor dual. Para desplegar una aplicación con VSH, usted necesita crear un paquete RPM con el uso entorno de una estructura NX-SDK y ENXOS SDK. Cisco DevNet proporciona a una imagen del estibador que permita la creación fácil del paquete RPM.
Note: Para la ayuda para instalar al estibador en su sistema operativo específico, refiera a la documentación sobre instalación del estibador.
En un host Estibador-capaz, tire de la versión de imagen de su opción con la extracción dockercisco/nxsdk del estibador: comando del <tag>, donde está la etiqueta el <tag> de la versión de imagen de su opción. Usted puede ver las versiones de imagen disponibles y sus etiquetas correspondientes aquí. Esto se demuestra con la etiqueta v1 aquí:
docker pull dockercisco/nxsdk:v1
Encienda un envase nombrado nxsdk de esta imagen y asocíe a ella. Si la etiqueta de su opción es diferente, substituya v1 para su etiqueta:
docker run -it --name nxsdk dockercisco/nxsdk:v1 /bin/bash
La actualización a la última versión de NX-SDK y navega al directorio NX-SDK, después tira de los últimos ficheros del git:
cd /NX-SDK/
git pull
Si usted necesita utilizar una versión anterior de NX-SDK, usted puede reproducir la bifurcación NX-SDK con el uso de la etiqueta de la versión respectiva con el clon del git - comando de https://github.com/CiscoDevNet/NX-SDK.git del v<version> b, donde <version> está la versión de NX-SDK usted necesita. Esto se demuestra aquí con NX-SDK v1.0.0:
cd /
rm -rf /NX-SDK
git clone -b v1.0.0 https://github.com/CiscoDevNet/NX-SDK.git
Después, transfiera su aplicación de Python al envase del estibador. Hay algunas maneras diferentes de hacer esto.
root@2dcbe841742a:~# exit
[root@localhost ~]# docker cp /app/python_app.py nxsdk:/root/
[root@localhost ~]# docker start nxsdk
nxsdk
[root@localhost ~]# docker attach nxsdk
root@2dcbe841742a:/# ls /root/
python_app.py
Después, utilice el script rpm_gen.py situado en /NX-SDK/scripts/ para crear un paquete RPM de la aplicación de Python. Este script tiene un argumento obligatorio, y dos requirieron el Switches:
Note: El nombre de fichero no necesita contener ninguna extensiones de archivo, tales como .py. En este ejemplo, si el nombre de fichero fuera python_app en vez de python_app.py, el paquete RPM sería generado sin un problema.
El uso del script rpm_gen.py se demuestra aquí.
root@7bfd1714dd2f:~# python /NX-SDK/scripts/rpm_gen.py test_python_app -s /root/ -u #################################################################################################### Generating rpm package... <snip> RPM package has been built #################################################################################################### SPEC file: /NX-SDK/rpm/SPECS/test_python_app.spec RPM file : /NX-SDK/rpm/RPMS/test_python_app-1.0-1.0.0.x86_64.rpm
El filepath al paquete RPM se indica en la línea final de la salida del script rpm_gen.py. Este fichero se debe copiar apagado del envase del estibador sobre el host para poder transferir al dispositivo del nexo que usted desea ejecutar la aplicación encendido. Después de que usted salga el envase del estibador, puede ser hecho fácilmente con el <container> del dockercp: el comando del <host_filepath> del <container_filepath>, donde está el nombre el <container> del envase del estibador NX-SDK (en este caso, nxsdk), <container_filepath> es el filepath completo del paquete RPM dentro del envase (en este caso, /NX-SDK/rpm/RPMS/test_python_app-1.0-1.0.0.x86_64.rpm), y el <host_filepath> es el filepath completo en nuestro host del estibador al donde está ser transferida el paquete RPM (en este caso, /root/). Este comando se demuestra aquí:
root@7bfd1714dd2f:/# exit [root@localhost ~]# docker cp nxsdk:/NX-SDK/rpm/RPMS/test_python_app-1.0-1.0.0.x86_64.rpm /root/ [root@localhost ~]# ls /root/ anaconda-ks.cfg test_python_app-1.0-1.0.0.x86_64.rpm
Transfiera este paquete RPM al dispositivo del nexo con el uso de su método preferido de transferencia de archivos. Una vez que el paquete RPM está en el dispositivo, debe ser instalado y ser activado semejantemente a un SMU. Esto se demuestra como sigue, bajo suposición que el paquete RPM fue transferido al bootflash del dispositivo.
N9K-C93180LC-EX# install add bootflash:test_python_app-1.0-1.0.0.x86_64.rpm [####################] 100% Install operation 27 completed successfully at Tue May 8 06:40:13 2018 N9K-C93180LC-EX# install activate test_python_app-1.0-1.0.0.x86_64 [####################] 100% Install operation 28 completed successfully at Tue May 8 06:40:20 2018
Note: Cuando usted instala el paquete RPM con el comando add del instalar, incluya el dispositivo de almacenamiento y el nombre de fichero exacto del paquete. Cuando usted activa el paquete RPM después de la instalación, no incluya el dispositivo de almacenamiento y el nombre de fichero - utilice el nombre del paquete sí mismo. Usted puede verificar que el nombre del paquete con la demostración instale el comando inactivo.
Una vez que se activa el paquete RPM, usted puede comenzar la aplicación con NX-SDK con el comando configuration del <application-name> del servicio del nxsdk, donde está el nombre el <application-name> del nombre de fichero de Python (y, posteriormente, de la aplicación) que fue definido cuando el script rpm_gen.py fue utilizado anterior. Se demuestra esto como sigue:
N9K-C93180LC-EX# conf Enter configuration commands, one per line. End with CNTL/Z. N9K-C93180LC-EX(config)# nxsdk service-name test_python_app % This could take some time. "show nxsdk internal service" to check if your App is Started & Runnning
Usted puede verificar que la aplicación sea ascendente y haya comenzado a ejecutarse con el comando service interno del nxsdk de la demostración:
N9K-C93180LC-EX# show nxsdk internal service NXSDK Started/Temp unavailabe/Max services : 1/0/32 NXSDK Default App Path : /isan/bin/nxsdk NXSDK Supported Versions : 1.0 Service-name Base App Started(PID) Version RPM Package ------------------------- --------------- ----------------- ---------- ------------------------ test_python_app nxsdk_app4 VSH(23195) 1.0 test_python_app-1.0-1.0.0.x86_64
Usted puede también verificar que los comandos CLI de encargo creados por esta aplicación sean accesibles en NX-OS:
N9K-C93180LC-EX# show test? test_python_app Nexus Sdk Application