Querying the ACI object database with moquery

One of the most powerful aspects of ACI is the fact that all information about the state of the network is available in the object database that is stored on the APIC cluster. To access the information contained in this database you can use the GUI, which presents the information visually, or you can use the APIC CLI to present specific information in text format using more traditional NX-OS style commands. However, it is also possible to query the APIC object database directly using the managed object browser (also known as “visore”) and its command line form “moquery”. I found visore and moquery to be valuable tools in the ACI troubleshooting toolkit to supplement the GUI and APIC CLI. Unfortunately, I found the documentation of these tools to be somewhat limited and most of my knowledge about these tools was pieced together from various different sources. To gather some of the facts that I learned about the use of the moquery tool in a single place I decided to write this article.

The Basics

To access the moquery tool, you have to first SSH into the APIC. Originally, this would drop you in a bash shell where the moquery tool is available. Since the 1.2 Brazos release you now enter the NX-OS CLI when you SSH to the APIC. You can still switch to the bash shell by issuing the “bash” command. However, this is not required, because the bash shell commands are also available from the NX-OS CLI.

So first, let’s examine the documentation that is available on the APIC itself:

dcloud_apic1# moquery -h
usage: Command line cousin to visore [-h] [-i HOST] [-p PORT] [-d DN]
[-c KLASS] [-f FILTER] [-a ATTRS]
[-o OUTPUT] [-u USER]
[-x [OPTIONS [OPTIONS ...]]]

optional arguments:
-h, --help show this help message and exit
-i HOST, --host HOST Hostname or ip of apic
-p PORT, --port PORT REST server port
-d DN, --dn DN dn of the mo
-c KLASS, --klass KLASS
comma seperated class names to query
-f FILTER, --filter FILTER
property filter to accept/reject mos
-a ATTRS, --attrs ATTRS
type of attributes to display (config, all)
-o OUTPUT, --output OUTPUT
Display format (block, table, xml, son)
-u USER, --user USER User name
-x [OPTIONS [OPTIONS ...]], --options [OPTIONS [OPTIONS ...]]
Extra options to the query

This provides us with the basic options that can be appended to the command, but does not offer much explanation about the use of these options. The man page offers a bit more, but is still fairly limited:

dcloud_apic1# man moquery
This command is being deprecated on APIC controller, please use NXOS-style equivalent command
man(8)                              moquery                             man(8)

NAME
       moquery -- search for MO

SYNOPSIS
       moquery --help --host hostname --port portname --dn dn --klass classname --filter property --attrs attributes --output output --user username --options options

DESCRIPTION
       Searches for managed objects (MOs) within the management information tree (MIT).

       -h, --help
       Displays usage information.

       -i, --host
       Specifies an APIC host.

       hostname
              The hostname or IP address of an APIC.

       -p, --port
       Specifies a port for a REST interface.

       portname
              The REST interface port number.

       -d, --dn
       Specifies a distinguished name (DN) for a managed object (MO).

       dn
              The DN of an MO.

       -c, --klass
       Specifies a class name for the query.

       classname
              Specifies a class. You can enter multiple classes separated by commas.

       -f, --filter
       Specifies a property on which to filter MOs.

       property
              The property on which to filter MOs.

       -a, --attrs
       Specifies the attributes that the query displays.

       attributes
              The  type of attributes to display. You can choose config or all. If config is selected, only configurable attributes are displayed. Unless the 'table' output for-
              mat is specified, the default is all.

       -o, --output
       Specifies the output format of the query results.

       output
              The query output format. You can choose xml, json, block, or table.

       -u, --user
       Specifies a user name.

       username
              The user name.

       -x, --options
       Specifies query options.

       options
              The query options to enable. You can specify options as supported by the REST API. You can add multiple options statements to the command, using syntax such as the
              following:  -x [OPTIONS [OPTIONS ...]] [-x [OPTIONS [OPTIONS ...]]]. For example:

              moquery -c firmwareCtrlrFwStatusCont -x query-target=subtree target-subtree-class=firmwareCtrlrRunning

