23 de jan de 2018

Python para Engenheiros de Redes - Parte VII



Olá Pessoal Bom Dia, hoje vamos falar sobre funções.

O que é uma função?
Uma função é um bloco de código que serve para executar uma determinada tarefa. Dessa forma o nosso programa pode ser particionado em vários blocos de códigos, módulos, assim o nosso programa fica melhor organizado, gerenciável e com código reutilizável.

Vejamos um exemplo:

>>> ips
['192.168.100.1', '172.16.2.2', '10.10.10.3']
>>> for ip in ips:
...  octects=ip.split('.')
...  firstdigit=int(octects[0])
...  if firstdigit>=0 and firstdigit <128:
...   print "%s eh Clase A" % ip
...  elif firstdigit>=128 and firstdigit <192:
...   print "%s eh Clase B" % ip
...  elif firstdigit>=192 and firstdigit <224:
...   print "%s eh Clase C" % ip
...  else:
...   print "%s pertence a Clase D ou E" % ip
...
192.168.100.1 eh Clase C
172.16.2.2 eh Clase B
10.10.10.3 eh Clase A
>>>


O código acima lê vários endereços ip da lista “ips”, e verifica a classe a qual o endereço pertence.

Se por acaso mais adiante no código tivessemos uma outra lista, “ips_2” por exemplo, e quiser novamente saber a classe, vou precisar duplicar o mesmo código.

Para deixar o código mais organizado, modular e reutilizável, podemos criar uma função que aceite como entrada o primeiro dígito do endereço ip e retorne como resultado a classe.



>>> def verificaclasse(ipaddressfirstdigit):
...  if ipaddressfirstdigit>=0 and ipaddressfirstdigit <128:
...   classe='A'
...  elif ipaddressfirstdigit>128 and ipaddressfirstdigit <192:
...   classe='B'
...  elif ipaddressfirstdigit>=192 and ipaddressfirstdigit <224:
...   classe='C'
...  else:
...   classe='D ou E'
...  return classe
...
>>> for ip in ips:
...  octects=ip.split('.')
...  firstdigit=int(octects[0])
...  classe=verificaclasse(firstdigit)
...  print "%s pertence a Classe %s" % (ip,classe)
...
192.168.100.1 pertence a Classe C
172.16.2.2 pertence a Classe B
10.10.10.3 pertence a Classe A
>>>


Foi definida a função “verificaclasse”, que recebe como argumento o primeiro dígito do endereço ip, e ela retorna como resultado o valor da variável "classe", sentença “return classe” . A variavél "classe" contem o tipo de classe do endereço ip.



Sintaxes de uma função:
Acriação de uma função, começa pela utilização da palavra “def”, seguidamente do nome da função, logo entre parenteses, os parâmetros que dita função irá receber, separados por vírgulas caso seja mais de um parâmetro e finalizando com o símbolo “:”

Depois vem o código da função, com alguns níveis de indentação a mais que o cabeçalho da função.

Uma sentença “return” pode ser utilizada , caso seja preciso retornar algum valor.

def nome_funcao(parametros):
 código


Alguns exemplos:


>>> def imprimetexto(texto):
...  print texto
...
>>> s="Ola Mundo"
>>> imprimetexto(s)
Ola Mundo
>>>


No exemplo acima a função “imprimetexto” não retorna nenhum valor, somente imprime o parâmetro que ela recebe.



>>> def calculadora(a,b,operacao):
...  if operacao=='sum':
...   resultado=a+b
...  elif operacao=='subs':
...   resultado==a-b
...  elif operacao=='mult':
...   resultado=a*b
...  elif operacao=='div':
...   resultado=a/b
...  else:
...   resultado=0
...  return resultado
...
>>> a=10
>>> b=2
>>> calculadora(a,b,'sum')
12
>>> calculadora(a,b,'mult')
20
>>> result=calculadora(a,b,'div')
>>> result
5
>>>

A função calculadora recebe três parametros “a”,”b”, e o tipo de operação a ser executada, que pode ser “sum”,”subs”,”mult” e “div.

É interessante ver que o resultado que retorna à função, pode ser atribuída a uma outra variável no caso a variavél “result”.

Executando uma função:
Dos exemplos anteriores podemos ver que para executar uma função basta simplesmente chamar ela pela nome. Inclusive podemos chamar uma função dentro de outra função.


>>> def soma(a,b):
...  return a+b
...
>>> def subs(a,b):
...  return a-b
...
>>> def mult(a,b):
...  return a*b
...
>>> def div(a,b):
...  return a/b
...
>>> def calculadora(a,b,operacao):
...  if operacao=='sum':
...   resultado=soma(a,b)
...  elif operacao=='subs':
...   resultado=subs(a,b)
...  elif operacao=='mult':
...   resultado=mult(a,b)
...  elif operacao=='div':
...   resultado=div(a,b)
...  else:
...   resultado=0
...  return resultado
...
>>> a=10
>>> b=2
>>> result=calculadora(a,b,'mult')
>>> result
20
>>>
Agora foi definida uma função para cada operação aritmética: soma, subtração, multiplicação e divisão. Seguidamente foi definida a função calculadora a qual chama as funções previamente definidas.


Escopo e Tempo de vida das variavéis dentro de uma função:

O escopo vem a ser o bloco de código onde uma variável é reconhecida. Parâmetros e variáveis dentro do escopo de uma função são somente válidas dentro da função e não fora dela.

O tempo de vida de uma variável em uma função é o tempo que demora a função em ser executada. Uma vez que retornamos de uma função as variaveis dentro dela são destruídas.

Vejamos um exemplo para esclarecimento:



