sexta-feira, 6 de junho de 2014
CORE
O CORE (link aqui) é um emulador de redes bastante interessante (provavelmente um dos melhores que eu já vi).
Estou criando um pequeno tutorial para uso dele (e do Quagga) e, assim que tiver terminado o mesmo, irei postar aqui para que possam ler. Vou tentar fazer no formato de texto, assim como um ppt com os principais passos e comandos.
Ele utiliza virtualização sobre Linux (e FreeBSD) e implementa switches e roteadores (entre outras coisas mais) usando software real, não simulado.
Para roteadores, ele utiliza o Quagga ou uma versão modificada do mesmo para operar com redes MANET.
Os roteadores podem ser acessados como se fossem equipamentos físicos e podemos dar comandos no mesmo, a semelhança do que seria feito sobre um Cisco, por exemplo.
Vale a pena olhar!!
Controlador SDN - Parte 2
Bom, antes de qualquer coisa, é importante avisar que o código que descreve a topologia do post anterior, caso se queira testar a rede, necessariamente deve usar algum controlador que implemente um método de spanning tree, sob pena do Mininet ficar inoperante... razões óbvias para tanto...
Um módulo do POX que pode ser usado é o samples.spanning_tree.
quarta-feira, 4 de junho de 2014
Controlador SDN - Parte 1
Como parte de um trabalho para um disciplina do meu doutorado, estou desenvolvendo um controlador SDN, baseado justamente no POX (veja outros posts associados).
A idéia é que o controlador seja capaz de fazer o balanceamento de uma conexão TCP sobre diversos caminhos distintos.
Isso poderia ser feito ao natural, por exemplo, em uma rede onde os roteadores, em razão da configuração do seus protocolos e esquemas de roteamento, decidissem encaminhar pacotes por caminhos distintos. Porém, mesmo nesse caso, não haveria um controle explícito do encaminhamento de pacotes por caminhos diferentes para uma dada conexão TCP. Esse balanceamento seria feito apenas baseado na chegada dos pacotes, independente do conteúdos dos mesmos.
Bom, como essa idéia de trabalho visa mostrar as potencialidades de uso das SDNs, vale a pena ir descrevendo o desenvolvimento do mesmo aqui.
Inicialmente (e apenas inicialmente), iremos considerar uma topologia de referência para começar o desenvolvimento.
A topologia em questão pode ser vista abaixo.
Fácil notar que é uma rede bastante simples, porém que oferece diversas possibilidades de caminhos alternativos entre quaisquer dois hosts. Para facilitar a nomenclatura, os hosts (são dois por cada comutador) são nomeados na forma H1SX e H2SX, onde SX indica o switch SDN ao qual o host está conectado.
A partir dessa topologia, foi criado um script para iniciar o mininet, conforme indicado abaixo:
Essa topologia inicial para o mininet foi criada a partir do próprio modelo oferecido na documentação do mininet (que pode ser visto aqui).
A idéia é que o controlador seja capaz de fazer o balanceamento de uma conexão TCP sobre diversos caminhos distintos.
Isso poderia ser feito ao natural, por exemplo, em uma rede onde os roteadores, em razão da configuração do seus protocolos e esquemas de roteamento, decidissem encaminhar pacotes por caminhos distintos. Porém, mesmo nesse caso, não haveria um controle explícito do encaminhamento de pacotes por caminhos diferentes para uma dada conexão TCP. Esse balanceamento seria feito apenas baseado na chegada dos pacotes, independente do conteúdos dos mesmos.
Bom, como essa idéia de trabalho visa mostrar as potencialidades de uso das SDNs, vale a pena ir descrevendo o desenvolvimento do mesmo aqui.
Inicialmente (e apenas inicialmente), iremos considerar uma topologia de referência para começar o desenvolvimento.
A topologia em questão pode ser vista abaixo.
A partir dessa topologia, foi criado um script para iniciar o mininet, conforme indicado abaixo:
#!/usr/bin/python
#coding: utf-8
"""
Cria a topologia inicial para testes com o controlador SDN. A topologia segue a
descrição e modelo proposto e documentado como topologia inicial, consistindo
em 8 switches interconectados de modo específico, conforme o diagrama
rede_topologia_inicial.jpg. Cada switch possui dois hosts, seguindo a
nomenclatura indicada no mesmo diagrama.
Autor: Ricardo Balbinot
Data: junho/2014
"""
from mininet.topo import Topo
class Topologia_Inicial(Topo):
""" Cria a tpologia indicada"""
def __init__( self ):
""" Inicializa a topologia"""
# Inicializa a topologia
Topo.__init__(self)
# Adiciona os switches
sw1 = self.addSwitch('sw1')
sw2 = self.addSwitch('sw2')
sw3 = self.addSwitch('sw3')
sw4 = self.addSwitch('sw4')
sw5 = self.addSwitch('sw5')
sw6 = self.addSwitch('sw6')
sw7 = self.addSwitch('sw7')
sw8 = self.addSwitch('sw8')
# Adiciona os hosts
h1s1 = self.addHost('h1s1')
h2s1 = self.addHost('h2s1')
h1s2 = self.addHost('h1s2')
h2s2 = self.addHost('h2s2')
h1s3 = self.addHost('h1s3')
h2s3 = self.addHost('h2s3')
h1s4 = self.addHost('h1s4')
h2s4 = self.addHost('h2s4')
h1s5 = self.addHost('h1s5')
h2s5 = self.addHost('h2s5')
h1s6 = self.addHost('h1s6')
h2s6 = self.addHost('h2s6')
h1s7 = self.addHost('h1s7')
h2s7 = self.addHost('h2s7')
h1s8 = self.addHost('h1s8')
h2s8 = self.addHost('h2s8')
# Cria os enlaces dos hosts aos switches
self.addLink(sw1,h1s1)
self.addLink(sw1,h2s1)
self.addLink(sw2,h1s2)
self.addLink(sw2,h2s2)
self.addLink(sw3,h1s3)
self.addLink(sw3,h2s3)
self.addLink(sw4,h1s4)
self.addLink(sw4,h2s4)
self.addLink(sw5,h1s5)
self.addLink(sw5,h2s5)
self.addLink(sw6,h1s6)
self.addLink(sw6,h2s6)
self.addLink(sw7,h1s7)
self.addLink(sw7,h2s7)
self.addLink(sw8,h1s8)
self.addLink(sw8,h2s8)
# Cria os enlaces entre os switches
self.addLink(sw1, sw2)
self.addLink(sw1, sw4)
self.addLink(sw2, sw3)
self.addLink(sw3, sw4)
self.addLink(sw3, sw5)
self.addLink(sw4, sw5)
self.addLink(sw4, sw6)
self.addLink(sw5, sw8)
self.addLink(sw6, sw7)
self.addLink(sw6, sw8)
self.addLink(sw7, sw8)
topos = { 'topologia_inicial': ( lambda: Topologia_Inicial() ) }
Essa topologia inicial para o mininet foi criada a partir do próprio modelo oferecido na documentação do mininet (que pode ser visto aqui).
domingo, 1 de junho de 2014
SDN e POX
Pessoal,
Iniciando essa postagem para conversar um pouco sobre um outro simulador/emulador (tecnicamente falando, é um emulador): Mininet.
O Mininet é especialmente focado na emulação de redes SDN (Software Defined Networks). SDNs são redes definidas por software, ou seja, onde o plano de controle da rede é implementado, possivelmente, fora do equipamento comutador. Ou seja, por exemplo, um switch Ethernet pode ter todas as funções de aprendizado, por exemplo, externas ao chassi do equipamento.
Bom, eu vou comentar um pouco mais sobre o Mininet em outros momentos, mas agora o importante é focar em um dos possíveis controladores para SDN que podem ser facilmente usados com o Mininet, que é o POX.
Maiores referências sobre o POX podem ser obtidas aqui, e sobre o Mininet aqui.
Alguns links associados ao POX:
Para desenvolvimento, recomenda-se o uso de debug-pox.py.
Os parâmetros associados a esse comando são os módulos/componentes que devem ser instanciados pelo controlador. Podem ser instanciados vários componentes, e os componentes podem ter dependências entre si, e podem ser especificados parâmetros para os mesmos via --parametro.
Numa lista bem curta (de quem ainda está aprendendo e quer lembrar disso depois), os seguintes componentes são importantes:
Iniciando essa postagem para conversar um pouco sobre um outro simulador/emulador (tecnicamente falando, é um emulador): Mininet.
O Mininet é especialmente focado na emulação de redes SDN (Software Defined Networks). SDNs são redes definidas por software, ou seja, onde o plano de controle da rede é implementado, possivelmente, fora do equipamento comutador. Ou seja, por exemplo, um switch Ethernet pode ter todas as funções de aprendizado, por exemplo, externas ao chassi do equipamento.
Bom, eu vou comentar um pouco mais sobre o Mininet em outros momentos, mas agora o importante é focar em um dos possíveis controladores para SDN que podem ser facilmente usados com o Mininet, que é o POX.
Maiores referências sobre o POX podem ser obtidas aqui, e sobre o Mininet aqui.
POX
O POX é um controlador e biblioteca para desenvolvimento de controladores SDN em Python.Alguns links associados ao POX:
- Manual/Tutorial do POX
- https://github.com/Lafaiet/POXDoc/blob/master/PT_BR/Main.md
- ou, em inglês (prefiro esse):
- https://openflow.stanford.edu/display/ONL/POX+Wiki
- Tutorial para início de trabalho com o OpenFlow e POX
Acionando ou invocando o controlador
Isso é feito via pox.py ou via debub-pox.py.Para desenvolvimento, recomenda-se o uso de debug-pox.py.
Os parâmetros associados a esse comando são os módulos/componentes que devem ser instanciados pelo controlador. Podem ser instanciados vários componentes, e os componentes podem ter dependências entre si, e podem ser especificados parâmetros para os mesmos via --parametro.
Alguns componentes úteis
Numa lista bem curta (de quem ainda está aprendendo e quer lembrar disso depois), os seguintes componentes são importantes:
- forwarding.l2_pairs - implementa um switch clássico, com o método de aprendizagem comum (obs: não oferece proteção contra loops, visto que não implementa nenhum tipo de spanning tree)
- forwarding.l2_multi - semelhante ao anterior, porém primeiro descobre a topologia global da rede e então monta as tabelas de comutação para uma certa origem em todos os switches envolvidos
- openflow.spanning_tree - implementa um mecanismo ala spanning tree (muito embora de um modo significativamente distinto)
- openflow.of_01 - é o componente que implementa e se comunica com o OpenFlow v1.0
- openflow.discovery - permite realizar a descoberta da topologia da rede
- openflow.keepalive - necessário para manter a conectividade com os switches, enviando echo requests periodicamente
- proto.arp_responder - um utilitário que implementa o protocolo ARP
- proto.dhcpd - implementa um servidor DHCP no controlador
- misc.gephi_topo - permite a visualização da topologia no utilitário Gephi
- log - permite customizar as mensagens de log geradas
- log.color - permite habilitar e customizar cores para uso com as mensagens de log
- log.level - permite especificar o nível de log a ser utilizado por cada logger no ambiente
Assinar:
Postagens (Atom)