EXAMPLE
       The following example shows how to use the moquery command.

       admin@apic1:~> moquery --dn unallocencap-[uni/infra]
       Total Objects shown: 1
       # stp.UnAllocEncapCont
       infraPKey    : uni/infra
       allocSize    : 0
       childAction  :
       descry        :
       dn           : unallocencap-[uni/infra]
       lastAssigned : 8192
       lcOwn        : local
       modTs        : 2014-07-26T16:46:27.176+00:00
       name         :
       ownerKey     :
       ownerTag     :
       rn           : unallocencap-[uni/infra]
       size         : 0
       status       :

AUTHOR
       Cisco Systems Inc.

SEE ALSO
       moconfig, mocreate, modelete, moprint, moset, moshow

1.1                               2015-02-11                            man(8)

The information in this man page is still a bit sparse, for example, we learn that we can apply the “-f” option to apply a filter, but the filter syntax is not explained. In this article I will run through some of these command line options and provide some examples of their use.

So let’s start simple. The moquery tool allows you to either query a specific object by its distinguished name, or get all objects of a particular object class. For example, we can find the list of tenants by querying the fvTenant class:

dcloud_apic1# moquery -c fvTenant
Total Objects shown: 21

# fv.Tenant
name         : test
childAction  : 
descry        :
dn           : uni/tn-test
lcOwn        : local
modTs        : 2015-12-29T00:02:20.064+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-test
status       : 
uid          : 15374

# fv.Tenant
name         : admin
childAction  : 
descry        :
dn           : uni/tn-admin
lcOwn        : local
modTs        : 2015-03-22T02:24:46.044+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-admin
status       : 
uid          : 15374

...further output omitted...

Or we can query a specific tenant by its DN:

dcloud_apic1# moquery -d uni/tn-tlijnse463
Total Objects shown: 1

# fv.Tenant
name         : tlijnse463
childAction  : 
descry        :
dn           : uni/tn-tlijnse463
lcOwn        : local
modTs        : 2016-10-26T22:21:24.407+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-tlijnse463
status       : 
uid          : 15374

By default, the output is displayed as blocks of human readable text, but if you want to further process the output with a script you can also have it presented in XML:

dcloud_apic1# moquery -d uni/tn-tlijnse463 -o xml  
<?xml version="1.0" ?>
<imdata totalCount="1">
  <fvTenant childAction="" descr="" dn="uni/tn-tlijnse463" lcOwn="local" modTs="2016-10-26T22:21:24.407+00:00" monPolDn="uni/tn-common/monepg-default" name="tlijnse463" ownerKey="" ownerTag="" rn="tn-tlijnse463" status="" uid="15374"/>
</imdata>

or you can have the same data presented in JSON:

dcloud_apic1# moquery -d uni/tn-tlijnse463 -o json
{
  "imdata": [
    {
      "fvTenant": {
        "attributes": {
          "dn": "uni/tn-tlijnse463", 
          "lcOwn": "local", 
          "ownerKey": "", 
          "name": "tlijnse463", 
          "descr": "", 
          "status": "", 
          "monPolDn": "uni/tn-common/monepg-default", 
          "modTs": "2016-10-26T22:21:24.407+00:00", 
          "ownerTag": "", 
          "rn": "tn-tlijnse463", 
          "childAction": "", 
          "uid": "15374"
        }
      }
    }
  ], 
  "totalCount": "1"
}

There is another option, “table”, which can be useful when you are querying a class of objects:

dcloud_apic1# moquery -c fabricNode -o table
Total Objects shown: 7

Id   Admin State  Fabric State
---  -----------  ------------
103  on           active      
101  on           active      
102  on           active      
104  on           active      
2    on           unknown     
3    on           unknown     
1    on           unknown     

However, by default the columns displayed in the table present only a subset of the object attributes. The reason for this is that the table output defaults to showing only configurable attributes, whereas the other output formats default to displaying all attributes. If you want all attributes to be displayed even when using table format, you can use the “-a all” option together with “-o table”. Unfortunately it seems like it is not possible to manually select the attributes that you want to be used as columns in the table.

Applying filters to moquery

Now that we have covered the basics of moquery, lets look at some of the more advanced options. The “-f” option allows you to specify a filter. Unfortunately, the filter syntax is not documented anywhere. I gleaned the basics of the use of these filters from examples in some Cisco Live presentations, but I recently stumbled onto this blog post by Joshua Morgan, who dug into the source code to find the filter syntax. Let’s look at some common uses.

