NX-SDK Python-toepassing ontwikkelen, debuggen en implementeren in Nexus 3000/9000-Switches

 switch(config)# run bash 
 bash-4.2$ vi /isan/bin/nxsdk-app.py 

Opmerking: De beste manier is om Python-bestanden te maken in de directory /isan/bin/. Python-bestanden hebben uitvoeringsrechten nodig om te kunnen worden uitgevoerd - plaats Python-bestanden niet in de bootflash / bootflash-directory of een van de subdirectory's.

Opmerking: Het is niet vereist om Python-bestanden te maken en te bewerken via NX-OS. De ontwikkelaar kan de toepassing maken met behulp van hun lokale omgeving en de voltooide bestanden overbrengen naar het apparaat met behulp van een protocol voor bestandsoverdracht van hun keuze. Het kan echter efficiënter zijn voor de ontwikkelaar om hun script te debuggen en problemen op te lossen met behulp van NX-OS-hulpprogramma's.

Implementeren van NX-SDK-onderdelen

1. NX-SDK moet in de toepassing worden geïmporteerd via de instructie import nx_sdk_py.
2. Een functie (meestal sdkThread genoemd) die de NX-SDK-toepassing start en verschillende opties met betrekking tot de toepassing wijzigt.
3. Het maken van aangepaste CLI-opdrachten en het definiëren van aangepaste CLI-opdrachtsyntaxis binnen de functie sdkThread.
4. Een klasse met de naam pyCmdHandler met een methode met de naam postCliCb, die aangepaste CLI-opdrachten verwerkt die door de NX-SDK-toepassing zijn toegevoegd.

sdkThread-functie

1. nx_sdk_py.NxSdk.getSdkInst(len(sys.argv), sys.argv) retourneert een SDK-instantieobject of retourneert Geen. Als een SDK-instantieobject wordt geretourneerd, heeft de NX-SDK-toepassing zich met succes geregistreerd bij de NX-OS-infrastructuur. Als Geen wordt geretourneerd, treden er fouten op op het moment van dit registratieproces en wordt er een foutlogboekvermelding weergegeven in de syslog van het apparaat. Deze methode is hier gedocumenteerd.

Opmerking: vanaf NX-SDK v1.5.0 kan een derde Booleaanse parameter worden doorgegeven aan de methode NxSdk.getSdkInst, die Geavanceerde uitzonderingen inschakelt wanneer Waar en Geavanceerde uitzonderingen uitschakelt wanneer Onwaar. Deze methode is hier gedocumenteerd.

1. sdk.startEventLoop(), waarbij sdk het SDK-instantieobject is dat wordt geretourneerd door de methode nx_sdk_py.NxSdk.getSdkInst(). Met deze methode wordt de NX-SDK-toepassing gestart en kan deze communiceren met de NX-OS-infrastructuur. Deze methode is hier gedocumenteerd.
2. nx_sdk_py.NxSdk.__swig_destroy__(sdk) methode, waarbij sdk het SDK-instantieobject is dat is geretourneerd door de methode nx_sdk_py.NxSdk.getSdkInst() eerder uitgelegd. Deze methode die aan het einde van de sdkThread-functie wordt geplaatst, maakt het mogelijk om de NX-SDK-toepassing sierlijk af te sluiten.

Enkele veelgebruikte methoden zijn:

• sdk.getTracer(), waarbij sdk het SDK-instantieobject is dat wordt geretourneerd door de methode nx_sdk_py.NxSdk.getSdkInst(). Deze methode retourneert een NxTrace-object dat kan worden gebruikt om aangepaste syslogs te genereren, evenals loggebeurtenissen en fouten in de gebeurtenisgeschiedenis van de toepassing. Aangepaste syslogs worden weergegeven in de syslog van het apparaat (zichtbaar via de opdracht logboekregistratie tonen) terwijl de gebeurtenissen die zijn aangemeld bij de gebeurtenisgeschiedenis van de toepassing zichtbaar zijn via de opdrachten show <application-name> nxsdk event-history events of show <application-name> nxsdk event-history errors. Deze methode is hier gedocumenteerd. Het NxTrace-object dat met deze methode wordt geretourneerd en de bijbehorende methoden worden hier gedocumenteerd. U kunt bijvoorbeeld de gebeurtenisgeschiedenis van een toepassing met de naam Transceiver_DOM.py bekijken via de show Transceiver_DOM.py nxsdk-gebeurtenisgeschiedenisgebeurtenissen en de opdrachten Transceiver_DOM.py nxsdk-gebeurtenisgeschiedenisfouten weergeven.
• sdk.getCliParser(), waarbij sdk het SDK-instantieobject is dat wordt geretourneerd door de methode nx_sdk_py.NxSdk.getSdkInst(). Deze methode retourneert een NxCliParser-object, dat kan worden gebruikt om de CLI-opdrachten uit te voeren die al bestaan via Python en aangepaste CLI-opdrachten te maken. Deze methode is hier gedocumenteerd. Het NxCliParser-object dat met deze methode wordt geretourneerd en de bijbehorende methoden worden hier gedocumenteerd.
• cliP.execShowCmd("cmd", return_type), waarbij cliP het NxCliParser-object is dat wordt geretourneerd door de methode sdk.getCliParser(), cmd is de opdracht show die u wilt uitvoeren, ingekapseld in aanhalingstekens, en return_type is de gegevensindeling die moet worden uitgevoerd. De gegevensindeling kan R_TEXT, R_JSON of R_XML zijn. Deze methode is hier gedocumenteerd.

Opmerking: De gegevensindelingen R_JSON en R_XML werken alleen als de opdracht uitvoer in die indelingen ondersteunt. In NX-OS kunt u controleren of een opdracht uitvoer in een bepaald gegevensformaat ondersteunt door de uitvoer naar het gevraagde gegevensformaat te leiden. Als de piped-opdracht zinvolle uitvoer retourneert, wordt die gegevensindeling ondersteund. Als u bijvoorbeeld mac address-table dynamic | json in NX-OS uitvoert en JSON-uitvoer retourneert, wordt de R_JSON-gegevensindeling ook ondersteund in NX-SDK.

• cliP.execConfigCmd(cmd_filename), waarbij cliP het NxCliParser-object is dat wordt geretourneerd door de methode sdk.getCliParser() en cmd_filename het absolute bestandspad is naar een bestand dat opdrachten bevat die door lijnen worden gescheiden. Deze methode retourneert een string die het succes van commando uitvoering aangeeft - als "SUCCES" in de string zit, dan worden alle commando's succesvol uitgevoerd. Anders bevat de tekenreeks de uitzondering die beschrijft waarom de opdrachten niet zijn uitgevoerd. Deze methode is hier gedocumenteerd.

Enkele optionele methoden die nuttig kunnen zijn, zijn:

• sdk.setAppDesc('description string'), waarbij sdk het SDK instance object is dat wordt geretourneerd door de nx_sdk_py.NxSdk.getSdkInst() methode. Met deze methode wordt de beschrijving van de NX-SDK-toepassing ingesteld. De beschrijving wordt weergegeven in het contextgevoelige helpmenu van NX-OS dat toegankelijk is via een vraagteken op de CLI. Deze methode is hier gedocumenteerd. Bijvoorbeeld, een toepassing met de naam Transceiver_DOM.py, een toepassingsbeschrijving van Geeft alle interfaces met DOM-compatibele transceivers ingevoegd als volgt weer in de NX-OS contextgevoelige help:

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

• sdk.getAppName(), waarbij sdk het SDK-instantieobject is dat wordt geretourneerd door de methode nx_sdk_py.NxSdk.getSdkinst(). Deze methode retourneert de naam van de Python-toepassing. Deze methode is hier gedocumenteerd.

Aangepaste CLI-opdrachten maken

In een Python-toepassing met behulp van NX-SDK worden aangepaste CLI-opdrachten gemaakt en gedefinieerd binnen de sdkThread-functie. Er zijn twee soorten opdrachten: Toon opdrachten en Config opdrachten.

1. Opdrachten weergeven geven informatie weer over het apparaat, de configuratie of de omgeving.
2. Config-opdrachten wijzigen de configuratie van het apparaat, waardoor wordt gewijzigd hoe het apparaat reageert op het omliggende netwerk.

Met deze twee methoden kunt u respectievelijk de opdracht show en de opdracht config maken:

• cliP.newShowCmd("cmd_name", "syntax"), waarbij cliP het NxCliParser-object is dat wordt geretourneerd door de methode sdk.getCliParser(), cmd_name is een unieke naam voor de opdracht die intern is voor de aangepaste NX-SDK-toepassing, en syntax beschrijft welke trefwoorden en parameters in de opdracht kunnen worden gebruikt. Deze methode retourneert een NxCliCmd-object, dat hier wordt gedocumenteerd. Deze methode is hier gedocumenteerd.

