future = listJobsPaginator.subscribe(response -> {
jobSummaries.addAll(response.jobSummaryList());
});
future.join();
return jobSummaries;
}
```
+ Per i dettagli sull'API, [ListJobsPaginator](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/ListJobsPaginator)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `RegisterJobDefinition` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `RegisterJobDefinition`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nei seguenti esempi di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
+ [Nozioni di base su Batch e Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come registrare una definizione di processo**
Questo esempio registra una definizione di processo per un processo container semplice.
Comando:
```
aws batch register-job-definition --job-definition-name sleep30 --type container --container-properties '{ "image": "busybox", "vcpus": 1, "memory": 128, "command": [ "sleep", "30"]}'
```
Output:
```
{
"jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep30:1",
"jobDefinitionName": "sleep30",
"revision": 1
}
```
+ Per i dettagli sull'API, consulta [RegisterJobDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/register-job-definition.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/batch#code-examples).
```
/**
* Registers a new job definition asynchronously in AWS Batch.
*
* When using Fargate as the compute environment, it is crucial to set the
* {@link NetworkConfiguration} with {@link AssignPublicIp#ENABLED} to
* ensure proper networking configuration for the Fargate tasks. This
* allows the tasks to communicate with external services, access the
* internet, or communicate within a VPC.
*
* @param jobDefinitionName the name of the job definition to be registered
* @param executionRoleARN the ARN (Amazon Resource Name) of the execution role
* that provides permissions for the containers in the job
* @param cpuArch a value of either X86_64 or ARM64 required for the service call
* @return a CompletableFuture that completes with the ARN of the registered
* job definition upon successful execution, or completes exceptionally with
* an error if the registration fails
*/
public CompletableFuture registerJobDefinitionAsync(String jobDefinitionName, String executionRoleARN, String image, String cpuArch) {
NetworkConfiguration networkConfiguration = NetworkConfiguration.builder()
.assignPublicIp(AssignPublicIp.ENABLED)
.build();
ContainerProperties containerProperties = ContainerProperties.builder()
.image(image)
.executionRoleArn(executionRoleARN)
.resourceRequirements(
Arrays.asList(
ResourceRequirement.builder()
.type(ResourceType.VCPU)
.value("1")
.build(),
ResourceRequirement.builder()
.type(ResourceType.MEMORY)
.value("2048")
.build()
)
)
.networkConfiguration(networkConfiguration)
.runtimePlatform(b -> b
.cpuArchitecture(cpuArch)
.operatingSystemFamily("LINUX"))
.build();
RegisterJobDefinitionRequest request = RegisterJobDefinitionRequest.builder()
.jobDefinitionName(jobDefinitionName)
.type(JobDefinitionType.CONTAINER)
.containerProperties(containerProperties)
.platformCapabilities(PlatformCapability.FARGATE)
.build();
CompletableFuture future = new CompletableFuture<>();
getAsyncClient().registerJobDefinition(request)
.thenApply(RegisterJobDefinitionResponse::jobDefinitionArn)
.whenComplete((result, ex) -> {
if (ex != null) {
future.completeExceptionally(ex);
} else {
future.complete(result);
}
});
return future;
}
```
+ Per i dettagli sull'API, [RegisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/RegisterJobDefinition)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `SubmitJob` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `SubmitJob`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nei seguenti esempi di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
+ [Nozioni di base su Batch e Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come inviare un processo**
Questo esempio invia un semplice processo contenitore chiamato example alla coda dei HighPriority lavori.
Comando:
```
aws batch submit-job --job-name example --job-queue HighPriority --job-definition sleep60
```
Output:
```
{
"jobName": "example",
"jobId": "876da822-4198-45f2-a252-6cea32512ea8"
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [SubmitJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/submit-job.html)Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/batch#code-examples).
```
/**
* Submits a job asynchronously to the AWS Batch service.
*
* @param jobDefinitionName the name of the job definition to use
* @param jobQueueName the name of the job queue to submit the job to
* @param jobARN the Amazon Resource Name (ARN) of the job definition
* @return a CompletableFuture that, when completed, contains the job ID of the submitted job
*/
public CompletableFuture submitJobAsync(String jobDefinitionName, String jobQueueName, String jobARN) {
SubmitJobRequest jobRequest = SubmitJobRequest.builder()
.jobDefinition(jobARN)
.jobName(jobDefinitionName)
.jobQueue(jobQueueName)
.build();
CompletableFuture responseFuture = getAsyncClient().submitJob(jobRequest);
responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Unexpected error occurred: " + ex.getMessage(), ex);
}
});
return responseFuture.thenApply(SubmitJobResponse::jobId);
}
```
+ Per i dettagli sull'API, [SubmitJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/SubmitJob)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `UpdateComputeEnvironment` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `UpdateComputeEnvironment`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nei seguenti esempi di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
+ [Nozioni di base su Batch e Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come aggiornare un ambiente di calcolo**.
Questo esempio disabilita l'ambiente di OnDemand calcolo P2 in modo che possa essere eliminato.
Comando:
```
aws batch update-compute-environment --compute-environment P2OnDemand --state DISABLED
```
Output:
```
{
"computeEnvironmentName": "P2OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand"
}
```
+ *Per i dettagli sull'API, consulta Command [UpdateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-compute-environment.html)Reference AWS CLI .*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/batch#code-examples).
```
/**
* Disables the specified compute environment asynchronously.
*
* @param computeEnvironmentName the name of the compute environment to disable
* @return a CompletableFuture that completes when the compute environment is disabled
*/
public CompletableFuture disableComputeEnvironmentAsync(String computeEnvironmentName) {
UpdateComputeEnvironmentRequest updateRequest = UpdateComputeEnvironmentRequest.builder()
.computeEnvironment(computeEnvironmentName)
.state(CEState.DISABLED)
.build();
CompletableFuture responseFuture = getAsyncClient().updateComputeEnvironment(updateRequest);
responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to disable compute environment: " + ex.getMessage(), ex);
}
});
return responseFuture;
}
```
+ Per i dettagli sull'API, [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateComputeEnvironment)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `UpdateJobQueue` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `UpdateJobQueue`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nei seguenti esempi di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
+ [Nozioni di base su Batch e Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come creare una coda di processi**
Questo esempio disabilita una coda di processi in modo che possa essere eliminata.
Comando:
```
aws batch update-job-queue --job-queue GPGPU --state DISABLED
```
Output:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/GPGPU",
"jobQueueName": "GPGPU"
}
```
+ Per i dettagli sull'API, consulta [UpdateJobQueue AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-job-queue.html)*Command Reference.*
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/batch#code-examples).
```
/**
* Disables the specified job queue asynchronously.
*
* @param jobQueueArn the Amazon Resource Name (ARN) of the job queue to be disabled
* @return a {@link CompletableFuture} that completes when the job queue update operation is complete,
* or completes exceptionally if an error occurs during the operation
*/
public CompletableFuture disableJobQueueAsync(String jobQueueArn) {
UpdateJobQueueRequest updateRequest = UpdateJobQueueRequest.builder()
.jobQueue(jobQueueArn)
.state(JQState.DISABLED)
.build();
CompletableFuture responseFuture = getAsyncClient().updateJobQueue(updateRequest);
return responseFuture.whenComplete((updateResponse, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to update job queue: " + ex.getMessage(), ex);
}
}).thenApply(updateResponse -> null);
}
```
+ Per i dettagli sull'API, [UpdateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateJobQueue)consulta *AWS SDK for Java 2.x API Reference*.
------