Agregação de Links (Port Bonding) em Linux

Introdução

Neste laboratório, você aprenderá como implementar a Agregação de Links (Link Aggregation), também conhecida como agregação de portas (port bonding), em um ambiente Linux. Esta técnica poderosa permite combinar múltiplas interfaces de rede físicas em uma única interface lógica, o que pode aumentar a taxa de transferência da rede e fornecer tolerância a falhas. Você ganhará experiência prática com comandos essenciais de rede Linux para configurar e gerenciar uma conexão agregada.

Seguindo um processo passo a passo, você primeiro identificará as interfaces de rede disponíveis em seu sistema usando o comando ip a. Para uma demonstração segura e prática, criaremos duas interfaces virtuais "dummy", dummy1 e dummy2, para simular um ambiente multi-interface. Em seguida, você criará uma nova interface de agregação virtual, bond0, e escravizará (enslave) essas duas interfaces dummy a ela. Subsequentemente, você atribuirá um endereço IP estático à interface bond0 recém-criada para habilitar a comunicação. Finalmente, você verificará toda a configuração e checará o status da agregação ativa para garantir que ela esteja funcionando corretamente.

Identificar Interfaces de Rede Disponíveis com `ip a`

Nesta etapa, você começará identificando as interfaces de rede disponíveis na sua VM LabEx. Antes de poder combinar múltiplas interfaces de rede em um único link agregado (bonded link), você precisa saber seus nomes. O comando moderno e preferido para esta tarefa no Linux é ip a (uma abreviação para ip addr show).

Este comando exibe todas as interfaces de rede no sistema, juntamente com seus endereços IP, endereços MAC e seu estado operacional.

Primeiro, abra seu terminal. Ele já deve estar aberto e no diretório ~/project. Agora, execute o comando ip a para listar todas as interfaces de rede:

ip a

Você verá uma saída listando várias interfaces. Você deve prestar atenção a alguns detalhes importantes:

lo: Esta é a interface de loopback, uma interface virtual para o sistema se comunicar consigo mesmo. Você a ignorará para agregação.
eth0: Esta é a interface Ethernet principal. Não a utilizaremos para garantir que nossa conexão com o ambiente do laboratório permaneça estável.
docker0: Esta é uma ponte virtual criada pelo Docker. Atualmente está DOWN (desativada) e não é adequada para este laboratório.
dummy1, dummy2: Estas são duas interfaces virtuais dummy que adicionamos para simular duas placas de rede extras para este laboratório. Estas serão as interfaces que agregaremos juntas.
state UP: Isso indica que a interface está ativa.

Sua saída será semelhante a esta. Observe os nomes de suas interfaces dummy, dummy1 e dummy2, pois você precisará delas nas próximas etapas.

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:16:3e:00:20:a3 brd ff:ff:ff:ff:ff:ff
    altname enp0s5
    altname ens5
    inet 172.16.50.188/24 metric 100 brd 172.16.50.255 scope global dynamic eth0
       valid_lft 1892159680sec preferred_lft 1892159680sec
    inet6 fe80::216:3eff:fe00:20a3/64 scope link
       valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
    link/ether 02:42:2c:eb:c9:91 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
4: dummy1: <BROADCAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN group default qlen 1000
    link/ether 2a:47:04:07:1a:ea brd ff:ff:ff:ff:ff:ff
    inet6 fe80::5caf:4ff:fe97:69bd/64 scope link
       valid_lft forever preferred_lft forever
5: dummy2: <BROADCAST,NOARP,UP,LOWER_UP> mtu 1500 qdisc noqueue state UNKNOWN group default qlen 1000
    link/ether 2e:5f:12:08:3a:eb brd ff:ff:ff:ff:ff:ff
    inet6 fe80::5caf:4ff:fe97:69be/64 scope link
       valid_lft forever preferred_lft forever

A partir da saída acima, identificamos duas interfaces adequadas para nossa configuração de agregação: dummy1 e dummy2. Nas próximas etapas, você usará esses nomes de interface para criar uma nova interface agregada.

Criar e Habilitar a Interface Bond 'bond0'

Nesta etapa, você criará a interface lógica "bond" que servirá como mestre para suas placas de rede. Isso requer duas ações principais: carregar o módulo de kernel Linux necessário para agregação e, em seguida, criar e ativar a própria interface.

Primeiro, você precisa garantir que o módulo de kernel bonding esteja carregado. Este módulo contém o código que permite ao kernel gerenciar interfaces agregadas. Você pode carregá-lo usando o comando modprobe.

sudo modprobe bonding

Para confirmar que o módulo foi carregado com sucesso, você pode usar o comando lsmod, que lista todos os módulos de kernel carregados, e grep para filtrar por "bonding".

lsmod | grep bonding

Você deverá ver uma saída indicando que o módulo bonding está agora em uso:

bonding               196608  0

Agora que o kernel está pronto, você pode criar a nova interface lógica. Vamos chamá-la de bond0. Use o comando ip link para adicionar um novo link virtual do tipo bond.

sudo ip link add bond0 type bond

Este comando cria a interface, mas ela está em estado "down" (desativada) por padrão. Você precisa ativá-la ("up") para torná-la ativa, semelhante a habilitar uma placa de rede física.

sudo ip link set dev bond0 up

Agora você pode verificar se sua nova interface bond0 existe e está ativa usando o comando ip a novamente, mas desta vez especificando o nome da interface.

ip a show bond0

A saída mostrará a interface bond0 com seu estado como DOWN e sem um endereço IP ainda. Isso será configurado em uma etapa posterior.

6: bond0: <NO-CARRIER,BROADCAST,MULTICAST,MASTER,UP> mtu 1500 qdisc noqueue state DOWN group default qlen 1000
    link/ether xx:xx:xx:xx:xx:xx brd ff:ff:ff:ff:ff:ff

Você agora criou e habilitou com sucesso a interface mestre bond0. O próximo passo é adicionar suas interfaces dummy a ela como escravas.

Adicionar Interfaces como Escravas ao 'bond0'

Nesta etapa, você escravizará as interfaces virtuais que identificou anteriormente (dummy1 e dummy2) à interface mestre bond0. "Escravizar" uma interface significa colocá-la sob o controle da interface agregada. Uma vez escravizada, a interface física não precisa mais de seu próprio endereço IP; todo o tráfego será gerenciado através da bond0.

Esta abordagem de usar interfaces dummy é completamente segura e permite que você aprenda o processo de agregação sem nenhum risco de perder a conectividade de rede.

Primeiro, adicione a interface dummy1 à agregação. Você precisa desativá-la antes de adicioná-la como escrava.

sudo ip link set dev dummy1 down
sudo ip link set dev dummy1 master bond0

Em seguida, faça o mesmo para a interface dummy2.

sudo ip link set dev dummy2 down
sudo ip link set dev dummy2 master bond0

Agora vamos ativar a interface de agregação e atribuir um endereço IP a ela. Usaremos uma sub-rede diferente para evitar conflitos com a configuração existente da eth0:

sudo ip addr add 192.168.100.10/24 dev bond0
sudo ip link set dev bond0 up

Vamos verificar se ambas as interfaces dummy1 e dummy2 estão agora escravizadas à bond0:

ip a

Observe as entradas para dummy1, dummy2 e bond0 na saída. Você verá ambas dummy1 e dummy2 listadas com master bond0 em suas descrições, confirmando que elas foram escravizadas com sucesso. Além disso, note que a interface bond0 está agora UP e possui o endereço IP que atribuímos.

4: dummy1: <BROADCAST,NOARP,SLAVE,UP,LOWER_UP> mtu 1500 qdisc noqueue master bond0 state UP group default qlen 1000
    link/ether 2a:47:04:07:1a:ea brd ff:ff:ff:ff:ff:ff
5: dummy2: <BROADCAST,NOARP,SLAVE,UP,LOWER_UP> mtu 1500 qdisc noqueue master bond0 state UP group default qlen 1000
    link/ether 2e:5f:12:08:3a:eb brd ff:ff:ff:ff:ff:ff
6: bond0: <BROADCAST,MULTICAST,MASTER,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether 2a:47:04:07:1a:ea brd ff:ff:ff:ff:ff:ff
    inet 192.168.100.10/24 scope global bond0
       valid_lft forever preferred_lft forever
    inet6 fe80::2847:4ff:fe07:1aea/64 scope link
       valid_lft forever preferred_lft forever

Com as interfaces agora atuando como escravas, o próximo passo é configurar as definições de rede para a própria interface bond0.

Testar Conectividade da Interface Bond

Nesta etapa, você testará a interface de agregação para garantir que ela esteja funcionando corretamente. Como criamos uma agregação funcional com duas interfaces dummy e atribuímos um endereço IP a ela, podemos agora testar sua funcionalidade básica.

Primeiro, vamos verificar se a interface de agregação está ativa e possui o endereço IP correto:

ip a show bond0

Você deverá ver a interface bond0 com o endereço IP que atribuímos (192.168.100.10/24) e o estado da interface deve mostrar como UP:

6: bond0: <BROADCAST,MULTICAST,MASTER,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
    link/ether 2a:47:04:07:1a:ea brd ff:ff:ff:ff:ff:ff
    inet 192.168.100.10/24 scope global bond0
       valid_lft forever preferred_lft forever

Agora vamos testar a interface de agregação pingando seu próprio endereço IP para verificar se a interface está respondendo:

ping -c 3 192.168.100.10

Você deverá ver respostas de ping bem-sucedidas, confirmando que a interface de agregação está funcionando.