Opmerking: Deze opdracht is een subklasse van cliP.newCliCmd("cmd_type", "cmd_name", "syntax") waarbij cmd_type ofwel CONF_CMD of SHOW_CMD is (afhankelijk van het type opdracht dat wordt geconfigureerd), cmd_name een unieke naam is voor de opdracht die intern is voor de aangepaste NX-SDK-toepassing, en syntaxis beschrijft welke trefwoorden en parameters in de opdracht kunnen worden gebruikt. Daarom is de API-documentatie voor deze opdracht mogelijk nuttiger ter referentie.

• cliP.newConfigCmd("cmd_name", "syntax"), waarbij cliP het NxCliParser-object is dat wordt geretourneerd door de methode sdk.getCliParser(), cmd_name is een unieke naam voor de opdracht die intern is voor de aangepaste NX-SDK-toepassing, en syntax beschrijft welke trefwoorden en parameters in de opdracht kunnen worden gebruikt. Deze methode retourneert een NxCliCmd-object, dat hier wordt gedocumenteerd. Deze methode is hier gedocumenteerd.

Opmerking: Deze opdracht is een subklasse van cliP.newCliCmd("cmd_type", "cmd_name", "syntax") waarbij cmd_type ofwel CONF_CMD of SHOW_CMD is (dit hangt af van het type opdracht dat is geconfigureerd), cmd_name een unieke naam is voor de opdracht die intern is voor de aangepaste NX-SDK-toepassing, en syntax beschrijft welke trefwoorden en parameters in de opdracht kunnen worden gebruikt. Daarom is de API-documentatie voor deze opdracht mogelijk nuttiger ter referentie.

Beide typen opdrachten hebben twee verschillende componenten: Parameters en Trefwoorden:

1. Parameters zijn waarden die worden gebruikt om de resultaten van de opdracht te wijzigen. In de opdracht show ip route 192.168.1.0, is er bijvoorbeeld een route trefwoord gevolgd door een parameter die een IP-adres accepteert, die specificeert dat alleen routes die het opgegeven IP-adres bevatten, moeten worden weergegeven.

2. Trefwoorden veranderen de resultaten van de opdracht alleen door hun aanwezigheid. Bijvoorbeeld, in de opdracht show mac address-table dynamic, is er een dynamisch trefwoord, dat aangeeft dat alleen dynamisch geleerde MAC-adressen moeten worden weergegeven.

Beide componenten worden gedefinieerd in de syntaxis van een NX-SDK-opdracht wanneer deze wordt gemaakt. Methoden voor het NxCliCmd-object bestaan om de specifieke implementatie van beide componenten te wijzigen.

• nx_cmd.updateParam("<parameter>", "help_str", type), waarbij nx_cmd het NxCliCmd-object is dat wordt geretourneerd door de cliP.newShowCmd() of de methoden cliP.newConfigCmd(), <parameter> de naam is van de opdrachtparameter die kan worden gewijzigd, ingesloten door hoekige haakjes (<>), help_str de help-tekenreeks van de aangepaste opdracht instelt en wordt weergegeven in het contextgevoelige Help-menu van NX-OS dat toegankelijk is via een vraagteken op de CLI, en type is het type parameter. Extra optionele parameters voor deze methode zijn hier beschikbaar en gedocumenteerd. Dit zijn geldige typen voor parameters die kunnen worden opgegeven in het argument type:
  
  
  • P_INTEGER - geeft een geheel getal op
  • P_STRING - geeft een willekeurige tekenreeks op
  • P_INTERFACE - geeft elke netwerkinterface op
  • P_IP_ADDR - geeft elk IP-adres op
  • P_MAC_ADDR - geeft elk MAC-adres op
  • P_VRF - geeft elke Virtual Routing and Forwarding (VRF)-instantie op
