Como antecipamos nos tutoriais anteriores desta série LFCE (Linux Foundation Certified Engineer), neste artigo discutiremos o encaminhamento 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 palavras simples, um pacote é a unidade básica usada para transmitir informações dentro de uma rede. Redes que usam TCP/IP como protocolo de rede seguem as mesmas regras para a transmissão de dados: a informação real é dividida em pacotes que são compostos tanto de dados quanto do endereço para onde devem ser enviados.
- O roteamento é o processo de “guiar” os dados de origem para o 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 utilizaremos 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 consultar o 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 na base de dados de política 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 ‘ip’ Úteis para Configurar Endereço IP
Exemplo 1: Desativando e ativando uma interface de rede
Neste exemplo, vamos desativar e ativar eth1:
# ip link show # ip link set eth1 down # ip link show
Se você deseja reativar 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 de destino. A saída do comando ip route show (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 ip-route e man 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 (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 (CentOS box):
# ip route show
e então modificá-la para usar sua NIC enp0s3 e a conexão com 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 significa, “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 (openSUSE box) para fazer ping nos hosts na rede 192.168.0.0/24:
# ip route add 192.168.0.0/24 via 10.0.0.15 dev enp0s3
Por fim, 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 durante as inicializações, edite /etc/sysctl.conf no roteador e certifique-se de que a variável net.ipv4.ip_forward esteja 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 máquina 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 o NIC eth0 deve ser usado para pacotes de saída.
MASQUERADE indica que este 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 que saiba onde retornar 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 máquina openSUSE) e o destino (DNS do Google) dos pacotes são destacados. Este foi o resultado da execução:
# curl www.tecmint.com
na máquina 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: Os pacotes de entrada da Internet só são aceitos se fizerem parte de uma conexão já estabelecida (comando #2), enquanto os pacotes de saída são permitidos com “saída livre” (comando #3).
Não se esqueça de tornar suas regras de iptables persistentes seguindo os passos descritos 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 sistema implementem, com um servidor Linux de baixo custo, a mesma funcionalidade fornecida por roteadores Cisco poderosos (e caros).
A própria ferramenta não lida com o roteamento, mas modifica a tabela de roteamento do kernel à medida que aprende novas melhores rotas para lidar com pacotes.
Como é um fork do zebra, um programa cujo desenvolvimento cessou há algum tempo, ele 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.
Por favor, note 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 sobre ele.
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]
Vamos usar o mesmo ambiente que no Exemplo #3, com a única diferença de que eth0 está conectado a um roteador principal com o 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 juntamente 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 o 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
Insira 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 fins de 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 é anexada às linhas que adicionamos anteriormente (/etc/quagga/zebra.conf e /etc/quagga/ripd.conf).
Finalmente, 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.