How do auto-scale formulas work?

Auto-scale formulas are evaluated every 15 minutes (configurable from 5 to 60 minutes) and return a target number of dedicated and/or low-priority nodes. Formulas can reference built-in variables like $PendingTasks (tasks waiting for a node), $RunningTasks, $ActiveTasks, and time-based functions. A common formula sets the target to the number of pending tasks divided by the tasks-per-node capacity: $TargetDedicatedNodes = min(maxNodes, $PendingTasks / tasksPerNode). You can combine multiple variables with conditional logic for sophisticated scaling behavior.

What is the difference between dedicated and low-priority nodes?

Dedicated nodes are allocated from Azure's regular capacity and are guaranteed to remain available for the lifetime of the pool. Low-priority nodes are provisioned from Azure's surplus capacity at up to 80% discount but can be preempted at any time when Azure needs the capacity back. When a low-priority node is preempted, running tasks are requeued. Use low-priority nodes for fault-tolerant, checkpointable workloads. Many batch workloads mix dedicated nodes (for steady baseline) with low-priority nodes (for burst capacity).

Azure Batch Pool Builder

ComputeAzure

Build Azure Batch pool configurations with auto-scale and container support.

Last verified: May 2026

Azure Batch Configuration

Build Azure Batch pool configs with auto-scale formulas, container support, and networking.

Required Fields

poolIdbatchAccountNamevmSizedeploymentConfigurationscaleSettings

{
  "poolId": "render-pool-linux",
  "batchAccountName": "batchcontosoprod",
  "resourceGroup": "rg-batch",
  "location": "eastus2",
  "vmSize": "Standard_HB120rs_v3",
  "deploymentConfiguration": {
    "virtualMachineConfiguration": {
      "imageReference": {
        "publisher": "microsoft-azure-batch",
        "offer": "ubuntu-server-container",
        "sku": "20-04-lts",
        "version": "latest"
      },
      "nodeAgentSkuId": "batch.node.ubuntu 20.04",
      "containerConfiguration": {
        "type": "DockerCompatible",
        "containerImageNames": [
          "myregistry.azurecr.io/render-engine:latest"
        ],
        "containerRegistries": [
          {
            "registryServer": "myregistry.azurecr.io",
            "identityReference": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-batch/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id-batch-acr"
          }
        ]
      }
    }
  },
  "scaleSettings": {
    "autoScale": {
      "evaluationInterval": "PT5M",
      "formula": "startingNumberOfVMs = 0; maxNumberOfVMs = 50; pendingTaskSamplePercent = $PendingTasks.GetSamplePercent(180 * TimeInterval_Second); pendingTaskSamples = pendingTaskSamplePercent < 70 ? startingNumberOfVMs : avg($PendingTasks.GetSample(180 * TimeInterval_Second)); $TargetDedicatedNodes = min(maxNumberOfVMs, pendingTaskSamples);"
    }
  },
  "taskSlotsPerNode": 4,
  "taskSchedulingPolicy": {
    "nodeFillType": "Pack"
  },
  "interNodeCommunication": "Enabled",
  "networkConfiguration": {
    "subnetId": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-networking/providers/Microsoft.Network/virtualNetworks/vnet-batch/subnets/snet-pool",
    "publicIPAddressConfiguration": {
      "provision": "NoPublicIPAddresses"
    }
  },
  "startTask": {
    "commandLine": "/bin/bash -c 'apt-get update && apt-get install -y libgl1-mesa-glx'",
    "waitForSuccess": true,
    "userIdentity": {
      "autoUser": {
        "scope": "Pool",
        "elevationLevel": "Admin"
      }
    },
    "maxTaskRetryCount": 2
  },
  "metadata": [
    { "name": "environment", "value": "production" },
    { "name": "workload", "value": "rendering" }
  ]
}

Generated Output

Output will appear here...

See It in Action

