Showing posts with label AI. Show all posts
Showing posts with label AI. Show all posts

Sunday, July 26, 2026

Working with GPUs - Part8 - Powering and cooling AI accelerators with OCP ORV3 HPR

When we talk about working with GPUs at scale, we usually focus on the software stack, CUDA tuning, or optimizing workloads across NVLink, etc. But if you are an infrastructure SRE managing bare-metal clusters, you quickly run into a much harsher physical reality: Power and Thermals.

As we deploy next-generation AI platforms like Nvidia’s GB200/ 300 NVL72 architectures - the power demands are obliterating traditional infrastructure. Standard server racks are physically hitting a wall. To keep these high-density clusters running without melting down, the industry is rapidly transitioning to the Open Compute Project’s (OCP) Open Rack Version 3 (ORV3) High Power Rack (HPR).

Here is what you need to know about how this architecture feeds and cools modern GPU nodes.

The GPU infrastructure bottleneck

Traditional data center racks rely on a 19-inch width standard with standard 44.45 mm Rack Units (RU). In that legacy model, every individual server chassis houses its own AC-to-DC power supply units (PSUs).

If you try to stuff a modern cluster of high-TDP GPUs into that traditional 19-inch racks, you run into immediate problems:

  • Cable chaos: The back of the rack becomes choked with heavy AC power cords, blocking vital airflow.
  • Efficiency loss: Converting AC to DC at every single node generates massive heat and power waste.
  • Weight limits: GPU nodes are incredibly dense and heavy; standard frames simply aren't structurally rated for them.

How ORV3 changes the game for GPU compute


Developed collaboratively by hyper-scalers like Meta, Google, and Microsoft, the ORV3 standard throws out the legacy playbook to accommodate modern accelerator demands.

Instead of treating the rack like a cabinet for isolated servers, ORV3 treats the entire rack as a single, unified compute machine:
  • Native 21-inch bays and Open Units (OU): Provides a wider internal bay (21 inches wide vs. the traditional 19 inches). It replaces RUs with Open Units (OU = 48mm), offering more structural space for complex GPU heat sinks and optimized front-to-rear airflow.
21-inch-wide rack

44 OU

  • Centralized 48V DC busbar: Individual server power supplies are completely gone. Instead, 3-phase AC or High Voltage DC (HVDC) enters a centralized power shelf, which converts it to 48V DC. This power is run down a copper busbar mounted at the rear center of the rack.
48V busbar

Busbar BarKlip connector

  • Power shelves: The ORV3 HPR power shelf acts as a centralized power hub that converts incoming 3-phase AC (from the overhead busways) into 48V DC power distributed via the rear busbar. Housing high-density 5.5 kW Power Supply Units (PSUs), a single 1U power shelf delivers up to 33kW of total output. Racks deploy multiple shelves in N+N or N+1 redundant configurations - complete with integrated Power Monitor Modules (PMM) to supply reliable, cable-free energy to high-TDP GPU clusters.

AC input overhead busways

AC input - Power shelf - DC output - Busbar

Power shelf with multiple PSUs inside it
GB200 NVL72 ORV3 HPR rack

  • Blind-mate infrastructure: When you slide a heavy GPU compute node into the rack, it connects directly to the 48V DC busbar via copper clips (blind-mate connections). No power cables required. The specialized copper clip/ jaw that physically clamps onto the vertical busbar blade to transmit high-current DC power is called a Busbar BarKlip connector. Blind-mate connectors are widely used for liquid cooling as well in modern high-density data centers. In the OCP ORV3 HPR architecture, the concept of "blind-mating" applies to both power and coolant distribution. Instead of manually hooking up coolant hoses to the back of a server, liquid-cooled blind-mate connectors (often referred to as BMQC or Blind Mate Quick Connectors) allow fluid lines to engage automatically as the compute tray slides into the rack.
Liquid cooling blind-mate connectors and manifold

  • Heavy duty chassis support: The frame is built to support up to 1400 kg, meaning it won't buckle under a full stack of liquid-cooled accelerators.


The ORV3 HPR specification


While standard ORV3 configurations top out at 18 kW to 36 kW per rack, modern AI workloads easily blow past those thresholds. To keep up with platforms like the Nvidia GB200 pushing rack limits to 140kW and beyond, the OCP community introduced the ORV3 HPR (High Power Rack) variant which is an extension of ORV3.
  • Power density: 92 kW to 140 kW+ / rack
  • Power shelf capacity: 5.5 kW PSUs (33 kW total per power shelf)
  • Cooling architecture: Blind-Mate Direct Liquid Cooling (DLC) Manifolds
To handle massive electrical currents without thermal runaway, the HPR upgrades to a massive 80 kg busbar with deeper tracking and aggressive grounding. More importantly, it addresses the massive heat generated by high-TDP GPUs by integrating blind-mate liquid cooling manifolds right into the chassis. Just like the power clips, the liquid cooling loops engage automatically when the node is seated.

