Máquina Virtual VM MiniNet

A MiniNet

Para a criação de uma arquitetura SDN é necessário múltiplos componentes em sua infraestrutura. Inicialmente precisamos de uma máquina controladora(controlador) operando algum sistema operacional de rede, como por exemplo, o NOX ou o POX. Posteriormente se fazem necessários elementos encaminhadores que tenham o plano de controle(software dedicado) separado do plano de dados(hardware dedicado) com alguma interface de programação, como por exemplo o OpenFlow. Além disso, ainda é necessário toda uma infraestrutura física que interligue esses elementos encaminhadores e o controlador por um canal seguro para a criação de uma Rede Definida por Software.

Ocorre que nem sempre um pesquisador dispõe de uma infraestrutura como essa para realizar seus experimentos, pois essa estrutura possui um custo elevado. Para lidar com esse problema é possível usar um simulador de Redes Definidas por Software.

A MiniNet é uma ferramenta para a simulação de Redes Definidas por Software que permite a rápida prototipação de uma grande infraestrutura virtual de rede com a utilização de apenas um computador. A Mininet também possibilita a criação de protótipos de redes virtuais escaláveis baseados em software como OpenFlow utilizando primitivas de virtualização do Sistema Operacional. Com essas primitivas, ele permite criar, interagir e customizar protótipos de Redes Definidas por Software de forma rápida.

São algumas características do MiniNet:

• Fornecer uma maneira simples e barata para a realização de testes em redes para desenvolvimento de aplicações OpenFlow;

• Permite que múltiplos pesquisadores possam trabalhar de forma independente na mesma topologia de rede;

• Permite o teste de uma topologia grande e complexa, sem mesmo a necessidade de uma rede física;

• Inclui ferramentas para depurar e executar testes em toda a rede;

• Dá suporte a inúmeras topologias, e inclui um conjunto básicos de topologias;

• Oferece API’s simples em Python(POX) para criação e experimentação de redes.

Com a MiniNet é possível realizar testes de depuração e de resoluções de problemas podendo se beneficiar de ter uma rede completa experimental em um laptop ou PC. Fornece, de maneira intuitiva, ferramentas para o desenvolvimento de aprendizagem na área de redes. Sua interface permite sua utilização em pesquisas e em aulas para o uso prático de técnicas e soluções de redes. A MiniNet é melhor executado em máquina virtual (VM MiniNet) sendo executada em VMware ou VirtualBox para os sistemas operacionais Windows, Mac e Linux com ferramentas OpenFlow já instaladas.

Mesmo com todas essas qualidades a MiniNet ainda não fornece desempenho e qualidade fieis de uma rede real, embora o código utilizado nele sirva para uma rede real baseada em switches de software NetFPGAs 1 , ou switches e, hardware comerciais. Isso ocorre devido aos recursos que são multiplexados em tempo real pelo kernel da máquina simuladora, e uma vez que a largura de banda total é limitada por restrições de CPU e memória da mesma.

Esta postagem irá apresentar um passo-a-passo dos principais comandos da MiniNet, assumindo uma utilização com máquinas virtuais. Mostrará também o passo-a-passo de como estabelecer um ambiente virtual de testes para a criação e o desenvolvimento de uma arquitetura baseada em Redes Definidas por Software. Com as explicações desta postagem é possível compreender melhor a MiniNet e, assim, poder executar os componentes do POX(por exemplo) em uma rede virtual, conforme será apresentado.

O Funcionamento

Quase todos os sistemas operacionais virtualizam os recursos de computação usando uma abstração de processos. A MiniNet usa processos baseados na virtualização de vários hosts e switches executados em um único kernel do sistema operacional.

A MiniNet pode criar switches OpenFlow, controladores e hosts para a comunicação da rede simulada. A MiniNet conecta switches e hosts usando enlaces ethernet virtuais entre os pares.A MiniNet ainda depende do kernel do Linux para sua execução, no entanto seus desenvolvedores estão desenvolvendo outras técnicas para sua execução em outros sistemas operacionais com virtualização baseada em processos, como por exemplo o Solaris.

A MiniNet na Prática

São apresentados os procedimentos de instalação e configuração do VM MiniNet, que além de recomendado pelos desenvolvedores é mais simples e pode ser executado em Windows, Mac e Linux por meio de uma VMware, VirtualBox, QEMU ou KVM.

Pré-Requisitos

É necessário um computador com 2GB de RAM e pelo menos 6GB de espaço livre no disco rígido. Um processador mais rápido pode acelerar o tempo de boot da máquina virtual, e uma tela maior pode ajudar a gerenciar as múltiplas janelas de terminal.

