Desarrolle, ponga a punto y despliegue la aplicación NX-SDK Python en el nexo 3000/9000 Switches

 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.

Ejecute los componentes NX-SDK

1. NX-SDK se debe importar en la aplicación vía la declaración nx_sdk_py de la importación.
2. Una función (sdkThread típicamente Nombrado) esa comienza la aplicación NX-SDK y modifica las diversas opciones relacionadas con la aplicación.
3. La creación de los comandos CLI de encargo así como la definición del sintaxis de encargo del comando CLI dentro del sdkThread funcionan.
4. Una clase nombrada pyCmdHandler con un método nombró el postCliCb, que procesa los comandos CLI de encargo agregados por la aplicación NX-SDK.

función del sdkThread

1. nx_sdk_py.NxSdk.getSdkInst (len(sys.argv), sys.argv) vuelve un objeto del caso SDK, o no vuelve ninguno. Si se vuelve un objeto del caso SDK, después la aplicación NX-SDK se ha registrado con éxito con la infraestructura NX-OS. Si no se vuelve ninguno, después los errores ocurren a la hora de este proceso de inscripción, y una entrada de registro de error aparece en el Syslog del dispositivo. Este método se documenta aquí.

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í.

1. método sdk.startEventLoop (), donde los sdkis el objeto del caso SDK volvieron por el método nx_sdk_py.NxSdk.getSdkInst (). Este método comienza la aplicación NX-SDK y permite que obre recíprocamente con la infraestructura NX-OS. Este método se documenta aquí.
2. método del __swig_destroy__(sdk) nx_sdk_py.NxSdk., donde está el objeto el sdk del caso SDK vuelto por el método nx_sdk_py.NxSdk.getSdkInst () explicado previamente. Este método puesto en el extremo de los functionallows del sdkThread para la salida agraciada de la aplicación NX-SDK.

Algunos métodos de uso general incluyen:

• sdk.getTracer (), donde los sdkis el objeto del caso SDK volvieron por el método nx_sdk_py.NxSdk.getSdkInst (). Este método vuelve un objeto de NxTrace que se pueda utilizar para generar los Syslog de encargo, así como los eventos y los errores del registro al historial de eventos de la aplicación. Los Syslog de encargo aparecerán en el Syslog del dispositivo (visible vía el comando del fichero de diario del registro de la demostración) mientras que los eventos registrados al historial de eventos de la aplicación son visibles vía los eventos del historial de eventos del nxsdk del <application-name> de la demostración o mostrarán los comandos de los errores del historial de eventos del nxsdk del <application-name>. Este método se documenta aquí. El NxTrace objectreturned con este método y sus métodos asociados se documentan aquí. Por ejemplo, la visión youcan el historial de eventos de una aplicación nombró los eventos del nxsdkevent-historial de la demostración Transceiver_DOM.py del throughthe Transceiver_DOM.py y los comandos de los errores del historial de eventos del nxsdk de la demostración Transceiver_DOM.py.
• sdk.getCliParser (), donde los sdkis el objeto del caso SDK volvieron por el método nx_sdk_py.NxSdk.getSdkInst (). Este método vuelve un objeto de NxCliParser, que se puede utilizar para ejecutar los comandos CLI que existen vía Python así como crean ya los comandos CLI de encargo. Este método se documenta aquí. El NxCliParserobject vuelto con este método y sus métodos asociados se documentan aquí.
• cliP.execShowCmd (“cmd”, return_type), donde están el comando show los cliPis el objeto de NxCliParser vuelto por el método sdk.getCliParser (), cmd que usted desea ejecutar encapsulado en las comillas, y return_type es el formato de datos que se hará salir. El formato de datos puede ser R_TEXT, R_JSON, o R_XML. Este método se documenta aquí.

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.

• cliP.execConfigCmd(cmd_filename), donde los cliPis el objeto de NxCliParser volvieron por el método sdk.getCliParser (), y cmd_filenameis que el filepath absoluto a un fichero que contiene los comandos se separó por las líneas. Este método vuelve una cadena que indique el éxito de la ejecución del comando - si el “ÉXITO” está en la cadena, después los comandos all consiguen con éxito ejecutados. Si no, la cadena contiene la excepción que describe porqué los comandos no pudieron ejecutar. Este método se documenta aquí.

Algunos métodos opcionales que pueden ser útiles son:

• sdk.setAppDesc (“cadena de la descripción "), donde los sdkis el objeto del caso SDK volvieron por el método nx_sdk_py.NxSdk.getSdkInst (). Este método fija la descripción de la aplicación NX-SDK. La descripción se visualiza en el menú de ayuda sensible al contexto NX-OS alcanzado vía un signo de interrogación en el CLI. Este método se documenta aquí. Por ejemplo, el anapplication nombró Transceiver_DOM.py, una descripción de la aplicación de las devoluciones que todos los interfaces con los transmisores-receptores DOM-capaces insertados aparece en la ayuda sensible al contexto NX-OS como sigue:

 N9K-C93180LC-EX# show Tra? 
  track                  Tracking information 
  Transceiver_DOM.py     Returns all interfaces with DOM-capable transceivers inserted 

• sdk.getAppName (), donde los sdkis el objeto del caso SDK volvieron por el método nx_sdk_py.NxSdk.getSdkinst (). Este método vuelve el nombre de la aplicación de Python. Este método se documenta aquí.

Cree los comandos CLI de encargo

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.

1. Mostrar información de los comandos show sobre el dispositivo, su configuración, o su entorno.
2. Los comandos config cambian la configuración de dispositivo, que se modifica cómo el dispositivo reacciona a la red circundante.

Estos dos métodos permiten la creación de los comandos show y de los comandos config respectivamente:

• cliP.newShowCmd (“cmd_name”, “sintaxis”), donde los cliPis el objeto de NxCliParser volvieron por un nombre único para el comando internal a la aplicación de la aduana NX-SDK, y los syntaxdescribes sdk.getCliParser () el método, los cmd_nameis qué palabras claves y parámetros se pueden utilizar en el comando. Este método vuelve un objeto de NxCliCmd, que se documenta aquí. Este método se documenta aquí.

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.

• cliP.newConfigCmd (“cmd_name”, “sintaxis”), donde los cliPis el objeto de NxCliParser volvieron por un nombre único para el comando internal a la aplicación de la aduana NX-SDK, y los syntaxdescribes sdk.getCliParser () el método, los cmd_nameis qué palabras claves y parámetros se pueden utilizar en el comando. Este método vuelve un objeto de NxCliCmd, que se documenta aquí. Este método se documenta aquí.

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.

• nx_cmd.updateParam (“<parameter>”, “help_str”, tipo), donde está el objeto el nx_cmd de NxCliCmd vuelto por el cliP.newShowCmd () o los métodos cliP.newConfigCmd (), <parameter> es el nombre del comando parameter que puede ser modificado incluido por las paréntesis angulares (<>), los help_strsets la ayuda-cadena del comando custom y se visualiza en el menú de ayuda sensible al contexto NX-OS alcanzado vía un signo de interrogación en el CLI, y el tipo es el tipo del parámetro. Los parámetros optativos adicionales para este método son disponibles y documentados aquí. Tipos válidos de Theseare para los parámetros que se pueden especificar en el argumento de tipo:
  
  
  • P_INTEGER - especifica cualquier número entero
  • P_STRING - especifica cualquier cadena
  • P_INTERFACE - especifica cualquier interfaz de red
  • P_IP_ADDR - especifica cualquier dirección IP
  • P_MAC_ADDR - especifica cualquier dirección MAC
  • P_VRF - especifica cualquier caso del ruteo virtual y de la expedición (VRF)
• nx_cmd.updateKeyword (“palabra clave”, “help_str”, is_key), donde está el objeto el nx_cmd de NxCliCmd vuelto por el cliP.newShowCmd () o los métodos cliP.newConfigCmd (), palabra clave es el nombre de la palabra clave del comando que usted desea modificar, de los help_strsets la ayuda-cadena del comando custom y se visualiza en el menú de ayuda sensible al contexto NX-OS alcanzado vía un signo de interrogación en el CLI, y el valor booleano opcional isan del is_key que omite falso. Si el isTrue del is_key, entonces configuración única creada por el comando con el uso de esta palabra clave no sobregraba la otra configuración única que es creada por el comando. Si el isFalse del is_key, entonces configuración creada por el comando con el uso de esta palabra clave sobregraba la otra configuración creada por el comando. Este método se documenta aquí.

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)

clase del pyCmdHandler

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:

• nx_sdk_py.void_to_int convierte un valor a un tipo del número entero.
• nx_sdk_py.void_to_string convierte un valor a un tipo string.

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

Ejemplos de sintaxis de encargo del comando CLI

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.

Sola palabra clave

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") 

Único parámetro

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) 

Palabra clave optativa

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"  ) 

Parámetro optativo

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) 

Solos palabra clave y parámetro

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) 

Palabras claves y parámetros múltiples

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) 

Palabras claves y parámetros múltiples con la palabra clave optativa

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") 

Palabras claves y parámetros múltiples con el parámetro optativo

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")

Despliegue una aplicación de Python con NX-SDK

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.

• Salga el envase del estibador (que para el envase y le requiere comenzarlo una vez más), transfiera la aplicación de Python al host del estibador, después utilice el comando del cp del estibador para copiar la aplicación del host al envase. Esto se demuestra aquí, bajo suposición que la aplicación de Python se ha transferido al host del estibador en /app/python_app.py.

 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 

• Copie el contenido de la aplicación de Python en su tablero del sistema, después pegue el contenido en un fichero creado en el envase del estibador con el uso del vim.

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:

• El nombre de fichero de la aplicación de Python. Por ejemplo, una aplicación de Python en un fichero nombrado python_app.py daría lugar a un argumento de python_app.py. Este nombre de fichero será utilizado más adelante como el nombre de la aplicación para NX-SDK, y también utilizado por NX-OS para referir a los comandos creados por esta aplicación.

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 conmutador s toma un argumento para el filepath absoluto que ése lleva a donde se localiza el nombre de fichero ya mencionado. Por ejemplo, si python_app.py está situado en /root/, después el argumento correcto sería - s /root/.
• - El conmutador u indica que el nombre de archivo de origen es lo mismo que el nombre de fichero ejecutable.

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

Información Relacionada

• NX-SDK GitHub
• Guía de la programabilidad de las 9000 Series NX-OS del nexo de Cisco, versión 7.x
• Guía de la programabilidad de las 3000 Series NX-OS del nexo de Cisco, versión 7.x
• Guía de la programabilidad de las 3500 Series NX-OS del nexo de Cisco, versión 7.x
• Programabilidad y automatización de la red con el Libro Blanco de los 9000 Series Switch del nexo de Cisco
• Programabilidad y automatización con Cisco NX-OS abierto (pdf)
• Soporte técnico y documentación - Cisco Systems