Mastering the `ip` Command: The Modern Replacement for `ifconfig` (and Why You Should Use It)

Table of Contents#

1. Why ip Replaces ifconfig (and Net-Tools)
2. Core Concepts: Iproute2 and Netlink
3. Diving into ip Subcommands
   • 3.1 Link Management: ip link
   • 3.2 Address Management: ip addr
   • 3.3 Routing: ip route
   • 3.4 Neighbor (ARP/NDP) Management: ip neigh
   • 3.5 Tunnels: ip tunnel
   • 3.6 VLANs and Virtual Interfaces
   • 3.7 Namespaces: ip netns
4. Common Workflows with ip
   • 4.1 Basic Network Setup
   • 4.2 Troubleshooting Connectivity
   • 4.3 Isolated Testing with Namespaces
5. Best Practices for Using ip
6. Migrating from ifconfig to ip: Cheat Sheet
7. Conclusion
8. References

1. Why ip Replaces ifconfig (and Net-Tools)#

Net-tools (which includes ifconfig, netstat, and arp) relies on ioctl—a legacy system call for device control. Ioctl is:

• Synchronous: The kernel can’t notify user-space of changes (e.g., a link going down) without polling.
• Limited: Doesn’t support modern features like multiple IP addresses per interface, IPv6 autoconfiguration, or network namespaces.

Iproute2 (and ip) uses netlink—a modern, socket-based protocol that:

• Supports asynchronous messages: The kernel can push updates to user-space (e.g., "interface eth0 is now DOWN").
• Is object-oriented: You operate on network objects (links, addresses, routes) instead of raw device settings.
• Scales: Works with thousands of interfaces (critical for cloud/container environments).

Most modern Linux distributions (Ubuntu 20.04+, RHEL 8+, Fedora 30+) ship with iproute2 preinstalled. Net-tools is often an optional package—and may not be available at all in minimal installations.

2. Core Concepts: Iproute2 and Netlink#

Before diving into ip, let’s clarify key terms:

What is Iproute2?#

Iproute2 is a suite of tools for Linux networking. The most important ones are:

• ip: Configure interfaces, addresses, routes, and namespaces.
• tc: Traffic control (QoS, bandwidth shaping).
• ss: Monitor sockets (replaces netstat).
• nstat: Network statistics (replaces netstat -s).

What is Netlink?#

Netlink is a communication protocol between user-space (your terminal) and kernel-space (the Linux network stack). It’s used by iproute2 to:

1. Send configuration commands to the kernel (e.g., "add IP 192.168.1.10 to eth0").
2. Receive notifications from the kernel (e.g., "eth0 lost carrier").

Netlink is the backbone of modern Linux networking—without it, tools like Docker or Kubernetes couldn’t exist.

3. Diving into ip Subcommands#

The ip command follows a simple syntax:

ip [ OPTIONS ] OBJECT { COMMAND | help }

Where:

• OBJECT: The network resource you want to modify (e.g., link, addr, route).
• COMMAND: The action to take (e.g., show, add, delete).

Let’s explore the most common objects.

3.1 Link Management: ip link#

A link is a physical or virtual network interface (e.g., eth0, wlan0, veth0). The ip link command manages these interfaces.

Common Use Cases#

Key Output Fields#

When you run ip link show eth0, you’ll see:

• State: UP (active) or DOWN (inactive).
• MAC address: link/ether 00:11:22:33:44:55.
• MTU: Maximum packet size (default: 1500 for Ethernet).
• qdisc: Queueing discipline (e.g., mq for multi-queue).

Example: Check Link Status#

$ ip link show eth0
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
    link/ether 00:11:22:33:44:55 brd ff:ff:ff:ff:ff:ff

The <UP,LOWER_UP> flags mean the interface is active and has carrier (connected to a switch).

3.2 Address Management: ip addr#

The ip addr command manages IP addresses assigned to links. Unlike ifconfig, ip supports:

• Multiple IP addresses per interface.
• IPv6 link-local addresses (e.g., fe80::/10).
• CIDR notation (e.g., /24 instead of 255.255.255.0).

Common Use Cases#

Key Concepts#

• CIDR Notation: Use /prefix (e.g., /24) instead of netmasks. It’s more concise and widely adopted.
• Scope: Defines where the address is valid:
  • global: Accessible from anywhere (public IPv4/IPv6).
  • link: Only valid on the local link (e.g., IPv6 link-local).
  • host: Only valid for the local system (loopback).
• Label: A nickname for multiple addresses on the same interface (e.g., eth0:1). Use label to avoid conflicts:

  sudo ip addr add 192.168.1.10/24 dev eth0 label eth0:office

Example: Add Multiple Addresses#

