Dynamic vs static IP addresses: when to use which, and how to configure them on Linux

When you connect a device to the internet — a smartphone, a laptop or a smart TV — that device gets a unique number: the IP address. That address works like a house number and lets other devices talk to yours.

There are two main ways your device can get an IP address: dynamically (assigned automatically and changeable) or statically (set by hand and unchanged until you change it). You do not need special prior knowledge. If you want to go deeper into networking, read the article on the OSI model.

Two paths to an IP address

┌─────────────────────────────────────────────────────────────┐
│   Two paths to an IP address                                │
│                                                             │
│   ┌────────────────┐                                        │
│   │ Dynamic IP     │  -->  Router assigns IP automatically  │
│   └───────┬────────┘                                        │
│           │  like a rented flat                             │
│           ▼                                                 │
│   ┌────────────────┐                                        │
│   │ Static IP      │  -->  Admin sets the IP                │
│   └───────┬────────┘                                        │
│           │  like owning the house                          │
└─────────────────────────────────────────────────────────────┘

⚠️ For beginners: Everyday picture:

┌─────────────────────────────────────────────────────────────┐
│   Everyday picture                                          │
│                                                             │
│   Dynamic IP  -->  hotel room number changes every stay     │
│                          ▼                                  │
│   Static IP   -->  your home number stays the same          │
└─────────────────────────────────────────────────────────────┘

❗ Important note: This is a practice-oriented companion for self-study. It does not replace an official course. It helps you apply the concepts on real system-administration scenarios.

Topics and how to work through them

You will cover the following topics:

• Basics of IP addresses
• Dynamic and static IPs compared in detail
• Practical setup and troubleshooting on Linux

Especially useful for beginners: typical pitfalls and concrete examples so you can start immediately.

Who this is for

You will get the most from it if you are:

• a Linux beginner who wants to learn networks
• a system administrator who wants to deepen existing knowledge
• an IT professional who wants a clear overview
• anyone who prefers practice-oriented explanations

How you get the most out of it

Follow these tips:

• Read step by step and test the examples in a virtual machine
• Note the commands and try them
• Use the ASCII diagrams as a visual aid
• Ask in forums when questions come up

Introduction to IP addresses

An IP address is like a digital identity card for your device on the network. Without it, targeted data exchange between computers would be impossible — imagine sending a letter when nobody has an address. The following sections unpack that step by step so you understand why IP addresses are the foundation of every network conversation.

First of all: IP stands for Internet Protocol, the standard that gets data packets through the network. Every IP address identifies a device uniquely and enables routing — forwarding data from source to destination. When you open a web page, your browser sends a request to the server’s IP address, and the server answers under yours.

There are two common versions: IPv4 and IPv6. IPv4 is the classic most people still know, but IPv6 matters more and more because the old addresses are running out. The next two sections show how each is built.

Structure of an IPv4 address

An IPv4 address consists of four number blocks, separated by dots. Each block runs from 0 to 255 — theoretically more than 4 billion addresses. Why exactly 0 to 255? That comes from binary representation: computers think in bits (0 or 1), and each block is 8 bits long. 2^8 minus 1 is 255.

Example: structure of an IPv4 address

┌─────────────────────────────────────────────────────────────┐
│   IPv4 address structure                                    │
│                                                             │
│   ┌─────────┬─────────┬─────────┬─────────┐                 │
│   │   192   │   168   │    1    │   100   │                 │
│   └─────────┴─────────┴─────────┴─────────┘                 │
│         Four number blocks (each block: 0 to 255)           │
└─────────────────────────────────────────────────────────────┘

In binary that looks like this: 192 is 11000000, 168 is 10101000, 1 is 00000001 and 100 is 01100100. Together: 11000000.10101000.00000001.01100100. That is the language routers and switches work in.

💡 Tip: To convert an IP to binary on Linux you can use ipcalc. Install it with sudo apt install ipcalc on Debian-based systems and try ipcalc 192.168.1.100.

Structure of an IPv6 address

IPv6 is the successor and solves address scarcity. Instead of 32 bits (as with IPv4) it uses 128 bits, which yields about 340 undecillion addresses — enough for every device on earth and more. An IPv6 address looks like eight groups of four hexadecimal digits (0-9, A-F), separated by colons. Example: 2001:0db8:0000:0000:0000:ff00:0042:8329.