>>> def ssh_to_router(ip, username, password):
...  command='sh run'
...  print "Executando %s em router %s" % (command,ip)
...
>>> command='sh ip int bri'
>>> ssh_to_router('192.168.100.1','cisco','cisco')
Executando sh run em router 192.168.100.1
>>> command
'sh ip int bri'
>>>

No exemplo acima temos a variável “command”, ela existe no programa principal com o valor “sh ip int bri”. Dentro da função "ssh_to_router" temos uma variável com o mesmo nome "command", porém com um valor diferente “sh run”. A variável "command" dentro da função, somente vai existir durante o tempo que a função seja executada.


Importando módulos:
Muitas vezes, precisamos dividir o nosso programa principal em vários scripts python, afim de obter um projeto melhor organizado e gerenciável.

Exemplo:

Precisamos nos conectar via telnet ou ssh para nossos roteadores. Para isso criamos um script chamado “connect.py” onde podemos definir as funções de conexão para telnet e ssh:



connect.py

jose@rejane:~/CloudGuru$ more connect.py
#!/usr/bin/python
def telnet_connect(ip,username,password):
 print "Telnet Connection to %s" % ip

def ssh_connect(ip,username,password):
 print "SSH Connection to %s" % ip
jose@rejane:~/CloudGuru$

Agora criamos o nosso programa principal chamado de “testingconnection.py”, logo para poder utilizar as funções definidas no script “connect.py”, utilizamos a sentença “import”.  A notação para executar uma função do modulo importado é "modulo.funcao".


testingconnection.py 

jose@rejane:~/CloudGuru$ more testingconnection.py

#!/usr/bin/python
import connect

R1=['192.168.100.1','cisco','cisco']
R2=['192.168.100.2','cisco','cisco']

#Aqui utilizamos as funções importadas do script connect.py

connect.telnet_connect(R1[0],R1[1],R1[2])
connect.ssh_connect(R2[0],R2[1],R2[2])

jose@rejane:~/CloudGuru$


Quando rodamos o programa principal “testingconnection.py”, obtemos como resultado:

jose@rejane:~/CloudGuru$ ./testingconnection.py
Telnet Connection to 192.168.100.1
SSH Connection to 192.168.100.1
jose@rejane:~/CloudGuru$

Importar módulos é corriqueiro em python, isso porque a grande maioria das vezes já existem módulos prontos para serem utilizados em diversas situações. Por exemplo, módulos para se conectar a um banco MySql, módulo de conexão SSH Paramiko, módulo de algebra lineal numpy etc etc.

Bom Pessoal por hoje é isso ai, o próximo post vamos tratar um pouco de como trabalhar com arquivos, sentença with e tratamento de erros via try. Com isso finalizariamos os fundamentos de programação python. Daí para frente vamos começar a criar aplicações que interajam com a nossa rede, como obter configurações dos roteadores para backup, armazenar as mesmas em bancos de dados, detectar mudanças de configuração, fazer inventário etc etc..


Abçs
Jose CCIE#35681

19 de jan de 2018

Preparatório CCNA R&S em Modo Gravado


O NetFindersBrasil atualizou o Preparatório para a Certificação CCNA incluindo aulas de eBGP, QoS, Cloud Computing e SDN para contemplar todos os tópicos do Exame 200-125. O curso é oferecido no formato online, com cerca de 40 horas de duração, podendo ser acessado em qualquer hora e a qualquer lugar durante 04 meses consecutivos, por apenas R$ 99,00.

Sobre o Preparatório CCNA em Modo Gravado:

◦Onde: http://www.netfindersbrasil.com.br -> Os alunos que adquirirem o curso online poderão acessar todo o material de apoio (slides e Laboratórios) em nossa plataforma Moodle

◦Quanto: O curso é oferecido por R$ 99,00 ◦Diferenciais: Laboratórios criados no Packet Tracer 6.0.1 para ilustrar os conceitos abordados e acesso/suporte online via Portal de Treinamentos NetFindersBrasil durante o curso online pelo período de 04 meses.

◦Instrutor: Adilson Florentino - CCNA R&S, CCNA Voice, CCNA Wireless, CCNA Security, CCNP R&S, CCAI e CCSI. Profissional com mais de 17 anos de experiência em tecnologias Cisco.


Diferenciais:


◦Certificado de participação para todos os alunos ao término do período de inscrição.

◦12 vídeo-aulas com cerca de 02 horas cada com a resolução de questões de Simulado para Exame CCNA.

Conteúdo Programático:


- CCNA-200-125-O que há de Novo?
- Modelo OSI
- Switching e VLANs
- TCP/IP e IPv6
- Endereçamento IP e SubRedes
- Introdução ao Sistema Op. IOS
- Roteamento IP Básico (RIP e rotas estáticas e NAT)
- Roteamento IP Avançado (EIGRP, OSPF e eBGP)
- Arquiteturas de Alta Disponibilidade - HSRP
- Gerenciamento e Troubleshooting Básico
- Listas de Controle de Acesso
- QoS - Qualidade de Serviço
- Protocolos WAN
- Cloud Computing e SDN
- Preparação para o Exame

12 vídeo-aulas com cerca de 02 horas de duração cada um com a resolução de 307 questões de um Simulado para Exame CCNA:

Simulado para o Exame - Sessão 01 - questões de 01 a 51
Simulado para o Exame - Sessão 02 - questões de 52 a 102
Simulado para o Exame - Sessão 03 - questões de 103 a 153
Simulado para o Exame - Sessão 04 - questões de 154 a 204
Simulado para o Exame - Sessão 05 - questões de 205 a 255
Simulado para o Exame - Sessão 06 - questões de 256 a 307

