> For clean Markdown content of this page, append .md to this URL. For the complete documentation index, see https://docs.nvidia.com/dynamo/llms.txt. For full content including API reference and SDK examples, see https://docs.nvidia.com/dynamo/llms-full.txt.

# Kubernetes Quickstart

Select **NVIDIA GPU** or **Intel GPU** based on the accelerator hardware in your cluster, and
follow that tab throughout the guide. The Intel GPU path uses the XPU runtime and tooling.

#### Check the prerequisites

#### NVIDIA GPU

You need:

* A Kubernetes v1.30 or later cluster with NVIDIA GPU nodes
* `kubectl` v1.30 or later configured for the cluster
* Helm v3 or later

#### Intel GPU

You need:

* A Kubernetes v1.34 or later cluster with Intel GPU nodes and Dynamic Resource Allocation (DRA) API v1 enabled
* `kubectl` matching the cluster's Kubernetes minor version
* Helm v3 or later
* Docker and access to a container registry
* A local clone of the Dynamo repository

#### Install accelerator support

#### NVIDIA GPU

Install the NVIDIA GPU Operator:

```bash
helm repo add nvidia https://helm.ngc.nvidia.com/nvidia --force-update
helm repo update nvidia
helm upgrade --install gpu-operator nvidia/gpu-operator \
  --namespace gpu-operator \
  --create-namespace \
  --wait \
  --timeout=10m
```

If your cluster provider installs the NVIDIA driver, add `--set driver.enabled=false`.
Add `--set toolkit.enabled=false` only when the provider also configures the GPU container runtime.

#### Intel GPU

Install the [Intel resource drivers for Kubernetes](https://github.com/intel/intel-resource-drivers-for-kubernetes),
then verify that the `gpu.intel.com` device class is available:

```bash
kubectl get deviceclass gpu.intel.com
kubectl get resourceslices
```

#### Install Dynamo

Install the Dynamo platform chart in a dedicated namespace. Helm creates the namespace for you:

```bash
export NAMESPACE=dynamo-system
export DYNAMO_VERSION=1.3.0

helm upgrade --install dynamo-platform \
  oci://helm.ngc.nvidia.com/nvidia/ai-dynamo/charts/dynamo-platform \
  --version "$DYNAMO_VERSION" \
  --namespace "$NAMESPACE" \
  --create-namespace \
  --wait \
  --timeout=10m

kubectl get pods --namespace "$NAMESPACE"
```

#### Create the model access secret

`Qwen/Qwen3-0.6B` is public and does not require a Hugging Face token. The DGDR profiler and
example DGD expect a Secret named `hf-token-secret`, so create it with an empty token:

```bash
kubectl create secret generic hf-token-secret \
  --namespace "$NAMESPACE" \
  --from-literal=HF_TOKEN= \
  --dry-run=client -o yaml | kubectl apply -f -
```

For a gated or private model, replace the empty value with your Hugging Face token.

#### Deploy Qwen3 0.6B

#### NVIDIA GPU

Apply a `DynamoGraphDeploymentRequest` (DGDR). The DGDR profiles the model and creates the
`DynamoGraphDeployment` (DGD) that serves it.

```bash
cat <<EOF | kubectl apply --namespace "$NAMESPACE" -f -
apiVersion: nvidia.com/v1beta1
kind: DynamoGraphDeploymentRequest
metadata:
  name: qwen3-quickstart
spec:
  model: Qwen/Qwen3-0.6B
  backend: auto
  image: nvcr.io/nvidia/ai-dynamo/dynamo-planner:${DYNAMO_VERSION}
EOF
```

#### Intel GPU

From the root of your Dynamo clone, build and push the vLLM XPU runtime image:

```bash
export XPU_IMAGE="registry.example.com/vllm-runtime-xpu:quickstart"

python3 container/render.py \
  --framework=vllm \
  --device=xpu \
  --target=runtime \
  --output-short-filename
docker build --tag "$XPU_IMAGE" --file container/rendered.Dockerfile .
docker push "$XPU_IMAGE"
```

Apply the aggregated XPU `DynamoGraphDeployment` (DGD), replacing the template image tags
with the images for this quickstart:

```bash
sed \
  -e "s|nvcr.io/nvidia/ai-dynamo/vllm-runtime:my-tag|nvcr.io/nvidia/ai-dynamo/vllm-runtime:${DYNAMO_VERSION}|g" \
  -e "s|nvcr.io/nvidia/ai-dynamo/vllm-runtime-xpu:my-tag|${XPU_IMAGE}|g" \
  examples/backends/vllm/deploy/v1beta1/xpu/agg_xpu_dra.yaml \
  | kubectl apply --namespace "$NAMESPACE" -f -
```

#### Wait for the deployment

Model download and startup can take several minutes.

#### NVIDIA GPU

```bash
kubectl wait \
  --for=jsonpath='{.status.phase}'=Deployed \
  dgdr/qwen3-quickstart \
  --namespace "$NAMESPACE" \
  --timeout=30m

export DGD_NAME=$(kubectl get dgdr/qwen3-quickstart \
  --namespace "$NAMESPACE" \
  --output=jsonpath='{.status.dgdName}')
export FRONTEND_SERVICE="${DGD_NAME}-frontend"
```

#### Intel GPU

```bash
kubectl wait \
  --for=condition=Ready \
  dgd/vllm-agg-xpu-dra \
  --namespace "$NAMESPACE" \
  --timeout=30m

export FRONTEND_SERVICE=vllm-agg-xpu-dra-frontend
```

#### Send a request

Port-forward the Frontend, wait for its health endpoint, and send a chat completion request:

```bash
kubectl port-forward \
  --namespace "$NAMESPACE" \
  "service/${FRONTEND_SERVICE}" 8000:8000 \
  >/tmp/dynamo-port-forward.log 2>&1 &
export PORT_FORWARD_PID=$!

until curl --silent --fail http://localhost:8000/health >/dev/null; do
  sleep 2
done

curl --silent --show-error http://localhost:8000/v1/chat/completions \
  --header "Content-Type: application/json" \
  --data '{
    "model": "Qwen/Qwen3-0.6B",
    "messages": [
      {"role": "user", "content": "What is NVIDIA Dynamo?"}
    ],
    "max_tokens": 200
  }' | python3 -m json.tool
```

## What You Did

* Installed the accelerator support required by your hardware.
* Installed the Dynamo platform on your Kubernetes cluster.
* Created either a DGDR that generated a DGD, or a DGD directly.
* Sent an OpenAI-compatible request to the deployed model.

## Clean Up

Stop the port-forward and remove the quickstart deployment:

```bash
kill "$PORT_FORWARD_PID"
```

#### NVIDIA GPU

```bash
kubectl delete dgdr/qwen3-quickstart --namespace "$NAMESPACE" --ignore-not-found
kubectl delete dgd/"$DGD_NAME" --namespace "$NAMESPACE" --ignore-not-found
```

#### Intel GPU

```bash
kubectl delete \
  --filename examples/backends/vllm/deploy/v1beta1/xpu/agg_xpu_dra.yaml \
  --namespace "$NAMESPACE" \
  --ignore-not-found
```