Creating Deployments

The scripts in the examples/<backend>/launch folder like agg.sh demonstrate how you can serve your models locally. The corresponding YAML files like agg.yaml show you how you could create a Kubernetes deployment for your inference graph.

This guide explains how to create your own deployment files.

Step 1: Choose Your Architecture Pattern

Before choosing a template, understand the different architecture patterns:

Aggregated Serving (agg.yaml)

Pattern: Prefill and decode on the same GPU in a single process.

Suggested to use for:

• Small to medium models (under 70B parameters)
• Development and testing
• Low to moderate traffic
• Simplicity is prioritized over maximum throughput

Tradeoffs:

• Simpler setup and debugging
• Lower operational complexity
• GPU utilization may not be optimal (prefill and decode compete for resources)
• Lower throughput ceiling compared to disaggregated

Example: agg.yaml

Aggregated + Router (agg_router.yaml)

Pattern: Load balancer routing across multiple aggregated worker instances.

Suggested to use for:

• Medium traffic requiring high availability
• Need horizontal scaling
• Want some load balancing without disaggregation complexity

Tradeoffs:

• Better scalability than plain aggregated
• High availability through multiple replicas
• Still has GPU underutilization issues of aggregated serving
• More complex than plain aggregated but simpler than disaggregated

Example: agg_router.yaml

Disaggregated Serving (disagg_router.yaml)

Pattern: Separate prefill and decode workers with specialized optimization.

Suggested to use for:

• Production-style deployments
• High throughput requirements
• Large models (70B+ parameters)
• Maximum GPU utilization needed

Tradeoffs:

• Maximum performance and throughput
• Better GPU utilization (prefill and decode specialized)
• Independent scaling of prefill and decode
• More complex setup and debugging
• Requires understanding of prefill/decode separation

Example: disagg_router.yaml

Quick Selection Guide

Select the architecture pattern as your template that best fits your use case.

For example, when using the vLLM backend:

• Development / Testing: Use agg.yaml as the base configuration.

• Production with Load Balancing: Use agg_router.yaml to enable scalable, load-balanced inference.

• High Performance / Disaggregated Deployment: Use disagg_router.yaml for maximum throughput and modular scalability.

Step 2: Customize the Template

You can run the Frontend on one machine, for example a CPU node, and the worker on a different machine (a GPU node). The Frontend serves as a framework-agnostic HTTP entry point and is likely not to need many changes.

It serves the following roles:

1. OpenAI-Compatible HTTP Server

• Provides /v1/chat/completions endpoint
• Handles HTTP request/response formatting
• Supports streaming responses
• Validates incoming requests

2. Service Discovery and Routing

• Auto-discovers backend workers via etcd
• Routes requests to the appropriate Processor/Worker components
• Handles load balancing between multiple workers

3. Request Preprocessing

• Initial request validation
• Model name verification
• Request format standardization

You should then pick a worker and specialize the config. For example,

1
VllmWorker:         # vLLM-specific config
2
  enforce-eager: true
3
  enable-prefix-caching: true
4
5
SglangWorker:       # SGLang-specific config
6
  router-mode: kv
7
  disagg-mode: true
8
9
TrtllmWorker:       # TensorRT-LLM-specific config
10
  engine-config: ./engine.yaml
11
  kv-cache-transfer: ucx

Here’s a template structure based on the examples:

1
    YourWorker:
2
      dynamoNamespace: your-namespace
3
      componentType: worker
4
      replicas: N
5
      envFromSecret: your-secrets  # e.g., hf-token-secret
6
      # Health checks for worker initialization
7
      readinessProbe:
8
        exec:
9
          command: ["/bin/sh", "-c", 'grep "Worker.*initialized" /tmp/worker.log']
10
      resources:
11
        requests:
12
          gpu: "1"  # GPU allocation
13
      extraPodSpec:
14
        mainContainer:
15
          image: your-image
16
          command:
17
            - /bin/sh
18
            - -c
19
          args:
20
            - python -m dynamo.YOUR_INFERENCE_ENGINE --model YOUR_MODEL --your-flags

Consult the corresponding sh file. Each of the python commands to launch a component will go into your yaml spec under the extraPodSpec: -> mainContainer: -> args:

The front end is launched with “python3 -m dynamo.frontend [—http-port 8000] [—router-mode kv]” Each worker will launch python -m dynamo.YOUR_INFERENCE_BACKEND --model YOUR_MODEL --your-flags command.

Step 3: Key Customization Points

Model Configuration

1
   args:
2
     - "python -m dynamo.YOUR_INFERENCE_BACKEND --model YOUR_MODEL --your-flag"

Resource Allocation

1
   resources:
2
     requests:
3
       cpu: "N"
4
       memory: "NGi"
5
       gpu: "N"

Scaling

1
   replicas: N  # Number of worker instances

Routing Mode

1
   args:
2
     - --router-mode
3
     - kv  # Enable KV-cache routing

Worker Specialization

1
   args:
2
     - --disaggregation-mode
3
     - prefill  # For disaggregated prefill workers

Image Pull Secret Configuration

Automatic Discovery and Injection

By default, the Dynamo operator automatically discovers and injects image pull secrets based on container registry host matching. The operator scans Docker config secrets within the same namespace and matches their registry hostnames to the container image URLs, automatically injecting the appropriate secrets into the pod’s imagePullSecrets.

Disabling Automatic Discovery: To disable this behavior for a component and manually control image pull secrets:

1
    YourWorker:
2
      dynamoNamespace: your-namespace
3
      componentType: worker
4
      annotations:
5
        nvidia.com/disable-image-pull-secret-discovery: "true"

When disabled, you can manually specify secrets as you would for a normal pod spec via:

1
    YourWorker:
2
      dynamoNamespace: your-namespace
3
      componentType: worker
4
      annotations:
5
        nvidia.com/disable-image-pull-secret-discovery: "true"
6
      extraPodSpec:
7
        imagePullSecrets:
8
          - name: my-registry-secret
9
          - name: another-secret
10
        mainContainer:
11
          image: your-image

This automatic discovery eliminates the need to manually configure image pull secrets for each deployment.

Step 6: Deploy LoRA Adapters (Optional)

After your base model deployment is running, you can deploy LoRA adapters using the DynamoModel custom resource. This allows you to fine-tune and extend your models without modifying the base deployment.

To add a LoRA adapter to your deployment, link it using modelRef in your worker configuration:

1
apiVersion: nvidia.com/v1alpha1
2
kind: DynamoGraphDeployment
3
metadata:
4
  name: my-deployment
5
spec:
6
  services:
7
    Worker:
8
      modelRef:
9
        name: Qwen/Qwen3-0.6B  # Base model identifier
10
      componentType: worker
11
      # ... rest of worker config

Then create a DynamoModel resource for your LoRA:

1
apiVersion: nvidia.com/v1alpha1
2
kind: DynamoModel
3
metadata:
4
  name: my-lora
5
spec:
6
  modelName: my-custom-lora
7
  baseModelName: Qwen/Qwen3-0.6B  # Must match modelRef.name above
8
  modelType: lora
9
  source:
10
    uri: s3://my-bucket/loras/my-lora

For complete details on managing models and LoRA adapters, see: 📖 Managing Models with DynamoModel Guide