Server, node, rack and data centre

Riya walks into a data centre

Server, node, rack and data centre

Words you'll meet in this lesson

Typical numbers to remember (2026, approximate)

These are ballpark figures to reason with. Real numbers vary by company, vendor and year.

The same idea at three levels

Kinds of servers, roles of nodes, and kinds of data centres

Server shapes

Roles a node can play in a Hadoop cluster

You will meet each role in detail in Lesson 1.2 and Module 3. For now: masters coordinate, workers store and compute, edge nodes are the front door.

Where the data centre is

Follow one piece of data from one node to another

A task on node dn1 (rack 1) needs a 128 MB block that sits on dn7 (rack 3). Here is the path, hop by hop.

1. Ask: which rack is each node on?

   rack_of = {"dn1": "/rack1", "dn2": "/rack1", "dn7": "/rack3"}
   print(rack_of["dn1"], "->", rack_of["dn7"])

   /rack1 -> /rack3
   This is exactly the information Hadoop gets from its rack-topology script: a map from host to rack. Different racks means the data must leave the rack.

2. Leave the server: the network card

   dn7 reads the block from one of its disks and sends it out through its 25 Gbps network card.

   A single hard disk reads around 200 MB/s, far slower than the 25 Gbps (about 3 GB/s) network card. One disk is usually the limit for one block.

3. Up to the rack's ToR switch

   The cable from dn7 goes to the switch at the top of rack 3.

   If the destination were in the same rack (say dn8), the switch would send it straight down to dn8. One hop, full speed. That's why same-rack traffic is cheap.

4. Across the core (spine) switch

   The ToR switch of rack 3 sends the data up one of its uplinks to the core switch, which forwards it to rack 1's ToR switch.

   The uplinks are shared by all 20–40 servers in the rack. When many servers send data out at once, they queue here. This is the busiest, most expensive link in a Hadoop cluster.

5. Down to dn1

   Rack 1's switch delivers the data to dn1, and the task starts reading it.

   Total: 4 hops instead of 0. Moving 128 MB across racks is fine once. Moving terabytes across racks for every job would choke the uplinks. Lesson 1.5 shows how Hadoop avoids this by sending the task to the data instead.

Two pings and a copy: what Riya types, and where the packets go

Riya logs in to node dn1 and talks to another node in the same rack, then to one in a different rack. Left: her terminal. Right: the path through the data centre.

Ping times and copy speeds in this animation are illustrative. Real values depend on the hardware and on how busy the network is.

Try it yourself: the Cluster Playground

This is a small simulated Hadoop cluster with 2 racks of 3 nodes. You'll use it in almost every lesson of this course. Today, just explore the pieces.

Where these racks are, and who uses them

Examples are simplified. Specific companies' setups vary and are often not public.

Describe a cluster in Python

A cluster is just data about machines: which nodes exist, which rack each is on, and what each one has. Here is a small cluster as a Python dictionary, and its total capacity. Then try the challenges.

cluster = {
    "/rack1": [{"name": "dn1", "cores": 32, "ram": 256, "disk_tb": 144},
               {"name": "dn2", "cores": 32, "ram": 256, "disk_tb": 144}],
    "/rack2": [{"name": "dn3", "cores": 32, "ram": 256, "disk_tb": 144},
               {"name": "dn4", "cores": 64, "ram": 512, "disk_tb": 192}],
}

nodes = [n for rack in cluster.values() for n in rack]
print("Racks :", len(cluster))
print("Nodes :", len(nodes))
print("Cores :", sum(n["cores"] for n in nodes))
print("RAM   :", sum(n["ram"] for n in nodes), "GB")
print("Disk  :", sum(n["disk_tb"] for n in nodes), "TB raw")

• cluster = {A dictionary: the key is the rack name, the value is the list of nodes in that rack. Hadoop stores its view of the cluster in a similar tree.
• nodes = [n for rack in cluster.values() for n in rack]A list comprehension with two fors: for every rack, take every node. It flattens the racks into one list of nodes.
• sum(n["cores"] for n in nodes)Add up one field across all nodes. The same pattern gives RAM and disk.

Run it on your PC: look at your computer as a node

An administrator's first question about any node is: how many cores, how much RAM, how much disk? This program answers it for your computer (Windows, macOS or Linux) and compares it with a typical Hadoop worker node. Save it as node_report.py and run it.

# node_report.py: look at your own computer the way a cluster admin looks at a node
import os, platform, shutil

def ram_gb():
    try:                                    # Linux and macOS
        return os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") / 1024**3
    except (ValueError, AttributeError, OSError):   # Windows
        import ctypes
        class M(ctypes.Structure):
            _fields_ = [("len", ctypes.c_ulong), ("load", ctypes.c_ulong), ("total", ctypes.c_ulonglong),
                        ("avail", ctypes.c_ulonglong), ("a", ctypes.c_ulonglong), ("b", ctypes.c_ulonglong),
                        ("c", ctypes.c_ulonglong), ("d", ctypes.c_ulonglong), ("e", ctypes.c_ulonglong)]
        m = M(); m.len = ctypes.sizeof(M)
        ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m))
        return m.total / 1024**3