Vamos também verificar se nossas interfaces escravas estão devidamente conectadas à agregação:

ip a | grep "master bond0"

Este comando mostrará as interfaces que estão escravizadas à bond0. Você deverá ver ambas dummy1 e dummy2 listadas:

4: dummy1: <BROADCAST,NOARP,SLAVE,UP,LOWER_UP> mtu 1500 qdisc noqueue master bond0 state UP group default qlen 1000
5: dummy2: <BROADCAST,NOARP,SLAVE,UP,LOWER_UP> mtu 1500 qdisc noqueue master bond0 state UP group default qlen 1000

Para verificação adicional, vamos verificar se a interface de agregação aparece na tabela de roteamento:

ip route | grep bond0

Você deverá ver entradas de roteamento para a rede 192.168.100.0/24 através da interface bond0.

Nota Educacional: Esta configuração demonstra perfeitamente os conceitos centrais de agregação. Em um ambiente de produção com múltiplas interfaces físicas, você veria balanceamento de carga de tráfego de rede e redundância com base no modo de agregação que você escolher.

Verificar o Status do Bond com `cat /proc/net/bonding/bond0`

Nesta etapa final, você realizará a verificação mais detalhada inspecionando diretamente o arquivo de status da agregação. O kernel Linux expõe informações em tempo real sobre cada interface agregada através de um arquivo especial no sistema de arquivos /proc. Para uma interface chamada bond0, este arquivo está localizado em /proc/net/bonding/bond0.

Usar o comando cat para visualizar este arquivo fornece uma visão abrangente da configuração da agregação, incluindo seu modo, o status de suas interfaces escravas e contadores de tráfego.

No seu terminal, execute o seguinte comando:

cat /proc/net/bonding/bond0

Isso exibirá um relatório detalhado. A saída será semelhante à seguinte, mostrando agora duas interfaces escravas:

Ethernet Channel Bonding Driver: vX.X.X (Month Day, Year)

Bonding Mode: load balancing (round-robin)
Primary Slave: None
Currently Active Slave: dummy1
MII Status: up
MII Polling Interval (ms): 100
Up Delay (ms): 0
Down Delay (ms): 0
Peer Notification Delay (ms): 0

Slave Interface: dummy1
MII Status: up
Speed: 1000 Mbps
Duplex: full
Link Failure Count: 0
Permanent HW addr: 2a:47:04:07:1a:ea
Slave queue ID: 0

Slave Interface: dummy2
MII Status: up
Speed: 1000 Mbps
Duplex: full
Link Failure Count: 0
Permanent HW addr: 2e:5f:12:08:3a:eb
Slave queue ID: 0

Vamos detalhar as informações chave nesta saída:

Bonding Mode: Isso mostra a política usada para distribuir o tráfego. Como não especificamos uma, o padrão é load balancing (round-robin), que transmite pacotes em ordem pelas escravas disponíveis.
MII Status: Isso mostra o status geral do link agregado. up significa que está ativo.
Slave Interface: Você pode ver uma seção para ambas dummy1 e dummy2. Ambas mostram um MII Status de up, confirmando que estão ativas e fazem parte da agregação. Note que Speed e Duplex podem mostrar como Unknown ou um valor padrão para interfaces dummy.

Parabéns! Você configurou com sucesso uma interface de rede agregada no Linux, combinando duas interfaces dummy em uma única e lógica.

Resumo

Neste laboratório, você aprendeu os conceitos fundamentais da implementação de agregação de links (port bonding) em um ambiente Linux. O procedimento começou com a identificação das interfaces de rede disponíveis, incluindo duas interfaces virtuais pré-configuradas, dummy1 e dummy2, usando o comando ip a. Após a identificação, você criou uma nova interface de agregação virtual chamada bond0, a habilitou e, em seguida, adicionou ambas as interfaces dummy como escravas para demonstrar o processo completo de agregação.

Essa abordagem proporcionou uma maneira completamente segura e eficaz de aprender os conceitos de agregação em um ambiente remoto, sem o risco de perda de conectividade.

Os principais pontos de aprendizado incluíram:

Criação de duas interfaces dummy para simular um ambiente multi-interface.
Carregamento do módulo do kernel bonding.
Compreensão da relação mestre-escravo na agregação de rede.
Escravização de múltiplas interfaces a um único mestre de agregação.
Atribuição segura de endereços IP a interfaces de agregação.
Verificação da configuração e status final da agregação.

O laboratório concluiu com o exame do status detalhado da agregação usando cat /proc/net/bonding/bond0, que fornece informações abrangentes sobre a configuração da agregação, modo e o status de todas as suas interfaces escravas. Esta etapa de verificação é essencial em cenários do mundo real para confirmar que a configuração de agregação está funcionando conforme o esperado.