Solucionar problemas e verificar a estrutura com comandos de linha única

Introdução

Este documento descreve diferentes maneiras de detectar um problema geral na estrutura.

Pré-requisitos

Requisitos

• A Cisco recomenda o conhecimento da ACI 
• Conhecimento básico de bash

Componentes Utilizados

Este documento não se restringe a versões de software e hardware específicas.

Dispositivos usados:

• Cisco ACI executando a versão 4.2(3)

As informações neste documento foram criadas a partir de dispositivos em um ambiente de laboratório específico. Todos os dispositivos utilizados neste documento foram iniciados com uma configuração (padrão) inicial. Se a rede estiver ativa, certifique-se de que você entenda o impacto potencial de qualquer comando.

Informações de Apoio

Ferramentas usadas para capturar as informações

• Enviar para substituto: sed "s/<oldword >/<new wordk>/g" g define que isso é feito mais de uma vez.
• Enviar para capturar linhas do início ao fim: sed "/<begin/,/end/p>". Combine a opção -n (noprint) com o sinalizador /p print para duplicações da funcionalidade do grep.
• O Sed pode ser usado mais de uma vez usando ‘;’, por exemplo: poderia: sed "s/<oldword >/<new wordk>/g; s/<oldword2 >/<new word2>/g"
• awk -F '<separador_de_campo>' '{print $2}' Neste exemplo específico, divida a linha pelo FIELD_SEPARATOR definido e imprima o segundo bloco delimitado. Ambas as sintaxes fazem exatamente a mesma coisa.
• awk '{ print $1, $2 }' imprime os dois primeiros campos de cada registro de entrada, com um espaço entre eles.
•  classificar | uniq Informa as linhas repetidas. Usando linhas de prefixo -c pelo número de ocorrências.
• sort -nrk <coluna> classifica as linhas com a maior altura. -n para uma classificação numérica, -k para uma chave para que possamos modificar a coluna e, se você quiser definir o mais baixo, poderá remover -r
• python -m json.tool Mostra o JSON em um formato bonito.

Lista de todos os comandos de linha única 

Obtenha apenas as IDs de nó dos LEAFs na estrutura:

1. Em uma lista:

APIC#acidiag fnvread | grep leaf | awk '{print $1}'

2. Em uma linha com vírgulas como separadores:

APIC#acidiag fnvread | grep leaf | awk '{print $1}' | sed -z 's/\n/,/g;s/,$/\n/'

Verifique se há redefinições de interface:

As informações são classificadas nas interfaces com o maior número de redefinições.

APIC#moquery -c ethpm.PhysIf | egrep "dn|lastLinkStChg|resetCtr" | tr -d "\n" | sed "s/dn/\ndn/g;s/lastLinkStChg/\tlastLinkStChg/g;s/resetCtr/\tresetCtr/g" | sort -nrk 9 | more

opção mais lenta

APIC#for leaf in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo " -> leaf ID: $leaf  "; fabric $leaf  show interface  | sed -n '/net[0-9]\/[0-9]\+ is up/,/Tx pause/p'  | egrep "is up|Last link flapped|interface resets" | grep -v Dedicated | tr -d "\n" | sed "s/resets/rests\n/g" | sort -nrk 9   ; done;

Verifique a interface com a classificação mais alta:

Para descobrir onde a maior parte do tráfego é recebida:

Consulte a estrutura para todas as interfaces com throughput de saída sobre o valor específico (b). O valor de m define se b é gb, mb ou kb.

Para filtrar em kb defina m como 125000000. Para filtrar em mb defina m como 125000. Para filtrar em kb defina m como 125.

APIC#bash
APIC#b=1; m=125000;b=$((b*m)); printf "%-65s %25s\n", "Node/Interface" "Bits/Second"; icurl 'http://localhost:7777/api/class/eqptEgrTotal5min.json?query-target-filter=gt(eqptEgrTotal5min.bytesRateLast,"'$b'")&order-by=eqptEgrTotal5min.bytesRateLast|desc' 2>/dev/null | python -m json.tool | egrep "dn|bytesRateLast" | sed -e 's/\s\+//g' | tr -d '\n' | sed -e 's/\"bytesRateLast\"/\n\"bytesRateLast\"/g' | sed -r '/^\s*$/d' | awk -F "\"" '{ printf "%-65s %25.2f\n", $8,$4*8}'

