> 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.

# Model Deployment

Deploying a model on Dynamo means describing an inference graph — a Frontend plus
one or more workers — as a Kubernetes Custom Resource, then letting the Dynamo
operator reconcile it into running pods, services, and scheduling resources.
There are **two CRDs** you can start from, and the whole section is organized
around choosing between them.

## Two ways to deploy: DGD and DGDR

| | **DynamoGraphDeployment (DGD)** | **DynamoGraphDeploymentRequest (DGDR)** |
|---|---|---|
| **Path** | Manual — you author the spec | Automatic — you describe intent |
| **You provide** | The full spec: components, parallelism, replicas, resource limits | Model, backend, workload, and optional SLA targets |
| **What happens** | The operator reconciles your spec into pods directly | The profiler sizes the deployment and **generates a DGD** for you |
| **Best for** | Known-good configs, tuned recipes, full control | New model/hardware combinations, SLA-driven sizing |

### DGD is the primary path

A **[DynamoGraphDeployment (DGD)](/dynamo/dev/kubernetes/model-deployment/deploy-with-dgd)** is the canonical
resource that serves traffic. You write the spec, `kubectl apply` it, and the
operator runs it. Because you control every field, a DGD works for **any** model
and backend, and it is the object that actually persists and serves. Even when
you use DGDR, what it produces is a DGD. Start here:
**[Deploy with DGD](/dynamo/dev/kubernetes/model-deployment/deploy-with-dgd)**.

### DGDR automates sizing — when your model is supported

A **[DynamoGraphDeploymentRequest (DGDR)](/dynamo/dev/kubernetes/auto-deployment/dgdr-walkthrough)** is the
deploy-by-intent path. Instead of hand-authoring parallelism and replica counts,
you describe what you want to run and Dynamo's profiler analyzes your GPUs,
selects a configuration, and generates a DGD.

DGDR is convenient but **does not yet cover every model, hardware, and backend
combination**. Its fast "rapid" profiling relies on the AIConfigurator support
matrix; for combinations outside that matrix it falls back to a naive
memory-fit configuration that may not be optimal. For this reason **DGD remains
the primary path**, and even in the DGDR flow the generated DGD is something you
can inspect and edit before it serves traffic. See
**[Auto Deploy with DGDR](/dynamo/dev/kubernetes/auto-deployment/dgdr-walkthrough)**.

## Aggregated or disaggregated — supported by both

Independent of which CRD you author, you choose how prefill and decode are
placed. **Both DGD and DGDR support both options.**

- **Aggregated** — one worker runs both the prefill (prompt) and decode
  (generation) phases. The simplest deployment; a good default for smaller
  models and uniform traffic.
- **Disaggregated** — separate prefill and decode worker pools, each sized and
  scaled independently, with the KV cache transferred between them over the
  network. Use it when prefill and decode have different bottlenecks — long
  prompts saturating prefill, or high concurrency saturating decode. It needs an
  RDMA-capable fabric for the KV transfer to perform well.

See **[Disaggregated Serving](/dynamo/dev/kubernetes/model-deployment/disaggregated-serving)** for
the architecture and the disaggregation-specific configuration.

## Where to go next

Run one model end to end with the [Kubernetes Quickstart](/dynamo/dev/kubernetes/getting-started/quickstart)
first if you are new here. Then pick your path:

| Goal | Guide |
|---|---|
| Author a deployment by hand (start here) | [Deploy with DGD](/dynamo/dev/kubernetes/model-deployment/deploy-with-dgd) |
| Let Dynamo size and generate the deployment | [Auto Deploy with DGDR](/dynamo/dev/kubernetes/auto-deployment/dgdr-walkthrough) |
| Split prefill and decode for performance | [Disaggregated Serving](/dynamo/dev/kubernetes/model-deployment/disaggregated-serving) |
| Auto-pick TP/PP/DP for a latency target | [Sizing with AIConfigurator](/dynamo/dev/kubernetes/model-deployment/size-with-ai-configurator) |
| Scale a model across multiple nodes | [Multinode Deployments](/dynamo/dev/kubernetes/model-deployment/multinode-deployments) |
| Understand the full resource model (DGD, DCD, DGDR, recipes) | [Deployment Overview](/dynamo/dev/kubernetes/model-deployment/model-deployment-guide) |
| Load models faster across pods | [Model Caching](/dynamo/dev/kubernetes/model-deployment/model-caching) |

If you are still evaluating Dynamo locally, start with the [Quickstart](/dynamo/dev/cli/getting-started/quickstart)
and [Local Installation](/dynamo/dev/cli/installation/install-dynamo) first.