Racks, Rack Units and Cabling

The 19-inch rack

A 19-inch rack is a frame with two pairs of vertical mounting rails, spaced so that equipment 19 inches (482.6 mm) wide across its mounting ears can be screwed or clipped in. The space between the rails is at least 450 mm (17.72 inches), which is the real width a device can have. The format goes back to telephone exchanges and is standardized in EIA-310; servers, switches, storage, patch panels and console drawers all use it, which is why a data center can mix vendors in one rack.

Open frames and cabinets

• Two-post open frame: two uprights, used for patch panels and light network equipment in network rooms.
• Four-post open frame: supports deep, heavy equipment at front and back, but has no doors or sides.
• Cabinet (enclosed rack): four posts plus perforated front and rear doors, side panels and locks. This is the normal choice in a data hall: the doors control airflow and access. Server cabinets are typically 600 mm wide; network cabinets are often 800 mm wide to leave room for cables at the sides.

Hyperscalers and some AI clusters also use the wider Open Rack designs of the Open Compute Project, which have their own unit size and power bars; this page sticks to the 19-inch standard that almost every enterprise and colocation rack uses.

Rails and mounting

Most rack posts have square holes that take either cage nuts (a screw nut in a spring clip) or tool-less rail kits that hook straight in. Servers ship with a rail kit: sliding rails that let you pull the server out to the front for service without unplugging it, often with a cable management arm at the back. Light 1U devices such as patch panels and switches mount on the front posts only; anything deep or heavy must be supported at all four posts by rails or a shelf, never by its front ears alone.

Rack units

A rack unit (U, sometimes RU) is the standard unit of height in a rack: 1.75 inches, or 44.45 mm. Equipment heights are whole multiples: a 1U switch, a 2U server, a 4U storage shelf. The holes in the rails repeat every U in a group of three, so you can count units from the hole pattern; many racks print the U numbers on the rails, counting from 1 at the bottom.

42U is the classic full-height rack; 45U, 47U and 48U are common in newer data halls with higher ceilings. Equipment that mounts vertically at the back or side of the rack, such as rack PDUs, is called "0U" because it uses no rack units.

Rack elevations

A rack elevation is a drawing or table of a rack that shows which device occupies which rack units, usually as a front view and a rear view. It is the plan you install from and the map you troubleshoot with: a technician in a colocation facility on the other side of the country finds db-01 by its rack and U position, not by its name. Good elevations also record each device's weight, power draw and which PDU outlets it uses.

Checking an elevation in Python

Most sites keep elevations in a data center infrastructure management (DCIM) tool, which refuses overlapping placements. The same idea in a few lines: each device has a lowest unit and a height, and a planned server is checked against the rack before anyone carries it in.

# A text rack elevation: place devices by their lowest rack unit (U)
# and height, refuse overlaps, and print the rack from the top down.
RACK_U = 42
MM_PER_U = 44.45

slots = {}  # rack unit -> device name


def place(name, bottom, height):
    units = range(bottom, bottom + height)
    if bottom < 1 or units[-1] > RACK_U:
        print(f"REFUSED {name}: U{bottom}-U{units[-1]} is outside the rack")
        return
    taken = sorted({slots[u] for u in units if u in slots})
    if taken:
        print(f"REFUSED {name}: U{bottom}-U{units[-1]} overlaps {', '.join(taken)}")
        return
    for u in units:
        slots[u] = name


place("patch panel", 42, 1)
place("leaf switch A", 41, 1)
place("leaf switch B", 40, 1)
place("cable manager", 39, 1)
place("app-01", 37, 2)
place("app-02", 35, 2)
place("db-01", 33, 2)
place("console drawer", 26, 1)
place("storage shelf", 6, 4)
place("storage array", 1, 5)
place("db-02", 34, 2)  # planned on a hunch, not on the elevation

print()
u = RACK_U
while u >= 1:
    name = slots.get(u)
    top = u
    while u - 1 >= 1 and slots.get(u - 1) == name:
        u -= 1
    span = f"U{top}" if top == u else f"U{top}-U{u}"
    label = name if name else f"({top - u + 1}U free)"
    print(f"{span:>8}  {label}")
    u -= 1

