If you’ve got two or more network interface cards (NICs) and you’re wondering if you can use them together to increase speed or make your network connection more reliable, you’re in the right place.

This guide explains Ethernet Channel Bonding (also called NIC teaming or interface bonding) – how to set it up, how it works, and how it can help you balance traffic or prevent network downtime.

What Is Ethernet Channel Bonding?

In simple terms, Ethernet Channel Bonding lets you combine multiple physical NICs into one single virtual NIC (bond0), which is a virtual interface that handles the network traffic and talks to the physical interfaces (like eth1 and eth2) behind the scenes.

Here’s what you get out of it:

  • Redundancy: If one NIC goes down (gets unplugged or fails), your server keeps running using the other one.
  • Load Balancing: Traffic gets shared between both NICs, which can improve performance in some cases.
  • Single IP: Even though you have two NICs, you only need one IP address for the bonded interface.

This setup is often used on servers, production systems, or network appliances where uptime and performance are critical.

Bonding Modes Overview

There are about 6 bonding modes in Linux, but for now, we’ll only look at the two most common and practical ones:

Mode 0 – Load Balancing (Round-Robin)

  • Sends packets in order across all available interfaces (eth1, eth2, etc.).
  • Gives you both redundancy and a performance boost.
  • Great for balanced outgoing traffic.
  • Note: Your switch must support it (like LACP or static link aggregation).

Mode 1 – Active-Backup

  • Only one NIC is active at a time.
  • If the active NIC fails, the other one takes over.
  • Gives you high availability (redundancy), not speed.
  • No special switch config needed.

Prerequisites

Before we start, make sure:

  • You’re on a Red Hat-based system (like RHEL, Alma Linux, Rocky Linux).
  • You have root access or sudo privileges.
  • You have two NICs: eth1 and eth2.
  • Your system is using network-scripts or NetworkManager.

(If you’re on Ubuntu/Debian – bonding is done via Netplan.

Step 1: Load the Bonding Kernel Module

Before Linux can combine two or more network cards (NICs), it needs to load a special piece of software called the bonding kernel module.

By default, most Linux systems have this bonding module available, but it’s not automatically loaded unless you tell it to load.

sudo modprobe bonding

To make sure the bonding feature is available every time your system starts, you’ll need to register it for auto-loading.

echo "bonding" | sudo tee /etc/modules-load.d/bonding.conf

To check if the module is successfully loaded, use:

lsmod | grep bonding
Load Bonding Kernel Module
Load Bonding Kernel Module

Step 2: Configure eth1 and eth2 for Bonding

In this step, we’re preparing each physical network interface (eth1 and eth2) to join the bonding group. Think of bond0 as a team leader, and these two interfaces are its team members (slaves). They won’t function independently anymore – they’ll only communicate through bond0.

We do this by creating or editing configuration files for each interface.

  • /etc/sysconfig/network-scripts/ifcfg-eth1
  • /etc/sysconfig/network-scripts/ifcfg-eth2

Now open and edit the ifcfg-eth1 file with the following configuration.

DEVICE=eth1
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes

Do the same for ifcfg-eth2.

DEVICE=eth2
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes

Without this configuration, the kernel wouldn’t know that , eth1 and eth2 are supposed to work together. Also, do not assign IP addresses to eth1 or eth2. Only bond0 should have the IP. Otherwise, the OS will get confused trying to route traffic.

Step 3: Create the Bond Interface (bond0)

Alright, so far, you’ve told Linux that eth1 and eth2 should act as slaves, but slaves need a master, right? That master is what we’re creating here: a bonded interface named bond0.

For Load Balancing (mode 0) – Create a config file ifcfg-bond0.

vi /etc/sysconfig/network-scripts/ifcfg-bond0

Add the following configuration.

DEVICE=bond0
TYPE=Bond
ONBOOT=yes
BOOTPROTO=static
IPADDR=192.168.1.100
NETMASK=255.255.255.0
BONDING_OPTS="mode=0 miimon=100"

For Active-Backup (mode 1) – Just change the bonding option:

BONDING_OPTS="mode=1 miimon=100"

Depending on your system:

sudo systemctl restart NetworkManager

Or, if you’re using the older network service:

sudo systemctl restart network

Step 4: Verify Bonding Status

Once you’ve configured your bonding setup and restarted your network service, you’ll want to verify that the bond is working correctly.

watch -n 1 cat /proc/net/bonding/bond0

Sample output for mode 0 (Round-Robin):

Bonding Mode: load balancing (round-robin)
Slave Interface: eth1
Slave Interface: eth2
MII Status: up

Sample output for mode 1 (Active-Backup):

Bonding Mode: fault-tolerance (active-backup)
Currently Active Slave: eth1
Slave Interface: eth2

This shows which NIC is active and whether both links are up.

Optional: Test Failover (Active-Backup Mode)

Want to test what happens when one NIC goes down?

sudo ifconfig eth1 down
# eth2 should automatically become active
watch -n 1 cat /proc/net/bonding/bond0

Bring it back:

sudo ifconfig eth1 up

You’ll see Linux switching interfaces automatically with no downtime – that’s the beauty of bonding!

Troubleshooting Tips

  • If bond0 doesn’t show up, double-check your config files and make sure all interfaces are brought up.
  • Make sure the bonding module is loaded (lsmod | grep bonding).
  • For mode 0, some switches require link aggregation settings on their end.
  • Use ip addr instead of ifconfig on newer systems.

How to Remove Ethernet Channel Bonding

Sometimes you might want to remove bonding and go back to using your NICs individually, maybe for testing, troubleshooting, or because you’re reconfiguring the server.

sudo systemctl stop NetworkManager
sudo ip link set bond0 down
sudo modprobe -r bonding

Now, go delete the configuration files that set up the bonding:

sudo rm /etc/sysconfig/network-scripts/ifcfg-bond0

Also, edit the config files for eth1 and eth2 to remove the MASTER and SLAVE lines and bring them back as standalone interfaces.

Here’s how a standalone ifcfg-eth1 file should look:

DEVICE=eth1
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=dhcp

Or with a static IP:

DEVICE=eth1
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=static
IPADDR=192.168.1.101
NETMASK=255.255.255.0

Do the same for eth2.

Once everything’s clean, restart the NetworkManager to bring up the interfaces again.

sudo systemctl start NetworkManager

You can confirm with:

ip addr

You should now see eth1 and eth2 back in action, and bond0 should be gone.

Conclusion

Ethernet Channel Bonding is a useful and straightforward tool for improving both network performance and reliability on your Linux systems. Whether you need to balance traffic across multiple network interfaces or ensure redundancy in case of NIC failure, bonding allows you to get the most out of your hardware.

By following the steps in this guide, you should now be able to configure bonding easily using two NICs and choose between Load Balancing or Active-Backup modes based on your needs.

Similar Posts