Download VM MiniNet

O download da VM Mininet pode ser feito em https://github.com/downloads/mininet/mininet/mininet-vm-ubuntu11.10-052312.vmware.zip . Nele está incluído uma imagem de disco VMware no formato .vmdk (disco de máquina virtual) no qual pode ser usado na maioria dos sistemas de virtualização. É necessário também um terminal capaz de se conectar via SSH 2 e um servidor. Com todos esses requisitos devidamente instalados basta inicializar a máquina virtual com o software de virtualização de preferência e extrair o arquivo baixado.

Configuração da VM MiniNet

Antes de executar o VM MiniNet algumas configurações são necessárias em seu software de virtualização:

• A escolha do sistema operacional deve ser o Linux Ubuntu;

• A alocação deve ser de pelo menos 512Mb de memória para a máquina virtual;

• Utilizar duas placas de rede na máquina virtual, sendo uma destinada a sua própria rede interna (NAT) e outra para uma interface entre a máquina virtual e máquina física para o uso do SSH (host-only network)

Para realizar essas configurações consulte a ajuda do software de virtualização utilizado. Neste ponto o sistema está pronto para a execução do VM MiniNet. Quando estiver executando a máquina virtual use os seguinte parâmetros:

• Username: openflow

• Password: openflow

A conta root não está ativada para login, é possível utilizar o comando ’sudo’ para realizar comandos como superusuário. Primeiro encontre os endereços IPs da máquina virtual, no terminal escreva:

$ ifconfig

Será possível ver três interfaces (Ex.: eth0, eth1 e lo). As duas primeiras são as configurações das duas placas de rede já configuradas antes de executar a máquina virtual. Caso seja possível ver, basta executar o comando:

$ sudo dhclient eth0

$ sudo dhclient eth1

Obs: Pode ser que precise executar duas vezes o comando.

Execute novamente o comando ’ifconfig ’ para habilitar as interfaces, que agora poderão ser vistas. Em alguns casos essas interfaces estão com outros nomes, no entanto o padrão é ’ethX’, onde ’X’ é algum número, execute os comandos com esses nomes e verifique se as interfaces são habilitadas. Com as interfaces habilitadas anote o endereço IP da segunda interface (host-only network) que provavelmente seguirá o padrão de IP da sua máquina física. Após isso não é necessário utilizar mais o terminal da máquina virtual, pois com este IP podemos conectar a máquina física na máquina virtual via SSH, tornando mais fácil a execução de comandos e o uso de múltiplas janelas de terminal.

Acessando a VM MiniNet via SSH

Com todos os requisitos instalados e as configurações feitas siga:

Para usuários de Mac OS X e Linux: Abra um terminal e digite:

$ ssh -X openflow@[Endereço IP anotado]

Após isso será pedido o password, digite openflow . A opção ’-X’ é para habilitar

o servidor X na máquina virtual. Execute:

$ xterm

Uma nova janela de terminal deve aparecer. Se tiver sucesso então está feita a configuração básica. Feche o xterm. Caso não tenha sucesso verifique a instalação do servidor X na plataforma. Caso queira outras janelas de SSH repita o processo.

Aprendendo as Ferramentas de Desenvolvimento

Esta seção apresenta o ambiente de desenvolvimento para a fácil familiarização das ferramentas utilizadas. São cobertas tanto ferramentas de depuração quanto ferramentas específicas de OpenFlow.

Definição dos termos, começando com os tipos de terminais:

Terminal da máquina virtual: Este terminal é o console criado quando você iniciou a MV. Não é possível copiar e colar neste terminal, nenhuma das ações com o mouse terá efeito neste terminal, inclusive barras de rolagem. Não será necessário o uso deste terminal, uma vez que você consiga configurar a rede.

Terminal SSH: Ele é criado a partir do software de SSH, conforme apresentado na seção anterior. Este terminal é utilizado para se conectar ao shell da máquina virtual. É possível copiar e colar por este terminal além de ter barra de rolagem de pelo menos 500 linhas.

Terminal xterm: Ele é utilizado para se conectar a um host da rede virtual. Ele é utilizado dentro do CLI 6 do MiniNet para que se possa ter múltiplas janelas para o desenvolvimento. Ele se conectará a uma elemento da rede virtual. A VM MiniNet contém uma série de ferramentas de rede pré-instaladas, sejam gerais ou específicas do OpenFlow. Algumas delas são:

Controlador OpenFlow: Situa-se acima da interface OpenFlow. A MV contém um controlador de referência pré-instalado no ambiente que age como um self learning Switch Ethernet.