To find the endpoint(s) with a specific IP address you can use:

dcloud_apic1# moquery -c fvCEp -f 'fv.CEp.ip=="198.18.1.49"'
Total Objects shown: 2

# fv.CEp
name         : 00:50:56:88:CD:CB
childAction  : 
contName     : 
dn           : uni/tn-tlijnse463/ap-3-tier-app/epg-3-tier-app_web/cep-00:50:56:88:CD:CB
encap        : vlan-1512
id           : 0
idepdn       : 
ip           : 198.18.1.49
lcC          : learned,vmm
lcOwn        : local
mac          : 00:50:56:88:CD:CB
mcastAddr    : not-applicable
modTs        : 2016-10-27T00:09:42.795+00:00
monPolDn     : uni/tn-common/monepg-default
rn           : cep-00:50:56:88:CD:CB
status       : 
uid          : 0
uuid         : 
vmmSrc       : avs

...further output omitted...

From the DN ” uni/tn-tlijnse463/ap-3-tier-app/epg-3-tier-app_web/cep-00:50:56:88:CD:CB” we can glean the tenant, application profile and EPG that this endpoint belongs to. Before the introduction of the APIC NX-OS CLI this was quite useful to confirm that an endpoint was learned and to verify its EPG membership. However, the NX-OS CLI now provides us with the same information:

dcloud_apic1# show endpoint ip 198.18.1.49
Legends:
(P):Primary VLAN
(S):Secondary VLAN

 
Dynamic Endpoints:
Tenant      : tlijnse463
Application : 3-tier-app
AEPg        : 3-tier-app_web

 End Point MAC      IP Address                                Node        Interface                       Encap            Multicast Address 
 -----------------  ----------------------------------------  ----------  ------------------------------  ---------------  ---------------   
 00:50:56:88:CD:CB  198.18.1.49                               102         port-channel vmware_hosts       vlan-1512        not-applicable    

...further output omitted...

Still, the filter syntax gives us more options than are currently available on the command line. For example, if I want to see all endpoints for a particular tenant, I can query for all endpoints that contain that tenant in their DN:

dcloud_apic1# moquery -c fvCEp -f 'fv.CEp.dn*"tn-tlijnse463"' | egrep '^ip|^mac|^dn|^#'
# fv.CEp
dn           : uni/tn-tlijnse463/ap-Infra_net/epg-DNS_DHCP/cep-00:50:56:88:65:A6
ip           : 198.18.1.2
mac          : 00:50:56:88:65:A6
# fv.CEp
dn           : uni/tn-tlijnse463/ap-Demo_net/epg-Users/cep-00:50:56:88:9A:F3
ip           : 198.18.1.48
mac          : 00:50:56:88:9A:F3
# fv.CEp
dn           : uni/tn-tlijnse463/ap-3-tier-app/epg-3-tier-app_app/cep-00:50:56:88:73:D9
ip           : 198.18.1.22
mac          : 00:50:56:88:73:D9
# fv.CEp
dn           : uni/tn-tlijnse463/ap-3-tier-app/epg-3-tier-app_web/cep-00:50:56:88:CD:CB
ip           : 198.18.1.49
mac          : 00:50:56:88:CD:CB
# fv.CEp
dn           : uni/tn-tlijnse463/ap-3-tier-app/epg-3-tier-app_db/cep-00:50:56:88:D3:8B
ip           : 198.18.1.26
mac          : 00:50:56:88:D3:8B

In this example I used the “*” operator to filter endpoints that contain the string “tn-tlijnse463” in their DN. I also applied the linux “egrep” utility to filter the output. Using egrep and regular expressions is outside the scope of this article, but definitely worth digging into if you’re going to be working with moquery a lot.

Some other interesting and/or useful examples:

dcloud_apic1# moquery -c eqptIngrPkts5min -f 'eqpt.IngrPkts5min.unicastRate>"100"' | egrep '^dn|^unicastRate'   
dn               : topology/pod-1/node-101/sys/aggr-[po6]/CDeqptIngrPkts5min
unicastRate      : 3574.533333
dn               : topology/pod-1/node-101/sys/aggr-[po8]/CDeqptIngrPkts5min
unicastRate      : 4266.500000
dn               : topology/pod-1/node-101/sys/aggr-[po9]/CDeqptIngrPkts5min
unicastRate      : 8708.122222
dn               : topology/pod-1/node-101/sys/aggr-[po10]/CDeqptIngrPkts5min
unicastRate      : 375.311111
dn               : topology/pod-1/node-101/sys/aggr-[po11]/CDeqptIngrPkts5min
unicastRate      : 1468.266667
dn               : topology/pod-1/node-102/sys/aggr-[po1]/CDeqptIngrPkts5min
unicastRate      : 27901.703079
dn               : topology/pod-1/node-102/sys/aggr-[po10]/CDeqptIngrPkts5min
unicastRate      : 671.966040
dn               : topology/pod-1/node-102/sys/aggr-[po11]/CDeqptIngrPkts5min
unicastRate      : 339.064684
dn               : topology/pod-1/node-102/sys/phys-[eth1/1]/CDeqptIngrPkts5min
unicastRate      : 197.716303
dn               : topology/pod-1/node-102/sys/phys-[eth1/2]/CDeqptIngrPkts5min
unicastRate      : 207.532730
dn               : topology/pod-1/node-102/sys/phys-[eth1/3]/CDeqptIngrPkts5min
unicastRate      : 169.338463

This query displays all ports that received more than 100 packets per second over the last 5 minutes.

dcloud_apic1# moquery -c fabricLink -f 'fabric.Link.n1=="101"' | egrep '^dn'       
dn           : topology/pod-1/lnkcnt-104/lnk-101-1-50-to-104-1-1
dn           : topology/pod-1/lnkcnt-2/lnk-101-1-2-to-2-2-2
dn           : topology/pod-1/lnkcnt-1/lnk-101-1-1-to-1-2-2
dn           : topology/pod-1/lnkcnt-103/lnk-101-1-49-to-103-1-1
dn           : topology/pod-1/lnkcnt-3/lnk-101-1-3-to-3-2-2

This query displays all fabric links from node 101 to other fabric nodes.

dcloud_apic1# moquery -c aaaModLR -f 'aaa.ModLR.created>"2016-10-27" and aaa.ModLR.user=="tlijnse463"' | egrep '^affected|^changeSet'
affected     : uni/tn-tlijnse463/flt-My_new_test_filter/e-ssh
changeSet    : applyToFrag:no, arpOpc:unspecified, dFromPort:22, dToPort:22, etherT:ip, icmpv4T:unspecified, icmpv6T:unspecified, matchDscp:unspecified, name:ssh, prot:tcp, sFromPort:unspecified, sToPort:unspecified, stateful:no
affected     : uni/tn-tlijnse463/flt-My_new_test_filter
changeSet    : name:My_new_test_filter

This query displays all changes made on October 27th 2016 by user tlijnse463. This example demonstrates how the logical “and” operator can be used to combine multiple filters.

For more examples of the use of moquery and other useful troubleshooting tips, refer to the excellent Cisco Live presentation BRKACI-2102 – ACI Troubleshooting (2016 Las Vegas), which some of the above examples were based on.

Scoping queries

In addition to the “-f” switch that can be used to filter the query, there is another interesting advanced option. The “-x” switch allows you to specify additional query options. This essentially allows you to scope the query and query responses. These options are documented here as part of the APIC REST API User Guide. This means that the options provided with the “-x” switch are not specific to moquery, but are general API options that can be appended to the URI of any API call.

Let’s illustrate some of these options through an example. If you wanted to list the EPGs that belong to a specific application profile, you could start by querying the application profile:

dcloud_apic1# moquery -c fvAp -f 'fv.Ap.name=="3-tier-app"'        
Total Objects shown: 1

# fv.Ap
name         : 3-tier-app
childAction  : 
descr        : 
dn           : uni/tn-tlijnse463/ap-3-tier-app
lcOwn        : local
modTs        : 2016-10-26T23:57:57.807+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
prio         : unspecified
rn           : ap-3-tier-app
status       : 
uid          : 15374