To shorten it you can drop leading zeros or replace consecutive zero groups with ::: 2001:db8::ff00:42:8329

Structure of an IPv6 address

┌─────────────────────────────────────────────────────────────┐
│   IPv6 address structure                                    │
│                                                             │
│      ┌──────┬──────┬──────┬──────┐                          │
│      │ 2001 │ 0db8 │ 0000 │ 0000 │                          │
│      ├──────┼──────┼──────┼──────┤                          │
│      │ 0000 │ ff00 │ 0042 │ 8329 │                          │
│      └──────┴──────┴──────┴──────┘                          │
│         Eight hex groups (each group: 0000 to FFFF)         │
└─────────────────────────────────────────────────────────────┘

🔧 Practical example: In a modern dual-stack network (IPv4 and IPv6 in parallel) you see both.

Check your own IP with:

ip addr show

Look for inet for IPv4 and inet6 for IPv6. If you only see IPv4, your network is not yet on IPv6 — but that is changing.

Why IP addresses matter

Picture a large shopping mall. Without shop names and numbers you would search forever for a specific store. Computers likewise need unique addresses to send and receive data. Without IP, your email client would not know where the message should go, and your browser could not load a page.

Here is a simple diagram of network communication:

┌─────────────────────────────────────────────────────────────┐
│   Packet exchange between two hosts                         │
│                                                             │
│   ┌──────┐                                   ┌──────┐       │
│   │ PC-A │  ------------------------------>  │ PC-B │       │
│   └──────┘                                   └──────┘       │
│   "I am 192.168.1.100"      "Ah, the message is for me!"    │
│              data packet (with source and dest IP)          │
└─────────────────────────────────────────────────────────────┘

Every data packet contains the source IP (sender) and destination IP (receiver). Routers look at that and forward until it arrives. If the IP is wrong, the message is lost — like a letter without an address.

⚠️ For beginners: Think of IP addresses as an addressing system:

┌─────────────────────────────────────────────────────────────┐
│   Street system vs IP system                                │
│                                                             │
│   Street system  -->  city | street name | house number     │
│                          ▼                                  │
│   IP system      -->  network part | subnet | host ID       │
└─────────────────────────────────────────────────────────────┘

The network part identifies the large net (like the city), the subnet a subdivision (like the district) and the host ID the individual device (like the house number).

Private and public IP addresses

Before dynamic and static, you need the difference between private and public IPs. That is decisive for understanding how your home network is separated from the internet.

Public IPs are globally unique and assigned by Internet Service Providers (ISPs). They are like the street address of your house — anyone on the internet can reach you through them. Private IPs are valid only in your local network, like room numbers in a building. They are not routed on the internet, which provides security.

Think of your home network as a large office building. The public IP is the street address of the building, while the private IPs are the office numbers inside. The router (like the receptionist) translates between them using NAT (Network Address Translation).

Internet and your home network

┌─────────────────────────────────────────────────────────────┐
│   Internet                                                  │
│   (public IP: 203.0.113.17)                                 │
│                         ▼                                   │
│                    ┌──────────┐                             │
│                    │  Router  │                             │
│                    └──────────┘                             │
│                         ▼                                   │
│   Private IP addresses:                                     │
│   ┌───────┐   ┌───────┐   ┌───────┐                         │
│   │ PC    │   │ Phone │   │ Smart │                         │
│   │ .100  │   │ .101  │   │ .102  │                         │
│   └───────┘   └───────┘   └───────┘                         │
└─────────────────────────────────────────────────────────────┘

Private IPv4 ranges (per RFC 1918): 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16. For IPv6 there are Unique Local Addresses (ULA) such as fc00::/7.

🔧 Practical example:

Check your public IP with:

curl ifconfig.me

And your private IP with ip addr show. NAT makes all devices in your net share one public IP — economical and safer, because attackers from outside cannot reach private IPs directly.

❗ Watch out: In enterprise networks you often mix private IPs with VPNs for secure access. If you host a server, you need a public IP or port forwarding.