# Add IPv4 and IPv6 addresses to eth0
sudo ip addr add 192.168.1.10/24 dev eth0
sudo ip addr add 2001:db8::1/64 dev eth0
 
# Verify
ip addr show dev eth0

3.3 Routing: ip route#

The ip route command manages the routing table—a list of rules that tell the kernel how to forward traffic to remote networks.

Common Use Cases#

Key Concepts#

• Default Route: The "catch-all" route for traffic not matching any other rule (usually your router’s IP).
• Gateway: The next-hop IP address for remote traffic.
• Dev: The exit interface for the route (e.g., eth0).
• Metric: A priority value (lower = higher priority). Use this for load balancing or failover:

  # Add two default routes with different metrics
  sudo ip route add default via 192.168.1.1 dev eth0 metric 100
  sudo ip route add default via 192.168.1.2 dev eth0 metric 200

Example: Verify Routing#

$ ip route show
default via 192.168.1.1 dev eth0 proto dhcp src 192.168.1.10 metric 100
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.10

• proto dhcp: The route was added by DHCP.
• scope link: The route is valid only on the local link.

3.4 Neighbor (ARP/NDP) Management: ip neigh#

The ip neigh command manages the neighbor table—a mapping of IP addresses to MAC addresses. For IPv4, this is the ARP table; for IPv6, it’s NDP (Neighbor Discovery Protocol).

Common Use Cases#

Key States#

• REACHABLE: The entry is valid (recently used).
• STALE: The entry hasn’t been used in a while (will be refreshed on next use).
• PERMANENT: A static entry (won’t expire).
• FAILED: The ARP request timed out (indicates a connectivity issue).

Example: Check ARP Entries#

$ ip neigh show
192.168.1.1 dev eth0 lladdr 00:aa:bb:cc:dd:ee STALE
192.168.1.5 dev eth0 lladdr 00:11:22:33:44:55 PERMANENT

3.5 Tunnels: ip tunnel#

Tunnels let you encapsulate one network protocol within another (e.g., IPv6 over IPv4, GRE for VPNs). The ip tunnel command creates and manages tunnel interfaces.

Common Use Cases#

Example: GRE Tunnel Setup#

Suppose you have two servers:

• Local: 203.0.113.1 (public IP)
• Remote: 198.51.100.1 (public IP)

Create a tunnel between them:

# On local server
sudo ip tunnel add gre0 mode gre remote 198.51.100.1 local 203.0.113.1 ttl 255
sudo ip link set gre0 up
sudo ip addr add 10.1.1.1/24 dev gre0
 
# On remote server
sudo ip tunnel add gre0 mode gre remote 203.0.113.1 local 198.51.100.1 ttl 255
sudo ip link set gre0 up
sudo ip addr add 10.1.1.2/24 dev gre0
 
# Test connectivity
ping 10.1.1.2  # From local server

3.6 VLANs and Virtual Interfaces#

VLANs (Virtual Local Area Networks) segment a physical network into logical subnets. The ip link command creates VLAN interfaces using the type vlan parameter.

Create a VLAN Interface#

# Create VLAN 10 on eth0 (interface name: eth0.10)
sudo ip link add link eth0 name eth0.10 type vlan id 10
 
# Bring it up and assign an IP
sudo ip link set eth0.10 up
sudo ip addr add 192.168.10.10/24 dev eth0.10

Virtual Ethernet (veth) Pairs#

Veth pairs are "virtual cables" that connect two network namespaces (e.g., a container and the host). Use type veth to create them:

# Create a veth pair (veth0 and veth1)
sudo ip link add veth0 type veth peer name veth1

3.7 Namespaces: ip netns#

Network namespaces are isolated network environments—processes in a namespace can’t see interfaces, routes, or neighbors from other namespaces. This is how containers (Docker, Kubernetes) achieve network isolation.

Common Use Cases#

Example: Isolated Namespace Setup#

Let’s create a namespace (ns1) and connect it to the host using a veth pair:

1. Create a veth pair:

   sudo ip link add veth0 type veth peer name veth1

2. Move one end to the namespace:

   sudo ip link set veth1 netns ns1

3. Configure the host side:

   sudo ip link set veth0 up
   sudo ip addr add 10.0.0.1/24 dev veth0

4. Configure the namespace:

   # Enter the namespace
   sudo ip netns exec ns1 bash
    
   # Bring up veth1 and set IP
   ip link set lo up  # Enable loopback (required for some tools)
   ip link set veth1 up
   ip addr add 10.0.0.2/24 dev veth1
    
   # Test connectivity to the host
   ping 10.0.0.1

5. Exit the namespace:

   exit

This setup lets you test network configurations without affecting the host.

4. Common Workflows with ip#

Let’s walk through real-world scenarios where ip shines.

