Microsoft.Batch (stable:2024-07-01)

2025/08/27 • 6 updated methods

Pool_ListByBatchAccount (updated)
Description Lists all of the pools in the specified account.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_ListByBatchAccount",
  "$responses": {
    "200": {
      "$properties": {
        "value": {
          "$properties": {
            "properties": [
              {
                "scaleSettings": [
                  {
                    "fixedScale": [
                      {
                        "#name": "nodeDeallocationOption",
                        "Enum": {
                          "new": [
                            [
                              "Requeue",
                              "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                            ],
                            [
                              "Terminate",
                              "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                            ],
                            [
                              "TaskCompletion",
                              "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                            ],
                            [
                              "RetainedData",
                              "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                            ]
                          ],
                          "old": [
                            [
                              "Requeue",
                              "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                            ],
                            [
                              "Terminate",
                              "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                            ],
                            [
                              "TaskCompletion",
                              "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                            ],
                            [
                              "RetainedData",
                              "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                            ]
                          ]
                        }
                      }
                    ]
                  }
                ]
              },
              {
                "resizeOperationStatus": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          }
        }
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools
{
resourceGroupName: string ,
accountName: string ,
maxresults: integer ,
$select: string ,
$filter: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
value:
[
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
]
,
nextLink: string ,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}
Pool_Create (updated)
Description Creates a new pool inside the specified account.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_Create",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  },
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

PUT:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}
{
resourceGroupName: string ,
accountName: string ,
poolName: string ,
parameters:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
If-Match: string ,
If-None-Match: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
$headers:
{
etag: string ,
}
,
$schema:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}
Pool_Update (updated)
Description Updates the properties of an existing pool.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_Update",
  "$parameters": {
    "parameters": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  },
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

PATCH:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}
{
resourceGroupName: string ,
accountName: string ,
poolName: string ,
parameters:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
If-Match: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
$headers:
{
etag: string ,
}
,
$schema:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}
Pool_Get (updated)
Description Gets information about the specified pool.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_Get",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

GET:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}
{
resourceGroupName: string ,
accountName: string ,
poolName: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
$headers:
{
etag: string ,
}
,
$schema:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}
Pool_DisableAutoScale (updated)
Description Disables automatic scaling for a pool.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_DisableAutoScale",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

POST:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}/disableAutoScale
{
resourceGroupName: string ,
accountName: string ,
poolName: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
$headers:
{
etag: string ,
}
,
$schema:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}
Pool_StopResize (updated)
Description This does not restore the pool to its previous state before the resize operation: it only stops any further changes being made, and the pool maintains its current state. After stopping, the pool stabilizes at the number of nodes it was at when the stop operation was done. During the stop operation, the pool allocation state changes first to stopping and then to steady. A resize operation need not be an explicit resize pool request; this API can also be used to halt the initial sizing of the pool when it is created.
Reference Link ¶

⚶ Changes

{
  "#id": "Pool_StopResize",
  "$responses": {
    "200": {
      "$properties": {
        "properties": [
          {
            "scaleSettings": [
              {
                "fixedScale": [
                  {
                    "#name": "nodeDeallocationOption",
                    "Enum": {
                      "new": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ],
                      "old": [
                        [
                          "Requeue",
                          "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "Terminate",
                          "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                        ],
                        [
                          "TaskCompletion",
                          "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                        ],
                        [
                          "RetainedData",
                          "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                        ]
                      ]
                    }
                  }
                ]
              }
            ]
          },
          {
            "resizeOperationStatus": [
              {
                "#name": "nodeDeallocationOption",
                "Enum": {
                  "new": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Deprecated, we encourage you to upload task data to Azure Storage in your task and use `TaskCompletion` instead. Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ],
                  "old": [
                    [
                      "Requeue",
                      "Terminate running task processes and requeue the tasks. The tasks will run again when a node is available. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "Terminate",
                      "Terminate running tasks. The tasks will be completed with failureInfo indicating that they were terminated, and will not run again. Remove nodes as soon as tasks have been terminated."
                    ],
                    [
                      "TaskCompletion",
                      "Allow currently running tasks to complete. Schedule no new tasks while waiting. Remove nodes when all tasks have completed."
                    ],
                    [
                      "RetainedData",
                      "Allow currently running tasks to complete, then wait for all task data retention periods to expire. Schedule no new tasks while waiting. Remove nodes when all task retention periods have expired."
                    ]
                  ]
                }
              }
            ]
          }
        ]
      }
    }
  }
}

⚼ Request

POST:  /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Batch/batchAccounts/{accountName}/pools/{poolName}/stopResize
{
resourceGroupName: string ,
accountName: string ,
poolName: string ,
api-version: string ,
subscriptionId: string ,
}

⚐ Response (200)

{
$headers:
{
etag: string ,
}
,
$schema:
{
properties:
{
displayName: string ,
lastModified: string ,
creationTime: string ,
provisioningState: enum ,
provisioningStateTransitionTime: string ,
allocationState: enum ,
allocationStateTransitionTime: string ,
vmSize: string ,
deploymentConfiguration:
{
virtualMachineConfiguration:
{
imageReference:
{
publisher: string ,
offer: string ,
sku: string ,
version: string ,
id: string ,
sharedGalleryImageId: string ,
communityGalleryImageId: string ,
}
,
nodeAgentSkuId: string ,
windowsConfiguration:
{
enableAutomaticUpdates: boolean ,
}
,
dataDisks:
[
{
lun: integer ,
caching: enum ,
diskSizeGB: integer ,
storageAccountType: enum ,
}
,
]
,
licenseType: string ,
containerConfiguration:
{
type: enum ,
containerImageNames:
[
string ,
]
,
containerRegistries:
[
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
}
,
diskEncryptionConfiguration:
{
targets:
[
string ,
]
,
}
,
nodePlacementConfiguration:
{
policy: enum ,
}
,
extensions:
[
{
name: string ,
publisher: string ,
type: string ,
typeHandlerVersion: string ,
autoUpgradeMinorVersion: boolean ,
enableAutomaticUpgrade: boolean ,
settings: object ,
protectedSettings: object ,
provisionAfterExtensions:
[
string ,
]
,
}
,
]
,
osDisk:
{
ephemeralOSDiskSettings:
{
placement: enum ,
}
,
caching: enum ,
managedDisk:
{
storageAccountType: enum ,
securityProfile:
{
securityEncryptionType: enum ,
}
,
}
,
diskSizeGB: integer ,
writeAcceleratorEnabled: boolean ,
}
,
securityProfile:
{
securityType: enum ,
encryptionAtHost: boolean ,
uefiSettings:
{
secureBootEnabled: boolean ,
vTpmEnabled: boolean ,
}
,
}
,
serviceArtifactReference:
{
id: string ,
}
,
}
,
}
,
currentDedicatedNodes: integer ,
currentLowPriorityNodes: integer ,
scaleSettings:
{
fixedScale:
{
resizeTimeout: string ,
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
nodeDeallocationOption: enum ,
}
,
autoScale:
{
formula: string ,
evaluationInterval: string ,
}
,
}
,
autoScaleRun:
{
evaluationTime: string ,
results: string ,
error:
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
}
,
interNodeCommunication: enum ,
networkConfiguration:
{
subnetId: string ,
dynamicVnetAssignmentScope: enum ,
endpointConfiguration:
{
inboundNatPools:
[
{
name: string ,
protocol: enum ,
backendPort: integer ,
frontendPortRangeStart: integer ,
frontendPortRangeEnd: integer ,
networkSecurityGroupRules:
[
{
priority: integer ,
access: enum ,
sourceAddressPrefix: string ,
sourcePortRanges:
[
string ,
]
,
}
,
]
,
}
,
]
,
}
,
publicIPAddressConfiguration:
{
provision: enum ,
ipAddressIds:
[
string ,
]
,
}
,
enableAcceleratedNetworking: boolean ,
}
,
taskSlotsPerNode: integer ,
taskSchedulingPolicy:
{
nodeFillType: enum ,
}
,
userAccounts:
[
{
name: string ,
password: string ,
elevationLevel: enum ,
linuxUserConfiguration:
{
uid: integer ,
gid: integer ,
sshPrivateKey: string ,
}
,
windowsUserConfiguration:
{
loginMode: enum ,
}
,
}
,
]
,
metadata:
[
{
name: string ,
value: string ,
}
,
]
,
startTask:
{
commandLine: string ,
resourceFiles:
[
{
autoStorageContainerName: string ,
storageContainerUrl: string ,
httpUrl: string ,
blobPrefix: string ,
filePath: string ,
fileMode: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
]
,
environmentSettings:
[
{
name: string ,
value: string ,
}
,
]
,
userIdentity:
{
userName: string ,
autoUser:
{
scope: enum ,
elevationLevel: enum ,
}
,
}
,
maxTaskRetryCount: integer ,
waitForSuccess: boolean ,
containerSettings:
{
containerRunOptions: string ,
imageName: string ,
registry:
{
username: string ,
password: string ,
registryServer: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
workingDirectory: enum ,
containerHostBatchBindMounts:
[
{
source: enum ,
isReadOnly: boolean ,
}
,
]
,
}
,
}
,
certificates:
[
{
id: string ,
storeLocation: enum ,
storeName: string ,
visibility:
[
string ,
]
,
}
,
]
,
applicationPackages:
[
{
id: string ,
version: string ,
}
,
]
,
applicationLicenses:
[
string ,
]
,
resizeOperationStatus:
{
targetDedicatedNodes: integer ,
targetLowPriorityNodes: integer ,
resizeTimeout: string ,
nodeDeallocationOption: enum ,
startTime: string ,
errors:
[
{
code: string ,
message: string ,
details:
[
string ,
]
,
}
,
]
,
}
,
mountConfiguration:
[
{
azureBlobFileSystemConfiguration:
{
accountName: string ,
containerName: string ,
accountKey: string ,
sasKey: string ,
blobfuseOptions: string ,
relativeMountPath: string ,
identityReference:
{
resourceId: string ,
}
,
}
,
nfsMountConfiguration:
{
source: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
cifsMountConfiguration:
{
userName: string ,
source: string ,
relativeMountPath: string ,
mountOptions: string ,
password: string ,
}
,
azureFileShareConfiguration:
{
accountName: string ,
azureFileUrl: string ,
accountKey: string ,
relativeMountPath: string ,
mountOptions: string ,
}
,
}
,
]
,
targetNodeCommunicationMode: enum ,
currentNodeCommunicationMode: enum ,
upgradePolicy:
{
mode: enum ,
automaticOSUpgradePolicy:
{
disableAutomaticRollback: boolean ,
enableAutomaticOSUpgrade: boolean ,
useRollingUpgradePolicy: boolean ,
osRollingUpgradeDeferral: boolean ,
}
,
rollingUpgradePolicy:
{
enableCrossZoneUpgrade: boolean ,
maxBatchInstancePercent: integer ,
maxUnhealthyInstancePercent: integer ,
maxUnhealthyUpgradedInstancePercent: integer ,
pauseTimeBetweenBatches: string ,
prioritizeUnhealthyInstances: boolean ,
rollbackFailedInstancesOnPolicyBreach: boolean ,
}
,
}
,
resourceTags: object ,
}
,
identity:
{
type: enum ,
userAssignedIdentities: object ,
}
,
}
,
}

⚐ Response (default)

{
error:
{
code: string ,
message: string ,
target: string ,
details:
[
string ,
]
,
}
,
}