BatchTask

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://artifacts.apis.io/microsoft-azure-batch/json-schema/microsoft-azure-batch-batch-task-schema.json",
  "title": "BatchTask",
  "description": "Batch will retry Tasks when a recovery operation is triggered on a Node.\nExamples of recovery operations include (but are not limited to) when an\nunhealthy Node is rebooted or a Compute Node disappeared due to host failure.\nRetries due to recovery operations are independent of and are not counted\nagainst the maxTaskRetryCount. Even if the maxTaskRetryCount is 0, an internal\nretry due to a recovery operation may occur. Because of this, all Tasks should\nbe idempotent. This means Tasks need to tolerate being interrupted and\nrestarted without causing any corruption or duplicate data. The best practice\nfor long running Tasks is to use some form of checkpointing.",
  "x-generated": "2026-11-05",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/_superseded/microsoft-azure-batch-tasks-api-openapi.yml#/components/schemas/BatchTask",
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A string that uniquely identifies the Task within the Job. The ID can contain any combination of alphanumeric characters including hyphens and underscores, and cannot contain more than 64 characters.",
      "readOnly": true
    },
    "displayName": {
      "type": "string",
      "description": "A display name for the Task. The display name need not be unique and can contain any Unicode characters up to a maximum length of 1024.",
      "readOnly": true
    },
    "url": {
      "type": "string",
      "format": "uri",
      "description": "The URL of the Task.",
      "readOnly": true
    },
    "eTag": {
      "$ref": "#/$defs/Azure.Core.eTag",
      "description": "The ETag of the Task. This is an opaque string. You can use it to detect whether the Task has changed between requests. In particular, you can be pass the ETag when updating a Task to specify that your changes should take effect only if nobody else has modified the Task in the meantime.",
      "readOnly": true
    },
    "lastModified": {
      "type": "string",
      "format": "date-time",
      "description": "The last modified time of the Task.",
      "readOnly": true
    },
    "creationTime": {
      "type": "string",
      "format": "date-time",
      "description": "The creation time of the Task.",
      "readOnly": true
    },
    "exitConditions": {
      "$ref": "#/$defs/ExitConditions",
      "description": "How the Batch service should respond when the Task completes.",
      "readOnly": true
    },
    "state": {
      "$ref": "#/$defs/BatchTaskState",
      "description": "The current state of the Task.",
      "readOnly": true
    },
    "stateTransitionTime": {
      "type": "string",
      "format": "date-time",
      "description": "The time at which the Task entered its current state.",
      "readOnly": true
    },
    "previousState": {
      "$ref": "#/$defs/BatchTaskState",
      "description": "The previous state of the Task. This property is not set if the Task is in its initial Active state.",
      "readOnly": true
    },
    "previousStateTransitionTime": {
      "type": "string",
      "format": "date-time",
      "description": "The time at which the Task entered its previous state. This property is not set if the Task is in its initial Active state.",
      "readOnly": true
    },
    "commandLine": {
      "type": "string",
      "description": "The command line of the Task. For multi-instance Tasks, the command line is executed as the primary Task, after the primary Task and all subtasks have finished executing the coordination command line. The command line does not run under a shell, and therefore cannot take advantage of shell features such as environment variable expansion. If you want to take advantage of such features, you should invoke the shell in the command line, for example using \"cmd /c MyCommand\" in Windows or \"/bin/sh -c MyCommand\" in Linux. If the command line refers to file paths, it should use a relative path (relative to the Task working directory), or use the Batch provided environment variable (https://learn.microsoft.com/azure/batch/batch-compute-node-environment-variables).",
      "readOnly": true
    },
    "containerSettings": {
      "$ref": "#/$defs/BatchTaskContainerSettings",
      "description": "The settings for the container under which the Task runs. If the Pool that will run this Task has containerConfiguration set, this must be set as well. If the Pool that will run this Task doesn't have containerConfiguration set, this must not be set. When this is specified, all directories recursively below the AZ_BATCH_NODE_ROOT_DIR (the root of Azure Batch directories on the node) are mapped into the container, all Task environment variables are mapped into the container, and the Task command line is executed in the container. Files produced in the container outside of AZ_BATCH_NODE_ROOT_DIR might not be reflected to the host disk, meaning that Batch file APIs will not be able to access those files.",
      "readOnly": true
    },
    "resourceFiles": {
      "type": "array",
      "description": "A list of files that the Batch service will download to the Compute Node before running the command line. For multi-instance Tasks, the resource files will only be downloaded to the Compute Node on which the primary Task is executed. There is a maximum size for the list of resource files.  When the max size is exceeded, the request will fail and the response error code will be RequestEntityTooLarge. If this occurs, the collection of ResourceFiles must be reduced in size. This can be achieved using .zip files, Application Packages, or Docker Containers.",
      "items": {
        "$ref": "#/$defs/ResourceFile"
      },
      "readOnly": true
    },
    "outputFiles": {
      "type": "array",
      "description": "A list of files that the Batch service will upload from the Compute Node after running the command line. For multi-instance Tasks, the files will only be uploaded from the Compute Node on which the primary Task is executed.",
      "items": {
        "$ref": "#/$defs/OutputFile"
      },
      "readOnly": true
    },
    "environmentSettings": {
      "type": "array",
      "description": "A list of environment variable settings for the Task.",
      "items": {
        "$ref": "#/$defs/EnvironmentSetting"
      },
      "readOnly": true
    },
    "affinityInfo": {
      "$ref": "#/$defs/BatchAffinityInfo",
      "description": "A locality hint that can be used by the Batch service to select a Compute Node on which to start the new Task.",
      "readOnly": true
    },
    "constraints": {
      "$ref": "#/$defs/BatchTaskConstraints",
      "description": "The execution constraints that apply to this Task."
    },
    "requiredSlots": {
      "type": "integer",
      "format": "int32",
      "description": "The number of scheduling slots that the Task requires to run. The default is 1. A Task can only be scheduled to run on a compute node if the node has enough free scheduling slots available. For multi-instance Tasks, this must be 1.",
      "readOnly": true
    },
    "userIdentity": {
      "$ref": "#/$defs/UserIdentity",
      "description": "The user identity under which the Task runs. If omitted, the Task runs as a non-administrative user unique to the Task.",
      "readOnly": true
    },
    "executionInfo": {
      "$ref": "#/$defs/BatchTaskExecutionInfo",
      "description": "Information about the execution of the Task.",
      "readOnly": true
    },
    "nodeInfo": {
      "$ref": "#/$defs/BatchNodeInfo",
      "description": "Information about the Compute Node on which the Task ran.",
      "readOnly": true
    },
    "multiInstanceSettings": {
      "$ref": "#/$defs/MultiInstanceSettings",
      "description": "An object that indicates that the Task is a multi-instance Task, and contains information about how to run the multi-instance Task.",
      "readOnly": true
    },
    "stats": {
      "$ref": "#/$defs/BatchTaskStatistics",
      "description": "Resource usage statistics for the Task.",
      "readOnly": true,
      "x-ms-client-name": "taskStatistics"
    },
    "dependsOn": {
      "$ref": "#/$defs/BatchTaskDependencies",
      "description": "The Tasks that this Task depends on. This Task will not be scheduled until all Tasks that it depends on have completed successfully. If any of those Tasks fail and exhaust their retry counts, this Task will never be scheduled.",
      "readOnly": true
    },
    "applicationPackageReferences": {
      "type": "array",
      "description": "A list of Packages that the Batch service will deploy to the Compute Node before running the command line. Application packages are downloaded and deployed to a shared directory, not the Task working directory. Therefore, if a referenced package is already on the Node, and is up to date, then it is not re-downloaded; the existing copy on the Compute Node is used. If a referenced Package cannot be installed, for example because the package has been deleted or because download failed, the Task fails.",
      "items": {
        "$ref": "#/$defs/BatchApplicationPackageReference"
      },
      "readOnly": true
    }
  },
  "required": [
    "id",
    "url",
    "eTag",
    "lastModified",
    "creationTime",
    "state",
    "stateTransitionTime",
    "commandLine"
  ],
  "$defs": {
    "AutoUserScope": {
      "type": "string",
      "description": "AutoUserScope enums",
      "enum": [
        "task",
        "pool"
      ],
      "x-ms-enum": {
        "name": "AutoUserScope",
        "modelAsString": true,
        "values": [
          {
            "name": "Task",
            "value": "task",
            "description": "Specifies that the service should create a new user for the Task."
          },
          {
            "name": "Pool",
            "value": "pool",
            "description": "Specifies that the Task runs as the common auto user Account which is created on every Compute Node in a Pool."
          }
        ]
      }
    },
    "AutoUserSpecification": {
      "type": "object",
      "description": "Specifies the options for the auto user that runs an Azure Batch Task.",
      "properties": {
        "scope": {
          "$ref": "#/$defs/AutoUserScope",
          "description": "The scope for the auto user. The default value is pool. If the pool is running Windows a value of Task should be specified if stricter isolation between tasks is required. For example, if the task mutates the registry in a way which could impact other tasks."
        },
        "elevationLevel": {
          "$ref": "#/$defs/ElevationLevel",
          "description": "The elevation level of the auto user. The default value is nonAdmin."
        }
      }
    },
    "Azure.Core.eTag": {
      "type": "string",
      "description": "The ETag (or entity tag) HTTP response header is an identifier for a specific version of a resource.\nIt lets caches be more efficient and save bandwidth, as a web server does not need to resend a full response if the content was not changed.\n\nIt is a string of ASCII characters placed between double quotes, like \"675af34563dc-tr34\"."
    },
    "BatchAffinityInfo": {
      "type": "object",
      "description": "A locality hint that can be used by the Batch service to select a Compute Node\non which to start a Task.",
      "properties": {
        "affinityId": {
          "type": "string",
          "description": "An opaque string representing the location of a Compute Node or a Task that has run previously. You can pass the affinityId of a Node to indicate that this Task needs to run on that Compute Node. Note that this is just a soft affinity. If the target Compute Node is busy or unavailable at the time the Task is scheduled, then the Task will be scheduled elsewhere."
        }
      },
      "required": [
        "affinityId"
      ]
    },
    "BatchApplicationPackageReference": {
      "type": "object",
      "description": "A reference to an Package to be deployed to Compute Nodes.",
      "properties": {
        "applicationId": {
          "type": "string",
          "description": "The ID of the application to deploy. When creating a pool, the package's application ID must be fully qualified (/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/applications/{applicationName})."
        },
        "version": {
          "type": "string",
          "description": "The version of the application to deploy. If omitted, the default version is deployed. If this is omitted on a Pool, and no default version is specified for this application, the request fails with the error code InvalidApplicationPackageReferences and HTTP status code 409. If this is omitted on a Task, and no default version is specified for this application, the Task fails with a pre-processing error."
        }
      },
      "required": [
        "applicationId"
      ]
    },
    "BatchErrorSourceCategory": {
      "type": "string",
      "description": "BatchErrorSourceCategory enums",
      "enum": [
        "usererror",
        "servererror"
      ],
      "x-ms-enum": {
        "name": "BatchErrorSourceCategory",
        "modelAsString": true,
        "values": [
          {
            "name": "UserError",
            "value": "usererror",
            "description": "The error is due to a user issue, such as misconfiguration."
          },
          {
            "name": "ServerError",
            "value": "servererror",
            "description": "The error is due to an internal server issue."
          }
        ]
      }
    },
    "BatchJobActionKind": {
      "type": "string",
      "description": "BatchJobAction enums",
      "enum": [
        "none",
        "disable",
        "terminate"
      ],
      "x-ms-enum": {
        "name": "BatchJobActionKind",
        "modelAsString": true,
        "values": [
          {
            "name": "None",
            "value": "none",
            "description": "Take no action."
          },
          {
            "name": "Disable",
            "value": "disable",
            "description": "Disable the Job. This is equivalent to calling the disable Job API, with a disableTasks value of requeue."
          },
          {
            "name": "Terminate",
            "value": "terminate",
            "description": "Terminate the Job. The terminationReason in the Job's executionInfo is set to \"TaskFailed\"."
          }
        ]
      }
    },
    "BatchNodeIdentityReference": {
      "type": "object",
      "description": "The reference to a user assigned identity associated with the Batch pool which\na compute node will use.",
      "properties": {
        "resourceId": {
          "type": "string",
          "format": "arm-id",
          "description": "The ARM resource id of the user assigned identity."
        }
      }
    },
    "BatchNodeInfo": {
      "type": "object",
      "description": "Information about the Compute Node on which a Task ran.",
      "properties": {
        "affinityId": {
          "type": "string",
          "description": "An identifier for the Node on which the Task ran, which can be passed when adding a Task to request that the Task be scheduled on this Compute Node."
        },
        "nodeUrl": {
          "type": "string",
          "format": "uri",
          "description": "The URL of the Compute Node on which the Task ran."
        },
        "poolId": {
          "type": "string",
          "description": "The ID of the Pool on which the Task ran."
        },
        "nodeId": {
          "type": "string",
          "description": "The ID of the Compute Node on which the Task ran."
        },
        "taskRootDirectory": {
          "type": "string",
          "description": "The root directory of the Task on the Compute Node."
        },
        "taskRootDirectoryUrl": {
          "type": "string",
          "format": "uri",
          "description": "The URL to the root directory of the Task on the Compute Node."
        }
      }
    },
    "BatchTaskConstraints": {
      "type": "object",
      "description": "Execution constraints to apply to a Task.",
      "properties": {
        "maxWallClockTime": {
          "type": "string",
          "format": "duration",
          "description": "The maximum elapsed time that the Task may run, measured from the time the Task starts. If the Task does not complete within the time limit, the Batch service terminates it. If this is not specified, there is no time limit on how long the Task may run. The time duration is specified in ISO 8601 format."
        },
        "retentionTime": {
          "type": "string",
          "format": "duration",
          "description": "The minimum time to retain the Task directory on the Compute Node where it ran, from the time it completes execution. After this time, the Batch service may delete the Task directory and all its contents. The default is 7 days, i.e. the Task directory will be retained for 7 days unless the Compute Node is removed or the Job is deleted. The time duration is specified in ISO 8601 format."
        },
        "maxTaskRetryCount": {
          "type": "integer",
          "format": "int32",
          "description": "The maximum number of times the Task may be retried. The Batch service retries a Task if its exit code is nonzero. Note that this value specifically controls the number of retries for the Task executable due to a nonzero exit code. The Batch service will try the Task once, and may then retry up to this limit. For example, if the maximum retry count is 3, Batch tries the Task up to 4 times (one initial try and 3 retries). If the maximum retry count is 0, the Batch service does not retry the Task after the first attempt. If the maximum retry count is -1, the Batch service retries the Task without limit, however this is not recommended for a start task or any task. The default value is 0 (no retries)."
        }
      }
    },
    "BatchTaskContainerExecutionInfo": {
      "type": "object",
      "description": "Contains information about the container which a Task is executing.",
      "properties": {
        "containerId": {
          "type": "string",
          "description": "The ID of the container."
        },
        "state": {
          "type": "string",
          "description": "The state of the container. This is the state of the container according to the Docker service. It is equivalent to the status field returned by \"docker inspect\"."
        },
        "error": {
          "type": "string",
          "description": "Detailed error information about the container. This is the detailed error string from the Docker service, if available. It is equivalent to the error field returned by \"docker inspect\"."
        }
      }
    },
    "BatchTaskContainerSettings": {
      "type": "object",
      "description": "The container settings for a Task.",
      "properties": {
        "containerRunOptions": {
          "type": "string",
          "description": "Additional options to the container create command. These additional options are supplied as arguments to the \"docker create\" command, in addition to those controlled by the Batch Service."
        },
        "imageName": {
          "type": "string",
          "description": "The Image to use to create the container in which the Task will run. This is the full Image reference, as would be specified to \"docker pull\". If no tag is provided as part of the Image name, the tag \":latest\" is used as a default."
        },
        "registry": {
          "$ref": "#/$defs/ContainerRegistryReference",
          "description": "The private registry which contains the container Image. This setting can be omitted if was already provided at Pool creation."
        },
        "workingDirectory": {
          "$ref": "#/$defs/ContainerWorkingDirectory",
          "description": "The location of the container Task working directory. The default is 'taskWorkingDirectory'."
        },
        "containerHostBatchBindMounts": {
          "type": "array",
          "description": "The paths you want to mounted to container task. If this array is null or be not present, container task will mount entire temporary disk drive in windows (or AZ_BATCH_NODE_ROOT_DIR in Linux). It won't' mount any data paths into container if this array is set as empty.",
          "items": {
            "$ref": "#/$defs/ContainerHostBatchBindMountEntry"
          }
        }
      },
      "required": [
        "imageName"
      ]
    },
    "BatchTaskDependencies": {
      "type": "object",
      "description": "Specifies any dependencies of a Task. Any Task that is explicitly specified or\nwithin a dependency range must complete before the dependant Task will be\nscheduled.",
      "properties": {
        "taskIds": {
          "type": "array",
          "description": "The list of Task IDs that this Task depends on. All Tasks in this list must complete successfully before the dependent Task can be scheduled. The taskIds collection is limited to 64000 characters total (i.e. the combined length of all Task IDs). If the taskIds collection exceeds the maximum length, the Add Task request fails with error code TaskDependencyListTooLong. In this case consider using Task ID ranges instead.",
          "items": {
            "type": "string"
          }
        },
        "taskIdRanges": {
          "type": "array",
          "description": "The list of Task ID ranges that this Task depends on. All Tasks in all ranges must complete successfully before the dependent Task can be scheduled.",
          "items": {
            "$ref": "#/$defs/BatchTaskIdRange"
          }
        }
      }
    },
    "BatchTaskExecutionInfo": {
      "type": "object",
      "description": "Information about the execution of a Task.",
      "properties": {
        "startTime": {
          "type": "string",
          "format": "date-time",
          "description": "The time at which the Task started running. 'Running' corresponds to the running state, so if the Task specifies resource files or Packages, then the start time reflects the time at which the Task started downloading or deploying these. If the Task has been restarted or retried, this is the most recent time at which the Task started running. This property is present only for Tasks that are in the running or completed state."
        },
        "endTime": {
          "type": "string",
          "format": "date-time",
          "description": "The time at which the Task completed. This property is set only if the Task is in the Completed state."
        },
        "exitCode": {
          "type": "integer",
          "format": "int32",
          "description": "The exit code of the program specified on the Task command line. This property is set only if the Task is in the completed state. In general, the exit code for a process reflects the specific convention implemented by the application developer for that process. If you use the exit code value to make decisions in your code, be sure that you know the exit code convention used by the application process. However, if the Batch service terminates the Task (due to timeout, or user termination via the API) you may see an operating system-defined exit code."
        },
        "containerInfo": {
          "$ref": "#/$defs/BatchTaskContainerExecutionInfo",
          "description": "Information about the container under which the Task is executing. This property is set only if the Task runs in a container context."
        },
        "failureInfo": {
          "$ref": "#/$defs/BatchTaskFailureInfo",
          "description": "Information describing the Task failure, if any. This property is set only if the Task is in the completed state and encountered a failure."
        },
        "retryCount": {
          "type": "integer",
          "format": "int32",
          "description": "The number of times the Task has been retried by the Batch service. Task application failures (non-zero exit code) are retried, pre-processing errors (the Task could not be run) and file upload errors are not retried. The Batch service will retry the Task up to the limit specified by the constraints."
        },
        "lastRetryTime": {
          "type": "string",
          "format": "date-time",
          "description": "The most recent time at which a retry of the Task started running. This element is present only if the Task was retried (i.e. retryCount is nonzero). If present, this is typically the same as startTime, but may be different if the Task has been restarted for reasons other than retry; for example, if the Compute Node was rebooted during a retry, then the startTime is updated but the lastRetryTime is not."
        },
        "requeueCount": {
          "type": "integer",
          "format": "int32",
          "description": "The number of times the Task has been requeued by the Batch service as the result of a user request. When the user removes Compute Nodes from a Pool (by resizing/shrinking the pool) or when the Job is being disabled, the user can specify that running Tasks on the Compute Nodes be requeued for execution. This count tracks how many times the Task has been requeued for these reasons."
        },
        "lastRequeueTime": {
          "type": "string",
          "format": "date-time",
          "description": "The most recent time at which the Task has been requeued by the Batch service as the result of a user request. This property is set only if the requeueCount is nonzero."
        },
        "result": {
          "$ref": "#/$defs/BatchTaskExecutionResult",
          "description": "The result of the Task execution. If the value is 'failed', then the details of the failure can be found in the failureInfo property."
        }
      },
      "required": [
        "retryCount",
        "requeueCount"
      ]
    },
    "BatchTaskExecutionResult": {
      "type": "string",
      "description": "BatchTaskExecutionResult enums",
      "enum": [
        "success",
        "failure"
      ],
      "x-ms-enum": {
        "name": "BatchTaskExecutionResult",
        "modelAsString": true,
        "values": [
          {
            "name": "Success",
            "value": "success",
            "description": "The Task ran successfully."
          },
          {
            "name": "Failure",
            "value": "failure",
            "description": "There was an error during processing of the Task. The failure may have occurred before the Task process was launched, while the Task process was executing, or after the Task process exited."
          }
        ]
      }
    },
    "BatchTaskFailureInfo": {
      "type": "object",
      "description": "Information about a Task failure.",
      "properties": {
        "category": {
          "$ref": "#/$defs/BatchErrorSourceCategory",
          "description": "The category of the Task error."
        },
        "code": {
          "type": "string",
          "description": "An identifier for the Task error. Codes are invariant and are intended to be consumed programmatically."
        },
        "message": {
          "type": "string",
          "description": "A message describing the Task error, intended to be suitable for display in a user interface."
        },
        "details": {
          "type": "array",
          "description": "A list of additional details related to the error.",
          "items": {
            "$ref": "#/$defs/NameValuePair"
          }
        }
      },
      "required": [
        "category"
      ]
    },
    "BatchTaskIdRange": {
      "type": "object",
      "description": "The start and end of the range are inclusive. For example, if a range has start\n9 and end 12, then it represents Tasks '9', '10', '11' and '12'.",
      "properties": {
        "start": {
          "type": "integer",
          "format": "int32",
          "description": "The first Task ID in the range."
        },
        "end": {
          "type": "integer",
          "format": "int32",
          "description": "The last Task ID in the range."
        }
      },
      "required": [
        "start",
        "end"
      ]
    },
    "BatchTaskState": {
      "type": "string",
      "description": "BatchTaskState enums",
      "enum": [
        "active",
        "preparing",
        "running",
        "completed"
      ],
      "x-ms-enum": {
        "name": "BatchTaskState",
        "modelAsString": true,
        "values": [
          {
            "name": "Active",
            "value": "active",
            "description": "The Task is queued and able to run, but is not currently assigned to a Compute Node. A Task enters this state when it is created, when it is enabled after being disabled, or when it is awaiting a retry after a failed run."
          },
          {
            "name": "Preparing",
            "value": "preparing",
            "description": "The Task has been assigned to a Compute Node, but is waiting for a required Job Preparation Task to complete on the Compute Node. If the Job Preparation Task succeeds, the Task will move to running. If the Job Preparation Task fails, the Task will return to active and will be eligible to be assigned to a different Compute Node."
          },
          {
            "name": "Running",
            "value": "running",
            "description": "The Task is running on a Compute Node. This includes task-level preparation such as downloading resource files or deploying Packages specified on the Task - it does not necessarily mean that the Task command line has started executing."
          },
          {
            "name": "Completed",
            "value": "completed",
            "description": "The Task is no longer eligible to run, usually because the Task has finished successfully, or the Task has finished unsuccessfully and has exhausted its retry limit. A Task is also marked as completed if an error occurred launching the Task, or when the Task has been terminated."
          }
        ]
      }
    },
    "BatchTaskStatistics": {
      "type": "object",
      "description": "Resource usage statistics for a Task.",
      "properties": {
        "url": {
          "type": "string",
          "format": "uri",
          "description": "The URL of the statistics."
        },
        "startTime": {
          "type": "string",
          "format": "date-time",
          "description": "The start time of the time range covered by the statistics."
        },
        "lastUpdateTime": {
          "type": "string",
          "format": "date-time",
          "description": "The time at which the statistics were last updated. All statistics are limited to the range between startTime and lastUpdateTime."
        },
        "userCPUTime": {
          "type": "string",
          "format": "duration",
          "description": "The total user mode CPU time (summed across all cores and all Compute Nodes) consumed by the Task. The time duration is specified in ISO 8601 format.",
          "x-ms-client-name": "userCpuTime"
        },
        "kernelCPUTime": {
          "type": "string",
          "format": "duration",
          "description": "The total kernel mode CPU time (summed across all cores and all Compute Nodes) consumed by the Task. The time duration is specified in ISO 8601 format.",
          "x-ms-client-name": "kernelCpuTime"
        },
        "wallClockTime": {
          "type": "string",
          "format": "duration",
          "description": "The total wall clock time of the Task. The wall clock time is the elapsed time from when the Task started running on a Compute Node to when it finished (or to the last time the statistics were updated, if the Task had not finished by then). If the Task was retried, this includes the wall clock time of all the Task retries. The time duration is specified in ISO 8601 format."
        },
        "readIOps": {
          "type": "string",
          "format": "int64",
          "description": "The total number of disk read operations made by the Task.",
          "x-ms-client-name": "readIops"
        },
        "writeIOps": {
          "type": "string",
          "format": "int64",
          "description": "The total number of disk write operations made by the Task.",
          "x-ms-client-name": "writeIops"
        },
        "readIOGiB": {
          "type": "number",
          "format": "float",
          "descriptio

# --- truncated at 32 KB (55 KB total) ---
# Full source: https://artifacts.apis.io/microsoft-azure-batch/json-schema/microsoft-azure-batch-batch-task-schema.json