Garanta já a sua vaga adquirindo o Curso pelo botão abaixo:








Maiores Informações:
adilson.aflorentino@eamsoft.com.br

17 de jan de 2018

Python para Engenheiros de Redes - Parte VI



Olá Pessoal Bom Dia, continuando com nosso curso de python hoje vamos aprender sobre laços de repetição, sentenças “for” e “while”.

Laço de Repetição “for”:
A sentença “for” é utilizada para iterar sobre uma sequência de elementos. Frequentemente utilizada quando precisamos repetir um bloco de instruções “n” vezes.

Exemplo:

jose@rejane:~$ python
Python 2.7.6 (default, Jun 22 2015, 17:58:13)
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> MyRouters=['R1','R2','R3','R4']
>>> MyRouters
['R1', 'R2', 'R3', 'R4']
>>> for myrouter in MyRouters:
...  print myrouter
..
R1
R2
R3
R4
>>>

No exemplo acima temos criado uma lista com o nome de 4 routers, e temos utilizado um laço “for” para iterar sobre cada elemento da lista. A variável “myrouter” é uma variável que é criada dentro da sintaxe do laço “for” e representa um elemento da lista, ela pode ter qualquer nome.

Também posso iterar sobre uma sequência de números:

>>> for i in range(5):
...  print i
...
0
1
2
3
4
>>>

A função range(n), utilizando um único argunmento, me devolve uma sequência de números de 0,1..n-1. Vocês podem ver a doc da função range() em https://docs.python.org/3/library/stdtypes.html#range

Utilizando a função range e len, podemos iterar sobre uma lista utilizando os índices da lista por exemplo:

>>> for i in range(len(MyRouters)):
...  print MyRouters[i]
...
R1
R2
R3
R4
>>>


Vejamos agora como fazer um loop em um dicionário.

Definindo o dicionário MyRoutersDict:

>>> MyRoutersDict={'R1': '192.168.100.1','R2':'192.168.100.2','R3':'192.168.100.3','R4':'192.168.100.4'}
>>> MyRoutersDict
{'R4': '192.168.100.4', 'R1': '192.168.100.1', 'R2': '192.168.100.2', 'R3': '192.168.100.3'}
>>>

Para iterar sobre as chaves:

>>> for key in MyRoutersDict:
...  print key
...
R4
R1
R2
R3
>>>

Para iterar sobre os pares chave, valor:

>>> for key,value in MyRoutersDict.items():
...  print "Chave %s,Valor %s" % (key,value)
...
Chave R4,Valor 192.168.100.4
Chave R1,Valor 192.168.100.1
Chave R2,Valor 192.168.100.2
Chave R3,Valor 192.168.100.3
>>>

Se queremos iterar sobre os valores somente:

>>> for value in MyRoutersDict.values():
...  print value
...
192.168.100.4
192.168.100.1
192.168.100.2
192.168.100.3
>>>



Break:
Em alguns casos se faz necessário quebrar um laço quando alguma condição é alcançada:

>>> for i in range(1,20):
...  if i==4:
...   break
...  print i
...
1
2
3
>>>
No exemplo acima, é feita uma iteração de 1,2..20, porém existe uma condição dentro do laço for que diz que quando cheguemos ao valor i==4 o laço deve ser quebrado, caso contrário imprime o valor da variavél “i”.

Continue:
Existem ocasiões que vamos precisar executar um laço de repetição, pulando alguns valores da sequência de iteração.

>>> for value in MyRoutersDict.values():
...  if value=='192.168.100.2':
...   continue
...  print "Valor: %s" % value
...
Valor: 192.168.100.4
Valor: 192.168.100.1
Valor: 192.168.100.3
>>>
Do exemplo acima, quando a iteração chega no valor da chave R2 (192.168.100.2), a sentença “continue” ordena ao laço pular o código do bloco “for”, no caso o “print” para o valor da chave R2.

Pass: 
Pass em python é uma sentença nula, ela não faz nada, a única diferença entre um comentário e o pass, é que o interpretador ignora os comentários enquanto que o pass não, porém nada acontece quando um “pass” é executado.

Geralmente é utilizado quando queremos implementar um laço ou uma função no futuro, porém não temos uma idéia clara do código que deverá ser executado. Como o corpo do laço ou a função não pode ficar vazio, utilizamos uma sentença “pass”.

>>> for router in MyRouters:
...  pass
...
>>> 



Laço de Repetição While:

O laço while, serve para executar um bloco de código sempre e quando uma condição seja verdadeira. Em outra palavras “Enquanto isso seja verdadeiro, executa”.

>>> j=0
>>> while j<=10:
...  print j
...  j=j+1
...
0
1
2
3
4
5
6
7
8
9
10
Do exemplo acima temos a variável “j” setada inicialmente no valor zero, o laço While nos diz, enquanto “j” seja menor ou igual a 10, imprime o resultado e incrementa “j”. Quando “j” chega no valor de 11 a condição j<=10 não é mais satisfeita e o laço termina.

Laços de repetição aninhados (nested loops):
Muitas vezes é preciso executar um laço de repetição, que à sua vez executa um outro laço de repetição vejamos um exemplo:

Seja a lista MyRouters:

>>> MyRouters
['R1', 'R2', 'R3', 'R4']
>>>

E a lista MyCommands:


>>> MyCommands=['show ip int bri','show run','show ip ospf']
>>> MyCommands
['show ip int bri', 'show run', 'show ip ospf']
>>>


