KAHIBARO
Discord Login Register ☰
☰

2.2. IP Addresses

Table of Contents

Why IP Addresses Exist

When two computers talk over the internet, they must know where to send data. An IP address is the basic way to identify a device on a network, similar to a phone number or a street address for a house.

Every time you:

your computer sends data to an IP address.

Without IP addresses, routers and servers would not know where any packet of data should go. For backend developers, understanding IPs is essential for configuring servers, debugging connectivity problems, and securing applications.

Important: An IP address uniquely identifies a device or interface on a network so that data can be routed to and from it.

IPv4 Basics

The most common IP version you will see is IPv4. It uses 32 bits to represent an address.

Human-readable IPv4 format

IPv4 addresses are usually written as four numbers separated by dots, for example:

Each of the four numbers is called an octet and can range from 0 to 255.

Under the hood, each octet is 8 bits, so an IPv4 address is:

$$4 \text{ octets} \times 8 \text{ bits per octet} = 32 \text{ bits}$$

Example:

So the full binary representation is:

11000000 10101000 00000001 00001010

You will rarely need to work directly with the binary representation, but it helps to understand that IPs are just numbers.

Total number of IPv4 addresses

With 32 bits, the total number of unique IPv4 addresses is:

$$2^{32} = 4,294,967,296$$

So there are about 4.29 billion possible IPv4 addresses.

Because the internet has grown a lot, 4.29 billion is not enough for all devices worldwide, which is one reason why IPv6 exists and why we have techniques like private IP ranges and NAT (more on these later).

Rule: An IPv4 address is a 32-bit number, usually written as four decimal numbers from 0 to 255, separated by dots.

IPv6 Basics

IPv6 is the newer version of the Internet Protocol. It was created to solve the address exhaustion problem of IPv4 and to simplify some network operations.

IPv6 format

IPv6 uses 128 bits, which provides a huge address space.

An IPv6 address looks like this:

It is written as eight groups (hextets) of four hexadecimal digits, separated by colons.

For example:

Each hexadecimal digit represents 4 bits, so:

The total number of IPv6 addresses is:

$$2^{128} \approx 3.4 \times 10^{38}$$

This is an astronomically large number. For practical purposes, we will never run out.

Shortening IPv6 addresses

IPv6 addresses can be long, so there are rules to shorten them.

  1. Leading zeros inside a group can be removed:
    • 0db8 → db8
    • 0370 → 370
  2. One sequence of consecutive groups of 0000 can be replaced by :: (double colon), but only once per address.

Example:

Full form:

Shortened step by step:

Both represent the same IPv6 address.

Rule: An IPv6 address is a 128-bit number, written as eight groups of 4 hexadecimal digits, separated by colons. You can remove leading zeros and compress one sequence of zero groups using ::.

Public vs Private IP Addresses

Not every IP address is reachable from the entire internet. Some address ranges are reserved for private networks, such as your home Wi-Fi or a company LAN.

Public IP addresses

A public IP address is globally unique on the internet and can be routed across the public network.

If a server should be reachable from anywhere (for example an API server), it needs a public IP address, or it must be reachable through something that has one (like a load balancer or NAT gateway).

You can usually see your current public IP by visiting a site like https://ifconfig.me or https://ipinfo.io.

Private IP addresses (IPv4)

Private IPv4 address ranges are defined so that organizations can have many devices internally without needing a public address for each.

The commonly used private IPv4 ranges are:

RangeCIDRExample addresses
10.0.0.0 to 10.255.255.25510.0.0.0/810.0.0.1, 10.10.5.2
172.16.0.0 to 172.31.255.255172.16.0.0/12172.16.0.3, 172.31.200.5
192.168.0.0 to 192.168.255.255192.168.0.0/16192.168.0.1, 192.168.1.10

You will see 192.168.x.x very often in home networks. For example, your router might be at 192.168.0.1 and your laptop at 192.168.0.23.

These private addresses are not routable over the public internet. They are only meaningful inside their own network.

NAT and private IPs

If many devices use private IP addresses, how do they access the public internet?

Usually through Network Address Translation (NAT), which is typically implemented in your router. In simple terms:

As a backend developer, NAT affects things like:

Private IPv6

IPv6 has its own way of defining addresses that are meant to be local only, such as:

In practice, as a beginner backend developer you will more often deal with IPv4 private ranges, but IPv6 is increasingly common on modern systems and cloud providers.

Rule:
Public IPs are globally routable on the internet.
Private IPs are used only inside local networks and are not directly reachable from the public internet.