• nx_cmd.updateKeyword("trefwoord", "help_str", is_key), waarbij nx_cmd het NxCliCmd-object is dat wordt geretourneerd door de cliP.newShowCmd() of de cliP.newConfigCmd()-methoden, trefwoord is de naam van het opdrachttrefwoord dat u wilt wijzigen, help_str stelt de help-string van de aangepaste opdracht in en wordt weergegeven in het contextgevoelige Help-menu van NX-OS dat toegankelijk is via een vraagteken op de CLI, en is_key optionele Booleaanse waarde die standaard wordt ingesteld op Onwaar. Als is_key true is, overschrijft de unieke configuratie die door de opdracht met behulp van dit trefwoord is gemaakt, geen andere unieke configuratie die door de opdracht is gemaakt. Als is_key FALSE is, overschrijft de configuratie die met de opdracht is gemaakt met behulp van dit trefwoord de andere configuratie die met de opdracht is gemaakt. Deze methode is hier gedocumenteerd.

Als u codevoorbeelden van veelgebruikte opdrachtcomponenten wilt bekijken, bekijkt u de sectie Aangepaste CLI-opdrachtvoorbeelden van dit document.

Nadat aangepaste CLI-opdrachten zijn gemaakt, moet een object uit de klasse pyCmdHandler die verderop in dit document wordt beschreven, worden gemaakt en ingesteld als het CLI-callbackhandlerobject voor het NxCliParser-object. Dit wordt als volgt aangetoond:

 cmd_handler = pyCmdHandler() 
 cliP.setCmdHandler(cmd_handler) 

Vervolgens moet het NxCliParser-object worden toegevoegd aan de NX-OS CLI-parserstructuur, zodat aangepaste CLI-opdrachten zichtbaar zijn voor de gebruiker. Dit wordt gedaan met de opdracht cliP.addToParseTree(), waarbij cliP het object NxCliParser is dat wordt geretourneerd door de methode sdk.getCliParser().

sdkThread Functie Voorbeeld

Hier is een voorbeeld van een typische sdkThread-functie met het gebruik van de functies die eerder zijn uitgelegd. Deze functie (onder andere binnen een typische aangepaste NX-SDK Python applicatie) maakt gebruik van globale variabelen, die worden geïnstantieerd bij script uitvoering.

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)

pyCmdHandler, klasse

De klasse pyCmdHandler wordt overgeërfd van de klasse NxCmdHandler in de bibliotheek nx_sdk_py. De methode postCliCb(self, clicmd) die is gedefinieerd in de klasse pyCmdHandler wordt aangeroepen wanneer CLI-opdrachten afkomstig zijn van een NX-SDK-toepassing. De methode postCliCb(self, clicmd) definieert dus hoe de aangepaste CLI-opdrachten die zijn gedefinieerd in de sdkThread-functie zich op het apparaat gedragen.

De functie postCliCb(self, clicmd) retourneert een Booleaanse waarde. Als True wordt geretourneerd, wordt aangenomen dat de opdracht met succes is uitgevoerd. Onwaar moet worden teruggegeven als het commando om welke reden dan ook niet succesvol is uitgevoerd.

De parameter clicmd gebruikt de unieke naam die is gedefinieerd voor de opdracht toen deze werd gemaakt in de sdkThread-functie. Als u bijvoorbeeld een nieuwe opdracht show maakt met een unieke naam show_xcvr_dom, wordt het aanbevolen om naar deze opdracht te verwijzen met dezelfde naam in de functie postCliCb(self, clicmd) nadat u hebt gecontroleerd of de naam van het argument clicmd show_xcvr_dom bevat. Het wordt hier gedemonstreerd:

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

Als een opdracht met parameters wordt gemaakt, moet u die parameters waarschijnlijk op een bepaald moment in de postCliCb (zelf, klikken) functie gebruiken. Dit kan worden gedaan met de methode clicmd.getParamValue("<parameter>"), waarbij <parameter> de naam is van de opdrachtparameter waarvan u de waarde wilt ophalen tussen haakjes (<>). Deze methode is hier gedocumenteerd. De waarde die door deze functie wordt geretourneerd, moet echter worden geconverteerd naar het type dat u nodig hebt. Dit kan worden gedaan met deze methoden:

• nx_sdk_py.void_to_int converteert een waarde naar een geheel getal.
• nx_sdk_py.void_to_string converteert een waarde naar een tekenreekstype.

De functie postCliCb (zelf, klikken) (of eventuele volgende functies) wordt ook gebruikt waar de uitvoer van de opdracht wordt afgedrukt op de console. Dit wordt gedaan met de methode clicmd.printConsole().