Gostaria de executar todos os comandos da lista MyCommands, para cada um dos roteadores da lista MyRouters.


>>> for router in MyRouters:
...  for command in MyCommands:
...   print "Executando comando %s em roteador %s" % (command,router)
...
Executando comando show ip int bri em roteador R1
Executando comando show run em roteador R1
Executando comando show ip ospf em roteador R1
Executando comando show ip int bri em roteador R2
Executando comando show run em roteador R2
Executando comando show ip ospf em roteador R2
Executando comando show ip int bri em roteador R3
Executando comando show run em roteador R3
Executando comando show ip ospf em roteador R3
Executando comando show ip int bri em roteador R4
Executando comando show run em roteador R4
Executando comando show ip ospf em roteador R4
>>>

Podemos ver que todos os comandos foram executados para cada um dos roteadores.

Por hoje é isso ai, no próximo post vamos tratar sobre funções.. espero que tenham gostado e estejam praticando nem que seja um pouco os conceitos aqui apresentados.

Abçs e uma ótima semana.
Jose CCIE#35681

16 de jan de 2018

Como Filtrar Rotas indesejadas ANTES delas chegarem ao Roteador de Borda


Com BGP ORF, uma prefix-list criada em seu roteador de borda pode ser enviada para sua Operadora e todo o consumo de CPU resultante da execução dos Filtros fica por conta dela.

É muito comum um Provedor solicitar Full-Route para uma Operadora mas filtrar a maioria das rotas que chegam no seu roteador de Borda, deixando muitas vezes apenas a rota padrão ser aprendida ou então apenas um determinado conjunto de rotas (Partial Route). Isso por quê pedir para a Operadora mudar o anúncio pode demorar algum tempo.

Com roteadores Cisco, é possível criar um Filtro em seu Roteador de Borda e executa-lo no roteador da Operadora. Assim, o processamento do Filtro é feito externamente e apenas as rotas desejadas chegam até sua borda. Vejamos um exemplo de configuração:

Obs: Este conteúdo é abordado no Curso Preparatório para o Exame CCIE Written 400-101

Passo 1 - Configuração Básica - Vamos assumir aqui que R1 é o roteador da Operadora e R2 é o roteador de Borda:

ena
conf t
hostname R1
int lo0
ip addr 6.6.6.6 255.255.255.255
int lo1
ip addr 200.10.1.1 255.255.255.0
int lo2
ip addr 200.10.2.1 255.255.255.0
int lo3
ip addr 200.10.3.1 255.255.255.0
int lo4
ip addr 200.10.4.1 255.255.255.0
int lo5
ip addr 200.10.5.1 255.255.255.0
int e0/0
ip addr 200.10.0.1 255.255.255.252
no shut
exit
ip route 0.0.0.0 0.0.0.0 lo0
router bgp 65001
neighbor 200.10.0.2 remote-as 65002
netw 200.10.1.0 mask 255.255.255.0
netw 200.10.2.0 mask 255.255.255.0
netw 200.10.3.0 mask 255.255.255.0
netw 200.10.4.0 mask 255.255.255.0
netw 200.10.5.0 mask 255.255.255.0
netw 0.0.0.0 mask 0.0.0.0
end
wr


ena
conf t
hostname R2
int e0/0
ip addr 200.10.0.2 255.255.255.252
no shut
exit
router bgp 65002
neighbor 200.10.0.1 remote-as 65001
end
wr

O roteador1 vai enviar 5 rotas 200.10 mais a rota padrão para o roteador2, as quais serão aprendidas, conforme a saida abaixo:

R2#sh ip route bgp

B* 0.0.0.0/0 [20/0] via 200.10.0.1, 00:00:46
B 200.10.1.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.2.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.3.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.4.0/24 [20/0] via 200.10.0.1, 00:00:46
B 200.10.5.0/24 [20/0] via 200.10.0.1, 00:00:46


Passo 2 - Vamos criar uma Prefix-List que só aceite o recebimento da rota padrão e descarte as demais rotas, e então vamos associar essa prefix-list
com o vizinho roteador1:

R2(config)#ip prefix-list DEFAULT-ROUTE permit 0.0.0.0/0
R2(config)#router bgp 65002
R2(config-router)#neighbor 200.10.0.1 prefix-list DEFAULT-ROUTE in

Passo 3 - Vamos forçar a atualização das rotas com o comando clear ip bgp * (mas antes vamos ativar um debug para acompanhar a execução do filtro)

R2#debug ip bgp update
BGP updates debugging is on for address family: IPv4 Unicast

R2#clear ip bgp *
R2#
*Jan 16 13:36:20.118: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Down User reset
*Jan 16 13:36:20.118: %BGP_SESSION-5-ADJCHANGE: neighbor 200.10.0.1 IPv4 Unicast topology base removed from session User reset
*Jan 16 13:36:20.464: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Up
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd UPDATE w/ attr: nexthop 200.10.0.1, origin i, metric 0, merged path 65001, AS_PATH
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 0.0.0.0/0
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.1.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.2.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.3.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.4.0/24 -- DENIED due to: distribute/prefix-list;
*Jan 16 13:36:20.466: BGP(0): 200.10.0.1 rcvd 200.10.5.0/24 -- DENIED due to:
R2# distribute/prefix-list;
*Jan 16 13:36:21.483: BGP(0): Revise route installing 1 of 1 routes for 0.0.0.0/0 -> 200.10.0.1(global) to main IP table

Conforme podemos acompanhar acima, as 5 redes 200.10 recebidas foram negadas pela prefix-list e apenas o rota padrão doi instalada. Podemos confirmar isso como o comando abaixo em R2:

R2#show ip route bgp
B* 0.0.0.0/0 [20/0] via 200.10.0.1, 00:02:22

Passo 4 - Vimos que o Filtro funciona, agora, vamos configurar a feature BGP ORF (Outbound Router Filter) que permite que R2 exporte o filtro para R1 de modo que o mesmo seja executado no roteador que faz o anúncio e não naquele que recebe as rotas:

em R1
router bgp 65001
neighbor 200.10.0.2 capability orf prefix-list receive
end
wr

em R2
router bgp 65002
neighbor 200.10.0.1 capability orf prefix-list send
end
wr

Passo 5 - Verique que ao forçar novamente a atualização, apenas a rota padrão é enviada ao R2, o descarte já foi feito na origem, que recebeu a Prefix-list e a executou localmente:

R2#clear ip bgp *
R2#
*Jan 16 13:58:54.546: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Down User reset
*Jan 16 13:58:54.546: %BGP_SESSION-5-ADJCHANGE: neighbor 200.10.0.1 IPv4 Unicast topology base removed from session User reset
R2#
*Jan 16 13:58:55.576: %BGP-5-ADJCHANGE: neighbor 200.10.0.1 Up
R2#
*Jan 16 13:58:56.602: BGP(0): 200.10.0.1 rcvd UPDATE w/ attr: nexthop 200.10.0.1, origin i, metric 0, merged path 65001, AS_PATH
*Jan 16 13:58:56.602: BGP(0): 200.10.0.1 rcvd 0.0.0.0/0
R2#
*Jan 16 13:58:57.633: BGP(0): Revise route installing 1 of 1 routes for 0.0.0.0/0 -> 200.10.0.1(global) to main IP table


Limitações: BGP ORF requer que os dois lados suportem a capability, não funciona com Access-list nem com tráfego Multicast

Maiores Informações:

Outbound Route Filtering Capability for BGP-4
http://www.ietf.org/internet-drafts/draft-ietf-idr-route-filter-16.txt

BGP Prefix-Based Outbound Route Filtering
http://www.cisco.com/en/US/docs/ios/12_2t/12_2t11/feature/guide/ft11borf.html










13 de jan de 2018

Chamada para a Palestra - Tenha uma Carreira Abundante!!!



Victor Gomes, 18o. CCIE Voice e 1o. CCIE Collaboration do Brasil, estará ministrando a Palestra "Tenha uma Carreira Abundante" aqui pelo NetfindersBrasil, dia 20/01/2018, as 20:00 horas.

Inscrições pelo link abaixo:
http://netfindersbrasil.blogspot.com.br/2017/12/palestra-tenha-uma-carreira-abundante.html

Vagas Limitadas! Garanta já a sua!

11 de jan de 2018

Configuração de Switches Cisco - Lab 100% Hands-On


Curso Presencial voltado a configuração de Switches Cisco. Domine as principais caracteristicas do protocolo Ethernet.

Descrição:

Ethernet é o protocolo dominante em redes de Camada 2 já há muitos anos em ambiente LAN e a cada dia firma-se como a melhor opção em redes MAN e WAN . Este curso se propõe a realizar, de forma prática, a configuração e o Troubleshooting de Switches Cisco Ethernet de forma 100% prática.

Metodologia E-Doing (Aprenda Fazendo):

Os alunos irão construir um cenário a partir do zero, levantando todas as configurações, de modo a ter um exemplo de rede Ethernet com imagens de Switches de Camada 2 e 3, configurando todos os protocolos necessários para tornar a Rede estável e segura.

Público-Alvo: Profissionais de TI que desejam dominar os fundamentos de Redes Ethernet para prestar Exames Cisco da Carreira de Routing & Switching ou para melhorar suas capacidades de configuração e troubleshooting em Switches Cisco L2 e L3.

Local:

Rua Marquês de Itu, 408 - Conjunto 24
Vila Buarque - São Paulo - SP (Próximo a Estação República do Metrô)


Vagas Limitadas - garanta já a sua!!! Está longe de SP ? Acompanhe o curso remotamente em Tempo Real!!!

Conteúdo Programático:

Dia 01 - Configuração e Administração de um Switch Cisco
- Comandos Básicos em um Switch Cisco
- Funcionamento da tabela CAM
- Protocolos de camada 2 - CDP, LLDP e UDLD
- Criação de VLANs - portas de acesso e trunk, vlan database, tipos de VLANs
- Protocolo VTP versões 1,2 e 3 - VTP pruning, encapsulamento dot1Q, VLAN Nativa.
- EtherChannels - negociação via LACP, PAgP e configuração manual, funcionamento em camada 2 e 3, balanceamento de carga
- Protocolo Spanning Tree - PVST+, RPVST+, MST, Switch priority, port priority, path cost, STP timers
- Spanning-Tree Tool-Kit - PortFast, BPDUguard, BPDUfilter, Loopguard e Rootguard
- Captura de dados para análise com SPAN e RSPAN

Dia 02 - Infraestrutura de Serviços e Segurança
- Hardening da Caixa - Configurando senhas e desabilitando serviços desnecessários
- DHCP snooping
- IP Source Guard
- Dynamic ARP inspection
- Port security
- Troubleshoot de interfaces em Err-disable
- Private VLAN
- Storm control
- Autenticação, Autorização e Account - AAA com TACACS+ e RADIUS
- Protocolos de Redundância de primeiro salto - HSRP, VRRP e GLBP

Diferenciais:

Uso do Emulador EVE (Emulated Virtual Environment) que permite a criação de cenários Multivendor com soluções de dezenas de fabricantes. Os alunos poderão baixar e criar seu próprio servidor local, de modo a utiliza-lo para testes e homologação de cenários de Redes Reais.
120 dias de acesso a Plataforma NetFindersBrasil, onde o aluno poderá interagir via Fóruns de Aula para sanar suas dúvidas após a realização do Treinamento

Periodo:

Dias 27/01/2017 e 03/02/2017 - das 09:00 as 18:00 - com intervalo de 01 hora para almoço e coffee-breaks nos períodos da manhã e tarde

Carga Horária: 16 horas

Investimento:

R$ 590,00 - Podendo ser parcelado em até 12X via PagSeguro

Mini-Curriculum do Instrutor:

·Adilson Aparecido Florentino é Tecnólogo em Processamento de Dados pela Universidade Mackenzie e Especialista em Redes de Computadores pela FASP - Faculades Associadas de São Paulo. Atua como Instrutor Cisco desde 2001, primeiro no Programa Cisco Network Academy e atualmente como Instrutor Cisco CCSI # 33706.Possui as Certificações CCNA RS, CCNA Voice, CCNA Security, CCNA Wireless, CCDA, CCDP e CCNP RS.
·Fundador e CEO da EAMSOFT Consultoria e Treinamento em Informática Ltda. Atuou como Professor Universitário em diversas Instituições de Ensino tais como FATEC, IFSP, UNICID, FIAP e IBTA. Prestador de SErviços para o NIC.br nos cursos de IPv6 e Boas Práticas em BGP
·Autor do Livro IPv6 na Prática - primeiro livro em português sobre o tema. Consultor independente atuando em várias empresas em Projetos de Rede e treinamento utilizando roteadores Cisco, Juniper e Mikrotik

Garanta já a sua vaga comprando esta Oficina Hand-On pelo botão abaixo:








Maiores Informações pelo e-mail: adilson.aflorentino@eamsoft.com.br

10 de jan de 2018

Preparatório CCIE Written 400-101 - Fevereiro de 2018 - aos Sábados

Devido a grande procura pelo Preparatório para o Exame CCIE Written aos Sábados em 2017, o NetFindersBrasil está lançando a primeira turma aos sábados de 2018 agora em fevereiro.


O objetivo deste curso é preparar os candidatos para passar no Exame Teórico - CCIE Written - e estarem aptos a realizar o curso Bootcamp CCIE Hands-on, a ser realizado no segundo semestre de 2018. Após passarem no Exame Teórico, os candidatos renovarão todas as suas Certificações Cisco de nível CCNA e CCNP e terão 18 meses para prestar e passar no Exame Prático.

O curso ocorre na região central de São Paulo. São apenas 10 vagas, à um valor promocional de R$ 1.990,00

Os treinamentos serão ministrados aos Sábados, das 09:00hs às 18:00hs, com intervalo de 1 hora para almoço e coffee-breaks. O pagamento pode ser parcelado no Cartão de Crédito via PagSeguro.

Os participantes contarão também com acesso a Laboratórios similares aos Cobrados no Exame CCIE, de forma a já se ambientarem com o ritmo e o conteúdo cobrado no Exame Prático

◦Quando:

Preparatório CCIE Written 400-101 - dias 24/02, 03/03, 10/03, 17/03, 24/03, 31/03, 07/04 e 14/04, sempre das 09:00hs às 18:00hs

Conteúdo Programático: 64 horas - 8 encontros de 8 horas cada:

Aula 01 - LAN Switching
Aula 02 - IP Networking
Aula 03 - IP IGP Routing
Aula 04 - IP BGP Routing
Aula 05 - QoS & WAN
Aula 06 - IP Multicast & Security
Aula 07 - MPLS
Aula 08 - Evolving Technologies

◦Onde:

Rua Marquês de Itu, 408 - Conjunto 24 (próximo a Estação República do Metrô)

◦Investimento: R$ 1.990,00 (Podendo ser parcelado no Cartão de Crédito via PagSeguro).

◦Carga Horária: 64 horas presenciais.

◦Diferenciais: Os alunos terão acesso, desde o momento em que sua matrícula for confirmada, um ambiente criado no Servidor Moodle do netfindersbrasil.com.br contendo uma série de materiais para que os alunos se preparem para os Exames Teórico e Prático, sendo que os Fóruns de Dúvidas de cada Aula estarão disponíveis

Solicite informações sobre as inscrições pelo e-mail: adilson.aflorentino@eamsoft.com.br

Python para Engenheiros de Redes - Parte V



Olá Pessoal Bom Dia, depois de uma breve pausa por festas de final de ano, vamos continuar com nosso curso de introdução à programação Python.

Hoje continuaremos falando dos tipos de dados que existem em python e sobre a condicional “if”, que é uma das sentenças utilizadas para controlar o fluxo do nosso programa.

No post anterior, conhecemos o que são as listas, as quais servem para agrupar uma série de valores em uma única variavél. Existe um tipo de dado que tem uma função similar chamado de dicionário, os dicionários são estruturas de dados que permitem armazenar um conjunto não organizado de pares do tipo Key-Value (Chave-Valor), sendo as chaves únicas dentro de um mesmo dicionário.

Vejamos um exemplo para esclarecimento, vamos armazenar os valores de ip, usuário e senha para dois roteadores R1 e R2:


>>> R1={'ip':"192.168.0.100",'user':"cisco",'senha':"cisco123"}
>>> R1
{'ip': '192.168.0.100', 'user': 'cisco', 'senha': 'cisco123'}
>>> R2={'ip':"192.168.0.101",'user':"cisco2",'senha':"cisco456"}
>>> R2
{'ip': '192.168.0.101', 'user': 'cisco2', 'senha': 'cisco456'}
>>>