cores = os.cpu_count()
ram = ram_gb()
disk = shutil.disk_usage(os.path.abspath(os.sep)).total / 1024**4      # in TB

print("Host name :", platform.node())
print("OS        :", platform.system())
print("CPU cores :", cores)
print(f"RAM       : {ram:.1f} GB")
print(f"Disk      : {disk:.2f} TB")

# a typical Hadoop worker node (approximate, 2026)
worker = {"cores": 32, "ram": 256, "disk": 12 * 12}
print("\nOne typical worker node equals about:")
print(f"  {worker['cores'] / cores:.0f} of your machines in CPU cores")
print(f"  {worker['ram'] / ram:.0f} of your machines in RAM")
print(f"  {worker['disk'] / disk:.0f} of your machines in disk")

# In a terminal:  python node_report.py

Counting a cluster, one line at a time

Watch the loop visit each rack, then each node inside it, adding up the cores. Notice the dictionary and the lists appear as numbered objects.

Worked examples: real problems, solved and traced in memory

Three calculations that cluster and data-centre teams do in real life: an inventory, usable storage, and how many servers a rack can really take. Each program runs live and is traced in memory.

dn1 r1 32, dn2 r1 32, dn3 r2 32, dn4 r2 64, dn5 r2 32

r1 : 2 nodes, 64 cores
r2 : 3 nodes, 128 cores

20 nodes · 12 disks × 12 TB · replication 3 · 25% headroom

Raw disk      : 2880 TB
After headroom: 2160.0 TB
Business data : 720.0 TB

42U − 2U · 2U servers · 9,000 W, 450 W each · 48 ports

space : 20 servers
power : 20 servers
ports : 48 servers
Limit reached first: space -> 20 servers

Check yourself

Quick revision

Interview and viva questions

Practice problems

Quick calculations about servers, racks and networks. The last ones are the kind of planning a platform team does before buying hardware.

42U, 1U = 4.445 cm

186.7 cm

print(round(42 * 4.445, 1), "cm")

12 disks × 16 TB

192 TB

print(12 * 16, "TB")

10 Gbps

1.25 GB per second

print(10 / 8, "GB per second")

40 × 25 Gbps, 4 × 100 Gbps

2.5 : 1

down = 40 * 25
up = 4 * 100
print(f"{down / up:g} : 1")

{"dn3": "/r2", "dn1": "/r1", "dn4": "/r2", "dn2": "/r1", "dn5": "/r3"}

/r1 ['dn1', 'dn2']
/r2 ['dn3', 'dn4']
/r3 ['dn5']

rack_of = {"dn3": "/r2", "dn1": "/r1", "dn4": "/r2", "dn2": "/r1", "dn5": "/r3"}
by_rack = {}
for host, rack in rack_of.items():
    by_rack.setdefault(rack, []).append(host)
for rack in sorted(by_rack):
    print(rack, sorted(by_rack[rack]))

rack_of = {dn1: r1, dn2: r1, dn3: r2}

dn1 dn1 -> 0 hops
dn1 dn2 -> 2 hops
dn1 dn3 -> 4 hops

rack_of = {"dn1": "r1", "dn2": "r1", "dn3": "r2"}

def hops(a, b):
    if a == b:
        return 0
    if rack_of[a] == rack_of[b]:
        return 2
    return 4

for a, b in [("dn1", "dn1"), ("dn1", "dn2"), ("dn1", "dn3")]:
    print(a, b, "->", hops(a, b), "hops")

900 TB data · 144 TB/node · ×3 · 25% free · 18 nodes/rack

Raw disk needed: 3600.0 TB
Nodes: 25 Racks: 2

import math
data_tb = 900
raw_needed = data_tb * 3 / 0.75
nodes = math.ceil(raw_needed / 144)
racks = math.ceil(nodes / 18)
print("Raw disk needed:", raw_needed, "TB")
print("Nodes:", nodes, "Racks:", racks)

18 × 450 W · +50% cooling · 24×365 h · Rs 9/kWh

Power: 12.15 kW
Cost per year: Rs 9.6 lakh

kw = 18 * 450 / 1000
kw_with_cooling = kw * 1.5
kwh_year = kw_with_cooling * 24 * 365
print(f"Power: {kw_with_cooling:.2f} kW")
print(f"Cost per year: Rs {kwh_year * 9 / 1e5:.1f} lakh")

Real-world scenario questions (asked in company interviews)

Situations about hardware and racks that interviewers describe to see whether you understand the physical side of a cluster.