# dr run
URL: https://docs.datarobot.com/en/docs/agentic-ai/cli/commands/run.html

> Execute tasks defined in application templates.

# dr run

Execute tasks defined in application templates.

## Synopsis

The `dr run` command executes tasks defined in Taskfiles within DataRobot application templates. It automatically discovers component Taskfiles and aggregates them into a unified task execution environment.

```
dr run [TASK_NAME...] [flags]
```

## Description

The `run` command provides a convenient way to execute common application tasks such as starting development servers, running tests, building containers, and deploying applications. It works by discovering Taskfiles in your template directory and generating a consolidated task runner configuration.

Key features:

- Automatic discovery —finds and aggregates Taskfiles from template components.
- Template validation —verifies you're in a DataRobot template directory.
- Conflict detection —prevents dotenv directive conflicts in nested Taskfiles.
- Parallel execution —run multiple tasks simultaneously.
- Watch mode —automatically re-run tasks when files change.

## Template requirements

To use `dr run`, your directory must meet these requirements:

1. Contains a .env file —indicates you're in a DataRobot template directory.
2. Contains Taskfiles —component directories with Taskfile.yaml or Taskfile.yml files.
3. No dotenv conflicts —component Taskfiles cannot have their own dotenv directives.

If these requirements aren't met, the command provides clear error messages explaining the issue.

## Options

```
  -l, --list              List all available tasks
  -d, --dir string        Directory to look for tasks (default ".")
  -p, --parallel          Run tasks in parallel
  -C, --concurrency int   Number of concurrent tasks to run (default 2)
  -w, --watch             Enable watch mode for the given task
  -y, --yes               Assume "yes" as answer to all prompts
  -x, --exit-code         Pass-through the exit code of the task command
  -s, --silent            Disable echoing
  -h, --help              Help for run
```

## Global options

```
  -v, --verbose    Enable verbose output
      --debug      Enable debug output
```

## Examples

### List available tasks

```
dr run --list
```

Output:

```
Available tasks:
* dev        Start development server
* test       Run tests
* lint       Run linters
* build      Build Docker container
* deploy     Deploy to DataRobot
```

### Run a single task

```
dr run dev
```

Starts the development server defined in your template's Taskfile.

### Run multiple tasks sequentially

```
dr run lint test
```

Runs the lint task, then the test task in sequence.

### Run multiple tasks in parallel

```
dr run lint test --parallel
```

Runs lint and test tasks simultaneously.

### Run with watch mode

```
dr run dev --watch
```

Runs the development server and automatically restarts it when source files change.

### Control concurrency

```
dr run task1 task2 task3 --parallel --concurrency 3
```

Runs up to 3 tasks concurrently.

### Silent execution

```
dr run build --silent
```

Runs the build task without echoing commands.

### Pass-through exit codes

```
dr run test --exit-code
```

Exits with the same code as the task command (useful in CI/CD).

## Task discovery

The `dr run` command discovers tasks in this order:

1. Check for .env file —verifies you're in a template directory.
2. Scan for Taskfiles —finds Taskfile.yaml or Taskfile.yml files up to 2 levels deep.
3. Validate dotenv directives —ensures component Taskfiles don't have conflicting dotenv declarations.
4. Generate Taskfile.gen.yaml —creates a unified task configuration.
5. Execute tasks —runs the requested tasks using the task binary.

### Directory structure

```
my-template/
├── .env                          # Required: template marker
├── Taskfile.gen.yaml            # Generated: consolidated tasks
├── backend/
│   ├── Taskfile.yaml            # Component tasks (no dotenv)
│   └── src/
└── frontend/
    ├── Taskfile.yaml            # Component tasks (no dotenv)
    └── src/
```

### Generated Taskfile

The CLI generates `Taskfile.gen.yaml` with this structure:

```
version: '3'

dotenv: [".env"]

includes:
  backend:
    taskfile: ./backend/Taskfile.yaml
    dir: ./backend
  frontend:
    taskfile: ./frontend/Taskfile.yaml
    dir: ./frontend
```

This allows you to run component tasks with prefixes:

```
dr run backend:build
dr run frontend:dev
```

## Error handling

### Not in a template directory

If you run `dr run` outside a DataRobot template:

```
You don't seem to be in a DataRobot Template directory.
This command requires a .env file to be present.
```

Solution: Navigate to a template directory or run `dr templates setup` to create one.

### Dotenv directive conflict

If a component Taskfile has its own `dotenv` directive:

```
Error: Cannot generate Taskfile because an existing Taskfile already has a dotenv directive.
existing Taskfile already has dotenv directive: backend/Taskfile.yaml
```

Solution: Remove the `dotenv` directive from component Taskfiles. The generated `Taskfile.gen.yaml` handles environment variables.