APIC#for leaf in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo " -> leaf ID: $leaf  "; fabric $leaf  show int | sed -n '/net[0-9]\/[0-9]\+ is up/,/Tx pause/p' | egrep -i '[0-9]+ is up|30 seconds input' | tr -d '\n' | sed 's/packets\/sec/\n/g' | sort -n -r -k 10 ; done;

Localizar todas as alterações de topologia do STP:

1. O comando entra em cada folha e verifica se há alguma alteração recente na topologia e em que interfaces:

APIC#for node in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo "node ID: $node "; fabric $node  show mcp internal info vlan all |  grep -A 2 -B 4 "Last TC flush at"  | sed -z 's/\n/ /g' | sed 's/--/\n/g;s/  $/\n/' | sort -n -r -k 22  ; done;

2. O comando entra em cada folha e verifica a contagem mais alta em alterações de PVRSTP e quais interfaces são vistas:
   
   

APIC#for node in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo "node ID: $node "; fabric $node  show mcp internal info vlan all |  grep -A 2 -B 4 "Last TC flush at"  | sed -z 's/\n/ /g' | sed 's/--/\n/g;s/  $/\n/' | sort -n -r -k 11 ; done;

Verifique se há descartes de RPF multicast:

Isso precisa ser para a folha individual no momento e verifica todos os PIM VRF habilitados para qualquer queda de RPF:

APIC#for vrf in `show ip mroute summary vrf all | grep 'IP Multicast Routing Table for VR' | awk '{print $7}' | sed 's/"//g' `  ; do echo; echo -e "VRF  id: $vrf: \n" ; show ip mroute summary rpf-failed vrf $vrf | egrep "Source count: [1-9][0-9]*|[1-9]\.[0-9]{3}|LEAF|leaf" | sed -n '/Group.*count: [1-9][0-9]*/,/bps  [0-9]*/p' | awk '{print $1, $2}' | sed 's/,/ - SRC \/ pckt:\n/g' ; done;

Verifique se há muitos pacotes recebendo Glean:

1. Gleans ARP de malha:

APIC#for leaf in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo " -> leaf ID: $leaf  "; fabric $leaf show ip arp internal event-history event | grep glean | grep "Received pkt Fabric-Glean" | awk -F 'log_collect_arp_glean;' '{print $2}' | awk -F 'info =' '{print $1}' | sort | uniq -c ; done;

2. ARP obtém pacotes recebidos:

APIC#for leaf in `acidiag fnvread | grep leaf | awk '{print $1}'`; do echo; echo " -> leaf ID: $leaf  "; fabric $leaf show ip arp internal event-history event | grep "Received glean packet" | awk -F 'log_collect_arp_glean;' '{print $2}' | awk -F 'info =' '{print $1}' | sort | uniq -c ; done;

Estatísticas de queda de QoS:

Verifique os descartes recebidos de QoS para toda a estrutura:

 APIC#moquery -c qosmIfClass -f 'qosm.IfClass.RxDropPacketsCount!="0"' | egrep "RxDropPacketsCount|dn" | awk '{print $3}' | tr -d "\n" | sed 's/level[0-9]/level\t\n/g'| sed 's/plane/plane\n/g' | awk -F 'topology/' '{print $2}'

Verifique os descartes de transmissão de QoS para toda a estrutura:

APIC#moquery -c qosmIfClass -f 'qosm.IfClass.TxDropPacketsCount!="0"' | egrep "TxDropPacketsCount|dn" | awk '{print $3}' | tr -d "\n" | sed 's/level[0-9]/level\t\n/g'| sed 's/plane/plane\n/g' | awk -F 'topology/' '{print $2}'

desconexão de interfaces:

Erros de FCS (erros de CRC não estopados)

APIC#moquery -c rmonDot3Stats -f 'rmon.Dot3Stats.fCSErrors>="1"' | egrep "dn|fCSErrors"

Erros de FCS + CRC interrompidos