Opmerking: Als de toepassing een fout tegenkomt, een niet-afgehandelde uitzondering tegenkomt of anderszins plotseling wordt afgesloten, wordt uitvoer van de functie clicmd.printConsole() helemaal niet weergegeven. Om deze reden is de beste praktijk wanneer u uw Python-toepassing debugt, om debug-berichten te loggen naar de syslog met het gebruik van een NxTrace-object dat wordt geretourneerd door de methode sdk.getTracer(), of om afdrukinstructies te gebruiken en de toepassing uit te voeren via de binaire /isan/bin/python van de Bash-shell.

pyCmdHandler, klasse voorbeeld

De volgende code dient als voorbeeld voor de hierboven beschreven klasse pyCmdHandler. Deze code is afkomstig uit het bestand ip_move.py in de ip-movement NX-SDK-applicatie die hier beschikbaar is. Het doel van deze applicatie is om de beweging van een door de gebruiker gedefinieerd IP-adres over interfaces van een Nexus-apparaat te volgen. Om dit te doen, zoekt de code het MAC-adres van het IP-adres dat is ingevoerd via de parameter <ip> in de ARP-cache van het apparaat en controleert vervolgens in welk VLAN dat MAC-adres zich bevindt met behulp van de MAC-adrestabel van het apparaat. Met deze MAC en VLAN geeft de opdracht Systeemintern l2fm l2dbg macdb-adres <mac> vlan <vlan> een lijst weer van SNMP-interface-indexen waaraan deze combinatie onlangs is gekoppeld. De code gebruikt vervolgens de opdracht show interface snmp-ifindex om recente SNMP interface-indexen te vertalen naar voor mensen leesbare interfacenamen.

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

Aangepaste CLI-opdrachtsyntaxisvoorbeelden

In deze sectie worden enkele voorbeelden getoond van de parameter syntax die wordt gebruikt wanneer u aangepaste CLI-opdrachten maakt met de methoden cliP.newShowCmd() of cliP.newConfigCmd(), waarbij cliP het object NxCliParser is dat wordt geretourneerd door de methode sdk.getCliParser().

Opmerking: Ondersteuning voor syntaxis met openings- en sluitingshoeken ("(" en ")") is geïntroduceerd in NX-SDK v1.5.0, opgenomen in NX-OS Release 7.0(3)I7(3). Er wordt aangenomen dat de gebruiker NX-SDK v1.5.0 gebruikt wanneer ze een van deze gegeven voorbeelden volgen, waaronder syntaxis met gebruik van openings- en sluitingshoeken.

Enkelvoudig trefwoord

Deze show-opdracht neemt één trefwoord mac en voegt een helperstring toe van Toont alle verkeerd geprogrammeerde MAC-adressen op dit apparaat aan het trefwoord.

 nx_cmd = cliP.newShowCmd("show_misprogrammed", "mac") 
 nx_cmd.updateKeyword("mac", "Shows all misprogrammed MAC addresses on this device") 

enkele parameter

Deze show opdracht neemt een enkele parameter <mac>. De insluitende haakjes rond het woord mac betekenen dat dit een parameter is. Een helper string van MAC-adres om te controleren op misprogrammering wordt toegevoegd aan de parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type parameter als MAC-adres te definiëren, waardoor invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen.

 nx_cmd = cliP.newShowCmd("show_misprogrammed_mac", "<mac>") 
 nx_cmd.updateParam("<mac>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR) 

Optioneel trefwoord

Deze show opdracht kan optioneel een enkel trefwoord [mac]. De omsluitende haakjes rond het woord mac betekenen dat dit zoekwoord optioneel is. Een helper string van Toont alle verkeerd geprogrammeerde MAC-adressen op dit apparaat wordt toegevoegd aan het zoekwoord.

 nx_cmd = cliP.newShowCmd(  "show_misprogrammed_mac"  ,   "[mac]"  ) 
 nx_cmd.updateKeyword(  "mac"  ,   "Shows all misprogrammed MAC addresses on this device"  ) 

Optionele parameter

Deze show opdracht kan optioneel een enkele parameter [<mac>] nemen. De omsluitende haakjes rond het woord < mac > geven aan dat deze parameter optioneel is. De insluitende haakjes rond het woord mac betekenen dat dit een parameter is. Een helper string van MAC-adres om te controleren op misprogrammering wordt toegevoegd aan de parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type parameter als MAC-adres te definiëren, waardoor invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen.

 nx_cmd = cliP.newShowCmd("show_misprogrammed_mac", "[<mac>]") 
 nx_cmd.updateParam("<mac>", "MAC address to check for misprogramming", nx_sdk_py.P_MAC_ADDR) 

Enkelvoudig trefwoord en parameter

Deze show opdracht neemt een enkel trefwoord mac onmiddellijk gevolgd door de parameter <mac-adres>. De insluitingshoeken rond het woord mac-adres geven aan dat dit een parameter is. Een helper string van Check MAC-adres voor verkeerde programmering wordt toegevoegd aan het zoekwoord. Een helper string van MAC-adres om te controleren op misprogrammering wordt toegevoegd aan de parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type parameter als MAC-adres te definiëren, waardoor invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen.

 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) 

