docs: add docs for DGDR usage -- golden path (#7304)

Signed-off-by: Hannah Zhang <hannahz@nvidia.com>
Signed-off-by: Dan Gil <dagil@nvidia.com>
Co-authored-by: hhzhang16 <54051230+hhzhang16@users.noreply.github.com>

Author: dagil-nvidia

components/src/dynamo/profiler/deploy/profile_sla_aic_dgdr.yaml

@@ -8,60 +8,45 @@ Complete examples for profiling with DGDRs.
 
 ## DGDR Examples
 
-### Dense Model: AIPerf on Real Engines
+### Dense Model: Rapid
 
-Standard online profiling with real GPU measurements:
+Fast profiling (~30 seconds):
 
 ```yaml
 apiVersion: nvidia.com/v1beta1
 kind: DynamoGraphDeploymentRequest
 metadata:
-  name: vllm-dense-online
+  name: qwen-0-6b
 spec:
   model: "Qwen/Qwen3-0.6B"
-  backend: vllm
-  image: "nvcr.io/nvidia/ai-dynamo/vllm-runtime:0.9.0"
-
-  workload:
-    isl: 3000
-    osl: 150
-
-  sla:
-    ttft: 200.0
-    itl: 20.0
-
-  autoApply: true
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
 ```
 
-### Dense Model: AI Configurator Simulation
+### Dense Model: Thorough
 
-Fast offline profiling (~30 seconds, TensorRT-LLM only):
+Profiling with real GPU measurements:
 
 ```yaml
 apiVersion: nvidia.com/v1beta1
 kind: DynamoGraphDeploymentRequest
 metadata:
-  name: trtllm-aic-offline
+  name: vllm-dense-online
 spec:
-  model: "Qwen/Qwen3-32B"
-  backend: trtllm
-  image: "nvcr.io/nvidia/ai-dynamo/tensorrtllm-runtime:0.9.0"
-
-  workload:
-    isl: 4000
-    osl: 500
-
-  sla:
-    ttft: 300.0
-    itl: 10.0
-
-  autoApply: true
+  model: "Qwen/Qwen3-0.6B"
+  backend: vllm
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
+  searchStrategy: thorough
 ```
 
 ### MoE Model
 
 Multi-node MoE profiling with SGLang:
 
+> [!IMPORTANT]
+> The PVC referenced by `modelCache.pvcName` must already exist in the same namespace and contain
+> the model weights at the specified `pvcModelPath`. The DGDR controller does not create or
+> populate the PVC — it only mounts it into the profiling job and deployed workers.
+
 ```yaml
 apiVersion: nvidia.com/v1beta1
 kind: DynamoGraphDeploymentRequest
@@ -70,53 +55,138 @@ metadata:
 spec:
   model: "deepseek-ai/DeepSeek-R1"
   backend: sglang
-  image: "nvcr.io/nvidia/ai-dynamo/sglang-runtime:0.9.0"
-
-  workload:
-    isl: 2048
-    osl: 512
-
-  sla:
-    ttft: 300.0
-    itl: 25.0
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
 
   hardware:
     numGpusPerNode: 8
 
-  autoApply: true
+  modelCache:
+    pvcName: "model-cache"
+    pvcModelPath: "deepseek-r1"      # path within the PVC
 ```
 
-### Using Existing DGD Config (ConfigMap)
+### Private Model
 
-Reference a custom DGD configuration via ConfigMap:
+For gated or private HuggingFace models, pass your token via an environment variable injected
+into the profiling job. Create the secret first:
 
 ```bash
-# Create ConfigMap from your DGD config file
-kubectl create configmap deepseek-r1-config \
-  --from-file=/path/to/your/disagg.yaml \
-  --namespace $NAMESPACE \
-  --dry-run=client -o yaml | kubectl apply -f -
+kubectl create secret generic hf-token-secret \
+  --from-literal=HF_TOKEN="${HF_TOKEN}" \
+  -n ${NAMESPACE}
 ```
 
+Then reference it in your DGDR:
+
 ```yaml
 apiVersion: nvidia.com/v1beta1
 kind: DynamoGraphDeploymentRequest
 metadata:
-  name: deepseek-r1
+  name: llama-private
 spec:
-  model: deepseek-ai/DeepSeek-R1
-  backend: sglang
-  image: "nvcr.io/nvidia/ai-dynamo/sglang-runtime:0.9.0"
+  model: "meta-llama/Llama-3.1-8B-Instruct"
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
+
+  overrides:
+    profilingJob:
+      template:
+        spec:
+          containers: []    # required placeholder; leave empty to inherit defaults
+          initContainers:
+            - name: profiler
+              env:
+                - name: HF_TOKEN
+                  valueFrom:
+                    secretKeyRef:
+                      name: hf-token-secret
+                      key: HF_TOKEN
+```
+
+### Custom SLA Targets
+
+Control how the profiler optimizes your deployment by specifying latency targets and workload
+characteristics.
+
+**Explicit TTFT + ITL targets** (default mode):
+
+```yaml
+apiVersion: nvidia.com/v1beta1
+kind: DynamoGraphDeploymentRequest
+metadata:
+  name: low-latency-dense
+spec:
+  model: "Qwen/Qwen3-0.6B"
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
+
+  sla:
+    ttft: 500      # Time To First Token target in milliseconds
+    itl: 20        # Inter-Token Latency target in milliseconds
 
   workload:
-    isl: 4000
-    osl: 500
+    isl: 2000      # expected input sequence length (tokens)
+    osl: 500       # expected output sequence length (tokens)
+```
 
+**End-to-end latency target** (alternative to ttft+itl):
+
+```yaml
+spec:
+  ...
+  sla:
+    e2eLatency: 10000    # total request latency budget in milliseconds
+```
+
+**Optimization objective without explicit targets** (maximize throughput or minimize latency):
+
+```yaml
+spec:
+  ...
   sla:
-    ttft: 300
-    itl: 10
+    optimizationType: throughput    # or: latency
+```
+
+### Overrides
+
+Use `overrides` to customize the profiling job pod spec — for example to add tolerations for
+GPU node taints or inject environment variables.
+
+**GPU node toleration** (common on GKE and shared clusters):
 
-  autoApply: true
+```yaml
+apiVersion: nvidia.com/v1beta1
+kind: DynamoGraphDeploymentRequest
+metadata:
+  name: dense-with-tolerations
+spec:
+  model: "Qwen/Qwen3-0.6B"
+  image: "nvcr.io/nvidia/ai-dynamo/dynamo-frontend:1.0.0"
+
+  overrides:
+    profilingJob:
+      template:
+        spec:
+          containers: []    # required placeholder; leave empty to inherit defaults
+          tolerations:
+            - key: nvidia.com/gpu
+              operator: Exists
+              effect: NoSchedule
+```
+
+**Override the generated DynamoGraphDeployment** (e.g., to use a custom worker image):
+
+```yaml
+spec:
+  ...
+  overrides:
+    dgd:
+      apiVersion: nvidia.com/v1alpha1
+      kind: DynamoGraphDeployment
+      spec:
+        services:
+          VllmWorker:
+            extraEnvs:
+              - name: CUSTOM_ENV
+                value: "my-value"
 ```
 
 ## SGLang Runtime Profiling

components/src/dynamo/profiler/deploy/profile_sla_dgdr.yaml

@@ -47,6 +47,8 @@ navigation:
         contents:
           - page: Detailed Installation Guide
             path: kubernetes/installation-guide.md
+          - page: Deploying Your First Model
+            path: kubernetes/dgdr.md
           - page: Dynamo Operator
             path: kubernetes/dynamo-operator.md
           - page: Service Discovery

components/src/dynamo/profiler/deploy/profile_sla_moe_dgdr.yaml

@@ -82,26 +82,12 @@ Each backend has deployment examples and configuration options:
 
 ## 3. Deploy Your First Model
 
-```bash
-export NAMESPACE=dynamo-system
-kubectl create namespace ${NAMESPACE}
-
-# to pull model from HF
-export HF_TOKEN=<Token-Here>
-kubectl create secret generic hf-token-secret \
-  --from-literal=HF_TOKEN="$HF_TOKEN" \
-  -n ${NAMESPACE};
+Follow the **[Deploying Your First Model](dgdr.md)** guide for a complete end-to-end
+walkthrough using `DynamoGraphDeploymentRequest` (DGDR) — Dynamo's recommended path that
+handles profiling and configuration automatically.
 
-# Deploy any example (this uses vLLM with Qwen model using aggregated serving)
-kubectl apply -f examples/backends/vllm/deploy/agg.yaml -n ${NAMESPACE}
-
-# Check status
-kubectl get dynamoGraphDeployment -n ${NAMESPACE}
-
-# Test it
-kubectl port-forward svc/vllm-agg-frontend 8000:8000 -n ${NAMESPACE}
-curl http://localhost:8000/v1/models
-```
+The tutorial deploys `Qwen/Qwen3-0.6B` with vLLM and walks you through every step: creating
+the DGDR, watching the profiling lifecycle, and sending your first inference request.
 
 For SLA-based autoscaling, see [SLA Planner Guide](../components/planner/planner-guide.md).