4.1 Basic Network Setup#

Suppose you want to configure eth0 with a static IP:

# 1. Bring up the interface
sudo ip link set eth0 up
 
# 2. Add an IPv4 address
sudo ip addr add 192.168.1.10/24 dev eth0
 
# 3. Add a default route
sudo ip route add default via 192.168.1.1 dev eth0
 
# 4. Verify
ip addr show dev eth0
ip route show

Compare this to ifconfig:

# Legacy ifconfig command (don’t use this!)
sudo ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up
sudo route add default gw 192.168.1.1 eth0

The ip version is more explicit and supports modern features.

4.2 Troubleshooting Connectivity#

If you can’t reach a remote server (e.g., 8.8.8.8), use these steps:

1. Check if the interface is up:

   ip link show eth0  # Look for <UP,LOWER_UP>

2. Verify the interface has an IP:

   ip addr show dev eth0

3. Check the default route:

   ip route show | grep default

4. Ping the gateway:

   ping 192.168.1.1  # Replace with your gateway IP

5. Check ARP entries for the gateway:

   ip neigh show dev eth0 | grep 192.168.1.1

6. Check if the remote IP is reachable:

   ip route get 8.8.8.8  # Shows which route is used
   ping 8.8.8.8

If the ping fails at step 5, the gateway’s MAC address is missing—check the physical connection!

4.3 Isolated Testing with Namespaces#

Suppose you want to test a new firewall rule without breaking the host network. Use a namespace:

1. Create a namespace:

   sudo ip netns add test-ns

2. Create a veth pair and connect it to the namespace:

   sudo ip link add veth0 type veth peer name veth1
   sudo ip link set veth1 netns test-ns

3. Configure the host and namespace:

   # Host side
   sudo ip link set veth0 up
   sudo ip addr add 10.0.0.1/24 dev veth0
    
   # Namespace side
   sudo ip netns exec test-ns ip link set lo up
   sudo ip netns exec test-ns ip link set veth1 up
   sudo ip netns exec test-ns ip addr add 10.0.0.2/24 dev veth1

4. Test connectivity:

   # From the host
   ping 10.0.0.2
    
   # From the namespace
   sudo ip netns exec test-ns ping 10.0.0.1

This setup lets you test firewall rules (e.g., iptables) in isolation.

5. Best Practices for Using ip#

Follow these rules to avoid mistakes and write maintainable scripts:

1. Use Explicit Commands in Scripts#

Avoid shortcuts (e.g., ip a for ip addr)—they’re harder to read in scripts. Use full commands:

# Good
sudo ip link set eth0 up
 
# Bad (don’t do this!)
sudo ip l set eth0 up

2. Back Up Before Making Changes#

Always save your routing table or addresses before modifying them:

# Backup routing table
ip route show > route_backup.txt
 
# Backup addresses for eth0
ip addr show dev eth0 > eth0_addr_backup.txt

3. Use CIDR Notation#

CIDR (/24) is more concise and less error-prone than netmasks (255.255.255.0).

4. Prefer replace Over add in Scripts#

Use replace to overwrite existing addresses/routes (avoids "address already exists" errors):

# Add or replace an IP address
sudo ip addr replace 192.168.1.10/24 dev eth0

5. Use Namespaces for Testing#

Never test network changes on a production host. Use namespaces to isolate experiments.

6. Use ss Instead of netstat#

The ss command (from iproute2) is faster and more feature-rich than netstat. Use it to check open ports:

# Show all TCP ports (listen state)
ss -tuln

6. Migrating from ifconfig to ip: Cheat Sheet#

Use this table to translate legacy ifconfig commands to ip:

7. Conclusion#

The ip command is the future of Linux networking. It’s more powerful, more efficient, and better supported than ifconfig. By learning ip, you’ll:

• Master modern networking features (VLANs, tunnels, namespaces).
• Write scripts that work on all modern Linux distributions.
• Troubleshoot complex issues faster (thanks to netlink’s asynchronous updates).

If you’re still using ifconfig, now is the time to switch. Start with basic tasks (setting an IP, checking routes) and work your way up to advanced topics like namespaces. The investment will pay off—especially in cloud or container environments where ip is the only game in town.

8. References#

• Iproute2 Official Wiki: https://wiki.linuxfoundation.org/networking/iproute2
• ip Man Page: https://man7.org/linux/man-pages/man8/ip.8.html
• Linux Kernel Netlink Documentation: https://www.kernel.org/doc/html/latest/networking/netlink.html
• Red Hat Ip Command Guide: https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_and_managing_networking/using-the-ip-command_configuring-and-managing-networking
• Ubuntu Network Configuration: https://ubuntu.com/server/docs/network-configuration

Let me know if you have questions—happy to help!