Network Interfaces: Configuration & Management

A network interface is the doorway between your machine and a network — usually a physical NIC like eth0, sometimes a virtual one. For traffic to flow, two things have to be true: the interface has to be up (turned on), and it has to have an IP address so other hosts can reach it.

You will manage both with a single modern tool: `ip` (from the iproute2 package). It replaced the older ifconfig and is what every current certification expects.

But there is a catch that trips up almost everyone, and it is the heart of this lesson. Changes you make with ip are live but temporary — they take effect this instant and disappear at the next reboot. To make a configuration stick, you write it into a configuration manager — and which manager depends on the distro. On the RHEL family (and desktop Ubuntu) it is NetworkManager, driven by nmcli. On Ubuntu Server — including the lab box beside this lesson — it is netplan, a YAML file the system replays at boot. This lesson teaches both, because the mental model is identical; only the filing cabinet changes.

An analogy makes the split concrete. Think of the running kernel's network config as a whiteboard in the office: anyone can write an address on it instantly, everyone in the room can read it, and it is wiped clean every night when the building's power cycles. NetworkManager's config files are the permanent record in the filing cabinet — slower to update, but it is what gets copied back onto the whiteboard every morning when the building reopens (a reboot).

ip writes on the whiteboard. nmcli — or, on a netplan system, a YAML file plus netplan apply — writes in the filing cabinet.

The operations golden rule: look before you leap. The ip command splits its world into objects. The two you need are link (the interface itself — is it up?) and addr (the addresses bound to it). The -br ("brief") flag prints one tidy line per interface, which is the fastest way to get your bearings.

Two verbs do the everyday work. ip link set <dev> up|down flips the interface on or off, and ip addr add <cidr> dev <dev> binds an address to it. Both take effect the moment you press Enter — no reboot, no service restart.

To make config permanent you talk to NetworkManager through its command-line client, `nmcli`. NetworkManager's unit of config is a connection profile — a named bundle of settings (which device, which addresses, which gateway, DNS) stored on disk. At boot, NetworkManager reads these profiles and writes them onto the kernel's whiteboard for you.

The workflow is three verbs: `add` a profile, optionally `mod` (modify) it later, then `up` to activate it now.

Ubuntu Server keeps its filing cabinet somewhere else entirely: netplan. Instead of profiles you talk to through a CLI, the persistent intent is a small YAML file under /etc/netplan/ (on these lab boxes: /etc/netplan/01-netcfg.yaml). You don't run commands to build the config — you declare the end state in the file, then tell netplan to make reality match it.

Start, as always, by reading what's there. A fresh box usually declares nothing but DHCP:

To pin a static address, you flip DHCP off and declare the three things DHCP was providing — address, default route, DNS:

Field by field:

• `dhcp4: false` — the master switch, exactly like ipv4.method manual in nmcli. Leave it true and your static declarations are ignored in favour of DHCP: the same #1 static-IP mistake, in YAML clothing.
• `addresses:` — a list, and each entry carries its CIDR prefix (192.0.2.20/24, never a bare IP).
• `routes:` with `- to: default` — the default gateway. (Older guides show gateway4:; it still parses but is deprecated — the routes: form is what current docs and these rooms expect, and it also handles static routes to specific subnets: - to: 10.20.0.0/16 + via: ....)
• `nameservers.addresses:` — the DNS resolvers, also a list.

Sometimes one network cable is a single point of failure you cannot accept — a database server whose uptime depends on staying reachable. Bonding (Linux's name; some vendors call the same idea teaming) joins two or more physical NICs into one logical interface, commonly bond0. The server uses bond0 for everything; underneath, the kernel spreads or fails over traffic across the member NICs.

The analogy: a bond is a braided rope. You hang your traffic on the single rope (bond0), but it is woven from several strands (eth0, eth1). Cut one strand — a dead switch port, an unplugged cable — and the rope still holds because the others carry the load. The application never notices.

You have a real root shell. The commands below are read-only or fully reversible, so they are safe to run as-is. They walk the same inspect-then-change loop a real configuration task follows.