💡 Tip: For more detail on private vs public IPs, see Public vs private IP addresses.

With these basics you are ready for the next step: comparing dynamic and static IPs.

Dynamic vs static IP addresses in detail

Now that you have the IP basics — structure, the role in communication, private and public variants — the core question is how those addresses are actually assigned. That is where dynamic and static IPs come in. The following sections go through the mechanisms, then advantages and disadvantages, and end with practical scenarios including a comparison table.

How dynamic IPs work

Automation through DHCP

Dynamic IPs are assigned automatically, which keeps the process simple and low-maintenance. The heart of that is the DHCP protocol (Dynamic Host Configuration Protocol), which works like a smart landlord: it hands out IPs from a pool without you intervening by hand. Picture checking into a hotel — the room (the IP) is assigned to you, and on your next visit it might be a different one.

The sequence runs in four steps, known as DORA (Discover, Offer, Request, Acknowledge):

• 1. Discover: Your device sends a broadcast: Hey, I need an IP!
• 2. Offer: The DHCP server answers: Here is this IP, plus subnet mask, gateway and DNS server.
• 3. Request: Your device confirms: Yes, I will take that one.
• 4. Acknowledge: The server finalises: Okay, the IP is reserved for you.
• 5. Release: After the lease expires, the server frees the IP again.

Lease times matter: typically 24 hours in home networks, shorter on public WLANs. After expiry the lease renews automatically, but the IP can change if the pool is tight.

DHCP sequence visualised

┌─────────────────────────────────────────────────────────────┐
│   DHCP DORA sequence                                        │
│                                                             │
│   ┌────────────┐                     ┌────────────┐         │
│   │  Client    │                     │ DHCP server│         │
│   └────────────┘                     └────────────┘         │
│        │  Discover (broadcast)            │                 │
│        │ ------------------------------>  │                 │
│        │                                  │                 │
│        │      Offer (IP proposal)         │                 │
│        │ <------------------------------  │                 │
│        │                                  │                 │
│        │  Request (acceptance)            │                 │
│        │ ------------------------------>  │                 │
│        │                                  │                 │
│        │    Acknowledge (confirmation)    │                 │
│        │ <------------------------------  │                 │
└─────────────────────────────────────────────────────────────┘

🔧 Practical example: In a home network with many devices (laptop, smartphone, smart TV) DHCP keeps everything connected without you assigning addresses.

Check your dynamic IP on Linux with:

ip addr show | grep inet

Or force a renewal with:

sudo dhclient -r && sudo dhclient

That is useful when you have connection problems — it fetches a fresh IP.

Advantages of dynamic IPs:

• Simplicity: no manual work, ideal for beginners or large nets.
• Scalability: the server avoids conflicts automatically by reusing IPs.
• Flexibility: perfect for mobile devices that connect here and there.
• Resource efficiency: in times of IPv4 scarcity, DHCP hands out IPs efficiently.

Disadvantages:

• Unpredictability: the IP can change, which can break connections.
• Dependence on the server: if the DHCP server fails, new devices cannot get an IP.
• Security risks: rogue DHCP servers (attackers handing out wrong IPs).

⚠️ For beginners: If you look at DHCP settings in your router (usually 192.168.1.1 in the browser), you see the IP pool, for example 192.168.1.100 to 192.168.1.200. Those are the addresses handed out dynamically.

How static IPs work: manual stability

By contrast, static IPs are set by hand — you decide which address a device gets, and it stays until you change it. That is like a fixed address at your own house: reliable and predictable.

Configuration happens on the device itself or centrally via tools. On Linux you edit files such as /etc/netplan/ (on Ubuntu) or use commands such as nmcli. You do not only set the IP, but also the subnet mask (for example 255.255.255.0 for /24), gateway (router IP) and DNS servers (for example 8.8.8.8 for Google).

Example of a static configuration in Netplan (YAML file under /etc/netplan/01-netcfg.yaml):

network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: no
      addresses: [192.168.1.50/24]
      gateway4: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]

Apply with:

sudo netplan apply

Static IP assignment