Do exemplo acima podemos ver que um dicionário é definido entre chaves {}, e que cada elemento dentro do dicionário é separado por vírgula. Para a definição dos pares chave-valor é utilizado o símbolo “:”

Sendo assim temos o elemento dicionário R1, contém os seguintes pares chave:valor

'ip':"192.168.0.100"
'user':"cisco"
'senha':"cisco123"

A chave pode ser númerica também, no caso eu utilizei uma chave do tipo string.

Vejamos alguns métodos que é possível executar nos dicionários:

O número de elementos do dicionário:

>>> numElemR1 = len(R1)
>>> numElemR1
3
>>>

As chaves do dicionário:

>>> keys=R1.keys()
>>> keys
['ip', 'user', 'senha']


Os valores do dicionário:

>>> values=R1.values()
>>> values
['192.168.0.100', 'cisco', 'cisco123']
>>>

Acessando um elemento em particular do dicionário utilizando o valor da chave:

>>> R1_ipaddress=R1['ip']
>>> R1_ipaddress
'192.168.0.100'
>>>


Adicionando um par chave: valor no dicionário, no exemplo o par "command:show run" :

>>> R1.setdefault('command','show run')
'show run'
>>> R1
{'ip': '192.168.0.100', 'command': 'show run', 'user': 'cisco', 'senha': 'cisco123'}
>>>


Modificando o valor,

>>> R1['command']="show ip int bri"
>>> R1
{'ip': '192.168.0.100', 'command': 'show ip int bri', 'user': 'cisco', 'senha': 'cisco123'}
>>>


Eliminando um elemento do dicionário utilizando “pop”:

>>> R1.pop('command')
'show run'
>>> R1
{'ip': '192.168.0.100', 'user': 'cisco', 'senha': 'cisco123'}
>>>



Scripting:

Até agora temos trabalhado com o interpretador de python de forma interativa, porém existe uma outra forma que é a mais utilizada, e com a qual vamos trabalhar a grande maioria do tempo, é a chamada forma de “script”.

Basicamente vamos colocar o nosso código em um arquivo texto de extensão “*.py” e chamar o interpretador para que o código seja executado. Eu chamei o script de "meuprimeiroscript.py".


Do exemplo acima a primeira linha “#!/usr/bin/python” sinaliza qual é o interpretador que vamos utilizar no caso o python, a terceira linha que começa com o símbolo “#”, é um comentário. O interpretador irá descartar essa linhas, porém para nós eles ajudam bastante no momento de ler o código.

Executemos o nosso primeiro script, não esqueçam de dar permissão de execução ao seu arquivo via comando “chmod”.





Pronto!! Acabamos de executar o nosso primeiro script python!.


Indentação:
Em outras linguagens de programação, blocos de instrução como if, for, while, iniciam e finalizam com chaves {}. Em python existe o conceito de “indentação”, que não é outra coisa que um espaçamento do texto em referência à margem esquerda vejamos um exemplo:




Do exemplo acima a primeira linha vermelha começando pelo lado esquerdo, não tem espaços vazios, então ela tem indentação=0, e todas as linhas de código que tenham indentação =0 farão parte de um bloco de instruções, depois da linha “if x==1”, tem um primeiro espaço, é dizer indentação=1, fazem parte desse bloco as linhas “print(“X=1”) e “if y==2”; por último depois do “if y==2” vem mais um espaço vazio, o que da indentação=2 , a linha “print(“X=1 e Y=2”) faz parte desse bloco de instrução. Finalizado o bloco de indentação=2, voltamos à indentação=0 onde a linha “print(“Feliz Natal”) será executada.

A indentação em python é similar aos {} em outras linguagens, por exemplo um código similar em php:


$x=1;
$y=2;
if ($x==1) {
 echo "$x";
 if ($y==2) {
  echo "$x,$y";
 }
}

Em php, são as chaves que indicam os blocos de instruções.

Podemos ver que a profundidade da indentação ajuda a definir os blocos de instruções. A indentação é de vital importância em python, o mau uso dela, acarreta geralmente em errors de interpretação, vejamos alguns exemplos:



Quando rodamos o exemplo acima obtemos o seguinte erro:




O erro é devido ao fato que o interpretador espera depois da linha “print(“X=1”)”, uma linha de código na mesma profundidade de indentação do print, isso porque o print não é um comando que inicia um bloco de execução, como if, while, for, with etc.

Vejamos outro exemplo:



Ao executar o código acima temos:




O erro dessa vez acontece, porque depois do “if y==2”, o interpretador python espera mais um nível de indentação, porém em vez disso temos o “print(“X=1 e Y+2”)” no mesmo nível.

Como regra geral, toda vez que precisem utilizar algum bloco if, while, for with etc adicionem mais um nível de indentação, em outras palavras adicionem mais um espaço vazio.



Controle de Fluxo:

Condicional “if”:

if condição:
 linha1
 linha2
….

A sentença “if”, é utilizada caso queira se executar um bloco de instruções se uma certa condição/condições é/são verdadeiras.

Para avaliar se uma “condição” é verdadeira ou não, geralmente é utilizada uma série de operadores que podem ser de comparação , lógicos, booleanos etc. Nesse link https://www.tutorialspoint.com/python/python_basic_operators.htm podem encontrar todos os operadores que existem em python.

Exemplo utilizando “if” com operador de comparação igual “==”:

x=10

if x==10:
 print(“X=10”)