used = len(slots)
print(f"\nUsed {used}U of {RACK_U}U, free {RACK_U - used}U "
      f"({(RACK_U - used) * MM_PER_U:.1f} mm of mounting height)")

REFUSED db-02: U34-U35 overlaps app-02, db-01

     U42  patch panel
     U41  leaf switch A
     U40  leaf switch B
     U39  cable manager
 U38-U37  app-01
 U36-U35  app-02
 U34-U33  db-01
 U32-U27  (6U free)
     U26  console drawer
 U25-U10  (16U free)
   U9-U6  storage shelf
   U5-U1  storage array

Used 20U of 42U, free 22U (977.9 mm of mounting height)

Free units are not the same as free capacity. The 22 free units in this rack only matter if the rack's power budget, cooling and floor loading allow more equipment; the next sections show why those often run out first.

Installing equipment safely

A fully loaded rack can weigh several hundred kilograms, and a single 2U server often weighs 20 to 30 kg. Most racking accidents come from that weight.

• Load from the bottom up, heaviest equipment (storage, UPS units in small rooms, large servers) lowest. A top-heavy rack tips over when a server is slid out on its rails.
• Rack balancing: before pulling out any device, make sure the rack is bolted down, connected to its neighbors, or has its stabilizer feet extended. Pull out only one device at a time.
• Floor load limitations: floors and raised-floor tiles have a maximum load per square meter and per point (a rack's feet or casters concentrate the weight). Check the rating before placing a heavy rack, and never roll a loaded rack across tiles not rated for it.
• Lifting: two people, or a server lift, for anything heavy or above shoulder height; see lifting and carrying. Install the rails first, then lift the device onto them.
• Airflow: equipment faces the same way (front to the cold aisle), and every empty unit gets a blanking panel so hot exhaust air cannot flow back to the front. See cooling and airflow.

Rack PDUs

A rack PDU (power distribution unit) is the power strip of the data center: a bar, usually mounted vertically at the back of the rack, that takes one feed from the room's distribution and provides outlets for each device. Unlike an office power strip it is rated for the rack's full load, often has a breaker per outlet group, and can usually be monitored over the network.

Devices plug into IEC 60320 outlets: C13 for most servers and switches, C19 for larger power supplies such as blade chassis and GPU servers. The PDU itself connects to the room with an industrial plug or a hard-wired connection, single-phase for small racks or three-phase for higher loads.

Most racks have two PDUs, one on each side, fed from separate sources, the A and B feeds. A dual-corded server connects one power supply to each, so that losing a whole feed does not stop it. How that works and why each PDU must be able to carry the whole rack is explained under A/B power feeds.

Balancing a three-phase PDU

A three-phase PDU groups its outlets per phase, and each phase has its own breaker. If all heavy devices land on one phase, that breaker trips while the other two are half empty. The example spreads a rack's loads over the phases (largest first, each to the least-loaded phase) and checks them against 80% of the breaker rating, a common design margin.

# Spread server loads over the three phases of a 3-phase rack PDU
# (230 V per phase, 16 A breaker per phase) and check each phase
# against an 80% design limit. Largest loads first, each to the
# phase that has the least load so far.
VOLTS = 230
BREAKER_A = 16
LIMIT = 0.8

loads_w = {
    "storage array": 1150, "storage shelf": 620, "app-01": 540,
    "app-02": 540, "db-01": 780, "leaf switch A": 310,
    "leaf switch B": 310, "console drawer": 40,
}

phases = {"L1": [], "L2": [], "L3": []}
for name, watts in sorted(loads_w.items(), key=lambda kv: (-kv[1], kv[0])):
    target = min(phases, key=lambda p: (sum(w for _, w in phases[p]), p))
    phases[target].append((name, watts))

for phase, devices in phases.items():
    watts = sum(w for _, w in devices)
    amps = watts / VOLTS
    share = amps / BREAKER_A
    flag = "ok" if share <= LIMIT else "OVER LIMIT"
    names = ", ".join(n for n, _ in devices)
    print(f"{phase}: {watts:5} W {amps:5.2f} A {share:4.0%}  {flag}  ({names})")

total = sum(loads_w.values())
print(f"Rack total {total / 1000:.2f} kW; "
      f"PDU limit {3 * VOLTS * BREAKER_A * LIMIT / 1000:.2f} kW at {LIMIT:.0%}")

L1:  1460 W  6.35 A  40%  ok  (storage array, leaf switch A)
L2:  1360 W  5.91 A  37%  ok  (db-01, app-02, console drawer)
L3:  1470 W  6.39 A  40%  ok  (storage shelf, app-01, leaf switch B)
Rack total 4.29 kW; PDU limit 8.83 kW at 80%

The wattages are measured draws, not the nameplate ratings of the power supplies, which are much higher; sizing by nameplate wastes capacity. In a real A/B rack, each device's load is split over both PDUs in normal operation, and the check must be done for the case where one PDU carries everything. The example uses European values (230 V per phase, also in the UK); in the United States, rack PDUs are typically fed at 208 V with 20 A or 30 A breakers, so the volts and amps in the check change.

Structured cabling

Structured cabling is a planned, standardized cabling system of permanent links between fixed termination points, laid out in a hierarchy, so that connections are changed with short patch cords at the ends instead of new cables pulled through the building. The alternative, a cable run straight from each server to wherever its switch happens to be, works for a week and becomes unmanageable within a year.

ANSI/TIA-942 describes the spaces of a data center cabling system as follows (EN 50173-5, its European counterpart, uses different names for the same ideas: main distributor, zone distributor, equipment outlet):

• Entrance room: where carrier cables enter the building; in a colocation facility, the meet-me room.
• Main distribution area (MDA): the central point with the core switches and routers and the main cross-connect.
• Horizontal distribution area (HDA): a distribution point per row or zone, often in an end-of-row cabinet.
• Equipment distribution area (EDA): the racks with servers and storage.

Patch panels

A patch panel is a passive panel of connectors where a permanent cable ends on one side and short patch cords plug in on the other. The permanent link between two panels is installed and tested once; moving a server to another switch port is then a matter of re-patching at the panel. Copper panels use RJ45 ports; fiber panels and cassettes use LC ports, often fed by pre-terminated trunk cables with multi-fiber MPO connectors that carry 12 or more fibers in one plug.

Copper and fiber in the data center

Inside a rack, servers usually connect to a top-of-rack switch with short direct-attach copper (DAC) cables or patch cords; between racks and rows, fiber dominates because it carries higher speeds over longer distances and is thinner. The physical side (cable categories, single-mode and multimode fiber, LC and SC connectors, SFP and QSFP transceivers) is covered in cabling and the physical layer; how the switches are arranged is in data center networking.

Cable management

Cable management is not about looks. A neat rack can be worked on without unplugging the wrong cable, lets air through, and makes a failed component quick to swap.

• Use horizontal cable managers between switch ports and patch panels, and vertical managers at the sides of the rack.
• Use cords of the right length; coils of excess cable block airflow.
• Respect the minimum bend radius, especially for fiber; a sharp bend causes loss or breaks the fiber.
• Bundle with hook-and-loop straps, not tight cable ties that crush cables and must be cut for every change.
• Keep power and data cables apart: power on one side of the rack, data on the other, which also makes it obvious which is which.
• Leave service loops so a server can slide out on its rails with its cables connected.
• Many sites color-code: for example one color per network or per power feed. A color scheme only helps if it is written down.

Overhead cable trays (ladder or basket trays above the racks) are now more common than cables under a raised floor, where abandoned cables pile up and block the cooling air. The safety page covers cables as trip hazards.

Labeling and documentation

A data center with thousands of cables is only manageable if every item can be identified without tracing it by hand.

• Racks get a unique identifier, often based on the floor grid (row and position), shown on the front and rear doors.
• Devices carry a label with their host name and asset tag on the front and the back, because you work on both sides.
• Cables are labeled at both ends, with a label that tells where the other end goes (for example rack, U position and port). ANSI/TIA-606 defines a standard identifier scheme for this.
• Patch panel ports are numbered and mapped to the far-end panel.

All of it is recorded: rack elevations, port maps, power connections and asset data in a DCIM tool or a configuration management database, updated as part of every change. An undocumented cable is the cable someone will unplug during the next maintenance window.