Azure Compute Batch Java

1---
2name: azure-compute-batch-java
3description: |
4  Azure Batch SDK for Java. Run large-scale parallel and HPC batch jobs with pools, jobs, tasks, and compute nodes.
5  Triggers: "BatchClient java", "azure batch java", "batch pool java", "batch job java", "HPC java", "parallel computing java".
6---
7 
8# Azure Batch SDK for Java
9 
10Client library for running large-scale parallel and high-performance computing (HPC) batch jobs in Azure.
11 
12## Installation
13 
14```xml
15<dependency>
16    <groupId>com.azure</groupId>
17    <artifactId>azure-compute-batch</artifactId>
18    <version>1.0.0-beta.5</version>
19</dependency>
20```
21 
22## Prerequisites
23 
24- Azure Batch account
25- Pool configured with compute nodes
26- Azure subscription
27 
28## Environment Variables
29 
30```bash
31AZURE_BATCH_ENDPOINT=https://<account>.<region>.batch.azure.com
32AZURE_BATCH_ACCOUNT=<account-name>
33AZURE_BATCH_ACCESS_KEY=<account-key>
34```
35 
36## Client Creation
37 
38### With Microsoft Entra ID (Recommended)
39 
40```java
41import com.azure.compute.batch.BatchClient;
42import com.azure.compute.batch.BatchClientBuilder;
43import com.azure.identity.DefaultAzureCredentialBuilder;
44 
45BatchClient batchClient = new BatchClientBuilder()
46    .credential(new DefaultAzureCredentialBuilder().build())
47    .endpoint(System.getenv("AZURE_BATCH_ENDPOINT"))
48    .buildClient();
49```
50 
51### Async Client
52 
53```java
54import com.azure.compute.batch.BatchAsyncClient;
55 
56BatchAsyncClient batchAsyncClient = new BatchClientBuilder()
57    .credential(new DefaultAzureCredentialBuilder().build())
58    .endpoint(System.getenv("AZURE_BATCH_ENDPOINT"))
59    .buildAsyncClient();
60```
61 
62### With Shared Key Credentials
63 
64```java
65import com.azure.core.credential.AzureNamedKeyCredential;
66 
67String accountName = System.getenv("AZURE_BATCH_ACCOUNT");
68String accountKey = System.getenv("AZURE_BATCH_ACCESS_KEY");
69AzureNamedKeyCredential sharedKeyCreds = new AzureNamedKeyCredential(accountName, accountKey);
70 
71BatchClient batchClient = new BatchClientBuilder()
72    .credential(sharedKeyCreds)
73    .endpoint(System.getenv("AZURE_BATCH_ENDPOINT"))
74    .buildClient();
75```
76 
77## Key Concepts
78 
79| Concept | Description |
80|---------|-------------|
81| Pool | Collection of compute nodes that run tasks |
82| Job | Logical grouping of tasks |
83| Task | Unit of computation (command/script) |
84| Node | VM that executes tasks |
85| Job Schedule | Recurring job creation |
86 
87## Pool Operations
88 
89### Create Pool
90 
91```java
92import com.azure.compute.batch.models.*;
93 
94batchClient.createPool(new BatchPoolCreateParameters("myPoolId", "STANDARD_DC2s_V2")
95    .setVirtualMachineConfiguration(
96        new VirtualMachineConfiguration(
97            new BatchVmImageReference()
98                .setPublisher("Canonical")
99                .setOffer("UbuntuServer")
100                .setSku("22_04-lts")
101                .setVersion("latest"),
102            "batch.node.ubuntu 22.04"))
103    .setTargetDedicatedNodes(2)
104    .setTargetLowPriorityNodes(0), null);
105```
106 
107### Get Pool
108 
109```java
110BatchPool pool = batchClient.getPool("myPoolId");
111System.out.println("Pool state: " + pool.getState());
112System.out.println("Current dedicated nodes: " + pool.getCurrentDedicatedNodes());
113```
114 
115### List Pools
116 
117```java
118import com.azure.core.http.rest.PagedIterable;
119 
120PagedIterable<BatchPool> pools = batchClient.listPools();
121for (BatchPool pool : pools) {
122    System.out.println("Pool: " + pool.getId() + ", State: " + pool.getState());
123}
124```
125 
126### Resize Pool
127 
128```java
129import com.azure.core.util.polling.SyncPoller;
130 
131BatchPoolResizeParameters resizeParams = new BatchPoolResizeParameters()
132    .setTargetDedicatedNodes(4)
133    .setTargetLowPriorityNodes(2);
134 
135SyncPoller<BatchPool, BatchPool> poller = batchClient.beginResizePool("myPoolId", resizeParams);
136poller.waitForCompletion();
137BatchPool resizedPool = poller.getFinalResult();
138```
139 
140### Enable AutoScale
141 
142```java
143BatchPoolEnableAutoScaleParameters autoScaleParams = new BatchPoolEnableAutoScaleParameters()
144    .setAutoScaleEvaluationInterval(Duration.ofMinutes(5))
145    .setAutoScaleFormula("$TargetDedicatedNodes = min(10, $PendingTasks.GetSample(TimeInterval_Minute * 5));");
146 
147batchClient.enablePoolAutoScale("myPoolId", autoScaleParams);
148```
149 
150### Delete Pool
151 
152```java
153SyncPoller<BatchPool, Void> deletePoller = batchClient.beginDeletePool("myPoolId");
154deletePoller.waitForCompletion();
155```
156 
157## Job Operations
158 
159### Create Job
160 
161```java
162batchClient.createJob(
163    new BatchJobCreateParameters("myJobId", new BatchPoolInfo().setPoolId("myPoolId"))
164        .setPriority(100)
165        .setConstraints(new BatchJobConstraints()
166            .setMaxWallClockTime(Duration.ofHours(24))
167            .setMaxTaskRetryCount(3)),
168    null);
169```
170 
171### Get Job
172 
173```java
174BatchJob job = batchClient.getJob("myJobId", null, null);
175System.out.println("Job state: " + job.getState());
176```
177 
178### List Jobs
179 
180```java
181PagedIterable<BatchJob> jobs = batchClient.listJobs(new BatchJobsListOptions());
182for (BatchJob job : jobs) {
183    System.out.println("Job: " + job.getId() + ", State: " + job.getState());
184}
185```
186 
187### Get Task Counts
188 
189```java
190BatchTaskCountsResult counts = batchClient.getJobTaskCounts("myJobId");
191System.out.println("Active: " + counts.getTaskCounts().getActive());
192System.out.println("Running: " + counts.getTaskCounts().getRunning());
193System.out.println("Completed: " + counts.getTaskCounts().getCompleted());
194```
195 
196### Terminate Job
197 
198```java
199BatchJobTerminateParameters terminateParams = new BatchJobTerminateParameters()
200    .setTerminationReason("Manual termination");
201BatchJobTerminateOptions options = new BatchJobTerminateOptions().setParameters(terminateParams);
202 
203SyncPoller<BatchJob, BatchJob> poller = batchClient.beginTerminateJob("myJobId", options, null);
204poller.waitForCompletion();
205```
206 
207### Delete Job
208 
209```java
210SyncPoller<BatchJob, Void> deletePoller = batchClient.beginDeleteJob("myJobId");
211deletePoller.waitForCompletion();
212```
213 
214## Task Operations
215 
216### Create Single Task
217 
218```java
219BatchTaskCreateParameters task = new BatchTaskCreateParameters("task1", "echo 'Hello World'");
220batchClient.createTask("myJobId", task);
221```
222 
223### Create Task with Exit Conditions
224 
225```java
226batchClient.createTask("myJobId", new BatchTaskCreateParameters("task2", "cmd /c exit 3")
227    .setExitConditions(new ExitConditions()
228        .setExitCodeRanges(Arrays.asList(
229            new ExitCodeRangeMapping(2, 4, 
230                new ExitOptions().setJobAction(BatchJobActionKind.TERMINATE)))))
231    .setUserIdentity(new UserIdentity()
232        .setAutoUser(new AutoUserSpecification()
233            .setScope(AutoUserScope.TASK)
234            .setElevationLevel(ElevationLevel.NON_ADMIN))),
235    null);
236```
237 
238### Create Task Collection (up to 100)
239 
240```java
241List<BatchTaskCreateParameters> taskList = Arrays.asList(
242    new BatchTaskCreateParameters("task1", "echo Task 1"),
243    new BatchTaskCreateParameters("task2", "echo Task 2"),
244    new BatchTaskCreateParameters("task3", "echo Task 3")
245);
246BatchTaskGroup taskGroup = new BatchTaskGroup(taskList);
247BatchCreateTaskCollectionResult result = batchClient.createTaskCollection("myJobId", taskGroup);
248```
249 
250### Create Many Tasks (no limit)
251 
252```java
253List<BatchTaskCreateParameters> tasks = new ArrayList<>();
254for (int i = 0; i < 1000; i++) {
255    tasks.add(new BatchTaskCreateParameters("task" + i, "echo Task " + i));
256}
257batchClient.createTasks("myJobId", tasks);
258```
259 
260### Get Task
261 
262```java
263BatchTask task = batchClient.getTask("myJobId", "task1");
264System.out.println("Task state: " + task.getState());
265System.out.println("Exit code: " + task.getExecutionInfo().getExitCode());
266```
267 
268### List Tasks
269 
270```java
271PagedIterable<BatchTask> tasks = batchClient.listTasks("myJobId");
272for (BatchTask task : tasks) {
273    System.out.println("Task: " + task.getId() + ", State: " + task.getState());
274}
275```
276 
277### Get Task Output
278 
279```java
280import com.azure.core.util.BinaryData;
281import java.nio.charset.StandardCharsets;
282 
283BinaryData stdout = batchClient.getTaskFile("myJobId", "task1", "stdout.txt");
284System.out.println(new String(stdout.toBytes(), StandardCharsets.UTF_8));
285```
286 
287### Terminate Task
288 
289```java
290batchClient.terminateTask("myJobId", "task1", null, null);
291```
292 
293## Node Operations
294 
295### List Nodes
296 
297```java
298PagedIterable<BatchNode> nodes = batchClient.listNodes("myPoolId", new BatchNodesListOptions());
299for (BatchNode node : nodes) {
300    System.out.println("Node: " + node.getId() + ", State: " + node.getState());
301}
302```
303 
304### Reboot Node
305 
306```java
307SyncPoller<BatchNode, BatchNode> rebootPoller = batchClient.beginRebootNode("myPoolId", "nodeId");
308rebootPoller.waitForCompletion();
309```
310 
311### Get Remote Login Settings
312 
313```java
314BatchNodeRemoteLoginSettings settings = batchClient.getNodeRemoteLoginSettings("myPoolId", "nodeId");
315System.out.println("IP: " + settings.getRemoteLoginIpAddress());
316System.out.println("Port: " + settings.getRemoteLoginPort());
317```
318 
319## Job Schedule Operations
320 
321### Create Job Schedule
322 
323```java
324batchClient.createJobSchedule(new BatchJobScheduleCreateParameters("myScheduleId",
325    new BatchJobScheduleConfiguration()
326        .setRecurrenceInterval(Duration.ofHours(6))
327        .setDoNotRunUntil(OffsetDateTime.now().plusDays(1)),
328    new BatchJobSpecification(new BatchPoolInfo().setPoolId("myPoolId"))
329        .setPriority(50)),
330    null);
331```
332 
333### Get Job Schedule
334 
335```java
336BatchJobSchedule schedule = batchClient.getJobSchedule("myScheduleId");
337System.out.println("Schedule state: " + schedule.getState());
338```
339 
340## Error Handling
341 
342```java
343import com.azure.compute.batch.models.BatchErrorException;
344import com.azure.compute.batch.models.BatchError;
345 
346try {
347    batchClient.getPool("nonexistent-pool");
348} catch (BatchErrorException e) {
349    BatchError error = e.getValue();
350    System.err.println("Error code: " + error.getCode());
351    System.err.println("Message: " + error.getMessage().getValue());
352    
353    if ("PoolNotFound".equals(error.getCode())) {
354        System.err.println("The specified pool does not exist.");
355    }
356}
357```
358 
359## Best Practices
360 
3611. **Use Entra ID** — Preferred over shared key for authentication
3622. **Use management SDK for pools** — `azure-resourcemanager-batch` supports managed identities
3633. **Batch task creation** — Use `createTaskCollection` or `createTasks` for multiple tasks
3644. **Handle LRO properly** — Pool resize, delete operations are long-running
3655. **Monitor task counts** — Use `getJobTaskCounts` to track progress
3666. **Set constraints** — Configure `maxWallClockTime` and `maxTaskRetryCount`
3677. **Use low-priority nodes** — Cost savings for fault-tolerant workloads
3688. **Enable autoscale** — Dynamically adjust pool size based on workload
369 
370## Reference Links
371 
372| Resource | URL |
373|----------|-----|
374| Maven Package | https://central.sonatype.com/artifact/com.azure/azure-compute-batch |
375| GitHub | https://github.com/Azure/azure-sdk-for-java/tree/main/sdk/batch/azure-compute-batch |
376| API Documentation | https://learn.microsoft.com/java/api/com.azure.compute.batch |
377| Product Docs | https://learn.microsoft.com/azure/batch/ |
378| REST API | https://learn.microsoft.com/rest/api/batchservice/ |
379| Samples | https://github.com/azure/azure-batch-samples |
380