Como antecipamos nos tutoriais anteriores desta série LFCE (Linux Foundation Certified Engineer), neste artigo discutiremos o roteamento do tráfego IP de forma estática e dinâmica com aplicações específicas.
Apresentando o Programa de Certificação da Linux Foundation
Primeiro as primeiras coisas, vamos esclarecer algumas definições:
- Em termos simples, um pacote é a unidade básica usada para transmitir informações dentro de uma rede. Redes que utilizam TCP/IP como protocolo de rede seguem as mesmas regras para transmissão de dados: a informação real é dividida em pacotes que são compostos tanto por dados quanto pelo endereço para onde devem ser enviados.
- Roteamento é o processo de “guiar” os dados do origem ao destino dentro de uma rede.
- O roteamento estático requer um conjunto de regras configuradas manualmente definidas em uma tabela de roteamento. Essas regras são fixas e são usadas para definir o caminho que um pacote deve percorrer enquanto viaja de uma máquina para outra.
- O roteamento dinâmico, ou roteamento inteligente (se preferir), significa que o sistema pode alterar automaticamente, conforme necessário, a rota que um pacote segue.
Configuração Avançada de Dispositivos IP e de Rede
O pacote iproute fornece um conjunto de ferramentas para gerenciar redes e controle de tráfego que usaremos ao longo deste artigo, pois representam a substituição de ferramentas legadas como ifconfig e route.
A utilidade central na suíte iproute é chamada simplesmente de ip. Sua sintaxe básica é a seguinte:
# ip object command
Onde objeto pode ser apenas um dos seguintes (apenas os objetos mais frequentes são mostrados – você pode se referir ao manual ip para uma lista completa):
- link: dispositivo de rede.
- addr: endereço de protocolo (IP ou IPv6) em um dispositivo.
- route: entrada na tabela de roteamento.
- rule: regra no banco de dados de políticas de roteamento.
Onde comando representa uma ação específica que pode ser realizada no objeto. Você pode executar o seguinte comando para exibir a lista completa de comandos que podem ser aplicados a um objeto específico:
# ip object help
Por exemplo,
# ip link help
A imagem acima mostra, por exemplo, que você pode alterar o status de uma interface de rede com o seguinte comando:
# ip link set interface {up | down}
Para mais exemplos de comandos ‘ip‘, leia 10 Comandos Úteis ‘ip’ para Configurar Endereço IP
Exemplo 1: Desabilitando e habilitando uma interface de rede
Neste exemplo, vamos desabilitar e habilitar eth1:
# ip link show # ip link set eth1 down # ip link show
Se você quiser reabilitar eth1,
# ip link set eth1 up
Em vez de exibir todas as interfaces de rede, podemos especificar uma delas:
# ip link show eth1
O que retornará todas as informações para eth1.
Exemplo 2: Exibindo a tabela de roteamento principal
Você pode visualizar sua tabela de roteamento principal atual com qualquer um dos seguintes 3 comandos:
# ip route show # route -n # netstat -rn
A primeira coluna na saída dos três comandos indica a rede alvo. A saída do comando ip route (seguido da palavra-chave dev) também apresenta os dispositivos de rede que servem como gateway físico para essas redes.
Embora hoje em dia o comando ip seja preferido sobre route, você ainda pode consultar o manual do ip-route e do route para uma explicação detalhada do restante das colunas.
Exemplo 3: Usando um servidor Linux para rotear pacotes entre duas redes privadas
Queremos rotear pacotes icmp (ping) de dev2 para dev4 e vice-versa também (observe que ambas as máquinas clientes estão em redes diferentes). O nome de cada NIC, juntamente com seu endereço IPv4 correspondente, é fornecido entre colchetes.
Nosso ambiente de teste é o seguinte:
Client 1: CentOS 7 [enp0s3: 192.168.0.17/24] - dev1 Router: Debian Wheezy 7.7 [eth0: 192.168.0.15/24, eth1: 10.0.0.15/24] - dev2 Client 2: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Vamos visualizar a tabela de roteamento em dev1 (caixa CentOS):
# ip route show
e então modificá-la para usar sua interface de rede enp0s3 e a conexão para 192.168.0.15 para acessar hosts na rede 10.0.0.0/24:
# ip route add 10.0.0.0/24 via 192.168.0.15 dev enp0s3
O que essencialmente lê, “Adicionar uma rota para a rede 10.0.0.0/24 através da interface de rede enp0s3 usando 192.168.0.15 como gateway”.
Da mesma forma em dev4 (caixa openSUSE) para fazer ping nos hosts da rede 192.168.0.0/24:
# ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3
Finalmente, precisamos habilitar o encaminhamento em nosso roteador Debian:
# echo 1 > /proc/sys/net/ipv4/ip_forward
Agora vamos fazer ping:
e,
Para tornar essas configurações persistentes através dos reinícios, edite /etc/sysctl.conf no roteador e verifique se a variável net.ipv4.ip_forward está definida como true da seguinte forma:
net.ipv4.ip_forward = 1
Configure as NICs em ambos os clientes (procure o arquivo de configuração dentro de /etc/sysconfig/network no openSUSE e /etc/sysconfig/network-scripts no CentOS – em ambos os casos é chamado de ifcfg-enp0s3).
Aqui está o arquivo de configuração da caixa openSUSE:
BOOTPROTO=static BROADCAST=10.0.0.255 IPADDR=10.0.0.18 NETMASK=255.255.255.0 GATEWAY=10.0.0.15 NAME=enp0s3 NETWORK=10.0.0.0 ONBOOT=yes
Exemplo 4: Usando um servidor Linux para rotear pacotes entre redes privadas e a Internet
Outro cenário onde uma máquina Linux pode ser usada como roteador é quando você precisa compartilhar sua conexão com a Internet com uma LAN privada.
Router: Debian Wheezy 7.7 [eth0: Public IP, eth1: 10.0.0.15/24] - dev2 Client: openSUSE 13.2 [enp0s3: 10.0.0.18/24] - dev4
Além de configurar o encaminhamento de pacotes e a tabela de roteamento estático no cliente como no exemplo anterior, precisamos adicionar algumas regras iptables no roteador:
# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE # iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT # iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT
O primeiro comando adiciona uma regra à cadeia POSTROUTING na tabela nat (Network Address Translation), indicando que a NIC eth0 deve ser usada para pacotes de saída.
MASQUERADE indica que esta NIC tem um IP dinâmico e que antes de enviar o pacote para o “mundo selvagem” da Internet, o endereço de origem privado do pacote deve ser alterado para o IP público do roteador.
Em uma LAN com muitos hosts, o roteador mantém o controle das conexões estabelecidas em /proc/net/ip_conntrack para saber para onde enviar a resposta da Internet.
Apenas parte da saída de:
# cat /proc/net/ip_conntrack
é mostrada na captura de tela a seguir.
Onde a origem (IP privado da caixa openSUSE) e o destino (DNS do Google) dos pacotes são destacados. Este foi o resultado da execução de:
# curl www.tecmint.com
na caixa openSUSE.
Como eu tenho certeza que você já pode adivinhar, o roteador está usando o 8.8.8.8 do Google como servidor de nomes, o que explica por que o destino dos pacotes de saída aponta para esse endereço.
Nota: Que pacotes de entrada da Internet só são aceitos se fizerem parte de uma conexão já estabelecida (comando #2), enquanto pacotes de saída são permitidos “saída livre” (comando #3).
Não se esqueça de tornar suas regras de iptables persistentes seguindo as etapas descritas na Parte 8 – Configurar o Firewall Iptables desta série.
Roteamento Dinâmico com Quagga
Atualmente, a ferramenta mais usada para roteamento dinâmico no Linux é o quagga. Ele permite que os administradores de sistemas implementem, com um servidor Linux relativamente de baixo custo, a mesma funcionalidade fornecida por roteadores Cisco poderosos (e caros).
A própria ferramenta não lida com o roteamento, mas sim modifica a tabela de roteamento do kernel à medida que aprende novas rotas melhores para lidar com pacotes.
Já que é um fork do zebra, um programa cujo desenvolvimento cessou há um tempo, mantém por razões históricas os mesmos comandos e estrutura do zebra. É por isso que você verá muitas referências ao zebra a partir deste ponto.
Tenha em mente que não é possível abordar o roteamento dinâmico e todos os protocolos relacionados em um único artigo, mas estou confiante de que o conteúdo apresentado aqui servirá como ponto de partida para você construir a partir disso.
Instalando o Quagga no Linux
Para instalar o quagga na sua distribuição escolhida:
# aptitude update && aptitude install quagga [On Ubuntu] # yum update && yum install quagga [CentOS/RHEL] # zypper refresh && zypper install quagga [openSUSE]
Usaremos o mesmo ambiente do Exemplo #3, com a única diferença de que eth0 está conectado a um roteador gateway principal com IP 192.168.0.1.
Em seguida, edite /etc/quagga/daemons com:
zebra=1 ripd=1
Agora crie os seguintes arquivos de configuração.
# /etc/quagga/zebra.conf # /etc/quagga/ripd.conf
e adicione estas linhas (substitua por um nome de host e senha de sua escolha):
service quagga restart hostname dev2 password quagga
# service quagga restart
Nota: Que ripd.conf é o arquivo de configuração para o Protocolo de Informações de Roteamento, que fornece ao roteador as informações de quais redes podem ser alcançadas e a que distância (em termos de quantidade de saltos) estão.
Observe que este é apenas um dos protocolos que podem ser usados junto com o quagga, e eu o escolhi para este tutorial devido à facilidade de uso e porque a maioria dos dispositivos de rede o suporta, embora tenha a desvantagem de passar credenciais em texto simples. Por esse motivo, você precisa atribuir permissões adequadas ao arquivo de configuração:
# chown quagga:quaggavty /etc/quagga/*.conf # chmod 640 /etc/quagga/*.conf
Exemplo 5: Configurando o quagga para rotear o tráfego IP dinamicamente
Neste exemplo, usaremos a seguinte configuração com dois roteadores (certifique-se de criar os arquivos de configuração para roteador #2 conforme explicado anteriormente):
Importante: Não se esqueça de repetir a seguinte configuração para ambos os roteadores.
Conecte-se ao zebra (ouvindo na porta 2601), que é o intermediário lógico entre o roteador e o kernel:
# telnet localhost 2601
Digite a senha que foi definida no arquivo /etc/quagga/zebra.conf, e então habilite a configuração:
enable configure terminal
Digite o endereço IP e a máscara de rede de cada NIC:
inter eth0 ip addr 192.168.0.15 inter eth1 ip addr 10.0.0.15 exit exit write
Agora precisamos nos conectar ao terminal do daemon RIP (porta 2602):
# telnet localhost 2602
Insira o nome de usuário e senha conforme configurado no arquivo /etc/quagga/ripd.conf, e em seguida digite os seguintes comandos em negrito (os comentários são adicionados para esclarecimento):
enable turns on privileged mode command. configure terminal changes to configuration mode. This command is the first step to configuration router rip enables RIP. network 10.0.0.0/24 sets the RIP enable interface for the 10.0.0.0/24 network. exit exit write writes current configuration to configuration file.
Nota: Que em ambos os casos a configuração é adicionada às linhas que adicionamos anteriormente (/etc/quagga/zebra.conf e /etc/quagga/ripd.conf).
Por fim, conecte-se novamente ao serviço zebra em ambos os roteadores e observe como cada um deles “aprendeu” a rota para a rede que está atrás do outro, e qual é o próximo salto para chegar a essa rede, executando o comando show ip route:
# show ip route
Se desejar experimentar diferentes protocolos ou configurações, talvez queira consultar o site do projeto Quagga para mais documentação.
Conclusão
Neste artigo, explicamos como configurar roteamento estático e dinâmico, usando um roteador de caixa Linux. Sinta-se à vontade para adicionar quantos roteadores desejar e experimentar o quanto quiser. Não hesite em nos contatar usando o formulário de contato abaixo se tiver algum comentário ou pergunta.