### Task binary not found

If the `task` binary isn't installed:

```
"task" binary not found in PATH. Please install Task from https://taskfile.dev/installation/
```

Solution: Install Task following the instructions at [taskfile.dev/installation](https://taskfile.dev/installation/).

### No tasks found

If no Taskfiles exist in component directories:

```
file does not exist
Error: failed to list tasks: exit status 1
```

Solution: Add Taskfiles to your template components or use `dr templates clone` to start with a pre-configured template.

## Task definitions

Tasks are defined in component `Taskfile.yaml` files using Task's syntax.

### Basic task

```
version: '3'

tasks:
  dev:
    desc: Start development server
    cmds:
      - python -m uvicorn src.app.main:app --reload
```

### Task with dependencies

```
tasks:
  build:
    desc: Build Docker container
    cmds:
      - docker build -t {{.APP_NAME}} .

  deploy:
    desc: Deploy application
    deps: [build]
    cmds:
      - docker push {{.APP_NAME}}
      - kubectl apply -f deploy.yaml
```

### Task with environment variables

```
tasks:
  test:
    desc: Run tests with coverage
    env:
      PYTEST_ARGS: "--cov=src --cov-report=html"
    cmds:
      - pytest {{.PYTEST_ARGS}}
```

### Task with preconditions

```
tasks:
  deploy:
    desc: Deploy to production
    preconditions:
      - sh: test -f .env
        msg: ".env file is required"
      - sh: test -n "$DATAROBOT_ENDPOINT"
        msg: "DATAROBOT_ENDPOINT must be set"
    cmds:
      - ./deploy.sh
```

## Best practices

### Descriptive task names

Use clear, action-oriented task names:

```
tasks:
  dev:           # ✅ Clear and concise
    desc: Start development server

  test:unit:     # ✅ Namespaced for organization
    desc: Run unit tests

  lint:python:   # ✅ Specific and descriptive
    desc: Run Python linters
```

### Useful descriptions

Provide helpful task descriptions:

```
tasks:
  deploy:
    desc: Deploy application to DataRobot (requires authentication)
    cmds:
      - ./deploy.sh
```

### Common task names

Use standard names for common operations:

- dev —start development server.
- build —build application or container.
- test —run test suite.
- lint —run linters and formatters.
- deploy —deploy to target environment.
- clean —clean build artifacts.

### Environment variable usage

Reference `.env` variables in tasks:

```
tasks:
  deploy:
    desc: Deploy {{.APP_NAME}} to {{.DEPLOYMENT_TARGET}}
    cmds:
      - echo "Deploying to $DATAROBOT_ENDPOINT"
      - ./deploy.sh
```

### Silent tasks

Use `silent: true` for tasks that don't need output:

```
tasks:
  check:version:
    desc: Check CLI version
    silent: true
    cmds:
      - dr version
```

## Integration with other commands

### With dr templates

```
# Clone and set up template
dr templates clone python-streamlit my-app
cd my-app

# Configure environment
dr dotenv setup

# Run tasks
dr run dev
```

### With dr dotenv

```
# Update environment variables
dr dotenv setup

# Run with updated configuration
dr run deploy
```

### In CI/CD pipelines

```
#!/bin/bash
# ci-pipeline.sh

set -e

# Run tests
dr run test --exit-code --silent

# Run linters
dr run lint --exit-code --silent

# Build
dr run build --silent
```

## Troubleshooting

### Tasks not found

Problem: `dr run --list` shows no tasks.

Causes: - No Taskfiles in component directories.
- Taskfiles at wrong depth (deeper than 2 levels).

Solution:

```
# Check for Taskfiles
find . -name "Taskfile.y*ml" -maxdepth 3

# Ensure Taskfiles are in component directories
# Correct: ./backend/Taskfile.yaml
# Wrong: ./backend/src/Taskfile.yaml
```

### Environment variables not loading

Problem: Tasks can't access environment variables.

Causes: - Missing `.env` file.
- Variables not exported.

Solution:

```
# Verify .env exists
ls -la .env

# Check variables are set
source .env
env | grep DATAROBOT
```

### Task execution fails

Problem: Task runs but fails with errors.

Solution:

```
# Enable verbose output
dr run task-name --verbose

# Enable debug output
dr run task-name --debug

# Check task definition
cat component/Taskfile.yaml
```

### Permission denied errors

Problem: Tasks fail with permission errors.

Solution:

```
# Make scripts executable
chmod +x scripts/*.sh

# Check file permissions
ls -l scripts/
```

## See also

- Template system overview —understanding templates.
- Task definitions —creating Taskfiles.
- Environment variables —managing configuration.
- dr dotenv —environment variable management.
- Task documentation —official Task runner docs.

---