Your data team's nightly transcoding pipeline runs ~2,000 video processing tasks per hour for 3 hours. The builder generates an auto-scaling Batch pool: VM size Standard_F8s_v2, container support with pre-fetched ffmpeg image, auto-scale formula targeting $PendingTasks / 4 (each VM handles 4 tasks), max 200 nodes. Mix: 20% dedicated baseline + 80% low-priority. Pool scales to ~125 nodes during peak. Total nightly cost: ~$80 vs ~$300 if running fixed 200 dedicated nodes 24/7.

What This Tool Does

Azure Batch provides cloud-scale job scheduling and compute management, letting you run large-scale parallel and HPC workloads without managing infrastructure. A Batch pool defines the compute nodes — VM size, image, scaling mode (fixed or auto-scale), container support, start tasks, and networking configuration. Auto-scale formulas use a rich expression language to dynamically adjust pool size based on pending tasks, time of day, or custom metrics. The Batch Pool Builder helps you configure pool specifications with proper auto-scale formulas, container settings, and node communication options.

Technical Details

The builder constructs Azure Batch pool definitions with: VM size and image reference, scaling mode (fixed with target node count OR auto-scale with formula), container configuration (registry credentials, prefetched images), start task (commands run on each node before tasks), networking (subnet, NSG), and inter-node communication settings. Output is generated as az batch pool create commands and ARM template / Terraform azurerm_batch_pool resources.

Common Use Cases

1Creating auto-scale pools that grow based on pending task count and shrink to zero during idle periods
2Configuring container-enabled pools with pre-fetched Docker images for fast job startup
3Building pool specifications with start tasks that install dependencies and mount Azure file shares
4Defining low-priority (Spot) node pools for cost-effective batch processing with preemption handling

Common Questions

How do auto-scale formulas work?: Auto-scale formulas are evaluated every 15 minutes (configurable from 5 to 60 minutes) and return a target number of dedicated and/or low-priority nodes. Formulas can reference built-in variables like $PendingTasks (tasks waiting for a node), $RunningTasks, $ActiveTasks, and time-based functions. A common formula sets the target to the number of pending tasks divided by the tasks-per-node capacity: $TargetDedicatedNodes = min(maxNodes, $PendingTasks / tasksPerNode). You can combine multiple variables with conditional logic for sophisticated scaling behavior.
What is the difference between dedicated and low-priority nodes?: Dedicated nodes are allocated from Azure's regular capacity and are guaranteed to remain available for the lifetime of the pool. Low-priority nodes are provisioned from Azure's surplus capacity at up to 80% discount but can be preempted at any time when Azure needs the capacity back. When a low-priority node is preempted, running tasks are requeued. Use low-priority nodes for fault-tolerant, checkpointable workloads. Many batch workloads mix dedicated nodes (for steady baseline) with low-priority nodes (for burst capacity).

Expert Tips

TIP

Low-priority (Spot) nodes deliver 60-80% cost savings but require checkpointing for any task longer than ~20 minutes. Without checkpoints, a preemption loses all progress. For tasks that can't checkpoint, use a mix: 30% dedicated baseline + 70% low-priority for burst capacity. Preempted tasks reschedule on dedicated nodes automatically.

TIP

Container-enabled pools with pre-fetched Docker images dramatically improve startup time. Without pre-fetch, each new node downloads the image on first task — adding 30-60 seconds of cold-start latency. Pre-fetch happens once at pool start, then every task on that node starts instantly.

TIP

Auto-scale formulas should reference $PendingTasks and divide by tasksPerNode (which depends on your VM size's CPU count). The naive 'scale by pending tasks' over-provisions. The right formula: $TargetDedicatedNodes = min(maxNodes, ceil($PendingTasks / tasksPerNode)).

Related Learning Guides

Azure VM Series Guide22 min read

Was this tool helpful?

Disclaimer: This tool runs entirely in your browser. No data is sent to our servers. Always verify outputs before using them in production. AWS, Azure, and GCP are trademarks of their respective owners.