Embed Size (px)
DESCRIPTION
Simulação de rede IP MPLS com o NETKIT
Citation preview
THIAGO SANTOS DE AMORIM
SIMULAÇÃO DE REDE MPLS UTILIZANDO O NETKIT
Palmas - TO
2010
ii
THIAGO SANTOS DE AMORIM
SIMULAÇÃO DE REDE MPLS UTILIZANDO O NETKIT
Relatório apresentado como requisito parcial
da disciplina Estágio Supervisionado em 2010
do Curso Sistemas de Informação,
supervisionado pelo Professor M. Sc. Ricardo
Marx Costa Soares de Jesus.
Palmas - TO
2010
iii
THIAGO SANTOS DE AMORIM
SIMULAÇÃO DE REDE MPLS UTILIZANDO O NETKIT
Relatório apresentado como requisito parcial
da disciplina Estágio Supervisionado em 2010
do Curso Sistemas de Informação,
supervisionado pelo Professor M. Sc. Ricardo
Marx Costa Soares de Jesus.
Aprovado em ___/___/____
BANACA EXAMINADORA
__________________________________________________
Ricardo Marx Costa Soares de Jesus - Orientador
Centro Universitário Luterano de Palmas
__________________________________________________
Profª. M.Sc Madianita Bogo
Centro Universitário Luterano de Palmas
__________________________________________________
Profº. M.Sc Jackson Gomes de Souza
Centro Universitário Luterano de Palmas
Palmas - TO
2010
iv
SUMÁRIO
LISTA DE FIGURAS ............................................................................................................... v
LISTA DE ABREVIATURAS ................................................................................................ vi
RESUMO ................................................................................................................................... 7
1. INTRODUÇÃO .............................................................................................................. 8
2. REVISÃO DE LITERATURA ...................................................................................... 9
2.1 O modelo de Referência OSI ...................................................................................... 9
2.2 Arquitetura TCP/IP e equivalência com o modelo OSI ........................................ 11
2.3 Qualidade de Serviços (QoS) .................................................................................... 13
2.4 Arquitetura MPLS e estrutura de pacote ............................................................... 14
2.5 Componentes de uma rede MPLS ........................................................................... 15
3. MATERIAL E MÉTODOS ......................................................................................... 21
3.1 Hardware ................................................................................................................... 21
3.2 Software...................................................................................................................... 21
3.2.1 Netkit ................................................................................................................... 21
3.2.2 TCPDUMP .......................................................................................................... 23
3.2.3 Wireshark ............................................................................................................ 23
4. RESULTADOS E DISCUSSÃO ................................................................................. 25
4.1 Topologia de rede do domínio MPLS sobre IPv4 simulado no NETKIT ............ 25
4.2 Configuração do laboratório IP/MPLS no NETKIT ............................................. 32
4.2.1 Configuração do laboratório no netkit ............................................................. 33
4.2.2 Configuração dos hosts ...................................................................................... 34
4.2.3 Configuração dos roteadores ............................................................................. 36
4.3 Execução do Laboratório ......................................................................................... 42
5 CONSIDERAÇÕES FINAIS .......................................................................................... 50
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 51
v
LISTA DE FIGURAS
Figura 1: Camadas do modelo de referência OSI ..................................................................... 10 Figura 2: Camadas da arquitetura TCP/IP ................................................................................ 12 Figura 3: Domínio MPLS ......................................................................................................... 15 Figura 4: Cabeçalho MPLS ...................................................................................................... 18 Figura 5: Rede MPLS/IP simulada utilizando o netkit ............................................................. 26 Figura 6: Tráfego IP entre hostx e hosty .................................................................................. 27 Figura 7: Tabelas de Roteamento IP ler1 ................................................................................. 28 Figura 8: Tabela de Roteamento IP lsr1 ................................................................................... 28 Figura 10: Tabela de comutação MPLS em ler1 ...................................................................... 29 Figura 9: Rótulos MPLS tráfego entre hostx e hostz................................................................ 29 Figura 11: Tabela de comutação MPLS em lsr1 ...................................................................... 30 Figura 12: Tabela de comutação MPLS em lsr2 ...................................................................... 31 Figura 13: Tabela de comutação MPLS em ler2 ...................................................................... 31 Figura 14: Topologia de rede simulada no netkit ..................................................................... 32 Figura 15: Conteúdo do arquivo lab.conf ................................................................................. 33 Figura 16: Conteúdo do arquivo hostx.startup ......................................................................... 34 Figura 17: Conteúdo do arquivo hosty.startup ......................................................................... 35 Figura 18: Conteúdo do arquivo hostz.startup.......................................................................... 35 Figura 19: Conteúdo do arquivo ler1.startup ............................................................................ 36 Figura 20: Conteúdo do arquivo ler2.startup ............................................................................ 38 Figura 21: Conteúdo do arquivo lsr1.startup ............................................................................ 40 Figura 22: Conteúdo do arquivo lsr2.startup ............................................................................ 41 Figura 23: Terminais das maquinas virtuais ............................................................................. 42 Figura 24: Locais de captura de tráfego entre hostx e hostz .................................................... 43 Figura 25: Local de captura de pacotes ler1 eth1 ..................................................................... 43 Figura 26: Pacotes capturados na eth1 do ler1 ......................................................................... 44 Figura 27: de captura de pacotes ler1 eth2 ............................................................................... 44 Figura 28: Pacotes capturados na eth2 do ler1 ......................................................................... 45 Figura 29: Pacotes capturados na eth2 do ler1 ......................................................................... 45 Figura 30: Pacotes capturados na eth3 do lsr1 ......................................................................... 46 Figura 31: Pacotes capturados na eth2 do lsr2 ......................................................................... 46 Figura 32: Pacotes capturados na eth2 do lsr2 ......................................................................... 47 Figura 33: Pacotes capturados na eth0 do ler2 ......................................................................... 47 Figura 34: Pacotes capturados na eth0 do ler2 ......................................................................... 48 Figura 35: Pacotes capturados na eth0 do lsr1 ......................................................................... 48 Figura 36: Pacotes capturados na eth0 do lsr1 ......................................................................... 49
vi
LISTA DE ABREVIATURAS
ARPA (Advanced Reseach Project Agency)
BSD (Berkeley Software Distribution)
FEC (Forwarding Equivalency Class)
FIB (Forwarding Information Base)
FTN (FEC – to – NHLFE)
GPL (General Public Licences)
ICMP (Internet Control Message Protocol)
ILM (Incoming Label Map)
IP (Internet Protocol)
IPX (Internetwork Packet Exchange)
ISO (Organização Internacional para Padronização)
LER (Label Edge Router)
LIB (Label Information Base)
LSP (Label Switch Path)
LSR (Label Switch Router)
MPLS (Multiprotocol Label Switching)
NHLFE (Next Hop Label Forwarding Entry)
QoS (Qualidade de Serviços)
7
RESUMO
Este trabalho tem como objetivo a criação de um laboratório virtual, simulando uma rede
IP/MPLS e descrevendo o funcionamento da mesma através de captura de pacotes e
verificação das alterações sofridas durante o encaminhamento dos mesmos pelas redes IP e
MPLS. Para criação do ambiente virtual e captura dos pacotes foi utilizado o software de
virtualização NETKIT, assim como os aplicativos TCPDUMP e WIRESHARK.
Palavras-Chave: Netkit, MPLS, Qualidade de Serviços
8
1. INTRODUÇÃO
Com o enriquecimento de serviços na internet, passando de apenas texto para serviços
multimídias, é requerida cada vez maior largura de banda na rede. Em contra partida, algumas
aplicações estão entrando no mundo IP, como a telefonia, que não requer muita banda, mas
tem a necessidade de um nível de qualidade de serviço que torne a aplicação aceitável. Este
contexto requer não apenas o aumento da velocidade das redes utilizadas, mas também uma
diferenciação do tráfego de forma categorizada, o que pode ser provido com o protocolo IP
associado ao protocolo MPLS.
O MPLS (Multiprotocol Label Switching), com o conceito de comutação de pacotes
por rótulo, torna a comutação dos pacotes independente do enlace utilizado, e, ainda,
possibilita a classificação dos pacotes. O que permite tratar os pacotes de forma diferenciada
e, assim conseguir manter Qualidade de Serviço essencial para o uso de serviços que
necessitam de um nível de Qualidade de Serviço.
Valores muito altos para compra de laboratórios tornam a produção de trabalhos
científicos, às vezes inviáveis, o que impede muitas pesquisas. Com o uso do NETKIT foi
possível fazer a simulação de um ambiente de testes de uma rede MPLS, mas com custos
ínfimos, visto que com o sistema de virtualização e testes de redes NETKIT, é possível
simular ambientes de redes e fazer testes em um computador.
Neste trabalho são apresentados o protocolo MPLS e o NETKIT, bem como conceitos
referentes à utilização deste protocolo e deste sistema. Na seqüência fez se uma simulação de
rede IP/MPLS através de um ambiente virtual criado com o uso do NETKIT. Por fim, foram
capturados pacotes para demonstrar as alterações dos pacotes no decorrer da rede simulada.
Para captura dos pacotes foram utilizados os softwares WIRESHARK e o TCPDUMP.
9
2. REVISÃO DE LITERATURA
Nesta seção são apresentados fundamentos teóricos que sustentam as afirmações contidas no
decorrer deste trabalho. São apresentados o modelo de referência OSI e a arquitetura TCP/IP,
conceitos de Qualidade de Serviço, a arquitetura MPLS e sua estrutura de pacotes.
2.1 O modelo de Referência OSI
Em meados da década de 1960, com a criação da ARPANET pela agência americana ARPA
(Advanced Reseach Project Agency), iniciou-se a era das tecnologias de rede de
computadores. Nesta mesma época, com o projeto da ARPA, os primeiros protocolos para
comutação de pacotes foram criados.
Com o crescimento da rede da ARPA, muitos fabricantes começaram a produzir seus
próprios padrões de arquiteturas de rede para prover estes serviços às universidades e outros
países (CARVALHO, 1997, p.03).
No final da década de 1970, por causa de uma possível crise que poderia impedir o
crescimento da rede anteriormente projetada, tendo em vista os múltiplos padrões, a ISO
(Organização Internacional para Padronização), entre 1978 e 1984, elaborou uma proposta
de padronização nomeada de OSI (Interconexão de Sistemas Abertos) (CARVALHO, 1997,
p.04). Este padrão elaborado pela ISO foi de suma importância para a interoperabilidade entre
fabricantes para o posterior crescimento da internet.
O modelo de Referência OSI foi revisado em 1995 e possui sete camadas numeradas
de baixo para cima (TANENBAUM, 2003, p. 40), como está representado na Figura 1,
10
Camada 1 - A camada física é a mais baixa do modelo de referência OSI, esta camada
é responsável por transmitir e receber fluxos de bits é usado para representar os meios físicos
usados para transmissão dos quatros da camada de enlace em forma de bits por meios
elétricos, ópticos e outros.
Camada 2 – A camada de enlace é responsável por encapsular os datagramas da
camada de rede, e transmiti-los utilizando quadros. Os protocolos da camada de enlace
também provêm mecanismos de correção de erros para que seja garantida a entrega confiável
dos quadros.
Camada 3 – Na camada de rede estão os protocolos de roteamento, responsáveis pelo
endereçamento dos equipamentos e pelas rotas entre uma fonte e um destino na rede. Os
principais protocolos desta camada são IP (Internet Protocol), IPX (Internetwork Packet
Exchange) e AppleTalk.
Camada 4 – A camada de transportes provê serviços com integridade fim a fim nas
transmissões. Esta camada também pode ser responsável por reordenar pacotes que por vários
Figura 1: Camadas do modelo de referência OSI
11
motivos podem ter tomado caminhos deferentes na rede antes de chegar a um determinado
destino, neste caso é feita a reordenação antes de ser repassado para a camada de sessão. Esta
camada está intrinsecamente ligada à camada 3 do modelo OSI um exemplo de protocolos
que integram estas duas camadas é o TCP/IP.
Camada 5 – A camada de sessão permite o estabelecimento, a manutenção e o
encerramento de sessões. As sessões permitem que uma conexão tenha segurança,
reconhecimento de nome e log.
Camada 6 – O gerenciamento da forma como os dados são codificados, e a tradução
de sistemas de codificação usados em uma comunicação, é de responsabilidade da Camada de
Apresentação. Alguns computadores utilizam esquemas de codificação de dados diferentes,
por isso a importância desta camada.
Camada 7 – A Camada de Aplicação está no nível mais alto do modelo OSI. Está
camada provê a interface entre as aplicações e os serviços de rede. Os principais serviços da
Camada de Aplicação são: seleção de módulo de diálogo, determinação de qualidade de
serviço, identificação dos futuros parceiros na comunicação e especificação de aspectos
relativos à segurança.
Esta divisão em camadas é utilizada em projetos de redes até hoje. Por ser um modelo
de referência não é implementada, como é o caso da arquitetura TCP/IP.
2.2 Arquitetura TCP/IP e equivalência com o modelo OSI
A arquitetura TCP/IP foi criada de acordo com a demanda e as necessidades do mercado, com
muito dos conhecimentos adquiridos com o uso dos modelos anteriores como o OSI
(CARVALHO, 1997, p.07). O número de camadas é bem inferior ao OSI, a saber: camada
Host/Rede, Camada Inter-redes, Camada de Transportes e Camada de Aplicação. A
numeração das camadas também se dá de baixo para cima, como mostra a Figura 2.
12
A camada de host/rede, primeira camada TCP/IP, corresponde as camadas 1 e 2 do
modelo OSI. As funções das duas últimas camadas estão presentes na primeira camada
TCP/IP. A camada 2 do modelo TCP/IP corresponde a camada 3 do modelo OSI, onde se
encontram os protocolos de roteamento.
A terceira camada do modelo OSI é correspondente à segunda camada da arquitetura
TCP/IP e tem como função a transferência de pacotes da origem ao destino. Para chegar ao
destino pode ser necessária a passagem por vários pontos nós de uma rede, também chamados
de hops(saltos)(TANENBAUM, 2003, p. 365).
Sobre a arquitetura TCP/IP, na camada de redes, ou camada 3 dos modelos de
referência, os dados são transportados usando o protocolo de internet IP (Protocolo de
internet). A camada de rede oferece serviços à camada de transportes. Sendo assim usando o
IP, os serviços são combinados com o TCP (TANENBAUM, 2003, p. 366).
Os pacotes de dados são encapsulados com os protocolos TCP/IP, nos quais são
inseridas informações como endereço de origem e destino e outras. Em seguida são
encapsulados em um quadro Ethernet e transmitidos pela camada física. Ao chegar ao destino
o encapsulamento é removido e o pacote TCP/IP é entregue a camada de rede e assim por
diante.
Figura 2: Camadas da arquitetura TCP/IP
13
2.3 Qualidade de Serviços (QoS)
Uma seqüência de pacotes desde sua origem até seu destino é chamado de fluxo
(TANENBAUM, 2003, p. 422). Um fluxo pode ser orientado ou não a conexão. Quando
orientado a conexão os pacotes seguem um mesmo caminho até seu destino, quando em uma
rede sem conexão, os pacotes podem seguir caminhos diferentes. As necessidades de cada
fluxo podem ser caracterizadas, segundo Tanenbaum (2003, p. 422), por quatro parâmetros
tidos como principais: confiabilidade, atraso, flutuação e largura de banda. A necessidade de
manter parâmetros mínimos para entrega de um serviço por uma aplicação é chamada de
Qualidade de Serviço.
A confiabilidade é requerida em serviços em que nenhum bit pode ser entregue de
forma incorreta, como: correio eletrônico, transferência de arquivos, acesso a Web e login
remoto. Para conseguir um alto grau de confiabilidade é feita uma checagem calculando se o
total de verificação de todos os pacotes da origem correspondentes ao total no destino
(TANENBAUM, 2003, p. 423).
Aplicações de tempo real como telefonia e videoconferência são mais sensíveis ao
Atraso, se alguns pacotes forem retardados em uma chamada telefônica, a ligação não terá a
qualidade esperada. A flutuação também é um requisito muito importante para transmissão de
áudio e vídeo (TANENBAUM, 2003, p. 423).
As necessidades de largura de banda são diferentes para cada aplicação. Por exemplo,
o serviço de VOIP (Voz Sobre IP) e o login remoto não necessitam de muita largura de banda
ao contrário do vídeo (TANENBAUM, 2003, p. 423).
A arquitetura TCP/IP foi desenvolvida para aplicações tolerantes ao atraso. Seguia o
modelo de melhor esforço e não possuía QoS. Com o crescimento da utilização de aplicações
que necessitam cada vez mais de recurso da rede como transmissão de TV via internet,
videoconferência e jogos online, surge a necessidade de que as tecnologias de rede utilizadas
possam diferenciar o fluxo de dados entre os de maior o de menor prioridade.
Para, dentre outras funcionalidades importantes, manter a qualidade de serviço foi
desenvolvida a tecnologia MPLS (Multiprotocol Label Switching), na qual os fluxos de dados
14
seguem um caminho definido por classes de encaminhamento por equivalência. A utilização
de MPLS ajuda a alcançar a qualidade de serviço exigida por aplicações que necessitam de
atraso mínimo, variação de atraso mínimo, perdas mínimas e largura de banda máxima.
2.4 Arquitetura MPLS e estrutura de pacote
MPLS (Multiprotocol Label Switching) é um padrão definido pelo IETF (Internet
Engineering Task Force), que possibilita designação, encaminhamento e comutação eficiente
de fluxos de tráfego através da rede. As informações em uma rede MPLS são classificadas e
os dados são encaminhados através de caminhos pré-estabelecidos, sendo feita a comutação,
sem o roteamento (ABREU, 2004, p. 14).
O MPLS possui algumas características que solucionam problemas das redes de
computadores atuais, como: orientação a conexão em redes IP, transferência da comutação de
pacotes da camada 3 para a camada 2, menor complexidade de decisões de encaminhamento
nos roteadores, engenharia de tráfego, eliminação de múltiplas camadas, CoS (classes de
serviços) e garantia de QoS (qualidade de serviço) (ABREU, 2004, p. 24 ).
O protocolo IP faz uso de um campo no cabeçalho dos pacotes que contém o endereço
de destino e origem dos pacotes, usados para encaminhamento dos mesmos, tais informações
são processadas em todos os nós intermediários, em um processo conhecido como hop-by-
hop. O MPLS consiste na geração e uso de um pequeno rótulo de tamanho fixo, usado como
argumento para tomada de decisão no encaminhamento de pacotes (NETO, 2006. p. 23).
15
A Figura 3 demonstra o esquema de um domínio MPLS.
Um domínio MPLS é uma rede formada por equipamentos que comutam pacotes
utilizando este protocolo.
2.5 Componentes de uma rede MPLS
O MPLS permite a construção de caminhos entre roteadores de entrada e de saída em um
domínio. Os pacotes, no interior da rede, são encaminhados sem consultar a tabela de
roteamento nível três do modelo OSI, como é feito no roteamento IP. A seguir, são descritos
os componentes necessários em um domínio MPLS.
Figura 3: Domínio MPLS
16
LSR (Label Switch Routers)
LSRs são roteadores de comutação por rótulos. Quando situados no núcleo da rede MPLS,
possuem como função encaminhar pacotes baseados apenas no rótulo. Ao receber um pacote,
cada LSR remove o rótulo existente e o substitui por outro da seqüência e o encaminha para o
próximo roteador.
LER (Label Edge Routers)
LERs (Roteadores de rótulos de borda) são LSRs situados na periferia do domínio MPLS.
Eles são responsáveis por fazer a interligação entre as diversas redes (Ethernet, ATM, Frame
Relay) as redes MPLS. São responsáveis pela designação e retirada do rótulo para cada
tráfego que entra ou sai da rede MPLS.
FEC (Forwarding Equivalency Class)
Uma FEC é a representação de um grupo de pacotes que pode ser tratado de uma maneira
equivalente, ou seja, possuem exigências de serviços similares. Pacotes de um fluxo de dados
pertencem em geral à mesma FEC.
17
LSP (Label Switch Path)
LSP é um caminho comutado por rótulo ou um circuito virtual, através do qual os pacotes de
uma mesma classe transitam. Uma rota deve ser inicialmente estabelecida, desta forma, um
circuito será fechado, de modo que os próximos pacotes não serão mais roteados, eles serão
apenas comutados com base em seus rótulos.
Encaminhamento de pacotes
O encaminhamento de pacotes em uma rede MPLS funciona da seguinte forma: ao chegar um
pacote IP no roteador periférico da rede MPLS, chamado de LER , este executa uma consulta
nível três na tabela de encaminhamento IP, classifica o pacote com base no resultado da
consulta e o marca com um rótulo de saída, em seguida encaminha o pacote com um rótulo
apropriado.
No núcleo da rede, outro roteador LSR recebe o pacote rotulado, executa uma consulta
de rótulo, usa a tabela de encaminhamento de rótulo para trocar o rótulo de entrada pelo rótulo
de saída correspondente e o encaminha ao próximo nó. Quando os pacotes recebidos não
possuírem um rótulo MPLS, são roteados usando algoritmos tradicionais de roteamento IP,
fazendo uma consulta nível três.
Na saída do pacote da rede MPLS, o último LER recebe o pacote rotulado, executa
uma consulta de rótulo, remove o rótulo, executa uma consulta nível três tradicional no pacote
IP e o encaminha para o próximo roteador externo ao domínio MPLS (NETO, 2006, p. 32).
18
Cabeçalho MPLS
O Cabeçalho MPLS possui quatro campos: Label, EXP, S e TTL (ASSIS, 2002, p. 6). O
label ou rótulo é um identificador de 20 bits, que é usado para identificar o pacote. O campo
EXP possui 3 bits é utilizado para identificar uma classe de encaminhamento. O campo S tem
tamanho de 1 bit e indica a presença de uma pilha de rótulos, se o rótulo é único ou o último
da fila o bit é zero senão o bit é 1. O campo TTL tem o tamanho de 8 bits e provê
funcionalidades de tempo vida do pacote.
A Figura 4 representa um cabeçalho MPLS e seus atributos.
Figura 4: Cabeçalho MPLS
Cross Connect e NHLFE (Next Hop Label Frowarding Entry)
Os roteadores MPLS são capazes de processar pacotes por rótulos de entrada, através
de uma matriz de comutação chamada de tabela cross connect. Esta tabela é constituída por
várias entradas de NHLFE (Encaminhamento por Rótulo ao Próximo Roteador) (NETO,
2006, p. 35).
Cada entrada NHLFE contém as seguintes informações: endereço do próximo roteador
(next hop) para o pacote, operação a ser feita com a pilha de rótulo, substituição do rotulo do
topo da pilha por um novo, retirada do rótulo do topo da pilha (operação pop) e substituição
do rótulo no topo da pilha (operação push).
19
ILM (Incoming Label Map) e FTN(FEC – to – NHLFE)
O ILM (Tabela de Rótulos Entrantes) faz o mapeamento de pacotes que são recebidos com
um cabeçalho MPLS. O rótulo do pacote de entrada é usado como referência na ILM, que
contém informações que permitem ao nó selecionar um conjunto de NHLFEs com instruções
de encaminhamento.
FTN realiza o mesmo mapeamento para pacotes que chegam sem rótulo, mas que
devem ser enviados com rótulo. O FTN considera apenas a FEC a qual o pacote pertence.
Esta FEC é utilizada como referencia na FTN, cujo mapa permite selecionar um conjunto de
NHLFEs que contém as instruções de encaminhamento.
Quando a verificação da existência de um rótulo no pacote é positiva, o LSR usa a
tabela ILM para encontrar uma entrada em NHLFE, com as informações obtidas encaminha o
pacote ao próximo LSR. Caso contrário o LSR processa o cabeçalho de rede do pacote,
determinando a partir deste pacote uma FEC e usa o FTN para mapear esta FEC para o
NHLFE (PINHEIRO, 2000, p.5).
FIB(Forwarding Information Base) e LIB(Label Information Base)
A FIB (Tabela de Comutação por Rótulo) é uma tabela existente em cada roteador do
domínio MPLS que possui uma base de dados que descreve como fazer comutação de rótulos,
e como associar os fluxos externos de rede aos rótulos MPLS. É utilizada para adicionar ou
remover um label a um pacote, enquanto determina a interface de saída pela qual o pacote
deve ser enviado. Quando utilizado em uma rede com protocolo de distribuição de label
recebe o nome de LIB (Label Information Base).
20
Neste capitulo fez se a revisão dos conceitos necessários ao entendimento do
funcionamento do laboratório que será simulado com o uso do NETKIT. A seguir serão
apresentados os materiais e métodos utilizados para criação de tal laboratório e posterior
captura dos pacotes nos resultados e discussões.
21
3. MATERIAL E MÉTODOS
Este capítulo descreve o hardware e o software utilizado para realização deste trabalho.
3.1 Hardware
O recurso de hardware utilizado para o desenvolvimento deste trabalho foi: um
notebook com um processador Intel Core2Duo 1.5 Ghz, 4 gigabytes de memória RAM e 500
gigabytes de disco rígido, com o sistema operacional GNU/Linux distribuição Ubuntu 9.10
64bits.
3.2 Software
Os recursos de software utilizados parado o desenvolvimento deste trabalho foram Netkit,
Wireshark e o tcpdump.
3.2.1 Netkit
O Netkit é um software livre, sobre uma licença BSD (Berkeley Software Distribution), usado
para criação de máquinas virtuais no intuito de testar ambientes de rede. O Netkit usa
aplicações de um ambiente de rede real que pode ser usado para testes, da mesma forma com
que se faz em uma rede com equipamentos reais (RIMONDINI, 2007, p. 03). Um laboratório
no Netkit é um conjunto composto por redes com máquinas virtuais interconectadas.
Os laboratórios no Netkit podem ser gerenciados por comandos no terminal da
máquina virtual, o que torna o uso da aplicação mais intuitivo, visto que os comandos para
22
manipulação das máquinas virtuais se dão pelo terminal do equipamento usado como
hospedeiro.
Toda a configuração das máquinas virtuais pode ser feita em arquivos de configuração
dentro de uma pasta à escolha do usuário, na máquina hospedeira. (Após a instalação do
Netkit e ativação das variáveis de ambiente.) O trabalho com o laboratório virtual é feito de
forma direta no terminal do servidor das máquinas virtuais. (RIMONDINI, 2007, p. 16).
Para instalar o Netkit é necessário fazer o download de alguns arquivos no sítio
http://www.netkit.org/download.html, os arquivos são:
netkitkerneli386K2.7.tar.bz2: o kernel UML(permite a execução de um kernel
dentro de um sistema operacional Linux.)
netkitfilesystemi386F5.0.tar.bz2: o sistema de arquivos
netkit2.6.tar.bz2: os utilitários do Netkit, que auxiliam a criação de
laboratórios.
Após ter feito o download dos arquivos os mesmos devem ser descompactados em um
diretório criado pelo usuário. Para a criação e execução dos laboratórios no netkit, não é
necessário ter permissão de usuário root (administrador do sistema). Após a descompactação
dos arquivos no diretório selecionado pelo usuário, é necessário editar o arquivo ~/.bashrc ou
~/.bash_profile (neste arquivo estão as configurações do shell) e acrescentar as seguintes
linhas para definição das variáveis de ambiente:
export NETKIT_HOME=/home/nomeUsuario/netkit: define o caminho para
diretório da palicação.
export MANPATH=:$NETKIT_HOME/man: define o caminho para que o
comando man localize as páginas do manual.
export PATH=$NETKIT_HOME/bin:$PATH: define o caminho para o diretório
no qual se encontram os arquivos executáveis da aplicação.
Os principais comandos para uso no netkit são:
23
vstart: pode ser usado para configurar e iniciar uma nova máquina virtual. Exemplo:
vstart pc1.
vlist: usado para listar as máquinas virtuais que estão em execução.
vhalt: comando usado para desligar uma máquina virtual
vcrash: possui métodos para desligar de forma imediata uma máquina virtual.
vclean: limpa as configurações das máquinas virtuais que estavam em execução.
Os comandos listados anteriormente funcionam da mesma forma para os laboratórios.
Para serem usados em um laboratório, muda-se a letra inicial de “v” para “l”, um exemplo,
para iniciar um laboratório usa-se lstart.
3.2.2 TCPDUMP
O tcpdump é um sniffer, software de captura de dados em interfaces de rede, licenciado pela
GPL, e que pode ser facilmente instalado nas distribuições do GNU/Linux. Para fazer a
instalação do tcpdump em uma distribuição derivada do debian pode-se usar o comando sudo
apt-get install tcpdump.
O tcpdump foi utilizado para captura dos pacotes em algumas interfaces das máquinas
virtualizadas, de forma que essas informações em um arquivo para posterior análise usando o
wireshark. Para captura dos pacotes com o tcpdump foi utilizado o seguinte comando nas
interfaces escolhidas: tcpdump -i ethX -w /hotlab/capturaEthx.cap -s 1500, onde X foi
substituído pela numeração correspondente à interface de rede.
3.2.3 Wireshark
O Wireshark é uma ferramenta livre sobre a licença GPL (General Public Licences) para
gerência de rede, que permite monitoramento de todo o tráfego em uma rede.
24
A instalação do wireshark foi feita usando o comando sudo apt-get install wireshark,
em um terminal de comando no ubuntu.
Neste trabalho, esse aplicativo foi utilizado para análise dos dados contidos em um
arquivo com extensão .cap, gerado pelo tcpdump dentro das máquinas virtuais.
Neste capítulo foram descritos os matérias e métodos utilizados para realização deste
trabalho, no capitulo a seguir são descritas as configurações do laboratório e das máquinas
virtuais, também são descritas as capturas de pacotes.
25
4. RESULTADOS E DISCUSSÃO
Nesta seção será apresentada a topologia utilizada para simulação da rede IP/MPLS, bem
como sua configuração, execução e análise de tráfego. Primeiro será demonstrada de forma
detalhada a topologia do domínio utilizado, em seguida serão demonstrados os arquivos de
configuração do laboratório no Netkit e, por fim a demonstração do funcionamento da rede
pela captura de pacotes em alguns pontos desta rede.
4.1 Topologia de rede do domínio MPLS sobre IPv4 simulado no NETKIT
A topologia da rede utilizada para realização dos testes possui, como apresentado na Figura 5:
quatro roteadores, sendo dois LERs e dois LSRs, e três hosts, seguindo as seguintes
estruturas: o hostx esta conectado ao hostz através da rede MPLS formada pelos roteadores
ler1, lsr1, lsr2 e ler2. Os roteadores ler1, lsr1, lsr2 e ler2 estão configurados em ordem para
permitir a comunicação entre o hostx e o hostz usando MPLS e ao mesmo tempo o hostx está
conectado ao hosty por intermédio de uma rede IPv4.
26
A rede possui seis domínios de colisão nomeados com as letras A, B, C, D, E e F. Os
roteadores ler1 e ler2 fazem a ponte entre a rede IP e a rede MPLS. Os LERs se comportam
de duas formas distintas, ao receber um pacote IP e ao receber um pacote MPLS. Quando
recebem um pacote da rede IP, o ler1 ou ler2 executa uma consulta nível três na tabela de
encaminhamento IP e, em seqüência encaminha o pacote para o próximo hop ou para o
destino apontado no cabeçalho IP. Já ao receber um pacote com cabeçalho MPLS, classifica-o
com base nas informações contidas em sua tabela FIB, e o marca com o rótulo de saída
correspondente. Finalmente, encaminha o pacote para a interface de saída com o rótulo
apropriado, segundo informações desta tabela.
Figura 5: Rede MPLS/IP simulada utilizando o netkit
27
Entre os LERs existem o lsr1 e o lsr2, são os roteadores de comutação por rótulos,
equipamentos situados no núcleo da rede com a função de encaminhar pacotes baseado
apenas no rótulo. Ao receber um pacote, cada LSR troca o rótulo existente por outro,
passando o pacote para o próximo roteador e assim sucessivamente.
A comunicação entre o hostx e o hosty será feita através do protocolo IP, usando os
roteadores ler1 e lsr1 para estabelecer a conexão, esta configuração será feita para demonstrar
a capacidade de uso dos mesmos roteadores para roteamento e comutação de tráfegos de redes
IP e MPLS, desta forma, pode se notar que é possível operar estes dois protocolos de uma só
vez em uma mesma infraestrutura de rede, como mostra a Figura 6.
Na comunicação entre o hostx e hosty, os pacotes serão encaminhados usando o
protocolo IP. Para estabelecer a comunicação foram adicionadas as tabelas de roteamento IP
dos roteadores ler1 e lsr1 entradas para que haja o roteamento dos pacotes entre as redes em
que estes hosts se encontram. Nas Figuras 7 e 8 estão as configurações das tabelas de
roteamento IP dos roteadores ler1 e lsr1, respectivamente, que farão o encaminhamento entre
as redes 192.168.0.0/24 e 172.16.2.0/24.
Figura 6: Tráfego IP entre hostx e hosty
28
Figura 7: Tabelas de Roteamento IP ler1
Estes roteadores farão o roteamento via endereço IP. Os pacotes possuem a indicação
da rede de origem e de destino. Para fazer o roteamento é necessária a verificação do
cabeçalho IP em cada hop.
A comunicação entre o hostx e o hostz será feita através unicamente de uma rede
MPLS, que usará para transporte os quatro roteadores presentes nesta topologia, como exibe a
Figura 9.
Ler1
REDE INTERFACE MASCARA Gateway
172.16.2.0 eth2 255.255.255.0 172.16.0.3
172.16.1.0 eth2 255.255.255.0 172.16.0.3
172.16.0.0 eth2 255.255.255.0 0.0.0.0
192.168.0.0 eth1 255.255.255.0 0.0.0.0
Lsr1
REDE INTERFACE MASCARA Gateway
172.16.2.0 eth0 255.255.255.0 0.0.0.0
172.16.0.0 eth2 255.255.255.0 0.0.0.0
172.16.1.0 eth3 255.255.255.0 0.0.0.0
192.168.0.0 eth2 255.255.255.0 172.16.0.2
Figura 8: Tabela de Roteamento IP lsr1
29
Para que o tráfego de pacotes entre os hosts seja feito usando apenas a rede MPLS os
roteadores foram configurados para comutar os pacotes segundo seus rótulos (label). Nas
Figuras 10, 11, 12 e 13 são apresentadas as tabela de comutação de cada roteador utilizado
para comutação dos pacotes com cabeçalho MPLS.
O roteador ler1, por ser um roteador de borda do domínio MPLS, é responsável por
colocar o cabeçalho inicial nos pacotes, com isso cria-se um novo LSP.
Figura 10: Tabela de comutação MPLS em ler1
FEC Label
entrada Labelspace Operação
Label
saída
Interface
saída
Destino:
192.168.1.0/24
- - Push 1000 eth2
- 2002 0 Pop - eth1
Figura 9: Rótulos MPLS tráfego entre hostx e hostz
30
Ao receber um pacote destinado à rede 192.168.1.0/24, é feita a operação push
(adiciona um label), que atribui um cabeçalho MPLS com o label 1000 ao pacote e o
encaminha pela interface eth2. Outra operação neste LER é o recebimento do pacote com
label 2002, remoção do mesmo pela operação pop (remove um label MPLS do pacote) e
encaminhamento do pacote usando a tabela de roteamento IP.
Os pacotes que forem encaminhados com o label 1000 pela eth2 do ler1 chegarão à
interface eth2 do lsr1 e serão tratados conforme a tabela de comutação representada na Figura
11.
Ao receber um pacote com label 1000, o lsr1 verifica em sua tabela ILM e faz uma
operação swap (troca de label) para posterior encaminhamento com o label 1001 pela
interface eth2. Este roteador também está configurado para receber os pacotes com label 2001
e fazer um swap para 2002 e encaminhar pela interface eth3.
O lsr2 ao receber o pacote 1001, verifica na tabela de comutação o label associado a
ele e o encaminha, após uma operação swap que troca o label para 1002, pela interface eth3,
como demonstrado na Figura 12.
Label
entrada Labelspace Operação
Label
saída
Interface
saída
1000 0 Swap 1001 eth2
2001 0 Swap 2002 eth3
Figura 11: Tabela de comutação MPLS em lsr1
31
Além da label 1001, o lsr2 foi configurado para receber os pacotes com o label 2000 e
fazer a comutação trocando o label para 2001 e encaminhando pela interface eth2.
O pacote com o label 1002, que foi comutado pelo lsr2, chegando no ler2, é tratado
pela operação pop, que remove o label e o encaminha pela rede IP. O ler2 foi configurado
também para receber os pacotes IP com destino a rede 192.168.0.0/24, colocando um
cabeçalho MPLS e encaminhado com o label 2000 pela interface eth3, como demonstrado na
Figura 13.
As informações de domínio que foram demonstradas nesta seção foram usadas para
configurar o laboratório no netkit. Tanto o roteamento IP quanto a comutação MPLS, aqui
apresentados, foram configurados com rotas estáticas.
Label
entrada Labelspace Operação
Label
saída
Interface
saída
1001 0 Swap 1002 eth2
2000 0 Swap 2001 eth1
Figura 12: Tabela de comutação MPLS em lsr2
FEC Label
entrada Labelspace Operação
Label
saída
Interface
saída
Destino:
192.168.0.0/24
- - Push 2000 eth3
- 1002 0 Pop - eth0
Figura 13: Tabela de comutação MPLS em ler2
32
4.2 Configuração do laboratório IP/MPLS no NETKIT
Para configuração dos laboratórios no netkit, foi utilizada como base a topologia de rede já
demonstrada na seção 4.1, Figura 5 e, de forma simplificada na Figura 14.
A configuração do laboratório no netkit possui as seguintes características: o ler1 está
conectado ao hostx e ao lsr1 pelos domínios de colisão A e B, o lsr1 está conectado ao ler1,
lsr2 e ao hosty respectivamente pelos domínios de colisão B, C e F, o lsr2 está conectado ao
lsr1 e ao ler2, nos domínios de colisão C e D, o ler2 está conectado ao lsr2 e hostz em D e E,
o hostx foi conectado ao ler1 em A, o hosty está conectado ao lsr1 em F; e o hostz possui
conexão direta ao ler2 pelo domínio de colisão E.
Figura 14: Topologia de rede simulada no netkit
33
4.2.1 Configuração do laboratório no netkit
Para configuração do laboratório no netkit, é necessário criar um diretório no computador, o
qual deve ser utilizado para manter os arquivos de configuração necessários para execução do
mesmo.
Para este trabalho foi criado um diretório com nome mpls_netkit, dentro deste
diretório foram colocados os arquivos de configuração do laboratório. O arquivo lab.conf,
necessário para iniciar o laboratório e que contém o nome das máquinas virtuais que serão
criadas, associadas a seus domínios de colisão, foi criado com as configurações exibidas na
Figura 15.
Figura 15: Conteúdo do arquivo lab.conf
34
Nas linhas de 1 a 5, são acrescentadas algumas informações opcionais para melhor
identificação do laboratório criado, a opção LAB_DESCRIPTION é utilizada para informar
uma descrição do laboratório criado, na LAB_VERSION se informa uma versão para o
laboratório e as demais opções são acrescentadas de acordo com que se achar necessário.
Em seguida são definidos os nomes das máquinas virtuais bem como suas interfaces e
o domínio de colisão. Nas linhas 7 e 8 estão as definições do ler1, de duas interfaces 1 e 2 e
do domínio de colisão ao qual esta máquina virtual irá pertencer no laboratório criado com o
uso do netkit.
As demais definições acrescentam as outras maquinas virtuais que formam a topologia
MPLS que será simulada no netkit e esta representada na Figura 14.
4.2.2 Configuração dos hosts
Após a configuração do arquivo lab.conf, foram configurados os arquivos
nomeMáquina.startup onde nomeMáquina é substituído pelo nome do roteador. Estes
arquivos são importantes, pois contêm as configurações que serão realizadas quando o
laboratório for iniciado, deve ser criado um para cada máquina virtual.
As configurações básicas dos hostx, hosty e hostz, estão representadas nas Figuras 16,
17 e 18.
Para configuração da máquina virtual hostx, foram acrescentadas ao arquivo .startup
duas linhas: a linha 1 contém a configuração da interface de rede eth1 e a linha 2 a definição
Figura 16: Conteúdo do arquivo hostx.startup
35
da rota estática padrão. Na linha 1 o comando ifconfig define para a interface eth1 o ip
192.168.0.1 máscara netmask 255.255.255.0 e broadcast 192.168.0.255 e na linha 2 o
comando ip route add adiciona uma rota como padrão (default) pelo endereço 192.168.0.2.
O hosty será configurado como demonstrado na Figura 17, na linha 1 é usado o
comando ifconfig para definir as configurações da interface eth0 com o endereço ip
172.16.2.2 netmask 255.255.255.0 e endereço broadcast 172.16.2.255, e a adição da rota
padrão na linha 2 utilizando o comando route add com parâmetros default gw e endereço
172.16.2.1.
O hostz foi configurado para estabelecer conexão com as demais redes simulada pelas
interfaces eth0 utilizando o comando ifconfig com os parâmetros, endereço 192.168.1.5,
mascara 255.255.255.0 e broadcast 192.168.1.255 linha 1, por fim na linha 2 é configurada a
rota estática padrão com o comando ip route add default pelo endereço de rede 192.168.1.4.
Figura 17: Conteúdo do arquivo hosty.startup
Figura 18: Conteúdo do arquivo hostz.startup
36
4.2.3 Configuração dos roteadores
Na Figura 19 é apresentada a configuração do roteador ler1 responsável por fazer o
encaminhamento dos pacotes IP entre as redes 192.168.0/24 e 172.16.0/24 e com destino a
rede 172.16.2.0/24. Faz também a designação e retirada do rótulo para cada tráfego que entra
ou sai da rede MPLS.
Nas linhas 1 e 2 o comando ifconfig é utilizado para configurar as interfaces eth1 e
eth2 nas redes 192.168.0.0 e 172.16.0.0 , que possuem as máscara netmask 255.255.255.0 e
Figura 19: Conteúdo do arquivo ler1.startup
37
255.255.255.0 e broadcast 192.168.0.255, e 172.16.0.255 respectivamente. O parâmetro up
no final da linha indica que esta interface ficará ativa.
Nas linhas 4,5 e 6 é utilizado o comando modeprobe para fazer o carregamento dos
módulos mpsl4, mplsbr e mpls_tunnel, necessários para o funcionamento da rede MPLS
em ambiente Linux/Unix.
Na linha 8 é utilizado o comando route com o parâmetro add para adicionar uma rota
na tabela de roteamento para a rede 172.16.2.0 com máscara netmask 255.255.255.0 através
do gateway 172.16.0.3 por meio da interface eth2.
Na linha 12 é utilizado o comando mpls com o parâmetro nhlfe para criação de uma
nova entrada na tabela NHLFE com a adição de uma chave a ser retornada caso este comando
tenha sucesso, parâmetro add key 0. Ainda na linha 12 é definida a instrução (instructions)
push que adiciona um cabeçalho mpls no pacote com encapsulamento ethernet definido pelo
parâmetro gen, com um valor de label 1000 e o encaminha para o nexthop (próximo nó) ip
172.16.0.3 pela interface eth2 usando o protocolo da camada três IP versão 4 (ipv4).
Na linha 14 é utilizado o comando ip route add para adicionar uma rota para a rede de
destino 192.168.1.0/24 pelo endereço 172.16.0.3, usando o valor de fac 0x2 que marca os
conjuntos de pacotes que utilizam o label 1000.
Na linha 18 é utilizado o comando mpls com o parâmetro labelspace definido com um
valor 0 que define as regras para encaminhamento dos pacotes por determinada interface e os
parâmetros set dev eth2 que definem a interface de entrada eth2 para receber o tráfego
MPLS.
Na linha 20 é utilizado o comando mpls com o parâmetro ilm que adiciona um label
com encapsulamento ethernet de número 2002, parâmetros add label gen 2002, e o associa ao
labelsapace 0.
Na linha 22 é utilizado o comando mpls com o parâmetro nhlfe para adicionar uma
entrada na tabela NHLFE para encaminhamento dos pacotes para o endereço 192.168.0.1
usando a interface eth1.
Por fim na linha 24 é utilizado o comando mpls com os parâmetro xc e ilm_label que
especifica o label de entrada usando o encapsulamento ethernet definido pelo parâmetro gen
associa a label com o valor 2002 e com o parâmetro nhlfe_key 0x3, remove o cabeçalho
38
MPLS com rótulo 2002 do pacote recebido, e encaminha o pacote usando a tabela de
roteamento IPv4.
A configuração do ler2 é muito similar ao ler1, visto que os dois são LSR periféricos
da rede. Nas primeiras linhas são configuradas as interfaces de rede eth3 e eth0, com os
parâmetros ip 172.16.3.4, mascara 255.255.255.0 e boradcast 172.16.3.255 para eth3 e ip
192.168.1.4, mascara 255.255.255.0 e broadcast 192.168.1.255 para eth0, em seguida são
ativados, nas linhas 4, 5 e 6, os módulo mpls4, mplsbr e mpls_tunnel necessários para o
funcionamento da rede MPLS. Na linha 10 é configurada a interface eth3 para receber tráfego
MPLS, em seguida é adicionada uma entrada na tabela ILM com o rótulo 1002, linha 12,
como demonstrado na Figura 20.
Figura 20: Conteúdo do arquivo ler2.startup
39
Na linha 16 é criada uma nova entrada na tabela NHLFE para o encaminhamento dos
pacotes para o endereço 192.168.1.5 usando a interface eth0. Em seguida o rótulo é removido
do pacote, linha 22.
Para o tráfego do hostz para o hostx, é criada uma entrada NHLFE, para
encaminhamento dos pacotes para o endereço 172.16.1.3 da eth3. Depois é feita a
distribuição de rótulo aos pacotes direcionados para a rede 192.168.0.0/24, roteados por
172.16.0.3 e é feita uma FEC com o rótulo 0x3 retornado anteriormente.
Na configuração dos LERs 1 e 2, a diferença mais significativa está na linha 5, que
adiciona uma rota para tráfego IP entre o hostx e o hosty. A configuração do tráfego MPLS
do hostx para o hostz fica da seguinte forma; a interface eth2 é configurada para receber o
tráfego MPLS, e em seguida é adicionada uma entrada em ordem na ILM e encaminhada com
o rótulo 1000, linhas 17 e 19. É feita a adição de uma nova entrada na tabela NHLFE para o
encaminhamento dos pacotes para o endereço 172.16.1.4, usando a interface eth3. Por fim, é
feita a remoção do rótulo 1000 do pacote.
Na Figura 21 é demonstrada a configuração do lsr1, neste roteador é configurada uma
conexão ip para comunicação com o hosty e a comunicação MPLS entre o hostx e hoxtz
40
O tráfego MPLS do hostz para o hostx é configurado da seguinte forma: a interface
eth3 é configurada para receber o tráfego MPLS, linha 23, e é adicionada uma entrada na
tabela ILM em ordem para o encaminhamento do rótulo 2001, linha 25. Em seguida é criada
uma nova entrada em NHLFE para encaminhamento dos pacotes ao endereço 172.16.0.2
usando a interface eth2, linha 27. Finalmente, é feita a remoção do rótulo 2000 do pacote,
linha 29.
Similar à configuração do lsr1, o lsr2, que tem sua configuração demonstrada na
Figura 22, é o que representa nesta experiência um LSR de núcleo de uma rede MPLS, visto
que o mesmo faz apenas comutação de pacotes baseado em rótulos. Possui duas interfaces
Figura 21: Conteúdo do arquivo lsr1.startup
41
configuradas nas linhas 1 e 2, após a inicialização dos módulos MPLS, é feita a configuração
de forma estática das tabelas ILM e NHLFE.
k
No tráfego de pacotes do hostx para o hostz, os pacotes recebidos pela interface eth1
possuem o rótulo 1001 e são encaminhados com o rótulo 1002. Os pacotes recebidos do hostz
a serem encaminhados para o hostx são capturados pela eth2, possuem o rótulo 2000 e são
encaminhados com o rótulo 2001.
Figura 22: Conteúdo do arquivo lsr2.startup
42
4.3 Execução do Laboratório
Depois de efetuada a configuração apontada nas seções anteriores, será feita a execução do
laboratório. As máquinas virtuais serão iniciadas, e para cada uma o netkit cria um terminal
de entrada. As configurações, inicialmente feitas nos arquivos .startup, são carregadas neste
processo, o que pode ser alterado também quando as máquinas estão ativas.
Apenas para ilustrar o laboratório criado neste trabalho, foi inserida a Figura 23. Em
um ambiente configurado usando o Ubuntu, versão 9.10.
Com o laboratório em execução, foram feitas algumas interceptações de pacotes para
testar a comunicação IP e MPLS entre as máquinas virtuais configuradas. Alguns pontos tidos
como estratégicos para análises do tráfego foram marcados com uma lupa, como demonstrado
na Figura 24. Estes pontos serão discutidos em seguida.
Figura 23: Terminais das maquinas virtuais
43
No ler1, o tráfego das duas interfaces foi capturado para que se verificassem as
informações do pacote antes e depois da imposição do rótulo MPLS. No lsr1 a interface onde
se fez a captura foi a eth3, para observação do encaminhamento. O mesmo foi feito na
interface eth2 do lsr2. Por fim, a interface eth0 foi usada para captura dos pacotes do ler2,
para verificarmos os pacotes após a remoção do rótulo MPLS.
No primeiro ponto de verificação, Figura 24, foi feita a captura dos pacotes que saiam
do hostx endereço IP 192.168.0.1, com destino ao hostz IP 192.168.1.5, percebe-se que ao
entrar no roteador ler1, o pacote não sofre ainda o encapsulamento MPLS, como pode ser
observado nas Figuras 26.
Figura 24: Locais de captura de tráfego entre hostx e hostz
Figura 25: Local de captura de pacotes ler1 eth1
44
Neste ponto as informações de rótulo ainda não são incrementadas no pacote, pois a
partir deste momento é que o pacote alcança a rede MPLS.
O ler1, após receber o pacote e verificar quem é o destinatário de tal pacote, atribui
um rótulo ao mesmo e, em seguida, o encaminha ao próximo hop, pela interface eth2. Como
demonstrado na Figura 27.
Figura 26: Pacotes capturados na eth1 do ler1
Figura 27: de captura de pacotes ler1 eth2
45
Pode se verificar também a entrada dos pacotes com rótulo 2002 vindos do hostz, o
rótulo destes pacotes são removidos, e o pacote encaminhado para o hostx por uma rede IP.
Esta comutação é demonstrada na Figura 28.
Na captura dos pacotes na eth3 do lsr1, foi observado que as informações do pacote
são alteradas e, após a remoção do rótulo 1000, o pacote é encaminhado com o rótulo 1001
para o lsr2, o que pode ser observado nas Figuras 29 e 30.
Figura 29: Pacotes capturados na eth2 do ler1
Figura 28: Pacotes capturados na eth2 do ler1
46
Nesta captura dos pacotes, verificou-se que o pacote encaminhado para o
hostz, está recebendo o label 1001 e encaminhado pela rede MPLS, como previsto na Figura
29.
O lsr2 não tem nenhuma informação sobre a rede 192.168.0.0/24. Porém, como
demonstrado na Figura 31, o que foi verificado com a captura dos dados no ponto de
verificação representado na Figura 32, é feito o encaminhamento do pacote recebido para o
próximo roteador que conhece um caminho para esta rede. Este encaminhamento é feito
baseado nas tabelas de comutação MPLS.
Figura 30: Pacotes capturados na eth3 do lsr1
Figura 31: Pacotes capturados na eth2 do lsr2
47
No cabeçalho MPLS capturado, na eth2 do ler2, Figura 32, o rótulo MPLS como
previsto está com a numeração 1002.
Finalmente, o pacote chega ao ler2, este remove o encapsulamento MPLS e após uma
consulta nível três, encaminha o pacote ao destino pela rede IP. A Figura 33 demonstra o
ponto de captura escolhido e a Figura 34 exibe as informações capturadas. O pacote neste
caso é uma mensagem ICMP (Internet Control Message Protocol), e encaminha como ICMP
plano.
Figura 32: Pacotes capturados na eth2 do lsr2
Figura 33: Pacotes capturados na eth0 do ler2
48
Nestes pacotes capturados, percebe-se que não mais existe um cabeçalho
MPLS, entre as camadas 2 e 3, o que pode ser verificado na Figura 34.
Por fim, foram interceptados pacotes na interface eth0 do lsr2 para análise do
tráfego entre o hostx e o hosty. Estes pacotes estão na rede 172.16.0.0/24 e usam apenas o
protocolo IP. O ponto de verificação está demonstrado na Figura 35.
Figura 34: Pacotes capturados na eth0 do ler2
Figura 35: Pacotes capturados na eth0 do lsr1
49
Nota-se que na configuração do lsr1 foi adicionada uma rota para a rede em que o
hosty se encontra. Desta forma, o roteamento IP é possível em um roteador que possui o
MPLS implementado. Os pacotes capturados na eth0 do lsr1 não possuem o encapsulamento
MPLS como demonstra a Figura 36.
Com esta última verificação foi possível demonstrar que além da interoperabilidade
entre as redes IP e MPLS, é possível ter estas duas redes em funcionando paralelo usando os
mesmos equipamentos de rede.
Figura 36: Pacotes capturados na eth0 do lsr1 Figura 36: Pacotes capturados na eth0 do lsr1
50
5 CONSIDERAÇÕES FINAIS
Este trabalho tinha como objetivo simular uma rede com distribuição de labels usando o
protocolo MPLS no NETKIT, fazer interceptação e verificação dos pacotes IP e dos
cabeçalhos MPLS e ainda fazer testes de comunicação com os host da rede simulada.
O NETKIT se mostrou um ótimo software para virtualização de laboratórios para
análise e teste de redes, tanto IP quanto MPLS. Com o domínio simulado foi possível fazer os
testes de comunicação necessários para verificação das redes IP/MPLS propostas.
Com a rede simulada foi possível fazer verificação das alterações sofridas pelos
pacotes ao trafegar entre as redes simuladas. Como descrito na revisão bibliográfica deste
trabalho, foram demonstrados os processo de atribuição de cabeçalho, a comutação em cada
nó da rede e o processo de remoção do label para finalização da comunicação. Desta forma
pode se verificar o comportamento dos cabeçalhos durante a comunicação nas redes
simuladas.
Com a classificação dos pacotes em uma FEC se consegue ter um controle do tráfego
com mais eficiência, desta forma pode se garantir qualidade aos serviços disponibilizados em
uma rede usando comutação com o protocolo MPLS.
Por fim, através deste trabalho podem ser desenvolvidos outros que envolvam não só a
comunicação entre hosts de uma mesma rede, mas também uma comunicação utilizando
outras redes que usam o protocolo MPLS fim a fim, podendo ser atribuídos outros cabeçalho
MPLS em cascata, fazendo, assim, uma reclassificação dos pacotes, e determinando outro
caminho dentro desta outra rede de acordo com a qualidade ou classes de serviços exigidas
por cada aplicação.
51
REFERÊNCIAS BIBLIOGRÁFICAS
ABREU, L. H. A Arquitetura MPLS para formação de VPN. 2004. 87 f. Monografia
(Trabalho de Conclusão do Curso de Sistemas de Informação) – UNIMINAS. União
Educacional Minas Gerais, Uberlândia, 2004.
ASSIS, Alexandre Urtado et al, Protocolo MPLS. Centro Brasileiro de Pesquisas Físicas-
Notas Técnicas, número 007, ano 2002, Disponível em
ftp://ftp2.biblioteca.cbpf.br/pub/apub/2002/nt/nt_zip/nt00702.pdf. Acesso em junho de 2010.
BARBOSA, Nyl Marcos Soares, ANJOS, Moisés Lima dos, BOGO, Madianita. Uso do
Netkit no Ensino de Roteamento Estático. In: XI Encontro de Estudantes de Informática do
Tocantins, 2009, Palmas. Anais do XI Encontro de Estudantes de Informática do Tocantins.
Palmas: Centro Universitário Luterano de Palmas, 2009. p. 215-222. Disponível em:
http://tinyurl.com/yfzsf34. Acesso em junho de 2010
CARVALHO, Tereza Cristina Melo de Brito. Arquiteturas de Redes de Computadores – OSI
e TCP/IP. 2ª Edição. Rev.Ampl. São Paulo: Makron Books. Brisa; Rio de Janeiro: Embratel.
Brasília-DF: SGA, 1997.
PINHEIRO, Ana J. F., Figueiredo, G., B., MICHELI, M. P., CARDOSO, C., G. Um Estudo
do MPLS e sua Importância para o REMA. Projeto REMAv - UFBA. Salvador-Bahia: abril
de 2000. 14 p. Disponível em
RIMONDINI, Rimondini Massimo, Emulation of Computer networsk with Netkit. Disponível
em http://www.netkit.org/publications/netkit-tr.pdf. Acesso em março de 2010. Publicado em
janeiro de 2007.
52
SILVA NETO, Edson Moreira. Especificação de uma rede MPLS Fim-a-Fim com
diferenciação de serviços. 2006. 173 f. Tese (Doutorado em Ciências em Engenharia
Elétrica), Universidade Federal do Rio Grande do Norte, Natal.
TANENBAUM, A. S. Redes de Computadores. 4 ª Edição. Rio de Janeiro: Campus, 2003,
945 p.