┌─────────────────────────────────────────────────────────────┐
│   Static IP assignment                                      │
│                                                             │
│   ┌─────────┐                        ┌─────────┐            │
│   │  Admin  │                        │ Device  │            │
│   └─────────┘                        └─────────┘            │
│        │  Configures IP by hand           │                 │
│        │ ------------------------------>  │                 │
│        │  (e.g. via config file)          │                 │
│        │                                  │                 │
│        │  Stays fixed, no change          │                 │
│        │ <------------------------------  │                 │
│        │    until a manual adjustment     │                 │
└─────────────────────────────────────────────────────────────┘

🔧 Practical example: For a web server or printer on your network, static is ideal — you can always reach it under the same IP, for example for port forwarding on the router.

Test reachability with:

ping 192.168.1.50

Advantages of static IPs:

• Reliability: perfect for devices that must always be reachable.
• Remote access: no surprises from IP changes; you can configure DNS records precisely.
• Optimisation: in enterprise nets you reserve IPs for critical systems to set priorities.
• Debugging: fixed IPs make troubleshooting easier because you know where each device “lives”.

Disadvantages:

• Effort: every assignment needs manual work, which is time-consuming in large nets.
• Conflict risk: if two devices get the same IP, a conflict occurs — nothing communicates any more.
• Less flexibility: not suitable for temporary devices, because you must manage the pool by hand.
• Scaling problems: when you grow you must replan IPs, which can cause outages.

❗ Watch out: Never mix static IPs from the DHCP pool — reserve separate ranges, for example .1–.50 static, .51–.254 dynamic.

💡 Tip: On Fedora or Red Hat-based systems use nmcli for static IPs:

sudo nmcli con mod "Wired connection 1" ipv4.addresses 192.168.1.50/24 ipv4.method manual
sudo nmcli con up "Wired connection 1"

Comparison and use cases

When to choose which?

To make the decision easier, here is a direct comparison. Remember: the choice depends on your scenario — home net vs server environment.

Comparison: dynamic vs static

┌─────────────────────────────────────────────────────────────┐
│ Comparison: dynamic vs static IP                            │
├──────────────┬──────────────────────┬───────────────────────┤
│ Aspect       │ Dynamic IP (DHCP)    │ Static IP             │
├──────────────┼──────────────────────┼───────────────────────┤
│ Assignment   │ Automatic by server  │ Manual by admin       │
│ Change       │ Can change           │ Stays fixed           │
│ Effort       │ Low                  │ High (config + docs)  │
│ Suited for   │ Mobiles, home nets   │ Servers, printers     │
│ Advantages   │ Scalable, no clash   │ Reliable, predictable │
│ Drawbacks    │ Unpredictable, deps  │ Conflicts, inflexible │
│ Security     │ Rogue-server risk    │ Easier to lock down   │
└──────────────┴──────────────────────┴───────────────────────┘

Use cases:

• Home net: dynamic for everything — your router handles it, and you save time.
• Small office: dynamic for laptops, static for printers and file servers so print jobs are not lost.
• Enterprise: dynamic for user devices, static for critical infrastructure such as databases.
• Server hosting: always static, or static leases in DHCP, so domains such as example.com always point at the same IP.

⚠️ For beginners: Start with dynamic in a VM (for example VirtualBox with Ubuntu) to experiment. Disable DHCP on the router and see what happens — devices no longer get an IP.

Setup and troubleshooting on Linux

With the theoretical foundation on dynamic and static IPs you can now go straight into practice — on Linux, where network configuration is a core piece of system administration. As a beginner you learn step by step how you set IPs, find typical errors and lock down your setup. The sections cover common distributions such as Ubuntu, Debian and Fedora, with a focus on tools such as Netplan, nmcli and systemd-networkd. Each step is explained so you can follow and try it without programming knowledge.

Setting up dynamic IPs: enabling and configuring DHCP

Dynamic IPs are the entry point for most Linux newcomers because they run automatically. On Linux the DHCP client (for example dhclient or systemd-networkd) talks to the server. On a freshly installed system DHCP is often enabled by default — but you should check and adjust it.

First: identify your network interface. On Linux these are typically named enp0s3 (Ethernet) or wlp2s0 (Wi-Fi).

Find them with:

ip link show

That lists all interfaces, including status (up/down).

For Ubuntu/Debian (with Netplan, default from Ubuntu 18.04):