Meerdere trefwoorden en parameters

Deze show-opdracht kan een van de twee zoekwoorden gebruiken, die beide twee verschillende parameters hebben die erop volgen. Het eerste trefwoord mac heeft een parameter van <mac-adres>, en het tweede trefwoord ip heeft een parameter van <ip-adres>. De insluitingshoeken rond de woorden mac-adres en ip-adres geven aan dat ze parameters zijn. Een helper string van Check MAC-adres voor verkeerde programmering wordt toegevoegd aan het mac-zoekwoord. Een helper string van MAC adres om te controleren op foutieve programmering wordt toegevoegd aan de <mac-address> parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <mac-address> parameter als MAC-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen. Een helper string van Controleer IP-adres voor misprogrammeren wordt toegevoegd aan het IP-trefwoord. Aan de parameter <ip-address> wordt een helperstring van het IP-adres toegevoegd om te controleren of er sprake is van een verkeerde programmering. De parameter nx_sdk_py.P_IP_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <ip-adres> parameter als IP-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen.

 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) 

Meerdere trefwoorden en parameters met optioneel trefwoord

Deze show-opdracht kan een van de twee zoekwoorden gebruiken, die beide twee verschillende parameters hebben die erop volgen. Het eerste trefwoord mac heeft een parameter <mac-adres>, en het tweede trefwoord ip heeft een parameter <ip-adres>. De insluitingshoeken rond de woorden mac-adres en ip-adres geven aan dat ze parameters zijn. Een helper string van Check MAC-adres voor verkeerde programmering wordt toegevoegd aan het mac-zoekwoord. Een helper string van MAC adres om te controleren op foutieve programmering wordt toegevoegd aan de <mac-address> parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <mac-address> parameter als MAC-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen. Een helper string van Controleer IP-adres voor misprogrammeren wordt toegevoegd aan het IP-trefwoord. Aan de parameter <ip-address> wordt een helperstring van het IP-adres toegevoegd om te controleren of er sprake is van een verkeerde programmering. De parameter nx_sdk_py.P_IP_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <ip-adres> parameter als IP-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen. Deze opdracht show kan optioneel een trefwoord [clear] nemen. Aan dit optionele trefwoord wordt een helperstring toegevoegd waarmee adressen worden gewist die zijn gedetecteerd als verkeerd geprogrammeerd.

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

Meerdere trefwoorden en parameters met optionele parameter

Deze show-opdracht kan een van de twee zoekwoorden gebruiken, die beide twee verschillende parameters hebben die erop volgen. Het eerste trefwoord mac heeft een parameter <mac-adres>, en het tweede trefwoord ip heeft een parameter <ip-adres>. De insluitingshoeken rond de woorden mac-adres en ip-adres geven aan dat ze parameters zijn. Een helper string van Check MAC adres voor misprogramming wordt toegevoegd aan het mac sleutelwoord. Een helper string van MAC adres om te controleren op foutieve programmering wordt toegevoegd aan de <mac-address> parameter. De parameter nx_sdk_py.P_MAC_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <mac-address> parameter als MAC-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen. Een helper string van Controleer IP-adres voor misprogrammeren wordt toegevoegd aan het IP-trefwoord. Aan de parameter <ip-address> wordt een helperstring van het IP-adres toegevoegd om te controleren of er sprake is van een verkeerde programmering. De parameter nx_sdk_py.P_IP_ADDR in de methode nx_cmd.updateParam() wordt gebruikt om het type van de <ip-adres> parameter als IP-adres te definiëren, waardoor de invoer van een ander type door de eindgebruiker, zoals een tekenreeks, geheel getal of IP-adres, wordt voorkomen. Deze opdracht show kan optioneel een parameter [<module>] nemen. Een helper string Alleen duidelijke adressen op een gespecificeerde module wordt toegevoegd aan deze optionele parameter.

 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) 

