Pesquisa de site

Como transformar um servidor Linux em um roteador para lidar com o tráfego de forma estática e dinâmica - Parte 10

Como antecipamos em 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 Linux Foundation

Primeiramente, vamos esclarecer algumas definições:

  1. Em palavras simples, um pacote é a unidade básica usada para transmitir informações dentro de uma rede. As redes que utilizam TCP/IP como protocolo de rede seguem as mesmas regras para transmissão de dados: a própria informação é dividida em pacotes que são compostos tanto pelos dados quanto pelo endereço para onde devem ser enviados.
  2. Roteamento é o processo de “guiar” os dados da origem ao destino dentro de uma rede.
  3. Roteamento estático requer um conjunto de regras configuradas manualmente em uma tabela de roteamento. Essas regras são fixas e usadas para definir o caminho que um pacote deve percorrer ao viajar de uma máquina para outra.
  4. Roteamento dinâmico, ou roteamento inteligente (se desejar), significa que o sistema pode alterar automaticamente, conforme necessário, a rota que um pacote segue.

Configuração avançada de IP e dispositivos 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.

O utilitário central do pacote iproute é chamado simplesmente de ip. Sua sintaxe básica é a seguinte:

ip object command

Onde object pode ser apenas um dos seguintes (apenas os objetos mais frequentes são mostrados – você pode consultar man ip para obter uma lista completa):

  1. link: dispositivo de rede.
  2. addr: endereço do protocolo (IP ou IPv6) em um dispositivo.
  3. route: entrada da tabela de roteamento.
  4. regra: regra no banco de dados de políticas de roteamento.

Enquanto comando representa uma ação específica que pode ser executada 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 obter mais exemplos do comando ‘ip’, leia 10 comandos ‘ip’ úteis para configurar o endereço IP

Exemplo 1: desabilitando e habilitando uma interface de rede

Neste exemplo, desabilitaremos e habilitaremos eth1:

ip link show
ip link set eth1 down
ip link show

Se você deseja reativar a eth1,

ip link set eth1 up

Em vez de exibir todas as interfaces de rede, podemos especificar uma delas:

ip link show eth1

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 três comandos a seguir:

ip route show
route -n
netstat -rn

A primeira coluna na saída dos três comandos indica a rede alvo. A saída de ip route show (seguindo a 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 ao route, você ainda pode consultar man ip-route e man route para uma explicação detalhada do resto 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 ver a tabela de roteamento em dev1 (caixa CentOS):

ip route show

e então modifique-o 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

Que basicamente diz: “Adicione uma rota à rede 10.0.0.0/24 por meio da interface de rede enp0s3 usando 192.168.0.15 como gateway”.

Da mesma forma no dev4 (caixa openSUSE) para executar ping em hosts na 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 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 verdadeira da seguinte maneira:

net.ipv4.ip_forward = 1

Além disso, configure as NICs em ambos os clientes (procure o arquivo de configuração em /etc/sysconfig/network no openSUSE e em /etc/sysconfig/network-scripts no CentOS – em ambos os casos é chamado ifcfg-enp0s3).

Aqui está o arquivo de configuração da caixa do 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 em que 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 de 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 possui 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 rastreia as conexões estabelecidas em /proc/net/ip_conntrack para saber para onde retornar a resposta da Internet.

Apenas parte da saída de:

cat /proc/net/ip_conntrack

é mostrado na imagem a seguir.

Onde é destacada a origem (IP privado da caixa openSUSE) e destino (Google DNS) dos pacotes. Este foi o resultado da execução:

curl linux-console.net

na caixa do openSUSE.

Como tenho certeza que você já deve imaginar, 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: Pacotes recebidos da Internet só são aceitos se fizerem parte de uma conexão já estabelecida (comando #2), enquanto pacotes enviados são permitidos “saída gratuita ”(comando nº 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

Hoje em dia, a ferramenta mais utilizada para roteamento dinâmico em Linux é o quagga. Ele permite que administradores de sistema implementem, com um servidor Linux de custo relativamente baixo, a mesma funcionalidade fornecida por roteadores Cisco poderosos (e caros).

A ferramenta em si não lida com o roteamento, mas modifica a tabela de roteamento do kernel à medida que aprende novas rotas melhores para lidar com pacotes.

Por ser um fork do Zebra, 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 à zebra a partir de agora.

Observe que não é possível cobrir 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ê desenvolver.

Instalando Quagga no Linux

Para instalar o quagga na 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 a eth0 está conectada 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: Esse ripd.conf é o arquivo de configuração do Routing Information Protocol, que fornece ao roteador informações sobre quais redes podem ser alcançados e quão longe (em termos de quantidade de saltos) eles 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 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 (escutando 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 ative a configuração:

enable
configure terminal

Insira 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 daemon RIP (porta 2602):

telnet localhost 2602

Digite o nome de usuário e a senha conforme configurados no arquivo /etc/quagga/ripd.conf e digite os seguintes comandos em negrito (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: Em ambos os casos a configuração é anexada às linhas que adicionamos anteriormente (/etc/quagga/zebra.conf e < b>/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 até lá. rede, executando o comando show ip route:

show ip route

Se você quiser experimentar protocolos ou configurações diferentes, consulte o site do projeto Quagga para obter mais documentação.

Conclusão

Neste artigo, explicamos como configurar o roteamento estático e dinâmico, usando roteador(es) de caixa Linux. Sinta-se à vontade para adicionar quantos roteadores desejar e experimentar o quanto quiser. Não hesite em entrar em contato conosco usando o formulário de contato abaixo se tiver algum comentário ou dúvida.