Edit the config file under /etc/netplan/. Create or edit a YAML file, for example 01-netcfg.yaml:

network:
  version: 2
  renderer: networkd  # Or NetworkManager for desktops
  ethernets:
    enp0s3:  # Replace with your interface
      dhcp4: yes  # Enables DHCP for IPv4
      dhcp6: yes  # Optional for IPv6

Apply the changes:

sudo netplan try  # Tests, rollback on errors
sudo netplan apply

If something goes wrong you have 120 seconds to abort — useful for beginners so you do not panic.

For Fedora/Red Hat (with NetworkManager): use nmcli, a command-line tool for graphical and server environments.

sudo nmcli con mod "Wired connection 1" ipv4.method auto  # Sets DHCP
sudo nmcli con up "Wired connection 1"

Wired connection 1 is the default name; adjust it with nmcli con show.

On older Debian systems (without Netplan, with /etc/network/interfaces):

sudo nano /etc/network/interfaces

Add:

auto enp0s3
iface enp0s3 inet dhcp

Then:

sudo ifup enp0s3

🔧 Practical example: On a home-server setup with Ubuntu, enable DHCP for a temporary test interface. Connect to a WLAN hotspot and watch the IP being assigned automatically.

Watch the process with:

sudo journalctl -u systemd-networkd -f  # Shows logs in real time

Look for DHCP lease obtained — that confirms success.

⚠️ For beginners: If you use Wi-Fi you need wpa_supplicant for authentication. Configure it in /etc/wpa_supplicant.conf and start with wpa_supplicant -B -i wlp2s0 -c /etc/wpa_supplicant.conf, then run dhclient on top.

If you want to host the DHCP server yourself

Install isc-dhcp-server on Ubuntu:

sudo apt update && sudo apt install isc-dhcp-server

Configure /etc/dhcp/dhcpd.conf:

subnet 192.168.1.0 netmask 255.255.255.0 {
  range 192.168.1.100 192.168.1.200;
  option routers 192.168.1.1;
  option domain-name-servers 8.8.8.8;
}

Start the service:

sudo systemctl start isc-dhcp-server
sudo systemctl enable isc-dhcp-server

DHCP server setup

┌─────────────────────────────────────────────────────────────┐
│   DHCP server setup                                         │
├────────────────────────┬────────────────────────────────────┤
│ 1. Install the package │ $ sudo apt install isc-dhcp-server │
│ 2. Edit the config     │ /etc/dhcp/dhcpd.conf               │
│ 3. Start the service   │ $ sudo systemctl start isc-dhcp... │
└────────────────────────┴────────────────────────────────────┘

❗ Watch out: Test this in a VM so you do not disturb your real network — conflicts with the router DHCP are common.

Setting up static IPs

Manual configuration per distribution

Static IPs need more steps, but they give you control. Important: pick an IP outside the DHCP pool to avoid conflicts. Take for example 192.168.1.50 if the pool starts at .100.

For Ubuntu with Netplan:

Extend the YAML file:

network:
  version: 2
  renderer: networkd
  ethernets:
    enp0s3:
      dhcp4: no
      addresses: [192.168.1.50/24]  # IP with subnet
      gateway4: 192.168.1.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]

Apply as above. For IPv6: add addresses: [2001:db8::50/64], gateway6: 2001:db8::1.

For Debian (older, with interfaces): In /etc/network/interfaces:

auto enp0s3
iface enp0s3 inet static
  address 192.168.1.50/24
  gateway 192.168.1.1
  dns-nameservers 8.8.8.8 8.8.4.4

Restart: sudo ifdown enp0s3 && sudo ifup enp0s3.

For Fedora with nmcli:

sudo nmcli con mod "Wired connection 1" ipv4.method manual ipv4.addresses 192.168.1.50/24 ipv4.gateway 192.168.1.1 ipv4.dns "8.8.8.8 8.8.4.4"
sudo nmcli con up "Wired connection 1"

For IPv6 add: ipv6.method manual ipv6.addresses 2001:db8::50/64 and so on.

On pure systemd-networkd, for example Arch Linux

Create /etc/systemd/network/10-static.network:

[Match]
Name=enp0s3