Zodra een NX-SDK Python-applicatie is gemaakt, moet deze vaak worden gedebugd. NX-SDK informeert u in het geval er syntaxisfouten in uw code zijn, maar omdat de Python NX-SDK-bibliotheek SWIG gebruikt om C ++-bibliotheken naar Python-bibliotheken te vertalen, resulteren alle uitzonderingen die op het moment van de uitvoering van de code worden aangetroffen in een kerndump van de toepassing die vergelijkbaar is met deze:

 terminate called after throwing an instance of 'Swig::DirectorMethodException' 
   what(): SWIG director method error. Error detected when calling 'NxCmdHandler.postCliCb' 
 Aborted (core dumped) 

Vanwege de dubbelzinnige aard van dit foutbericht is het de beste manier om Python-toepassingen te debuggen om debug-berichten naar de syslog te loggen met behulp van een NxTrace-object dat wordt geretourneerd door de methode sdk.getTracer(). Dit wordt als volgt aangetoond:

#! /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")

Als het loggen van foutopsporingsberichten naar de syslog geen optie is, is een alternatieve methode om afdrukinstructies te gebruiken en de toepassing uit te voeren via de binaire Bash-shell/isan/bin/python. De uitvoer van deze afdrukinstructies zal echter alleen zichtbaar zijn wanneer deze op deze manier wordt uitgevoerd - het uitvoeren van de toepassing door de VSH-shell levert geen uitvoer op. Een voorbeeld van het gebruik van print statements wordt hier getoond:

#! /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")

Een Python-toepassing implementeren met NX-SDK

Zodra een Python-toepassing volledig is getest in de Bash-shell en klaar is voor implementatie, moet de toepassing via VSH in productie worden geïnstalleerd. Hierdoor kan de toepassing blijven bestaan wanneer het apparaat opnieuw wordt geladen of wanneer de systeemomschakeling plaatsvindt in een scenario met twee supervisors. Als u een toepassing via VSH wilt implementeren, moet u een RPM-pakket maken met behulp van een NX-SDK- en ENXOS SDK-bouwomgeving. Cisco DevNet biedt een Docker-image waarmee eenvoudig RPM-pakketten kunnen worden gemaakt.

Opmerking: Raadpleeg de documentatie bij de installatie van Docker voor hulp bij de installatie van Docker op uw specifieke besturingssysteem.

Op een host die geschikt is voor Docker, kunt u de afbeeldingsversie van uw keuze kiezen met de opdracht docker pull dockercisco/nxsdk:<tag>, waarbij <tag> de tag is van de afbeeldingsversie van uw keuze. U kunt de beschikbare afbeeldingsversies en de bijbehorende tags hier bekijken. Dit wordt aangetoond met de v1 tag:

 docker pull dockercisco/nxsdk:v1 

Start een container met de naam nxsdk vanuit deze afbeelding en bevestig deze. Als de tag van uw keuze anders is, vervangt u v1 voor uw tag:

 docker run -it --name nxsdk dockercisco/nxsdk:v1 /bin/bash 

Update naar de nieuwste versie van NX-SDK en navigeer naar de NX-SDK-directory en haal vervolgens de nieuwste bestanden uit git:

 cd /NX-SDK/ 
 git pull 

Als u een oudere versie van NX-SDK moet gebruiken, kunt u de NX-SDK-tak klonen met het gebruik van de respectievelijke versietag met de git-kloon -b<versie> https://github.com/CiscoDevNet/NX-SDK.git opdracht, waarbij <versie> de versie van NX-SDK is die u nodig hebt. Dit wordt hier aangetoond met NX-SDK v1.0.0:

 cd / 
 rm -rf /NX-SDK 
 git clone -b v1.0.0 https://github.com/CiscoDevNet/NX-SDK.git 

Breng vervolgens uw Python-toepassing over naar de Docker-container. Er zijn een paar verschillende manieren om dit te doen.

• Sluit de Docker-container af (die de container stopt en vereist dat u deze opnieuw start), breng de Python-toepassing over naar de Docker-host en gebruik vervolgens de opdracht docker cp om de toepassing van de host naar de container te kopiëren. Dit wordt hier aangetoond, in de veronderstelling dat de Python-toepassing is overgedragen naar de Docker-host op /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 

• Kopieer de inhoud van de Python-toepassing naar uw systeemklembord en plak de inhoud vervolgens in een bestand dat is gemaakt in de Docker-container met behulp van vim.