However, this only shows some attributes of the application profile, but not the EPGs. The reason for this is that the EPGs ar child objects of the application profile. So you can add the “rsp-subtree=children” option to extend the response to children of the queried object:

dcloud_apic1# moquery -c fvAp -f 'fv.Ap.name=="3-tier-app"' -x 'rsp-subtree=children' | egrep '^#|name'
# fv.Ap
name         : 3-tier-app
# fv.AEPg
  name           : 3-tier-app_db
# fv.AEPg
  name           : 3-tier-app_web
# fv.AEPg
  name           : 3-tier-app_app

In this particular case, we get exactly what we want, because the only children of this application profile are the EPGs. However, some objects have all kinds of children and we may only be interested in a specific class of child objects. For example, we may want to list all application profiles in a particular tenant using the “rsp-subtree=children” option:

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"' -x "rsp-subtree=children" | egrep '^#|name'
# fv.Tenant
name         : tlijnse463
# fv.Ap
  name         : Infra_net
# vns.SvcCont
# vz.Filter
  name         : Allow_HTTP_and_HTTPS
# vz.Filter
  name         : Allow_MySQL
# fv.BD
  name                   : BridgeDomain_1
# fv.Ap
  name         : Demo_net
# vz.BrCP
  name           : 3-tier-app_Contract_web
# fv.Ctx
  name             : Context_1
# vz.BrCP
  name           : 3-tier-app_Contract_db
# fv.RsTenantMonPol
  tType            : name
# aaa.DomainRef
  name         : SecDo-tlijnse463
# fv.Ap
  name         : 3-tier-app
# vz.BrCP
  name           : 3-tier-app_Contract_app
# vz.Filter
  name         : Allow_Python

Unfortunately, this doesn’t quite give us what we want, because it lists all children of all classes. By using the “rsp-subtree-class=fvAp” option we can scope the response to only give us children of class fvAp (application profiles):

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"' -x "rsp-subtree=children rsp-subtree-class=fvAp" | egrep '^#|name' 
# fv.Tenant
name         : tlijnse463
# fv.Ap
  name         : Infra_net
# fv.Ap
  name         : Demo_net
# fv.Ap
  name         : 3-tier-app

In addition to the default option “self” and the option “children” for the rsp-subtree, you can also use the “rsp-subtree=full” option, which not only returns direct children of the queried object, but the complete subtree of that object, including children of children, etc. However, it seems that in this case the “rsp-subtree-class” option is only applied to direct children, but not to objects further down the subtree (such as children of children).

While the “rsp-subtree” options can be used to scope the responses to the query, there is also a set of “query-target” options that scope the query itself. Initially it looks like these two options do exactly the same:

dcloud_apic1# moquery -c fvTenant -x 'query-target=subtree' | wc -l
129469
dcloud_apic1# moquery -c fvTenant -x 'rsp-subtree=full' | wc -l    
129469

The number of lines in the output in these two queries is exactly the same, because in both cases we’re getting the full subtree of all tenants (objects of class fvTenant). However, when you apply a filter you can see that there is a difference:

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"' -x 'query-target=subtree' | wc -l
16
dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"' -x 'rsp-subtree=full' | wc -l    
2689

The difference is that in the first query we’re querying the full subtree of all tenants, but then applying the filter to all objects in those trees. In the second query we’re applying the filter only to the objects of class fvTenant and then obtaining the full unfiltered subtrees of those tenants.

The “query-target-filter” option can be used to filter the queries, similar to the “-f” option of the moquery command. Essentially, the “-f” option of the moquery command provides a somewhat more intuitive filtering syntax, which is then translated to the more cumbersome API filter syntax. The following example illustrates this principle. These two queries generate the exact same result:

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"'                      
Total Objects shown: 1

# fv.Tenant
name         : tlijnse463
childAction  : 
descr        : 
dn           : uni/tn-tlijnse463
lcOwn        : local
modTs        : 2016-10-26T22:21:24.407+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-tlijnse463
status       : 
uid          : 15374

dcloud_apic1# moquery -c fvTenant -x 'query-target-filter=eq(fvTenant.name,"tlijnse463")'
Total Objects shown: 1