What’s next: The 1-Megawatt sidecar


As we look forward, GPU power requirements show no signs of slowing down. As clusters head toward 1 Megawatt (MW) per rack, the OCP community is already developing Project Mount Diablo. This next step introduces a disaggregated Power Rack Sidecar, moving the massive rectifiers completely outside of the main compute rack so we can fill every square inch of the primary frame with pure, liquid-cooled GPU compute.



Working with GPUs at scale means understanding the infrastructure that keeps them alive. Without open standards like ORV3 HPR solving the physical limitations of power delivery and fluid dynamics, the next leap in AI compute wouldn't even be able to turn on.

References


Hope it was useful. Cheers!

Saturday, March 7, 2026

Working with GPUs – A Practical Blog Series

This blog series captures practical learnings from working with GPUs in real‑world environments, with a focus on operations, reliability, and scale. Each post deep‑dives into specific aspects of GPU systems based on hands‑on experience, incidents, and operational challenges. Together, these articles aim to share actionable insights, highlight common pitfalls, and help teams build more robust and predictable GPU operations.


Part 01: Using nvidia-smi
Part 02: Memory fault indicators
Part 03: Using dcgmi
Part 04: Thermal issues
Part 05: XID errors
Part 06: H100 SXM5 architecture
Part 07: GPU has fallen off the bus
Part 08: Powering and cooling AI accelerators with OCP ORV3 HPR
Part 09: Power shelves in OCP ORV3


Sunday, April 27, 2025

Azure AI Foundry - Part4 - Deploy and use a generative AI model

Azure AI Foundry supports deploying large language models (LLMs). In this article, we will see how to deploy a model and use it.

Azure AI Foundry Portal

  • Select your project - My assets - Models + endpoints - Deploy model
  • Click Deploy base model
  • Select the model you want to deploy (here I am selecting gpt-4.1) and click Confirm

  • You can see the deployment details like capacity (token per minute), resource location etc. 
  • Click on Create resource and deploy

  • Now it will start creating the resource and this step may take a minute or so.
  • Once it is done, it will take you to the following page where you can see the mode details on the model you just deployed.

  • Click on Open in playground to test the model.
  • Once the chat playground is open, you will see your deployment, and under that you will see a section where you can give the model instructions and context. An example is given in the following screenshot. Once the model instructions and context are provided make sure to click Apply changes button. 
  • Now you can click on Generate prompt, provide the query and click on Send.
  • You can also set values for limiting the maximum output token for the model response, temperature, frequency penalty etc. under the Parameters section.

  • A sample response is provided in the following screenshot.

  • To see the sample code, you can click on View code.
  • You can also see code samples and authentication using API key as shown below.

  • Metrics (total requests, token count, etc.) related to your LLM model deployment can be found on the following page.

 

Python


Sample code to interact with the model can be found in my GitHub repo.

Hope it was useful. Cheers!

Saturday, April 26, 2025

Azure AI Foundry Blog Series

Azure AI Foundry is a comprehensive suite of tools and services designed to accelerate the development and deployment of AI solutions on the Azure platform. Throughout this blog series, we will cover various aspects of Azure AI Foundry.



Part1 - Create project
Part2 - Language translation using AI Services
Part3 - Abstractive text summarization
Part4 - Deploy and use a generative AI model


Wednesday, April 23, 2025

Azure AI Foundry - Part3 - Abstractive text summarization

In this article, I will show you how to use Azure Cognitive Services for text summarization. 

Azure AI Foundry portal

  • AI Services - Language + Translator


  • Summarize Information - Summarize text


  • Select a connected AI service resource or create a new one.


  • Playgrounds - Summarize Information - Summarize text


Python


Sample code to summarize a PDF can be found in my GitHub repo. Following is an example of a resume summary: 


Hope this was useful. Cheers!

Tuesday, April 15, 2025

Azure AI Foundry - Part2 - Language translation using AI Services

In this article, I will show you how to use an Azure AI Service available within the Azure AI Foundry project. We'll use the language translator as an example.

Azure AI Foundry portal

  • Select AI Services. 
    • Click on Language + Translator.


  • Select Translation.

  • Select Text Translation.

  • Click on Try with your own.

  • Here I am translating language from English to Malayalam. Take a look at the Connected Azure AI Services, you can see it is already connected to one. Incase if it is not connected to an Azure AI Services resource, you can click on Create a new AI Services resource, select a region, provide an AI Services name if you like to and click Create and connect

  • You can also view the sample code by clicking on View code.

  • Here is the sample code in Python and when you scroll down you can find the Resource key and Region details.

Python

import os, requests, uuid, json

resource_key = 'resource_key_here'
region = 'region_here'
endpoint = 'https://api.cognitive.microsofttranslator.com/'