O código acima vai printar a mensagem “X=10” sempre e quando a condição de igualdade “x==10” seja verdadeira. Se trocarnos o valor de x, para qualquer outro valor diferente de 10, a condição vai ser falsa e o print não será executado:

Outro exemplo utilizando o operador booleano “and”


x=1
y=2

if x==1 and y==2 :
 print(“X=1 e Y=2”)

No exemplo acima, para que o print seja executado, é preciso que as duas condições sejam verdadeiras tanto “x==1” como “y==2”.

Utilizando o operador “or”


x=1
y=3

if x==1 or y==2 :
 print(“X=1 ou Y=2”)


Trocamos o valor de “y” para y=3. A condição “x==1” continua sendo verdadeira , porém a condição “y==2” agora é falsa. Como estamos utilizando o operador “or”, basta uma das condições ser verdadeira, no caso “x==1”, para o print ser executado, se rodar o código acima a mensagem do print será exibida na tela.


Condicional “if..else”:

if condição:
 linha1
 linha2
 …
else:
 linha3
 linha4


A condição “if..else”, serve para quando queremos executar código, caso a condição que estamos avaliando, de como resultado falso.


R1=['192.168.0.100','cisco','cisco123','show ip ospf']

if 'ospf' in R1[3]:
 print(“Vamos executar um comando ospf em R1”)
else:
 print(“O roteador R1, nao contem comandos ospf a serem executados”)


Do exemplo acima, se a palavra “ospf” existe no elemento da lista R1[3], é executado o print indicando que existe um comando ospf, caso contrário, um print indicando que não existem comandos ospfs em R1 é executado.

Condicional “if..elif..elif..else”


if condição:
 linha1
 linha2
elif condição:
 linha3
 linha4
elif condição:
 linha5
 linha6
else:
 linha7
 linha8


As vezes é preciso executar blocos de instruções, para um determinado número de condições:

Exemplo


x=10

if x<10:
 print(“X <10”)
elif x>10:
 print(“X >10”)
else:
 print(“X=10”)


No código acima, estamos avaliando duas condições, se “x>10” e se “x<10”, e caso nenhuma das condições acima seja cumprida, então quer dizer que “x=10”

Por hoje é isso, espero que tenham gostado do post, eu sei que para nós engenheiros de redes as vezes nos resulta um pouco tedioso aprender a programar, porém acreditem depois de aprenderem um novo mundo de possibilidades será aberto...










5 de jan de 2018

CCNA 200-125 - Curso Presencial em SP - Fevereiro de 2018


Uma excelente oportunidade para aqueles que residem na cidade de São Paulo e região, estão abertas as inscrições para o Preparatório CCNA 200-125 em fevereiro de 2018. Vagas Limitadas!!!

O curso ocorre em São Paulo - Capital. São apenas 10 vagas, à um valor promocional de R$ 1.590,00

O curso será ministrado de segunda a sexta, das 09:00hs às 18:00hs, com intervalo de 1 hora para almoço e coffee-breaks. O pagamento pode ser parcelado em até 12x via PagSeguro.

◦Carga Horária: 40 horas

◦Quando: dias 05/02, 06/02, 07/02, 08/02 e 09/02, sempre das 09:00hs às 18:00hs

◦Onde: Rua Marquês de Itu, 408 - Conjunto 24 - Vila Buarque - São Paulo - SP (próximo a Estação República do Metrô)

◦Quanto: R$ 1.590,00 (Podendo ser parcelado em até 12X via PagSeguro)

◦Diferenciais
: Incluso no valor do investimento acesso ao Curso CCNA Routing & Switching em Modo Gravado via ambiente Portal de Treinamentos NetFindersBrasil (o acesso é liberado logo após a confirmação do pagamento do curso e se estende por 120 dias após o término do curso presencial).

Conteúdo Programático:


Aula 01
Introdução as Carreiras Cisco
Apresentando o Exame 200-120
Modelo de referência ISO-OSI
O modelo de referência TCP/IP
Switching e VLANs
Configuração de Switches (Security, VLANs, Etherchannel)

Aula 02
Endereçamento IPv4
Subredes
Variable Lenght Subnet Masks (VLSM)
Classless Interdomain Routing (CIDR)
IPv6
Subredes IPv6

Aula 03
O sistema operacional Cisco IOS
O processo de licenciamento do IOS 15
Apresentação do Cisco Configuration Professional (CCP)
Gerenciamento básico de uma rede
Autenticação local de usuários
SNMPv2 e v3
Cisco Netflow
Syslog
Listas de Controle de Acesso (ACLs)

Aula 04
O processo de roteamento IP
Roteamento IP Estático
Roteamento IP dinâmico (RIPv1 e RIPv2)
Roteamento IP dinâmico – EIGRP
Roteamento IP dinâmico – OSPF multi-area
Sumarização de rotas (configuração)
Roteamento IPv6 estático
Roteamento IPv6 dinâmico – RIPng
Roteamento IPv6 dinâmico -OSPFv3
Roteamento IPv6 dinâmico – EIGRP

Aula 05
Protocolos WAN (HDLC / PPP / PPPoE / Metro Ethernet e MPLS)
Conceitos de QoS
First Hop Redundancy Protocols (HSRP, VRRP e GLBP)
Prática de Cenários para o exame: Laboratórios

◦IMPORTANTE: Os alunos deverão trazer notebook para a realização dos laboratórios utilizando o EVE-ng.

Os interessados devem enviar e-mail solicitando instruções para matricula para:

adilson.aflorentino@eamsoft.com.br

◦Inscrições por tempo limitado. São apenas 10 vagas. Garanta já a sua !!!

LinkWithin

Related Posts with Thumbnails