Power Delivery in Dense Rack Environments
Ajknox chargers are modular power delivery units designed primarily for GPU node configurations and edge computing deployments. They handle bus-powered and externally-powered device provisioning, which matters less in a home lab but becomes critical when you are deploying forty compute nodes in a single rack and every amp counts. The basic premise is straightforward: standardized input voltage, distributed output channels, and management firmware that lets you monitor per-port draw without running a separate IPMI rail for each device. The firmware stack on these units supports both local web management and SNMP v3 reporting to a central monitoring server. I found the web interface adequate for basic load balancing between AC inputs, but the real utility comes from scripting against the REST API endpoint. You can pull per-port current readings every thirty seconds, set hard overcurrent thresholds, and schedule power cycling on individual outputs. That last feature is what saved a production run for me last November. My cluster had twelve Ajknox AJP-4800 units powering mixed NVIDIA H100 and AMD MI300X nodes. About six months into deployment, I noticed intermittent PCIe enumeration failures during cold boots on roughly one in twenty nodes. The failures were random across the rack, which ruled out a single bad unit. After two weeks of logging, I correlated the pattern: nodes pulling above 340 watts on a single output channel at boot time would occasionally see a 120-millisecond voltage sag on the +12V rail. The Ajknox firmware was not brownout-protecting fast enough because the threshold was set to the default 400 amp limit for the entire unit, not per-channel.
The workaround was to drop the per-channel overcurrent threshold to 350 amps and add a ten-second ramp delay on boot. That gave the bulk capacitors on the server motherboards time to stabilize before full current draw kicked in. Boot failures dropped to zero after that change. It took about four hours to reconfigure all twelve units through the API using a Python script I wrote around their REST endpoint documentation, which is sparse but functional. Bulk power delivery on these units is rated at 4800 watts per chassis with dual redundant AC inputs. In practice, I would not push either input above 80 percent continuous load for extended training runs. The internal switch-mode supplies run about eleven degrees Celsius hotter than the spec sheet thermal curve suggests when ambient rack temperature exceeds 26 degrees Celsius. That thermal margin disappears quickly in a dense configuration. I moved three of my units to lower-density racks after monitoring internal thermistors through the SNMP interface showed sustained temperatures above 68 degrees Celsius on the SMPS boards. One thing the manual does not emphasize: the management Ethernet port shares a common ground with the power output stages. If you are running isolated network segments for management versus data plane traffic, you need a proper isolation transformer or optocoupler on that management link. I learned this after a ground loop introduced switching noise on the PCIe clock line, which caused ECC errors on GPU memory during collective communications. The fixes were a ground lift on the management port and a fiber uplink to the management switch. That added about $200 in SFP+ transceivers per unit but eliminated the error rate entirely.
The software side supports third-party orchestration through Kubernetes device plugins and a basic Terraform provider for infrastructure-as-code deployments. The Terraform provider is undocumented but reverse-engineered from the REST API. It works. I deployed an entire rack of nodes using it in about three hours, including power provisioning and network configuration. There are real limitations. The units do not support Power over Ethernet for management, so you need a dedicated network connection for each charger. The REST API lacks pagination on log endpoints, which means pulling historical data from a month ago will time out on a slow connection. And the per-channel load balancing algorithm is naive: it distributes based on current draw, not on thermal headroom or input rail health, so you can end up with one AC input carrying significantly more load than the other under certain configurations. If you need true per-port power capping with millisecond response times, the Ajknox units fall short. Their response time is roughly 200 milliseconds per control loop iteration, which is acceptable for general compute node provisioning but insufficient for dynamic voltage scaling during benchmark runs. For that use case, you are better off using a PDU with integrated power measurement like those from Vertiv or Schneider Electric, combined with a separate power management layer.
Downloads for the firmware are available through the vendor portal at ajknox.com/support/firmware. You need a registered account and a serial number from the unit label. The latest stable build is 3.2.1, which improves SNMP polling performance and adds a hidden debug command for forcing per-channel load redistribution. That command is not in the public documentation but is accessible through the serial console if you send a specific break sequence during boot. Use it carefully. A misconfigured redistribution during an active job will kill the job instantly. The device plugin for Kubernetes is on GitHub under the ajknox org. It has not been updated in eight months. It works with Kubernetes 1.28 and 1.29. I ran it on 1.30 without issues but patched a single resource leak in the device status reporter. The patch is trivial if you know Go. I submitted it upstream and have not heard back.
Practical Deployment Notes
Rack mounting requires a 2U space per unit and about 15 centimeters of clearance on all sides for airflow. The fans are axial and run at roughly 45 dBA under full load. That is loud in an office environment. If your data center is shared space, consider remote mounting the units and running DC cabling to the compute nodes instead. Cabling matters more than the manufacturer makes it sound. Use 10 AWG copper for the main AC inputs if you are running near-full load. Thinner gauge wire will heat up and introduce voltage drop that the firmware cannot compensate for. I replaced 12 AWG wiring on two of my racks and saw a 2.3 percent improvement in sustained compute throughput because the GPUs could maintain boost clocks without throttling. Monitoring should include at minimum per-port wattage, input rail voltage, and internal temperature. Anything less and you are flying blind. I recommend setting up alerts at 75 percent of rated capacity for sustained periods longer than five minutes. That catches thermal issues before they cause protective shutdowns mid-training run.
The initial cost is higher than generic PDUs, but the per-watt management overhead is lower once you have API-driven provisioning in place. For small deployments under eight nodes, a standard managed PDU is simpler and cheaper. For anything larger, the Ajknox units pay for themselves in reduced manual intervention and earlier fault detection.
