> For the complete documentation index, see [llms.txt](https://databricks-kube-operator.gitbook.io/doc/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://databricks-kube-operator.gitbook.io/doc/databricks-rust-jobs/docs/runtask.md).

# RunTask

## Properties

| Name                      | Type                                                                                                                                                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Notes       |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
| **run\_id**               | Option<**i64**>                                                                                                                                                                                                            | The ID of the task run.                                                                                                                                                                                                                                                                                                                                                                                                                                                              | \[optional] |
| **task\_key**             | Option<**String**>                                                                                                                                                                                                         | A unique name for the task. This field is used to refer to this task from other tasks. This field is required and must be unique within its parent job. On Update or Reset, this field is used to reference the tasks to be updated or reset. The maximum length is 100 characters.                                                                                                                                                                                                  | \[optional] |
| **description**           | Option<**String**>                                                                                                                                                                                                         | An optional description for this task. The maximum length is 4096 bytes.                                                                                                                                                                                                                                                                                                                                                                                                             | \[optional] |
| **state**                 | Option<[**crate::models::RunState**](/doc/databricks-rust-jobs/docs/runstate.md)>                                                                                                                                          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **depends\_on**           | Option<[**Vec**](https://github.com/mach-kernel/databricks-kube-operator/blob/master/databricks-rust-jobs/docs/TaskDependencies_inner.md)[**crate::models::TaskDependenciesInner**](crate::models::TaskDependenciesInner)> | An optional array of objects specifying the dependency graph of the task. All tasks specified in this field must complete successfully before executing this task. The key is `task_key`, and the value is the name assigned to the dependent task. This field is required when a job consists of more than one task.                                                                                                                                                                | \[optional] |
| **existing\_cluster\_id** | Option<**String**>                                                                                                                                                                                                         | If existing\_cluster\_id, the ID of an existing cluster that is used for all runs of this job. When running jobs on an existing cluster, you may need to manually restart the cluster if it stops responding. We suggest running jobs on new clusters for greater reliability.                                                                                                                                                                                                       | \[optional] |
| **new\_cluster**          | Option<[**crate::models::NewTaskCluster**](https://github.com/mach-kernel/databricks-kube-operator/blob/master/databricks-rust-jobs/docs/NewTaskCluster.md)>                                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **libraries**             | Option<[**Vec**](/doc/databricks-rust-jobs/docs/library.md)[**crate::models::Library**](crate::models::Library)>                                                                                                           | An optional list of libraries to be installed on the cluster that executes the job. The default value is an empty list.                                                                                                                                                                                                                                                                                                                                                              | \[optional] |
| **notebook\_task**        | Option<[**crate::models::NotebookTask**](/doc/databricks-rust-jobs/docs/notebooktask.md)>                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **spark\_jar\_task**      | Option<[**crate::models::SparkJarTask**](/doc/databricks-rust-jobs/docs/sparkjartask.md)>                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **spark\_python\_task**   | Option<[**crate::models::SparkPythonTask**](/doc/databricks-rust-jobs/docs/sparkpythontask.md)>                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **spark\_submit\_task**   | Option<[**crate::models::TaskSparkSubmitTask**](https://github.com/mach-kernel/databricks-kube-operator/blob/master/databricks-rust-jobs/docs/TaskSparkSubmitTask.md)>                                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **pipeline\_task**        | Option<[**crate::models::PipelineTask**](/doc/databricks-rust-jobs/docs/pipelinetask.md)>                                                                                                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **python\_wheel\_task**   | Option<[**crate::models::PythonWheelTask**](/doc/databricks-rust-jobs/docs/pythonwheeltask.md)>                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **sql\_task**             | Option<[**crate::models::SqlTask**](/doc/databricks-rust-jobs/docs/sqltask.md)>                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **dbt\_task**             | Option<[**crate::models::DbtTask**](/doc/databricks-rust-jobs/docs/dbttask.md)>                                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **start\_time**           | Option<**i64**>                                                                                                                                                                                                            | The time at which this run was started in epoch milliseconds (milliseconds since 1/1/1970 UTC). This may not be the time when the job task starts executing, for example, if the job is scheduled to run on a new cluster, this is the time the cluster creation call is issued.                                                                                                                                                                                                     | \[optional] |
| **setup\_duration**       | Option<**i64**>                                                                                                                                                                                                            | The time in milliseconds it took to set up the cluster. For runs that run on new clusters this is the cluster creation time, for runs that run on existing clusters this time should be very short. The duration of a task run is the sum of the `setup_duration`, `execution_duration`, and the `cleanup_duration`. The `setup_duration` field is set to 0 for multitask job runs. The total duration of a multitask job run is the value of the `run_duration` field.              | \[optional] |
| **execution\_duration**   | Option<**i64**>                                                                                                                                                                                                            | The time in milliseconds it took to execute the commands in the JAR or notebook until they completed, failed, timed out, were cancelled, or encountered an unexpected error.                                                                                                                                                                                                                                                                                                         | \[optional] |
| **cleanup\_duration**     | Option<**i64**>                                                                                                                                                                                                            | The time in milliseconds it took to terminate the cluster and clean up any associated artifacts. The total duration of the run is the sum of the setup\_duration, the execution\_duration, and the cleanup\_duration.                                                                                                                                                                                                                                                                | \[optional] |
| **end\_time**             | Option<**i64**>                                                                                                                                                                                                            | The time at which this run ended in epoch milliseconds (milliseconds since 1/1/1970 UTC). This field is set to 0 if the job is still running.                                                                                                                                                                                                                                                                                                                                        | \[optional] |
| **attempt\_number**       | Option<**i32**>                                                                                                                                                                                                            | The sequence number of this run attempt for a triggered job run. The initial attempt of a run has an attempt\_number of 0\\. If the initial run attempt fails, and the job has a retry policy (`max_retries` \\> 0), subsequent runs are created with an `original_attempt_run_id` of the original attempt’s ID and an incrementing `attempt_number`. Runs are retried only until they succeed, and the maximum `attempt_number` is the same as the `max_retries` value for the job. | \[optional] |
| **cluster\_instance**     | Option<[**crate::models::ClusterInstance**](/doc/databricks-rust-jobs/docs/clusterinstance.md)>                                                                                                                            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |
| **git\_source**           | Option<[**crate::models::GitSource**](/doc/databricks-rust-jobs/docs/gitsource.md)>                                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | \[optional] |

[\[Back to Model list\]](/doc/databricks-rust-jobs.md#documentation-for-models) [\[Back to API list\]](/doc/databricks-rust-jobs.md#documentation-for-api-endpoints) [\[Back to README\]](/doc/databricks-rust-jobs.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://databricks-kube-operator.gitbook.io/doc/databricks-rust-jobs/docs/runtask.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