Gebruik vervolgens het script rpm_gen.py in NX/SDK/scripts/ om een RPM-pakket te maken van de Python-toepassing. Dit script heeft één vereiste argumentatie en twee vereiste switches:

• De bestandsnaam van de Python applicatie. Een Python-toepassing in een bestand met de naam python_app.py zou bijvoorbeeld resulteren in een argument van python_app.py. Deze bestandsnaam zal later worden gebruikt als de naam van de toepassing voor NX-SDK en zal ook worden gebruikt door NX-OS om te verwijzen naar opdrachten die door deze toepassing zijn gemaakt.

Opmerking: De bestandsnaam hoeft geen bestandsextensies te bevatten, zoals .py. In dit voorbeeld, als de bestandsnaam python_app was in plaats van python_app.py, zou het RPM-pakket zonder probleem worden gegenereerd.

• De -s switch neemt een argument voor het absolute bestandspad dat leidt naar waar de bovengenoemde bestandsnaam zich bevindt. Als python_app.py bijvoorbeeld zich in /root/ bevindt, dan is het juiste argument -s /root/.
• De -u-switch geeft aan dat de bestandsnaam van de bron hetzelfde is als de uitvoerbare bestandsnaam.

Het gebruik van het rpm_gen.py script wordt hier getoond.

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

Het bestandspad naar het RPM-pakket wordt aangegeven in de laatste regel van de scriptuitvoer rpm_gen.py. Dit bestand moet van de Docker-container naar de host worden gekopieerd, zodat het kan worden overgedragen naar het Nexus-apparaat waarop u de toepassing wilt uitvoeren. Nadat u de Docker-container hebt afgesloten, kunt u dit eenvoudig doen met de opdracht docker cp <container>:<container_filepath> <host_filepath>. Hierbij is <container> de naam van de NX-SDK-docker-container (in dit geval nxsdk), <container_filepath> het volledige bestandspad van het RPM-pakket in de container (in dit geval NX-SDK/rpm/RPMS/test_python_app-1.0-1.0.0.0.x864.rpm) en <host_filepath> het volledige bestandspad op onze Docker-host waar het RPM-pakket naartoe moet worden overgebracht (in dit geval /root/). Dit commando wordt hier getoond:

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

Breng dit RPM-pakket over naar het Nexus-apparaat met behulp van uw voorkeursmethode voor bestandsoverdracht. Zodra het RPM-pakket op het apparaat is geïnstalleerd, moet het op dezelfde manier worden geïnstalleerd en geactiveerd als een SMU. Dit wordt als volgt aangetoond, in de veronderstelling dat het RPM-pakket is overgedragen naar de bootflash van het apparaat.

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

Opmerking: wanneer u het RPM-pakket installeert met de opdracht install add, moet u het opslagapparaat en de exacte bestandsnaam van het pakket opnemen. Wanneer u het RPM-pakket activeert na de installatie, moet u het opslagapparaat en de bestandsnaam niet opnemen - gebruik de naam van het pakket zelf. U kunt de naam van het pakket verifiëren met de opdracht Inactief installeren weergeven.

Zodra het RPM-pakket is geactiveerd, kunt u de toepassing starten met NX-SDK met de opdracht nxsdk service <application-name> configuratie, waarbij <application-name> de naam is van de Python-bestandsnaam (en vervolgens de toepassing) die is gedefinieerd toen het script rpm_gen.py eerder werd gebruikt. Dit wordt als volgt aangetoond:

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

U kunt controleren of de toepassing actief is en is gestart met de opdracht show nxsdk internal service:

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

U kunt ook controleren of aangepaste CLI-opdrachten die door deze toepassing zijn gemaakt, toegankelijk zijn in NX-OS:

N9K-C93180LC-EX# show test?
  test_python_app    Nexus Sdk Application

Gerelateerde informatie

• NX-SDK GitHub
• Cisco Nexus 9000 Series NX-OS Programmability Guide, versie 7.x
• Cisco Nexus 3000 Series NX-OS Programmability Guide, versie 7.x
• Cisco Nexus 3500 Series NX-OS Programmability Guide, versie 7.x
• Netwerkprogrammeerbaarheid en automatisering met Cisco Nexus 9000 Series Switches Whitepaper
• Programmeerbaarheid en automatisering met Cisco Open NX-OS (PDF)
• Technische ondersteuning en documentatie – Cisco Systems