Static vs Dynamic IP Addresses

IP addresses can be assigned in two main ways: statically or dynamically. This applies to both public and private IPs.

Static IP addresses

A static IP address is fixed and does not change over time, unless manually reconfigured.

Examples where static IPs are useful:

If you hard-code an IP in a configuration file, that address must be static, otherwise things will break when the IP changes.

Dynamic IP addresses

A dynamic IP address is assigned automatically, usually by a DHCP server.

Common examples:

Dynamic assignment makes network management easier, because you do not have to configure each device manually.

As a backend developer you typically care about static IPs for servers and services that other systems must reliably connect to. For local development, dynamic IPs are normally fine.

Special IP Addresses You Will See Often

There are several special IP addresses and ranges that behave differently. Knowing them helps when reading network configurations and logs.

The loopback address

The loopback address refers to the local machine itself.

When you connect to 127.0.0.1, the traffic never leaves your machine. It is used for:

For example, you might run a local FastAPI server on:

This means:

If you bind a server to 127.0.0.1, it listens only on the loopback interface. If you bind it to 0.0.0.0, it listens on all network interfaces.

The "any" address

The "any" address is a special one used by servers when binding to all interfaces.

You will often see configurations like:

It means:

In browser URLs, you do not use 0.0.0.0. It is mainly for server binding and routing, not for clients to connect to.

Broadcast and network addresses (IPv4)

In IPv4 networks, some addresses are reserved for special functions, such as:

For example, if you have a subnet like 192.168.1.0/24:

As a backend developer, you rarely need to deal with broadcast directly, but you may see such addresses in network diagrams or logs.

Documentation and example ranges

Some IP ranges are reserved for documentation and examples. They are not used on the public internet, so they are safe to show in tutorials.

For IPv4, example ranges include:

You will see addresses like 203.0.113.5 in documentation.

For IPv6, examples use 2001:db8::/32.

IP Addresses and Subnets

IP addresses are often written with something called CIDR notation, such as 192.168.1.10/24 or 10.0.0.5/16.

This combines:

Network part vs host part

In IPv4, a 32-bit address is divided into:

In CIDR notation A.B.C.D/N:

For example, 192.168.1.10/24:

The network address is 192.168.1.0, broadcast is 192.168.1.255, and the addresses between are usable for devices.

You will learn more about subnets and CIDR when dealing with cloud networking, firewalls, and security groups, but you should already be comfortable reading the notation.

Rule: In 192.168.1.10/24, /24 means the first 24 bits are the network part. The rest identify hosts within that network.

Why subnets matter for backend developers

Subnets are important because they define:

Examples:

When configuring cloud security groups or network ACLs, you will frequently see CIDR ranges like these.

IP Addresses in Backend Development Practice

To connect theory with what you will actually do, here are concrete situations where IP addresses matter in backend work.

Binding servers to an IP

When you start a backend server, you often choose which IP to bind to.

Examples:

For instance, with Uvicorn (a common Python ASGI server):

Understanding the difference helps you avoid two common issues:

  1. You cannot reach your development server from your phone on the same Wi-Fi because it is bound only to 127.0.0.1.
  2. You accidentally expose a development server publicly by binding to 0.0.0.0 on a machine with a public IP and no firewall.

Whitelisting and security rules

Many services allow traffic only from specific IP addresses or ranges. For example:

In these cases you must know:

Misconfiguring these can lead to being unable to connect to your own database or accidentally exposing it to the entire internet.

Logs and client IPs

Web server logs usually contain client IP addresses. For example, an Nginx access log line might start with:

If your application is behind a reverse proxy or load balancer, the IP you see in the application might be that proxy IP, not the original client. In such setups, the real client IP is typically passed in an HTTP header like X-Forwarded-For, which you will handle in later chapters.

From the perspective of this chapter, you should be able to:

Connecting to external APIs and services

When your backend calls an external API, packets go from one IP to another. If the external service restricts by IP (for example, "allow only calls from 198.51.100.12"), and your server’s public IP changes, those calls will start failing.

This is one of the reasons why production servers and outbound gateways are often given static public IPs.

Summary

In this chapter you have learned:

These concepts are the foundation for understanding DNS, ports, and how requests actually find your backend servers over the network.

Views: 9

Comments

Please login to add a comment.

Don't have an account? Register now!

© 2025 Kahibaro
Visitors: 3053 / 24h
Impressum / Imprint
Datenschutz / Data Policy