[Network]
Address=192.168.1.50/24
Gateway=192.168.1.1
DNS=8.8.8.8
DNS=8.8.4.4

Restart: sudo systemctl restart systemd-networkd.

🔧 Practical example: Set a static IP for a Raspberry Pi as NAS. Connect via SSH (after a temporary dynamic IP), set it static and test with ip addr show — the IP should stay fixed.

Static config steps

┌─────────────────────────────────────────────────────────────┐
│   Static configuration steps                                │
├───────────────────────────────┬─────────────────────────────┤
│ 1. Identify the interface     │ $ ip link show              │
│ 2. Edit the config file       │ /etc/netplan/...            │
│ 3. Test                       │ $ ip addr show              │
└───────────────────────────────┴─────────────────────────────┘

💡 Tip: For hybrid setups reserve IPs on the DHCP server (fixed-address in dhcpd.conf). That way you combine automation with stability.

Troubleshooting

Finding and fixing common problems

Network problems are frustrating, but they are solvable systematically. Always start with the basics: Is the cable plugged in? LED on the port lit?

1. No IP assigned

• For dynamic, check DHCP logs: sudo journalctl -u isc-dhcp-client.
• For static: compare ip addr with the config.

1. IP conflict:

• Symptoms: intermittent connections.
• Find duplicates with arping -D -I enp0s3 192.168.1.50 — a reply means a conflict.

1. Connection test:

• Ping local (127.0.0.1), then the router (192.168.1.1)
• then external (8.8.8.8). For DNS: nslookup google.com.

ping -c 4 8.8.8.8  # Tests internet
traceroute 8.8.8.8  # Shows the route

1. DNS problems:

If ping to an IP works but domains do not: check /etc/resolv.conf.

Set it manually:

echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

Troubleshooting flowchart

┌─────────────────────────────────────────────────────────────┐
│   Problem: no network?                                      │
│    ↓                                                        │
│   Check cable / LEDs                                        │
│    ↓                                                        │
│   ip addr show (has an IP?)                                 │
│    ↓                                                        │
│   ping router (local OK?)                                   │
│    ↓                                                        │
│   ping 8.8.8.8 (internet?)                                  │
│    ↓                                                        │
│   nslookup (DNS?)                                           │
└─────────────────────────────────────────────────────────────┘

⚠️ For beginners: Use tcpdump for a deep dive: sudo tcpdump -i enp0s3 port bootps — that shows DHCP traffic.

Common errors: wrong subnet mask (no local routing), gateway error (no internet). On Wi-Fi: wrong password in wpa_supplicant.

Security aspects

Protecting your network

Security goes hand in hand with configuration. Enable firewalld (Fedora) or ufw (Ubuntu):

sudo ufw allow from 192.168.1.0/24  # Allows local traffic
sudo ufw enable

Prevent IP spoofing with rp_filter: Set net.ipv4.conf.all.rp_filter=1 in /etc/sysctl.conf and run sudo sysctl -p.

For DHCP: enable DHCP authorization on the switch to block rogue servers. In static setups: use MAC binding on the router.

❗ Watch out: Scan open ports with nmap -sn 192.168.1.0/24 — close unnecessary ones.