Switch OpenFlow: Situa-se abaixo da interface OpenFlow. A MV contém três opções de switches para a rede virtual, switches que utilizem o user-space, switches que utilizem o kernel-space e switches que simulam o Open vSwitch já apresentado na pagina 40.

dpctl: Utilitário de linha de comando que envia mensagens rápidas do protocolo OpenFlow, útil para visualizar portas de switch e estatísticas de fluxo, além de manualmente inserir entradas de fluxo.

Wireshark: Ferramenta gráfica geral para a visualização de pacotes (não é específico de OpenFlow). A distribuição de referência OpenFlow inclui um Wireshark dissector, que disseca e analisa as mensagens OpenFlow enviado pela porta padrão do OpenFlow (6633).

iperf: Ferramenta geral de linha de comando para testar a velocidade de uma única conexão TCP.

MiniNet: A plataforma de simulação de rede que é utilizada.

Principais Comandos do MiniNet

Antes de mostrar as principais configurações para a execução do CLI do MiniNet, será mostrado os principais comando utilizados dentro do CLI do MiniNet. Como já dito assumimos que esteja utilizando a VM MiniNet. Para iniciar o CLI do MiniNet no terminal basta executar o comando:

$ sudo mn

Por padrão uma topologia minima é criada. Essa topologia inclui dois hosts ligados a um switch OpenFlow por um enlace ethernet e um controlador ligado ao switch. Em seguinte o CLI do MiniNet estará sendo executado apresentando no terminal:

mininet>

Obs.: Command-line Interface (CLI) é um meio de interação com um programa de computador onde o usuário (cliente) emite comando para um programa na forma de sucessivas linhas de texto (linhas de comando).

Para exibir os comandos do MiniNet, digite no terminal:

mininet> help

Exibir nós:

mininet> nodes

Exibir links

mininet> net

Mostrar informações sobre todos os nós:

mininet> dump

Se a primeira palavra digitada no CLI do MiniNet for o nome de um nó (switch, host ou controlador), o comando seguinte será executado por este nó. Exemplo:

mininet> h2 ifconfig

Irá apresentar as configurações de IP do host ’h2’. Outra opção é abrir uma janela de terminal separada para o nó desejado, para isso utiliza-se o servidor X. Exemplo:

mininet> xterm h2 h3 s1

Isso irá abrir três janelas cada uma com o nome correspondente ao seu nó. Vá na janela com nome ’switch: s1 (root)’ e execute:

# dcptl dump-flows tcp: 127.0.0.1:6634

Nada irá acontecer, pois o switch ainda não possui entradas de fluxo adicionadas.

Na janela com nome ’host: h2 (root)’ e execute:

# ping 10.0.0.3

Voltando a janela com nome ’switch: s1 (root)’ execute: ’# dcptl dump-flows tcp: 127.0.0.1:6634’. Agora sim é possível ver as entradas de fluxo do switch. O dcptl é um ferramenta que vem com a distribuição de referência OpenFlow permitindo a visibilidade e o controle sobre uma tabela de fluxos de um único switch OpenFlow. Ela é muito útil para a depuração de redes, pois permite exibição do estado dos fluxos e dos contadores de fluxo. A maioria dos switches OpenFlow começa com uma porta de escuta passiva (em sua configuração atual essa porta é 6634), na qual é possível interagir com o switch pela interface OpenFlow, sem ter a necessidade de adicionar código de debugging no controlador. Para exibir o estado das portas e capacidades do switch entre no seu terminal

’xterm’ e execute:

# dcptl show tcp: 127.0.0.1:6634

Para exibir a tabela de fluxo de um switch entre no seu terminal ’xterm’ e execute:

# dcptl dump-flows tcp: 127.0.0.1:6634

Outro comando utilizado dentro do CLI do MiniNet é o:

mininet> iperf

 ou

mininet> iperf [fonte] [destino]

O iperf analisa a largura de banda entre dois hosts da rede.

Um comando para teste de alcance entre todos os nós da rede é o:

mininet> pingall

O comando pingall faz com que todos os hosts da rede enviem pings entre si.

Para sair do CLI do MiniNet:

mininet> exit

Para maiores detalhes de comando utilizados dentro do CLI do MiniNet visite site http://yuba.stanford.edu/foswiki/bin/view/OpenFlow/Mininet e procure a documentação da MiniNet.

O Wireshark