# fv.Tenant
name         : tlijnse463
childAction  : 
descr        : 
dn           : uni/tn-tlijnse463
lcOwn        : local
modTs        : 2016-10-26T22:21:24.407+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-tlijnse463
status       : 
uid          : 15374

If you try to specify both the “-f” option and the “-x query-target-filter” option, then the “-x” option seems to win:

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="mgmt"'                                                        
Total Objects shown: 1

# fv.Tenant
name         : mgmt
childAction  : 
descr        : 
dn           : uni/tn-mgmt
lcOwn        : local
modTs        : 2015-03-21T04:21:41.708+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-mgmt
status       : 
uid          : 0

dcloud_apic1# moquery -c fvTenant -f 'fv.Tenant.name=="mgmt"' -x 'query-target-filter=eq(fvTenant.name,"tlijnse463")'
Total Objects shown: 1

# fv.Tenant
name         : tlijnse463
childAction  : 
descr        : 
dn           : uni/tn-tlijnse463
lcOwn        : local
modTs        : 2016-10-26T22:21:24.407+00:00
monPolDn     : uni/tn-common/monepg-default
ownerKey     : 
ownerTag     : 
rn           : tn-tlijnse463
status       : 
uid          : 15374

Although I have primarily written this article to gather some of the knowledge that I learnt about the use of the moquery tool, I hope that it may also serve others as a good starting point to get proficient with moquery. I found it to be a very powerful tool that can help you get information from the object database in cases where there is no convenient GUI page or CLI command that gives you exactly what you need. Also, I found that learning to formulate queries with moquery is a good foundation for learning the APIC API and scripting against that API with Cobra. What are your favorite use cases for moquery?

11 thoughts on “Querying the ACI object database with moquery

  1. Nice post! I personally use moquery within test cases of Change Implementation Plans to validate whatever is appropriate. Piping the output to commands like grep, wc, etc. makes it very easy to get the data required and cut out any ‘noise’.

    Although I will write scripts, using the Cobra Python bindings, to perform validation where appropriate.

    It’s also a great command to use to very easily pull information when troubleshooting (as you noted), rather than using Visore (can keep my head in the CLI).

    It’s also worth noting that moquery also exists on the leaf/spine switches, where it can be used to query the Management Information Tree (MIT) on those nodes.

    • Hi Joshua,

      Thanks for the comments and the effort you put into figuring out the filter syntax!
      I also use the Cobra Python modules for more structural work, but like to use moquery for simple one time queries.
      I have not used moquery on the switches yet, so thanks for that hint!

      Regards,

      Tom

  2. Hello All,

    very beautiful document and very informative.

    can you please tell me how to find all AP, BD, EPG under one Tenant through moquery or through any other output ?

    • I am glad you liked the article!

      If you look at some of the examples above you’ll see that the query “moquery -c fvTenant -f ‘fv.Tenant.name==”tlijnse463″‘ -x “rsp-subtree=children rsp-subtree-class=fvAp” lists all application profiles for tenant “tlijnse463” in addition to the tenant object itself. By replacing the “rsp-subtree-class” option with a different class such as “fvBD” you could find all child objects of that class.

      There may be a smarter way to get the same result, but I think this does what you are asking for (unless I misunderstand your question).

      Hope this helps!

      Tom

      • Great thanks a lot

        This will really help me

        Can you pls tell me how to get switch profile for particular port With using moquery commands ?

        Regards

        • Sorry, it looks like WordPress messed up my quote characters. Could you try again with the following:

          moquery -c fvTenant -f 'fv.Tenant.name=="tlijnse463"' -x "rsp-subtree=children rsp-subtree-class=fvAp"

          I just tested it with a different tenant and it worked for me…

          Tom

  3. Hi

    below is the output

    external@APIC-1:~> moquery -c fvTenant -f ‘fv.Tenant.name==“ITcorp”’ -x “rsp-subtree=children rsp-subtree-class=fvAp”
    >

    • Hi,

      That still looks like a quoting problem to me. The only thing I can recommend is that you paste the string to a plain text editor and replace all single and double quotes with the regular style of quotes.

      I just edited my previous reply to “code” style and if I copy and paste the query from there into an apic it works for me…

      Tom

Leave a Reply

Your email address will not be published. Required fields are marked *