# If you encounter any issues with the base_url or path, make sure
# that you are using the latest endpoint: https://docs.microsoft.com/azure/cognitive-services/translator/reference/v3-0-translate
path = '/translate?api-version=3.0'
params = '&to=ml'
constructed_url = endpoint + path + params

headers = {
    'Ocp-Apim-Subscription-Key': resource_key,
    'Ocp-Apim-Subscription-Region': region,
    'Content-type': 'application/json',
    'X-ClientTraceId': str(uuid.uuid4())
}

# You can pass more than one object in body.
body = [{
    'text' : 'where are you right now?'
}]
request = requests.post(constructed_url, headers=headers, json=body)
response = request.json()

print(json.dumps(response, sort_keys=True, indent=4, separators=(',', ': ')))


Sample output:

What you see is a unicode string and once it is converted you will see the corresponding Malayalam text. 

Curl

curl -X POST "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&to=ml" \
> -H "Ocp-Apim-Subscription-Key: your_key_here" \
> -H "Ocp-Apim-Subscription-Region: your_region_here" \
> -H "Content-Type: application/json" \
> -d "[{'Text':'where are you now?'}]" -v


Sample output:

Hope this was useful. Cheers!

References

Azure AI Foundry - Part1 - Create project

Azure AI Foundry is a unified platform that helps you design, customize, build, test, deploy, and manage generative AI applications. In this article, I will show you how to create a project and a hub, which are the first steps to building your AI solution. Let's get started!

Create project using the portal


  • Click Create project.
    • The project will have an auto generated name or you can provide one. 
    • You can also notice that it creates a new Hub, and Storage account, Key Vault and AI Services under a new resource group.
    • Click Create.
  • The project is getting created now. This may take a minute or two.


  • Once it's done, it will take you to this overview page.


  • On the Azure AI Foundry portal, you can use the Management center to configure/ get more details about your project, connected resources, models, endpoints etc.


  • Under the Hub or Project properties, if you select the Resource Group, it will open a new browser tab and navigate to the Azure portal where you can see all the Azure resources that have been created to support your hub and project.


Create project using Azure CLI


Note: Remove any existing installation of the ml and azure-cli-ml extensions and install new.
  • az extension remove -n azure-cli-ml
  • az extension remove -n ml
  • az extension add -n ml
  • az extension update -n ml

  • az login
  • az account set --subscription "subscription_id"
  • az group create --name "resource_group_name" --location "location_name"

  • az ml workspace create --kind hub --resource-group "resource_group_name" --name "hub_name"


  • $hub_id = "you will get this id from the output of previous step"
  • az ml workspace create --kind project --hub-id $hub_id --resource-group "resource_group_name" --name "project_name"

Friday, March 29, 2024

Generative AI and LLMs Blog Series

In this blog series we will explore the fascinating world of Generative AI and Large Language Models (LLMs). We delve into the latest advancements in AI technology, focusing particularly on LLMs, which have revolutionized various fields, including natural language processing and text generation.

Throughout this series, we will discuss LLM serving platforms such as Ollama and Hugging Face, providing insights into their capabilities, features, and applications. I will also guide you through the process of getting started with LLMs, from setting up your development/ test environment to deploying these powerful models on Kubernetes clusters. Additionally, we'll demonstrate how to effectively prompt and interact with LLMs using frameworks like LangChain, empowering you to harness the full potential of these cutting-edge technologies.

Stay tuned for insightful articles, and hands-on guides that will equip you with the knowledge and skills to unlock the transformative capabilities of LLMs. Let's explore the future of AI together!

Image credits: designer.microsoft.com/image-creator


Ollama

Part1 - Deploy Ollama on Kubernetes

Part2 - Prompt LLMs using Ollama, LangChain, and Python

Part3 - Web UI for Ollama to interact with LLMs

Part4 - Vision assistant using LLaVA


Hugging Face

Part1 - Getting started with Hugging Face

Part2 - Code generation with Code Llama Instruct

Part3 - Inference with Code Llama using LangChain

Part4 - Containerize your LLM app using Python, FastAPI, and Docker

Part5 - Deploy your LLM app on Kubernetes 

Part6 - LLM app observability <coming soon>


Monday, January 15, 2024

Ollama - Part1 - Deploy Ollama on Kubernetes

Docker published GenAI stack around Oct 2023 which consists of large language models (LLMs) from Ollama, vector and graph databases from Neo4j, and the LangChain framework. These utilities can help developers with the resources they need to kick-start creating new applications using generative AI. Ollama can be used to deploy and run LLMs locally. In this exercise we will deploy Ollama to a Kubernetes cluster and prompt it.

In my case I am using a Tanzu Kubernetes Cluster (TKC) running on vSphere with Tanzu 7u3 platform powered by Dell PowerEdge R640 servers. The TKC nodes are using best-effort-2xlarge vmclass with 8 CPU and 64Gi Memory.  Note that I am running it on a regular Kubernetes cluster without GPU. If you have GPU, additional configuration steps might be required.



Hope it was useful. Cheers!