A VM MiniNet possui o OpenFlow Wireshark dissector pré-instalado. O Wireshark é extremamente útil para a análise de mensagens do protocolo OpenFlow bem como depuração de um modo geral. Para iniciar o Wireshark crie uma nova janela SSH e certifique-se que ela executará o servidor X, explicado anteriormente. O comando para abrir o Wireshark é:

$ sudo wireshark &

Você provavelmente vai receber uma mensagem de aviso por usar o Wireshark com acesso root . Ignore o aviso e pressione OK. Clique em Capture -> Interfaces no menu. Abrirá uma nova janela e clique no botão Start ao lado da interface lo(loop back). Neste momento será apresentado uma lista com diversos pacotes em constante incremento. Crie um filtro para controle do tráfego OpenFlow. Na caixa de filtro(filter) coloque of(OpenFlow) e pressione Apply para filtrar o tráfego OpenFlow. Pronto!

Isso inicia um controlador simples, que atua como um learning switch(será explicado mais à frente) sem instalar nenhuma entrada na tabela de fluxo. Será exibida diversas mensagens Wireshark, começando com Hello. Clique em Features Reply. Abrirá uma nova janela, clique no triângulo ao lado de OpenFlow Protocol para exibir os campos de mensagens. Clique em no triangulo ao lado de Switch Features e veja as capacidades do datapath. Sinta-se a vontade, explore os recursos do Wireshark.

Tipos de mensagens OpenFlow apresentadas ao iniciar o controlador.

Hello: após o TCP handshake, o controlador envia seu número de versão para o switch.
(Controlador→Switch)

Hello: o switch responde com seu número de versão suportado.
(Switch→Controlador)

Features Request: o controlador pede ao switch para ver quais portas estão disponíveis.

(Controlador→Switch)

Set Config: O controlador pede ao switch para enviar expirações de fluxo
(Controlador→Switch)

Features Reply: as respostas do switch com uma lista de suas portas e outras características.

(Switch→Controlador)

Port Status: permite ao switch informar ao controlador mudanças de velocidades de porta ou de conectividade. Ignorar este, pois parece que está com problemas nesta versão do OpenFlow.
(Switch→Controlador)

Quando há muitos switches, a análise do Wireshark pode ficar um pouco confusa, pois varias mensagens repetidas vão aparecer. Mas isso não acontece quando criamos a topologia com um único switch. Note que as mensagens de Echo Request / Echo Reply são mensagens para manter a conexão entre os switches e o controlador ativas. Na janela Wireshark, é possível ver uma série de novos tipos de mensagens:

Primeiro vemos a mensagem Packet-In com uma requisição ARP. Logo depois vemos a mensagem Packet-Out que corresponde a ação tomada pelo controlado no switch, esta ação no caso é o envio em broadcast pelas portas do switch com exceção a porta que chegou o pacote. Quando o pacote de resposta chega ao switch este já conhece o caminho para h2(host 2) e neste momento ele envia a mensagem Flow-Mod criando uma entrada na tabela de fluxo do switch. Nos próximos pings, não há envolvimento do controlador, a exibição das mensagens no Wireshark devem parar por ai até a validade do fluxo vencer e apresentar a mensagem Flow-Expired.

Tipos de mensagens OpenFlow apresentadas ao realizar um ping.

Packet-In: o pacote foi enviado ao controlado pois não possui uma entrada correspondente a esse pacote na tabela de fluxo do switch.
Switch→Controlador

Packet-Out: controlador envia um pacote de uma ou mais portas do switch.
Controlador→Switch

Flow-Mod: adiciona uma entrada na tabela de fluxo do switch.
Controlador→Switch

Flow-Expired: um fluxo expirou após um período de inatividade.
Switch→Controlador

Caso tenha qualquer outra dúvida ou dificuldade em de utilizar o Wireshark procure pela documentação em http://www.wireshark.org/ .
.
Topologias

Como já vimos a topologia padrão é um único switch ligado a dois hosts, no entanto você pode criar topologias diferentes. Exemplos:

$ sudo mn --topo single, X

  ou

$ sudo mn --topo linear, X

 ou

$ sudo mn --topo tree,X,Y

A primeira cria uma topologia com um único switch ligados a ’X’ hosts, onde ’X’ é um número. A segunda cria uma topologia linear com ’X’ switches conectados entre si, ligados cada um a ’X’ hosts. A terceira cria uma topologia em árvore de altura ’X’ e com o número ’Y’ de filhos por nó.

Ainda assim é possível criar topologias totalmente diferentes e personalizadas por meio de uma simples API em Python. Um exemplo é fornecido em ’custom/topo-2sw-2host.py’. Este exemplo cria dois switches, ligados entre si, conectados a um host cada. Veja abaixo:

--------------------------------------------------------------------------------------------------------------------------------------------------

" " " Custom topology example

author : Brandon Heller (brandonh@stanford.edu)

Two directly connected switches plus a host for each switch:

host −−− s w i t c h −−− s w i t c h −−− host

Adding the ’ topos ’ dict with a key / value pair to generate our newly defined

topology enables one to pass i n ’−−topo=mytopo ’ from the command l i n e .

"""

from mininet.topo import Topo, Node

class MyTopo ( Topo ) :

    " Simple topology example . "

    def _ _ i n i t _ _ ( s e l f , e n a b l e _ a l l = True ) :

        " Create custom topo . "

        

        # Add default members to class.

        super ( MyTopo , s e l f ) . _ _ i n i t _ _ ( )

        # Set Node IDs for hosts and switches

        leftHost = 1

        leftSwitch = 2

        rightSwitch = 3

        rightHost = 4

        # Add nodes

        self.add_node ( leftSwitch, Node ( i s _ s w i t c h=True ) )

        self.add_node ( rightSwitch, Node ( is_switch=True ) )

        self.add_node ( leftHost, Node ( is_switch=False ) )

        self.add_node ( rightHost, Node( is_switch=False ) )

        

        # Add edges

        self.add_edge ( leftHost , leftSwitch )

        self.add_edge ( leftSwitch , rightSwitch )

        self.add_edge ( rightSwitch , rightHost )

        # Consider all switches and hosts ’ on ’

        self.enable_all ()

  topos = { ’ mytopo ’ : ( lambda : MyTopo ( ) ) }

--------------------------------------------------------------------------------------------------------------------------------------------------

codigos/topo–2sw–2host.py

Veja que é muito simples a criação de topologias customizadas, nas linha 23 a 26 temos o exemplo de como podemos criar os nós da rede, podemos colocar qualquer nome, no entanto temos que identificar um número pra cada nó. Nas linha 29 a 32 temos os exemplo de como adicionar nós a topologia da rede. Utiliza-se o método ’add_node’ identificando em sua segunda entrada se o nó é um switch ou não (true/-false). Nas linhas 35 a 37 temos o exemplo de como podemos criar as arestas entre os nós da rede. Utiliza-se o método ’add_edge’ identificando os pares de nós que estão interligados. Dessa maneira podemos criar topologias totalmente personalizadas de acordo com pesquisa.

Para executar o MiniNet com a topologia customizada execute:

$ sudo mn --custom ~/mininet/custom/minha_topologia.py --topo mytopo

Neste exemplo o arquivo ’minha_topologia.py’ está na pasta ’/mininet/custom/’, mas pode ficar em qualquer pasta do sistema. A opção ’mytopo ’ é o nome da topologia (veja a linha 42).

A MiniNet também fornece APIs para a criação e a configuração de Redes Definidas por Software. Alguns exemplos de uso pode ser encontradas em mininet/examples, suas descrições encontram-se em mininet/examples/README . Destaca-se duas API’s gráficas, não muito utilizáveis mais que consistem em ideias interessantes. Exemplo:

$ sudo ./ mininet/examples/miniedit.py

Abrirá uma janela gráfica com a qual é possível desenhar uma topologia de maneira simples e fácil, no entanto essa API não é funcional e não possível se fazer absolutamente nada com ela, feche-a e ela encerrará o CLI do MiniNet.

Outro exemplo é:

$ sudo ./ mininet/examples/consoles.py

Abrirá uma janela gráfica com uma grade de janelas de console, uma para cada nó, e permite a interação com o acompanhamento de cada console, incluindo monitoração com um gráfico e comandos como o iperf, pings. Também é possível criar API’s próprias para MiniNet. Uma API simples basicamente utiliza-se das bibliotecas mininet.net, mininet.node, mininet.cli. A primeira contém os módulos necessários para se montar a rede virtual propriamente dita, a segunda por sua vez contém os módulos para se criar todos os nós virtuais dessa rede e a terceira serve para que se possa executar o CLI do MiniNet. 

Caso tenha alguma dúvida consulte a documentação em :

http://yuba.stanford.edu/foswiki/bin/view/OpenFlow/MininetDocumentation

Como outras postagens, esta foi formulada com ajuda da Monografia de Lucas Rodrigues Costa da UnB com o título de "OpenFlow e o Paradigma de Redes Definidas por Software". Abaixo um link para download.

http://monografias.cic.unb.br/dspace/bitstream/123456789/391/1/Monografia_Vesao_Leitura_em_PC.pdf