If you’ve ever deployed a service, configured a server, or debugged a network timeout, you’ve already relied on IPv4—whether you realized it or not.
IPv4 (Internet Protocol version 4) is the system that assigns addresses to devices and moves data across networks. It’s one of the oldest pieces of the internet stack, but it still powers a huge portion of today’s infrastructure.
What IPv4 Actually Does
At its core, IPv4 solves a simple but critical problem: how does one machine find and talk to another?
Every device connected to a network gets an IPv4 address. Think of it as a unique identifier—similar to a mailing address, but for digital systems.
An IPv4 address looks like this:
192.168.1.1
This format is called dotted decimal notation, and it represents a 32-bit number split into four 8-bit sections (octets).
Breaking Down an IPv4 Address
Each section of an IPv4 address ranges from 0 to 255. For example:
- 192 → first octet
- 168 → second octet
- 1 → third octet
- 1 → fourth octet
Behind the scenes, this is just binary:
192.168.1.1 → 11000000.10101000.00000001.00000001
Why does this matter? Because networking decisions—like routing and subnetting—depend on how these bits are interpreted.
Network vs Host Portion
Here’s where things get interesting. An IPv4 address isn’t just a random number—it has structure.
It’s divided into:
- Network portion: identifies the network
- Host portion: identifies a device within that network
This division is defined using a subnet mask or CIDR notation.
Example with CIDR
192.168.1.10/24
- /24 means the first 24 bits are the network
- The remaining 8 bits identify hosts
That gives you:
- Network: 192.168.1.0
- Usable hosts: 192.168.1.1 – 192.168.1.254
- Broadcast: 192.168.1.255
How Data Travels Using IPv4
When your app sends a request (say, an HTTP call), it doesn’t magically reach the destination. It’s broken into packets.
Each packet contains:
- Source IP address
- Destination IP address
- Payload (actual data)
Routers use the destination IP to decide where to send the packet next. This process continues until the packet reaches its target.
IPv4 doesn’t guarantee delivery—it just moves packets. Reliability is handled by higher-level protocols like TCP.
Public vs Private IPv4 Addresses
Not all IP addresses are exposed to the internet.
Private IP Ranges
- 10.0.0.0 – 10.255.255.255
- 172.16.0.0 – 172.31.255.255
- 192.168.0.0 – 192.168.255.255
These are used داخل internal networks (like your home Wi-Fi or VPC in cloud environments).
Public IPs
These are globally routable and assigned by ISPs or cloud providers.
In DevOps, you’ll often deal with both:
- Private IPs for internal services
- Public IPs for external access
NAT: Why You Don’t Need Infinite IPv4 Addresses
IPv4 has a limitation: it supports about 4.3 billion addresses. That sounded like a lot in the 1980s. Not so much today.
This is where Network Address Translation (NAT) comes in.
NAT allows multiple devices in a private network to share a single public IP.
Example flow:
- Your laptop → 192.168.1.10
- Router translates request → Public IP (e.g., 8.8.8.8)
- Response comes back → Router maps it to your device
This is why your entire office can browse the internet using one public IP.
Common IPv4 Classes (Legacy but Useful)
You might still see references to IP classes:
| Class | Range | Typical Use |
|---|---|---|
| A | 0.0.0.0 – 127.255.255.255 | Large networks |
| B | 128.0.0.0 – 191.255.255.255 | Medium networks |
| C | 192.0.0.0 – 223.255.255.255 | Small networks |
Modern networking uses CIDR instead, but understanding classes helps when reading older documentation.
A Quick Command-Line Example
Here’s something practical. Run this in your terminal:
ping 8.8.8.8
You’re sending ICMP packets to Google’s DNS server. Each reply confirms:
- Your machine can reach the destination IP
- Routing is working
- Packets are returning successfully
Another useful one:
ip addr (Linux) or ipconfig (Windows)
This shows your assigned IPv4 address.
Where Developers Trip Up
A few common pitfalls show up again and again:
- Confusing localhost (127.0.0.1) with a network-accessible IP
- Forgetting that containers and VMs often have separate network namespaces
- Misconfiguring subnet masks, leading to unreachable hosts
- Assuming public IPs are always required (they often aren’t)
These aren’t theoretical issues—they’re the root cause of many “it works on my machine” problems.
Why IPv4 Still Matters
Yes, IPv6 exists. And yes, it solves address exhaustion.
But IPv4 is still everywhere:
- Cloud infrastructure defaults
- Internal service communication
- Legacy systems
- NAT-heavy environments
In practice, most engineers work with a mix of IPv4 and IPv6—but IPv4 remains foundational.
Wrapping It Up
IPv4 isn’t just a networking concept—it’s part of your daily workflow as a developer or DevOps engineer.
Understanding how addresses are structured, how packets move, and how networks are segmented gives you a real advantage when debugging, designing systems, or scaling infrastructure.
Once this clicks, topics like load balancing, DNS, and Kubernetes networking become much easier to reason about.