APIC#moquery -c rmonEtherStats -f 'rmon.EtherStats.cRCAlignErrors>="1"' | egrep "dn|cRCAlignErrors"

Quedas de buffer de saída

APIC#moquery -c rmonEgrCounters -f 'rmon.EgrCounters.bufferdroppkts>="1"' | egrep "dn|bufferdroppkts"

erros de saída

APIC#moquery -c rmonIfOut -f 'rmon.IfOut.errors>="1"' | egrep "dn|errors"

Limpar todos os contadores de interface

Comando para obter uma lista de nós de estrutura

APIC# acidiag fnvread | egrep " active" | egrep "leaf|spine" | awk '{print $1}' | sed -e 'H;${x;s/\n/,/g;s/^,//;p;};d' 
101,102,103,204,205,206,301,1001,1002,2001,2002

Comando para limpar os contadores da lista anterior

APIC# fabric 101,102,103,204,205,206,301,1001,1002,2001,2002 clear counters interface all

Problemas de sessão BGP:

Para verificar se há sessões BGP com problemas na estrutura subjacente

APIC#moquery -c bgpPeerEntry -f 'bgp.PeerEntry.operSt!="established" and  bgp.PeerEntry.dn*"overlay-1"' | egrep "dn|operSt" | tr -d "\n" | sed "s/dn/\ndn/g;s/operSt/\t-\toperSt/g"

Para verificar qualquer sessão BGP

APIC#moquery -c bgpPeerEntry -f 'bgp.PeerEntry.operSt!="established" | egrep "dn|operSt" | tr -d "\n" | sed "s/dn/\ndn/g;s/operSt/\t-\toperSt/g"

Problemas de sessão do OSPF:

Identifique as sessões que não estão em estado full.

APIC#moquery -c ospfAdjEp -f 'ospf.AdjEp.operSt!="full"' | egrep "dn|peerIp" | tr -d '\n' | sed "s/dn           : topology\//\nNode : /g;s/peerIp/\tpeerIp/g;s/       //g" | sed "s/\/sys.*dom-/ VRF: /g;s/\/if-\[/ Interface : /g;s/\]\/adj-/ Adj: /g"

Identifique as sessões que oscilam constantemente e classifique as informações na contagem mais alta:

APIC#moquery -c ospfAdjStats -f 'ospf.AdjStats.stChgCnt!="0"' | egrep "dn|stChgCnt" | tr -d "\n" | tr -d " " | sed "s/dn:topology\//\nNode: /g;s/\/adjstatsstChgCnt:/\tADJ changes: /g;s/\/if-\[/ Interface: /g;s/\]\/adj-/ Adj /g" | sed "s/\/sys.*dom-/ VRF: /g" | sort -nrk 11

Pacotes primários que são apontados para a CPU

Ter em conta: esse comando depura 500 pacotes. Para uma quantidade menor, modifique o número após -c.

lEAF#tcpdump -i kpm_inb -c 500 > /tmp/cpu-dp.txt

LEAF#cat /tmp/cpu-dp.txt | grep IP | awk '{print $3 , $4 , $5}' | grep -v $HOSTNAME | awk -F ':' '{print $1}' | sort | uniq -c | sort -nrk 1

Direcionar sem criar um arquivo totalmente novo:

LEAF#tcpdump -i kpm_inb -c 500 | grep IP | awk '{print $3 , $4 , $5}' | grep -v $HOSTNAME | awk -F ':' '{print $1}' | sort | uniq -c | sort -nrk 1

Verificar toda a malha a partir do apic onde todo um relacionamento de contrato específico é implantado

APIC#moquery -c actrlRule -f 'actrl.Rule.sPcTag=="32783" and actrl.Rule.dPcTag=="46" and actrl.Rule.scopeId=="2818048"'

Verifique onde um encapsulamento já está implantado e obtenha o epg correspondente

APIC#moquery -c l2CktEp -f 'l2.CktEp.encap=="vlan-3018"'

Utilização de memória de todos os nós na malha:

APIC#bash
APIC# clear ; echo -e "Node ID\t\tFree Memory\tUsed Memory" ; moquery -c procSysMemHist15min -f 'proc.SysMemHist15min.index=="1"' | grep dn | awk -F " " '{print $3}' | xargs -n 1 -I {} sh -c 'freeAvg=`moquery -d {} | grep freeAvg | sed -E -e "s/[[:blank:]]+/ /g" | cut -d " " -f3` ; usedAvg=`moquery -d {} | grep usedAvg | sed -E -e "s/[[:blank:]]+/ /g" | cut -d " " -f3` ; totalAvg=`moquery -d {} | grep totalAvg | sed -E -e "s/[[:blank:]]+/ /g" | cut -d " " -f3` ; node=`echo {} | cut -d "/" -f3` ; freeAdj=$(( freeAvg * 100 )) ; usedAdj=$(( usedAvg * 100 )) ; percFree=$(( freeAdj / totalAvg )) ; percUtil=$(( usedAdj / totalAvg )) ; echo -e "$node\tFree% : $percFree\tUsed% : $percUtil"'

Verificar quedas na pilha (os pacotes de exceção são lançados)

Revise as quedas de TX. Use o comando com sort -nk 6 -r :

 APIC# cat istack_debug | egrep "Protocol:|x_pkts_dropped" | tr -d "\n" | sed "s/Protocol/\nProtocol/g" | sort -nk 6 -r | more

Validação do contrato 

Revisar todos os relacionamentos de um contrato específico. Use o script que substitui o nome do contrato e do locatário:

APIC# CONTRACT='brc-<contract-name>'
APIC# TN='<tenant>'
#CHECK CONSUMERS
#To get the count of epgs consuming a contract (excluding vzany consumer):
APIC#icurl -g 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=subtree&target-subtree-class=vzRtCons,vzConsDef&rsp-subtree-include=count&query-target-filter=or(eq(vzRtCons.tCl,"fvAEPg"),eq(vzRtCons.tCl,"l2extInstP"),eq(vzRtCons.tCl,"l3extInstP"),wcard(vzConsDef.dn,"uni/tn-'.*'/inherited-\[uni/tn-"))'

#To list all epg objects consuming a contract (excluding vzany consumers):
APIC#icurl -g 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=subtree&target-subtree-class=vzRtCons,vzConsDef&query-target-filter=or(eq(vzRtCons.tCl,"fvAEPg"),eq(vzRtCons.tCl,"l2extInstP"),eq(vzRtCons.tCl,"l3extInstP"),wcard(vzConsDef.dn,"uni/tn-'.*'/inherited-\[uni/tn-"))' | python -m json.tool

#To get the count of vzanys consuming a contract:
APIC#icurl 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=children&target-subtree-class=vzRtAnyToCons&rsp-subtree-include=count'

#To list all vzany objects consuming a contract:
APIC#icurl 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=children&target-subtree-class=vzRtAnyToCons' | python -m json.tool

#CHECK PROVIDERS
#To get the count of epgs providing a contract (excluding vzany consumer):
APIC#icurl -g 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=subtree&target-subtree-class=vzRtProv,vzProvDef&rsp-subtree-include=count&query-target-filter=or(eq(vzRtProv.tCl,"fvAEPg"),eq(vzRtProv.tCl,"l2extInstP"),eq(vzRtProv.tCl,"l3extInstP"),wcard(vzProvDef.dn,"uni/tn-'.*'/inherited-\[uni/tn-"))'

#To list all epg objects providing a contract (excluding vzany consumers):
APIC#icurl -g 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=subtree&target-subtree-class=vzRtProv,vzProvDef&query-target-filter=or(eq(vzRtProv.tCl,"fvAEPg"),eq(vzRtProv.tCl,"l2extInstP"),eq(vzRtProv.tCl,"l3extInstP"),wcard(vzProvDef.dn,"uni/tn-'.*'/inherited-\[uni/tn-"))' | python -m json.tool

#To get the count of vzanys providing a contract:
APIC#icurl 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=children&target-subtree-class=vzRtAnyToProv&rsp-subtree-include=count'

#To list all vzany objects providing a contract:
APIC#icurl 'http://localhost:7777/api/node/mo/uni/tn-'$TN'/'$CONTRACT'.json?query-target=children&target-subtree-class=vzRtAnyToProv' | python -m json.tool