💡 Tip: Back up configs before changes: sudo cp /etc/netplan/* ~/backup/.

Practical tips

After you have learned in practice how to set IPs on Linux and how to fix faults, the next step is concrete advice from a system administrator’s daily work. These tips build on what you just learned and help you make networks not only functional, but also robust and future-proof.

If you have only just discovered the difference between dynamic and static, you will learn here how you manage IPs carefully, keep documentation and react to upcoming trends — with a focus on real scenarios such as a home server or a small company net.

Assigning and structuring IP addresses

Good IP management starts with planning. Instead of assigning IPs at random, split your address space logically — that avoids chaos, especially when the network grows. In a typical 192.168.1.0/24 net (254 usable IPs) you could reserve ranges: low numbers for infrastructure, middle for servers, high for dynamic devices. That way you keep an overview and minimise conflicts.

For example: in your DHCP server (via the router UI or isc-dhcp-server) define fixed reservations for important devices. That combines the advantages of both worlds — automatic assignment, but stable IPs.

🔧 Practical example:

In a home net with NAS, printer and guest network you set it up like this:

• 192.168.1.1-50: static for router, switches and critical devices (configure by hand).
• 192.168.1.51-100: static leases for servers (pin in DHCP by MAC address).
• 192.168.1.101-150: for printers and IoT devices (static, to make access easier).
• 192.168.1.151-254: dynamic pool for laptops and phones.

Adjust that in /etc/dhcp/dhcpd.conf:

subnet 192.168.1.0 netmask 255.255.255.0 {
  range 192.168.1.151 192.168.1.254;
  # Static lease example
  host nas {
    hardware ethernet aa:bb:cc:dd:ee:ff;  # MAC of the NAS
    fixed-address 192.168.1.51;
  }
}

Restart the service: sudo systemctl restart isc-dhcp-server.

Now your NAS always gets .51, even after a reboot.

Network structuring

┌─────────────────────────────────────────────────────────────┐
│   Split IP ranges with a purpose                            │
├────────────────────┬────────────────────────────────────────┤
│ 192.168.1.1-50     │ Infrastructure / gateway               │
│ 192.168.1.51-100   │ Servers / NAS                          │
│ 192.168.1.101-150  │ Printers / IoT                         │
│ 192.168.1.151-254  │ DHCP pool                              │
└────────────────────┴────────────────────────────────────────┘

Why this split?

┌─────────────────────────────────────────────────────────────┐
│   Why this split?                                           │
├──────────┬──────────────────────────────────────────────────┤
│ Range    │ Reason                                           │
├──────────┼──────────────────────────────────────────────────┤
│ 1-50     │ Stable base                                      │
│ 51-100   │ Important services                               │
│ 101-150  │ Peripherals                                      │
│ 151-254  │ Flexible devices                                 │
└──────────┴──────────────────────────────────────────────────┘

💡 Tip: Use tools such as ipcalc for calculations: ipcalc 192.168.1.0/24 shows you net details. For larger nets try phpIPAM (an open-source IP manager) — install it via Docker for easy tests.

⚠️ For beginners: Start small. In your test VM split 10 IPs and simulate devices with ip addr add 192.168.1.x/24 dev lo — that way you see how conflicts arise when you assign twice.

Documentation

The key to long-term success

Without documentation every network change becomes guesswork. As an admin, note every IP, MAC, device name and purpose — that saves hours when troubleshooting. Use simple tools such as a spreadsheet or Markdown files that you version in Git.

Example of an IP list:

• .1 : Router (gateway, DHCP server)
• .50: Printer (HP LaserJet, static)
• .51: NAS (Synology, static lease)
• .52: IP camera (garage, static)

Create a table in LibreOffice or via Markdown.

Network documentation

┌─────────────────────────────────────────────────────────────┐
│   IP list                                                   │
├──────────┬──────────────────────────────────────────────────┤
│ .1   --> │ Router                                           │
│ .50  --> │ Printer HP                                       │
│ .51  --> │ NAS Synology                                     │
│ .52  --> │ IP cam garage                                    │
└──────────┴──────────────────────────────────────────────────┘

Documentation tips:

┌─────────────────────────────────────────────────────────────┐
│   Documentation tips                                        │
├────────────────┬────────────────────────────────────────────┤
│ What           │ Why                                        │
├────────────────┼────────────────────────────────────────────┤
│ IP list        │ Fast lookup                                │
│ Changes        │ Version history                            │
│ Access data    │ Emergency access                           │
│ Network plan   │ Visual overview                            │
└────────────────┴────────────────────────────────────────────┘

🔧 Practical example: In a small office document changes with git: create a repo under ~/netdocs, add your IP list and commit with git commit -m "Added static IP for new printer". That way you track who changed what and when.

❗ Watch out: Protect sensitive data — encrypt the file with GPG: gpg -c ip-list.md and share it only with team members.

💡 Tip: Add diagrams with draw.io (free online) — draw your net with IPs to plan visually. Export as PNG and attach it to your docs.

Backing up your configuration

Never change without a backup

Network changes can go wrong — a typo in the config and everything is offline.

Therefore: always back up! Copy key files first and test in a staging environment.

Strategy: original → local backup → cloud backup (for example via rsync to a NAS).

Important files:

• /etc/netplan/ (Ubuntu configs)
• /etc/dhcp/dhcpd.conf (DHCP settings)
• /etc/network/interfaces (older Debian)
• /etc/resolv.conf (DNS)

Backup script example Save it as backup-net.sh and make it executable with chmod +x:

#!/bin/bash
BACKUP_DIR=~/net-backup/$(date +%Y-%m-%d)
mkdir -p $BACKUP_DIR
cp -r /etc/netplan/* $BACKUP_DIR/
cp /etc/dhcp/dhcpd.conf $BACKUP_DIR/
cp /etc/resolv.conf $BACKUP_DIR/
tar -czf $BACKUP_DIR.tar.gz $BACKUP_DIR
rm -r $BACKUP_DIR  # Optional: delete folder after archive

Run it with sudo ./backup-net.sh.

For cloud: rsync -avz $BACKUP_DIR.tar.gz user@nas:/backups/.

Backup strategy

┌─────────────────────────────────────────────────────────────┐
│   Original                                                  │
│    └──► Local backup                                        │
│          └──► Cloud backup                                  │
└─────────────────────────────────────────────────────────────┘

⚠️ For beginners: Test backups by changing a config, rebooting and then restoring: sudo cp backup/netplan.yaml /etc/netplan/ && sudo netplan apply.

Security aspects

Protection against common pitfalls

Security is not an afterthought — dynamic IPs can invite rogue servers, static ones allow precise but error-prone rules.

Start with a checklist:

• Firewall active? (ufw/firewalld)
• Unnecessary ports closed? (for example only SSH on 22 for static servers)
• Updates regular? (sudo apt update && sudo apt upgrade)
• Access locked down? (strong passwords, SSH keys instead of password)

Avoid pitfalls:

• IP conflicts: document and scan regularly with nmap -sn 192.168.1.0/24.
• No access: check firewall rules with sudo ufw status.
• DNS problems: test the resolver with dig example.com.

Security checklist

┌─────────────────────────────────────────────────────────────┐
│   □ Firewall active?                                        │
│   □ Ports closed?                                           │
│   □ Updates installed?                                      │
│   □ Access locked down?                                     │
└─────────────────────────────────────────────────────────────┘

Avoid typical pitfalls:

┌─────────────────────────────────────────────────────────────┐
│   Typical pitfalls                                          │
├────────────────┬────────────────────────────────────────────┤
│ Error          │ Fix                                        │
├────────────────┼────────────────────────────────────────────┤
│ IP conflicts   │ Scan with nmap                             │
│ No access      │ ufw status                                 │
│ DNS problems   │ Test with dig                              │
└────────────────┴────────────────────────────────────────────┘

🔧 Practical example: In a mixed net set VLANs for separation (for example IoT separate) via the vlan package: install vlan, configure /etc/network/interfaces with vlan_raw_device and reboot.

💡 Tip: For IPv6 security: enable ip6tables and set rules similar to IPv4 — many people forget that on dual-stack.

Future trends: IPv6 and IoT in view

Networks evolve: IPv6 becomes the standard because IPv4 addresses are running out. In dynamic setups DHCPv6 Stateful (like DHCP) or Stateless (SLAAC for autoconfig) is supported. Test with ip -6 addr show — many routers offer dual-stack.

⚠️ For beginners: Start with IPv6 in your VM: enable dhcp6: yes in Netplan and ping ping6 ipv6.google.com.

Golden rules for getting started

In short:

💡 Golden rules

• 1. Always document
• 2. Back up before changes
• 3. Test step by step
• 4. Prioritise security

Command Reference (Cheatsheet)

The following reference collects the essential commands for checking, assigning and troubleshooting IP addresses on Linux:

Further Resources

For deeper reading and further references, the following links give direct access to official sources and related articles:

Conclusion

The choice between dynamic and static IP addresses depends on your needs: dynamic for convenience in changing environments, static for stability on fixed services. Both have strengths — dynamic saves time through automation, static gives you control. As a beginner start with dynamic in a test net, switch to static for servers, and mix them carefully. With the tips here you build solid nets. Try it, and you will see how IPs make daily work easier.