future = listJobsPaginator.subscribe(response -> {
jobSummaries.addAll(response.jobSummaryList());
});
future.join();
return jobSummaries;
}
/**
* 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;
}
/**
* Deregisters a job definition asynchronously.
*
* @param jobDefinition the name of the job definition to be deregistered
* @return a CompletableFuture that completes when the job definition has been deregistered
* or an exception has occurred
*/
public CompletableFuture deregisterJobDefinitionAsync(String jobDefinition) {
DeregisterJobDefinitionRequest jobDefinitionRequest = DeregisterJobDefinitionRequest.builder()
.jobDefinition(jobDefinition)
.build();
CompletableFuture responseFuture = getAsyncClient().deregisterJobDefinition(jobDefinitionRequest);
responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Unexpected error occurred: " + ex.getMessage(), ex);
}
});
return responseFuture;
}
/**
* 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);
}
/**
* Deletes a Batch job queue asynchronously.
*
* @param jobQueueArn The Amazon Resource Name (ARN) of the job queue to delete.
* @return A CompletableFuture that represents the asynchronous deletion of the job queue.
* The future completes when the job queue has been successfully deleted or if an error occurs.
* If successful, the future will be completed with a {@code Void} value.
* If an error occurs, the future will be completed exceptionally with the thrown exception.
*/
public CompletableFuture deleteJobQueueAsync(String jobQueueArn) {
DeleteJobQueueRequest deleteRequest = DeleteJobQueueRequest.builder()
.jobQueue(jobQueueArn)
.build();
CompletableFuture responseFuture = getAsyncClient().deleteJobQueue(deleteRequest);
return responseFuture.whenComplete((deleteResponse, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to delete job queue: " + ex.getMessage(), ex);
}
}).thenApply(deleteResponse -> null);
}
/**
* Asynchronously describes the job queue associated with the specified compute environment.
*
* @param computeEnvironmentName the name of the compute environment to find the associated job queue for
* @return a {@link CompletableFuture} that, when completed, contains the job queue ARN associated with the specified compute environment
* @throws RuntimeException if the job queue description fails
*/
public CompletableFuture describeJobQueueAsync(String computeEnvironmentName) {
DescribeJobQueuesRequest describeJobQueuesRequest = DescribeJobQueuesRequest.builder()
.build();
CompletableFuture responseFuture = getAsyncClient().describeJobQueues(describeJobQueuesRequest);
return responseFuture.whenComplete((describeJobQueuesResponse, ex) -> {
if (describeJobQueuesResponse != null) {
String jobQueueARN;
for (JobQueueDetail jobQueueDetail : describeJobQueuesResponse.jobQueues()) {
for (ComputeEnvironmentOrder computeEnvironmentOrder : jobQueueDetail.computeEnvironmentOrder()) {
String computeEnvironment = computeEnvironmentOrder.computeEnvironment();
String name = getComputeEnvironmentName(computeEnvironment);
if (name.equals(computeEnvironmentName)) {
jobQueueARN = jobQueueDetail.jobQueueArn();
logger.info("Job queue ARN associated with the compute environment: " + jobQueueARN);
}
}
}
} else {
throw new RuntimeException("Failed to describe job queue: " + ex.getMessage(), ex);
}
}).thenApply(describeJobQueuesResponse -> {
String jobQueueARN = "";
for (JobQueueDetail jobQueueDetail : describeJobQueuesResponse.jobQueues()) {
for (ComputeEnvironmentOrder computeEnvironmentOrder : jobQueueDetail.computeEnvironmentOrder()) {
String computeEnvironment = computeEnvironmentOrder.computeEnvironment();
String name = getComputeEnvironmentName(computeEnvironment);
if (name.equals(computeEnvironmentName)) {
jobQueueARN = jobQueueDetail.jobQueueArn();
}
}
}
return jobQueueARN;
});
}
/**
* 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;
}
/**
* 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);
}
/**
* Asynchronously retrieves the status of a specific job.
*
* @param jobId the ID of the job to retrieve the status for
* @return a CompletableFuture that completes with the job status
*/
public CompletableFuture describeJobAsync(String jobId) {
DescribeJobsRequest describeJobsRequest = DescribeJobsRequest.builder()
.jobs(jobId)
.build();
CompletableFuture responseFuture = getAsyncClient().describeJobs(describeJobsRequest);
return responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Unexpected error occurred: " + ex.getMessage(), ex);
}
}).thenApply(response -> response.jobs().get(0).status().toString());
}
/**
* Disables the specific job queue using the asynchronous Java client.
*
* @param jobQueueArn the Amazon Resource Name (ARN) of the job queue to wait for
* @return a {@link CompletableFuture} that completes when the job queue is disabled
*/
public CompletableFuture waitForJobQueueToBeDisabledAsync(String jobQueueArn) {
AtomicBoolean isDisabled = new AtomicBoolean(false);
return CompletableFuture.runAsync(() -> {
while (!isDisabled.get()) {
DescribeJobQueuesRequest describeRequest = DescribeJobQueuesRequest.builder()
.jobQueues(jobQueueArn)
.build();
CompletableFuture responseFuture = getAsyncClient().describeJobQueues(describeRequest);
responseFuture.whenComplete((describeResponse, ex) -> {
if (describeResponse != null) {
for (JobQueueDetail jobQueue : describeResponse.jobQueues()) {
if (jobQueue.jobQueueArn().equals(jobQueueArn) && jobQueue.state() == JQState.DISABLED) {
isDisabled.set(true);
break;
}
}
} else {
throw new RuntimeException("Error describing job queues", ex);
}
}).join();
if (!isDisabled.get()) {
try {
logger.info("Waiting for job queue to be disabled...");
Thread.sleep(5000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Thread interrupted while waiting for job queue to be disabled", e);
}
}
}
}).whenComplete((result, throwable) -> {
if (throwable != null) {
throw new RuntimeException("Error while waiting for job queue to be disabled", throwable);
}
});
}
public CompletableFuture getJobQueueARN(String jobQueueName) {
// Describe the job queue asynchronously
CompletableFuture describeJobQueuesFuture = batchClient.describeJobQueues(
DescribeJobQueuesRequest.builder()
.jobQueues(jobQueueName)
.build()
);
// Handle the asynchronous response and return the Job Queue ARN in the CompletableFuture
CompletableFuture jobQueueArnFuture = new CompletableFuture<>();
describeJobQueuesFuture.whenComplete((response, error) -> {
if (error != null) {
if (error instanceof BatchException) {
logger.info("Batch error: " + ((BatchException) error).awsErrorDetails().errorMessage());
} else {
logger.info("Error describing job queue: " + error.getMessage());
}
jobQueueArnFuture.completeExceptionally(new RuntimeException("Failed to retrieve Job Queue ARN", error));
} else {
if (response.jobQueues().isEmpty()) {
jobQueueArnFuture.completeExceptionally(new RuntimeException("Job queue not found: " + jobQueueName));
} else {
// Assuming only one job queue is returned for the given name
String jobQueueArn = response.jobQueues().get(0).jobQueueArn();
jobQueueArnFuture.complete(jobQueueArn);
}
}
});
return jobQueueArnFuture;
}
private static String getComputeEnvironmentName(String computeEnvironment) {
String[] parts = computeEnvironment.split("/");
if (parts.length == 2) {
return parts[1];
}
return null;
}
public CompletableFuture getAccountId() {
StsAsyncClient stsAsyncClient = StsAsyncClient.builder()
.region(Region.US_EAST_1)
.build();
return stsAsyncClient.getCallerIdentity()
.thenApply(GetCallerIdentityResponse::account);
}
}
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dell’API AWS SDK for Java 2.x *.
+ [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateComputeEnvironment)
+ [CreateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateJobQueue)
+ [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteComputeEnvironment)
+ [DeleteJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteJobQueue)
+ [DeregisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeregisterJobDefinition)
+ [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeComputeEnvironments)
+ [DescribeJobQueues](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobQueues)
+ [DescribeJobs](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobs)
+ [ListJobsPaginator](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/ListJobsPaginator)
+ [RegisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/RegisterJobDefinition)
+ [SubmitJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/SubmitJob)
+ [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateComputeEnvironment)
+ [UpdateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateJobQueue)
------
# Azioni per l'utilizzo AWS Batch AWS SDKs
I seguenti esempi di codice mostrano come eseguire singole AWS Batch azioni con AWS SDKs. Ogni esempio include un collegamento a GitHub, dove sono disponibili le istruzioni per la configurazione e l'esecuzione del codice.
Questi estratti richiamano l' AWS Batch API e sono estratti di codice di programmi più grandi che devono essere eseguiti nel contesto. È possibile visualizzare le azioni nel contesto in [Scenari di AWS Batch utilizzo AWS SDKs](batch_code_examples_scenarios.md).
Gli esempi seguenti includono solo le azioni più comunemente utilizzate. Per un elenco completo, consulta la [documentazione di riferimento dell’API AWS Batch](https://docs.aws.amazon.com/batch/latest/APIReference/Welcome.html).
**Topics**
+ [`CreateComputeEnvironment`](batch_example_batch_CreateComputeEnvironment_section.md)
+ [`CreateJobQueue`](batch_example_batch_CreateJobQueue_section.md)
+ [`DeleteComputeEnvironment`](batch_example_batch_DeleteComputeEnvironment_section.md)
+ [`DeleteJobQueue`](batch_example_batch_DeleteJobQueue_section.md)
+ [`DeregisterJobDefinition`](batch_example_batch_DeregisterJobDefinition_section.md)
+ [`DescribeComputeEnvironments`](batch_example_batch_DescribeComputeEnvironments_section.md)
+ [`DescribeJobQueues`](batch_example_batch_DescribeJobQueues_section.md)
+ [`DescribeJobs`](batch_example_batch_DescribeJobs_section.md)
+ [`ListJobsPaginator`](batch_example_batch_ListJobsPaginator_section.md)
+ [`RegisterJobDefinition`](batch_example_batch_RegisterJobDefinition_section.md)
+ [`SubmitJob`](batch_example_batch_SubmitJob_section.md)
+ [`UpdateComputeEnvironment`](batch_example_batch_UpdateComputeEnvironment_section.md)
+ [`UpdateJobQueue`](batch_example_batch_UpdateJobQueue_section.md)
# Utilizzo `CreateComputeEnvironment` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `CreateComputeEnvironment`.
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 un ambiente di calcolo gestito con istanze on demand**
Questo esempio crea un ambiente di calcolo gestito con istanze di tipo C4 specifiche che vengono avviate on demand. L'ambiente di calcolo si chiama C4. OnDemand
Comando:
```
aws batch create-compute-environment --cli-input-json file:///C4OnDemand.json
```
Formato del file JSON:
```
{
"computeEnvironmentName": "C4OnDemand",
"type": "MANAGED",
"state": "ENABLED",
"computeResources": {
"type": "EC2",
"minvCpus": 0,
"maxvCpus": 128,
"desiredvCpus": 48,
"instanceTypes": [
"c4.large",
"c4.xlarge",
"c4.2xlarge",
"c4.4xlarge",
"c4.8xlarge"
],
"subnets": [
"subnet-220c0e0a",
"subnet-1a95556d",
"subnet-978f6dce"
],
"securityGroupIds": [
"sg-cf5093b2"
],
"ec2KeyPair": "id_rsa",
"instanceRole": "ecsInstanceRole",
"tags": {
"Name": "Batch Instance - C4OnDemand"
}
},
"serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole"
}
```
Output:
```
{
"computeEnvironmentName": "C4OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand"
}
```
**Come creare un ambiente di calcolo gestito con istanze spot**
Questo esempio crea un ambiente di calcolo gestito con l’istanza di tipo M4 che viene avviata quando il prezzo dell’offerta spot è pari o inferiore al 20% del prezzo on demand per il tipo di istanza. L’ambiente di calcolo è denominato M4Spot.
Comando:
```
aws batch create-compute-environment --cli-input-json file:///M4Spot.json
```
Formato del file JSON:
```
{
"computeEnvironmentName": "M4Spot",
"type": "MANAGED",
"state": "ENABLED",
"computeResources": {
"type": "SPOT",
"spotIamFleetRole": "arn:aws:iam::012345678910:role/aws-ec2-spot-fleet-role",
"minvCpus": 0,
"maxvCpus": 128,
"desiredvCpus": 4,
"instanceTypes": [
"m4"
],
"bidPercentage": 20,
"subnets": [
"subnet-220c0e0a",
"subnet-1a95556d",
"subnet-978f6dce"
],
"securityGroupIds": [
"sg-cf5093b2"
],
"ec2KeyPair": "id_rsa",
"instanceRole": "ecsInstanceRole",
"tags": {
"Name": "Batch Instance - M4Spot"
}
},
"serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole"
}
```
Output:
```
{
"computeEnvironmentName": "M4Spot",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/M4Spot"
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [CreateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-compute-environment.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).
```
/**
* Asynchronously creates a new compute environment in AWS Batch.
*
* @param computeEnvironmentName the name of the compute environment to create
* @param batchIAMRole the IAM role to be used by the compute environment
* @param subnet the subnet ID to be used for the compute environment
* @param secGroup the security group ID to be used for the compute environment
* @return a {@link CompletableFuture} representing the asynchronous operation, which will complete with the
* {@link CreateComputeEnvironmentResponse} when the compute environment has been created
* @throws BatchException if there is an error creating the compute environment
* @throws RuntimeException if there is an unexpected error during the operation
*/
public CompletableFuture createComputeEnvironmentAsync(
String computeEnvironmentName, String batchIAMRole, String subnet, String secGroup) {
CreateComputeEnvironmentRequest environmentRequest = CreateComputeEnvironmentRequest.builder()
.computeEnvironmentName(computeEnvironmentName)
.type(CEType.MANAGED)
.state(CEState.ENABLED)
.computeResources(ComputeResource.builder()
.type(CRType.FARGATE)
.maxvCpus(256)
.subnets(Collections.singletonList(subnet))
.securityGroupIds(Collections.singletonList(secGroup))
.build())
.serviceRole(batchIAMRole)
.build();
CompletableFuture response = getAsyncClient().createComputeEnvironment(environmentRequest);
response.whenComplete((resp, ex) -> {
if (ex != null) {
String errorMessage = "Unexpected error occurred: " + ex.getMessage();
throw new RuntimeException(errorMessage, ex);
}
});
return response;
}
```
+ Per i dettagli sull'API, [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateComputeEnvironment)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `CreateJobQueue` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `CreateJobQueue`.
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 a bassa priorità con un unico ambiente di calcolo**
Questo esempio crea una coda di lavoro chiamata LowPriority che utilizza l'ambiente di calcolo M4Spot.
Comando:
```
aws batch create-job-queue --cli-input-json file:///LowPriority.json
```
Formato del file JSON:
```
{
"jobQueueName": "LowPriority",
"state": "ENABLED",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "M4Spot"
}
]
}
```
Output:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/LowPriority",
"jobQueueName": "LowPriority"
}
```
**Come creare una coda di processi ad alta priorità con due ambienti di calcolo**
Questo esempio crea una coda di lavoro chiamata HighPriority che utilizza l'ambiente di calcolo C4 con un ordine di 1 e l'ambiente di OnDemand calcolo M4Spot con un ordine di 2. Lo scheduler tenterà innanzitutto di inserire i lavori nell'ambiente di calcolo C4. OnDemand
Comando:
```
aws batch create-job-queue --cli-input-json file:///HighPriority.json
```
Formato del file JSON:
```
{
"jobQueueName": "HighPriority",
"state": "ENABLED",
"priority": 1,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "C4OnDemand"
},
{
"order": 2,
"computeEnvironment": "M4Spot"
}
]
}
```
Output:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"jobQueueName": "HighPriority"
}
```
+ *Per i dettagli sull'API, consulta Command [CreateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-job-queue.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).
```
/**
* Creates a job queue asynchronously.
*
* @param jobQueueName the name of the job queue to create
* @param computeEnvironmentName the name of the compute environment to associate with the job queue
* @return a CompletableFuture that completes with the Amazon Resource Name (ARN) of the job queue
*/
public CompletableFuture createJobQueueAsync(String jobQueueName, String computeEnvironmentName) {
if (jobQueueName == null || jobQueueName.isEmpty()) {
throw new IllegalArgumentException("Job queue name cannot be null or empty");
}
if (computeEnvironmentName == null || computeEnvironmentName.isEmpty()) {
throw new IllegalArgumentException("Compute environment name cannot be null or empty");
}
CreateJobQueueRequest request = CreateJobQueueRequest.builder()
.jobQueueName(jobQueueName)
.priority(1)
.computeEnvironmentOrder(ComputeEnvironmentOrder.builder()
.computeEnvironment(computeEnvironmentName)
.order(1)
.build())
.build();
CompletableFuture response = getAsyncClient().createJobQueue(request);
response.whenComplete((resp, ex) -> {
if (ex != null) {
String errorMessage = "Unexpected error occurred: " + ex.getMessage();
throw new RuntimeException(errorMessage, ex);
}
});
return response.thenApply(CreateJobQueueResponse::jobQueueArn);
}
```
+ Per i dettagli sull'API, [CreateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateJobQueue)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DeleteComputeEnvironment` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeleteComputeEnvironment`.
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 eliminare un ambiente di calcolo**
Questo esempio elimina l'ambiente di calcolo P2OnDemand .
Comando:
```
aws batch delete-compute-environment --compute-environment P2OnDemand
```
+ *Per i dettagli sull'API, consulta Command [DeleteComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-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).
```
public CompletableFuture deleteComputeEnvironmentAsync(String computeEnvironmentName) {
DeleteComputeEnvironmentRequest deleteComputeEnvironment = DeleteComputeEnvironmentRequest.builder()
.computeEnvironment(computeEnvironmentName)
.build();
return getAsyncClient().deleteComputeEnvironment(deleteComputeEnvironment)
.whenComplete((response, ex) -> {
if (ex != null) {
Throwable cause = ex.getCause();
if (cause instanceof BatchException) {
throw new RuntimeException(cause);
} else {
throw new RuntimeException("Unexpected error: " + cause.getMessage(), cause);
}
}
});
}
```
+ Per i dettagli sull'API, [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteComputeEnvironment)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DeleteJobQueue` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeleteJobQueue`.
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 eliminare una coda di processi**
Questo esempio elimina la coda dei processi GPGPU.
Comando:
```
aws batch delete-job-queue --job-queue GPGPU
```
+ Per i dettagli sull'API, consulta [DeleteJobQueue AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-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).
```
/**
* Deletes a Batch job queue asynchronously.
*
* @param jobQueueArn The Amazon Resource Name (ARN) of the job queue to delete.
* @return A CompletableFuture that represents the asynchronous deletion of the job queue.
* The future completes when the job queue has been successfully deleted or if an error occurs.
* If successful, the future will be completed with a {@code Void} value.
* If an error occurs, the future will be completed exceptionally with the thrown exception.
*/
public CompletableFuture deleteJobQueueAsync(String jobQueueArn) {
DeleteJobQueueRequest deleteRequest = DeleteJobQueueRequest.builder()
.jobQueue(jobQueueArn)
.build();
CompletableFuture responseFuture = getAsyncClient().deleteJobQueue(deleteRequest);
return responseFuture.whenComplete((deleteResponse, ex) -> {
if (ex != null) {
throw new RuntimeException("Failed to delete job queue: " + ex.getMessage(), ex);
}
}).thenApply(deleteResponse -> null);
}
```
+ Per i dettagli sull'API, [DeleteJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteJobQueue)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DeregisterJobDefinition` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DeregisterJobDefinition`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
------
#### [ CLI ]
**AWS CLI**
**Come annullare la registrazione di una definizione di processo**
Questo esempio annulla la registrazione di una definizione di processo denominata sleep10.
Comando:
```
aws batch deregister-job-definition --job-definition sleep10
```
+ Per i dettagli sull'API, consulta [DeregisterJobDefinition AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/deregister-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).
```
/**
* Deregisters a job definition asynchronously.
*
* @param jobDefinition the name of the job definition to be deregistered
* @return a CompletableFuture that completes when the job definition has been deregistered
* or an exception has occurred
*/
public CompletableFuture deregisterJobDefinitionAsync(String jobDefinition) {
DeregisterJobDefinitionRequest jobDefinitionRequest = DeregisterJobDefinitionRequest.builder()
.jobDefinition(jobDefinition)
.build();
CompletableFuture responseFuture = getAsyncClient().deregisterJobDefinition(jobDefinitionRequest);
responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Unexpected error occurred: " + ex.getMessage(), ex);
}
});
return responseFuture;
}
```
+ Per i dettagli sull'API, [DeregisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeregisterJobDefinition)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DescribeComputeEnvironments` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeComputeEnvironments`.
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 eliminare un ambiente di calcolo**
Questo esempio descrive l'ambiente di OnDemand calcolo P2.
Comando:
```
aws batch describe-compute-environments --compute-environments P2OnDemand
```
Output:
```
{
"computeEnvironments": [
{
"status": "VALID",
"serviceRole": "arn:aws:iam::012345678910:role/AWSBatchServiceRole",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand",
"computeResources": {
"subnets": [
"subnet-220c0e0a",
"subnet-1a95556d",
"subnet-978f6dce"
],
"tags": {
"Name": "Batch Instance - P2OnDemand"
},
"desiredvCpus": 48,
"minvCpus": 0,
"instanceTypes": [
"p2"
],
"securityGroupIds": [
"sg-cf5093b2"
],
"instanceRole": "ecsInstanceRole",
"maxvCpus": 128,
"type": "EC2",
"ec2KeyPair": "id_rsa"
},
"statusReason": "ComputeEnvironment Healthy",
"ecsClusterArn": "arn:aws:ecs:us-east-1:012345678910:cluster/P2OnDemand_Batch_2c06f29d-d1fe-3a49-879d-42394c86effc",
"state": "ENABLED",
"computeEnvironmentName": "P2OnDemand",
"type": "MANAGED"
}
]
}
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeComputeEnvironments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-compute-environments.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).
```
/**
* Checks the status of the specified compute environment.
*
* @param computeEnvironmentName the name of the compute environment to check
* @return a CompletableFuture containing the status of the compute environment, or "ERROR" if an exception occurs
*/
public CompletableFuture checkComputeEnvironmentsStatus(String computeEnvironmentName) {
if (computeEnvironmentName == null || computeEnvironmentName.isEmpty()) {
throw new IllegalArgumentException("Compute environment name cannot be null or empty");
}
DescribeComputeEnvironmentsRequest environmentsRequest = DescribeComputeEnvironmentsRequest.builder()
.computeEnvironments(computeEnvironmentName)
.build();
CompletableFuture response = getAsyncClient().describeComputeEnvironments(environmentsRequest);
response.whenComplete((resp, ex) -> {
if (ex != null) {
String errorMessage = "Unexpected error occurred: " + ex.getMessage();
throw new RuntimeException(errorMessage, ex);
}
});
return response.thenApply(resp -> resp.computeEnvironments().stream()
.map(env -> env.statusAsString())
.findFirst()
.orElse("UNKNOWN"));
}
```
+ Per i dettagli sull'API, [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeComputeEnvironments)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DescribeJobQueues` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeJobQueues`.
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 descrivere una coda di processi**
Questo esempio descrive la coda dei HighPriority lavori.
Comando:
```
aws batch describe-job-queues --job-queues HighPriority
```
Output:
```
{
"jobQueues": [
{
"status": "VALID",
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"computeEnvironmentOrder": [
{
"computeEnvironment": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand",
"order": 1
}
],
"statusReason": "JobQueue Healthy",
"priority": 1,
"state": "ENABLED",
"jobQueueName": "HighPriority"
}
]
}
```
+ Per i dettagli sull'API, vedere [DescribeJobQueues](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-queues.html)in *AWS CLI 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).
```
/**
* Asynchronously describes the job queue associated with the specified compute environment.
*
* @param computeEnvironmentName the name of the compute environment to find the associated job queue for
* @return a {@link CompletableFuture} that, when completed, contains the job queue ARN associated with the specified compute environment
* @throws RuntimeException if the job queue description fails
*/
public CompletableFuture describeJobQueueAsync(String computeEnvironmentName) {
DescribeJobQueuesRequest describeJobQueuesRequest = DescribeJobQueuesRequest.builder()
.build();
CompletableFuture responseFuture = getAsyncClient().describeJobQueues(describeJobQueuesRequest);
return responseFuture.whenComplete((describeJobQueuesResponse, ex) -> {
if (describeJobQueuesResponse != null) {
String jobQueueARN;
for (JobQueueDetail jobQueueDetail : describeJobQueuesResponse.jobQueues()) {
for (ComputeEnvironmentOrder computeEnvironmentOrder : jobQueueDetail.computeEnvironmentOrder()) {
String computeEnvironment = computeEnvironmentOrder.computeEnvironment();
String name = getComputeEnvironmentName(computeEnvironment);
if (name.equals(computeEnvironmentName)) {
jobQueueARN = jobQueueDetail.jobQueueArn();
logger.info("Job queue ARN associated with the compute environment: " + jobQueueARN);
}
}
}
} else {
throw new RuntimeException("Failed to describe job queue: " + ex.getMessage(), ex);
}
}).thenApply(describeJobQueuesResponse -> {
String jobQueueARN = "";
for (JobQueueDetail jobQueueDetail : describeJobQueuesResponse.jobQueues()) {
for (ComputeEnvironmentOrder computeEnvironmentOrder : jobQueueDetail.computeEnvironmentOrder()) {
String computeEnvironment = computeEnvironmentOrder.computeEnvironment();
String name = getComputeEnvironmentName(computeEnvironment);
if (name.equals(computeEnvironmentName)) {
jobQueueARN = jobQueueDetail.jobQueueArn();
}
}
}
return jobQueueARN;
});
}
```
+ Per i dettagli sull'API, [DescribeJobQueues](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobQueues)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzo `DescribeJobs` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `DescribeJobs`.
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 descrivere un processo**
L’esempio `describe-jobs` seguente descrive un processo con l’ID processo specificato.
```
aws batch describe-jobs \
--jobs bcf0b186-a532-4122-842e-2ccab8d54efb
```
Output:
```
{
"jobs": [
{
"status": "SUBMITTED",
"container": {
"mountPoints": [],
"image": "busybox",
"environment": [],
"vcpus": 1,
"command": [
"sleep",
"60"
],
"volumes": [],
"memory": 128,
"ulimits": []
},
"parameters": {},
"jobDefinition": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep60:1",
"jobQueue": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"jobId": "bcf0b186-a532-4122-842e-2ccab8d54efb",
"dependsOn": [],
"jobName": "example",
"createdAt": 1480483387803
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeJobs AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.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).
```
/**
* Asynchronously retrieves the status of a specific job.
*
* @param jobId the ID of the job to retrieve the status for
* @return a CompletableFuture that completes with the job status
*/
public CompletableFuture describeJobAsync(String jobId) {
DescribeJobsRequest describeJobsRequest = DescribeJobsRequest.builder()
.jobs(jobId)
.build();
CompletableFuture responseFuture = getAsyncClient().describeJobs(describeJobsRequest);
return responseFuture.whenComplete((response, ex) -> {
if (ex != null) {
throw new RuntimeException("Unexpected error occurred: " + ex.getMessage(), ex);
}
}).thenApply(response -> response.jobs().get(0).status().toString());
}
```
+ Per i dettagli sull'API, [DescribeJobs](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobs)consulta *AWS SDK for Java 2.x API Reference*.
------
# Utilizzare `ListJobsPaginator` con un AWS SDK
Il seguente esempio di codice mostra come utilizzare`ListJobsPaginator`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Informazioni di base](batch_example_batch_Scenario_section.md)
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro da fare 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).
```
/**
* Asynchronously lists the jobs in the specified job queue with the given job status.
*
* @param jobQueue the name of the job queue to list jobs from
* @return a List that contains the jobs that succeeded
*/
public List listJobsAsync(String jobQueue) {
if (jobQueue == null || jobQueue.isEmpty()) {
throw new IllegalArgumentException("Job queue cannot be null or empty");
}
ListJobsRequest listJobsRequest = ListJobsRequest.builder()
.jobQueue(jobQueue)
.jobStatus(JobStatus.SUCCEEDED) // Filter jobs by status.
.build();
List jobSummaries = new ArrayList<>();
ListJobsPublisher listJobsPaginator = getAsyncClient().listJobsPaginator(listJobsRequest);
CompletableFuture 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*.
------
# Scenari di AWS Batch utilizzo AWS SDKs
I seguenti esempi di codice mostrano come implementare scenari comuni in AWS Batch with AWS SDKs. Questi scenari mostrano come eseguire attività specifiche richiamando più funzioni all'interno AWS Batch o combinandole con altre Servizi AWS. Ogni scenario include un collegamento al codice sorgente completo, dove è possibile trovare le istruzioni su come configurare ed eseguire il codice.
Gli scenari sono relativi a un livello intermedio di esperienza per aiutarti a comprendere le azioni di servizio nel contesto.
**Topics**
+ [Nozioni di base su Batch e Fargate](batch_example_fargate_GettingStarted_section.md)
# Nozioni di base su Batch e Fargate con la CLI
L’esempio di codice seguente mostra come:
+ Creare un ruolo di esecuzione IAM per le attività ECS
+ Creare un ambiente di calcolo Fargate gestito
+ Creare una coda di processi con impostazioni di priorità
+ Registrare una definizione di processo per carichi di lavoro containerizzati
+ Inviare e monitorare l’esecuzione di un processo batch
+ Visualizza l'output del lavoro nei registri CloudWatch
+ Eseguire la pulizia delle risorse nell’ordine di dipendenza corretto
------
#### [ Bash ]
**AWS CLI con lo script Bash**
C'è altro da fare. GitHub Trova l’esempio completo e scopri come eseguire la configurazione e l’esecuzione nel [repository dei tutorial sugli esempi di codice per gli sviluppatori](https://github.com/aws-samples/sample-developer-tutorials/tree/main/tuts/011-getting-started-batch-fargate).
```
#!/bin/bash
# AWS Batch Fargate Getting Started Script - Fixed Version
# This script demonstrates creating AWS Batch resources with Fargate orchestration
#
# HIGH SEVERITY FIXES APPLIED:
# 1. Added IAM role propagation delay after role creation
# 2. Added resource state validation before deletion attempts
set -e # Exit on any error
# Configuration
SCRIPT_NAME="batch-fargate-tutorial"
LOG_FILE="${SCRIPT_NAME}-$(date +%Y%m%d-%H%M%S).log"
RANDOM_SUFFIX=$(openssl rand -hex 6)
COMPUTE_ENV_NAME="batch-fargate-compute-${RANDOM_SUFFIX}"
JOB_QUEUE_NAME="batch-fargate-queue-${RANDOM_SUFFIX}"
JOB_DEF_NAME="batch-fargate-jobdef-${RANDOM_SUFFIX}"
JOB_NAME="batch-hello-world-${RANDOM_SUFFIX}"
ROLE_NAME="BatchEcsTaskExecutionRole-${RANDOM_SUFFIX}"
TRUST_POLICY_FILE="batch-trust-policy-${RANDOM_SUFFIX}.json"
# Array to track created resources for cleanup
CREATED_RESOURCES=()
# Logging function
log() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}
# Error handling function
handle_error() {
log "ERROR: Script failed at line $1"
log "Attempting to clean up resources created so far..."
cleanup_resources
exit 1
}
# Set up error handling
trap 'handle_error $LINENO' ERR
# Function to wait for resource to be ready
wait_for_compute_env() {
local env_name=$1
log "Waiting for compute environment $env_name to be VALID..."
while true; do
local status=$(aws batch describe-compute-environments \
--compute-environments "$env_name" \
--query 'computeEnvironments[0].status' \
--output text 2>/dev/null || echo "NOT_FOUND")
if [ "$status" = "VALID" ]; then
log "Compute environment $env_name is ready"
break
elif [ "$status" = "INVALID" ] || [ "$status" = "NOT_FOUND" ]; then
log "ERROR: Compute environment $env_name failed to create properly"
return 1
fi
log "Compute environment status: $status. Waiting 10 seconds..."
sleep 10
done
}
# Function to wait for job queue to be ready
wait_for_job_queue() {
local queue_name=$1
log "Waiting for job queue $queue_name to be VALID..."
while true; do
local state=$(aws batch describe-job-queues \
--job-queues "$queue_name" \
--query 'jobQueues[0].state' \
--output text 2>/dev/null || echo "NOT_FOUND")
if [ "$state" = "ENABLED" ]; then
log "Job queue $queue_name is ready"
break
elif [ "$state" = "DISABLED" ] || [ "$state" = "NOT_FOUND" ]; then
log "ERROR: Job queue $queue_name failed to create properly"
return 1
fi
log "Job queue state: $state. Waiting 10 seconds..."
sleep 10
done
}
# Function to wait for job completion
wait_for_job() {
local job_id=$1
log "Waiting for job $job_id to complete..."
while true; do
local status=$(aws batch describe-jobs \
--jobs "$job_id" \
--query 'jobs[0].status' \
--output text 2>/dev/null || echo "NOT_FOUND")
if [ "$status" = "SUCCEEDED" ]; then
log "Job $job_id completed successfully"
break
elif [ "$status" = "FAILED" ]; then
log "ERROR: Job $job_id failed"
return 1
fi
log "Job status: $status. Waiting 30 seconds..."
sleep 30
done
}
# FIXED: Added function to wait for resource state before deletion
wait_for_resource_state() {
local resource_type=$1
local resource_name=$2
local expected_state=$3
local max_attempts=30
local attempt=0
log "Waiting for $resource_type $resource_name to reach state: $expected_state"
while [ $attempt -lt $max_attempts ]; do
local current_state=""
case $resource_type in
"JOB_QUEUE")
current_state=$(aws batch describe-job-queues \
--job-queues "$resource_name" \
--query 'jobQueues[0].state' \
--output text 2>/dev/null || echo "NOT_FOUND")
;;
"COMPUTE_ENV")
current_state=$(aws batch describe-compute-environments \
--compute-environments "$resource_name" \
--query 'computeEnvironments[0].status' \
--output text 2>/dev/null || echo "NOT_FOUND")
;;
esac
if [ "$current_state" = "$expected_state" ]; then
log "$resource_type $resource_name is now in state: $expected_state"
return 0
fi
log "$resource_type $resource_name state: $current_state (waiting for $expected_state)"
sleep 10
((attempt++))
done
log "WARNING: $resource_type $resource_name did not reach expected state after $max_attempts attempts"
return 1
}
# Cleanup function
cleanup_resources() {
log "Starting cleanup of created resources..."
# Clean up in reverse order of creation
for ((i=${#CREATED_RESOURCES[@]}-1; i>=0; i--)); do
local resource="${CREATED_RESOURCES[i]}"
local resource_type=$(echo "$resource" | cut -d: -f1)
local resource_name=$(echo "$resource" | cut -d: -f2)
log "Cleaning up $resource_type: $resource_name"
case $resource_type in
"JOB_QUEUE")
# FIXED: Validate state before deletion
aws batch update-job-queue --job-queue "$resource_name" --state DISABLED 2>/dev/null || true
wait_for_resource_state "JOB_QUEUE" "$resource_name" "DISABLED" || true
aws batch delete-job-queue --job-queue "$resource_name" 2>/dev/null || true
;;
"COMPUTE_ENV")
# FIXED: Validate state before deletion
aws batch update-compute-environment --compute-environment "$resource_name" --state DISABLED 2>/dev/null || true
wait_for_resource_state "COMPUTE_ENV" "$resource_name" "DISABLED" || true
aws batch delete-compute-environment --compute-environment "$resource_name" 2>/dev/null || true
;;
"IAM_ROLE")
aws iam detach-role-policy --role-name "$resource_name" --policy-arn "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy" 2>/dev/null || true
aws iam delete-role --role-name "$resource_name" 2>/dev/null || true
;;
"FILE")
rm -f "$resource_name" 2>/dev/null || true
;;
esac
done
log "Cleanup completed"
}
# Main script execution
main() {
log "Starting AWS Batch Fargate tutorial script - Fixed Version"
log "Log file: $LOG_FILE"
# Get AWS account ID
log "Getting AWS account ID..."
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
log "Account ID: $ACCOUNT_ID"
# Get default VPC and subnets
log "Getting default VPC and subnets..."
DEFAULT_VPC=$(aws ec2 describe-vpcs \
--filters "Name=is-default,Values=true" \
--query 'Vpcs[0].VpcId' \
--output text)
if [ "$DEFAULT_VPC" = "None" ] || [ "$DEFAULT_VPC" = "null" ]; then
log "ERROR: No default VPC found. Please create a VPC first."
exit 1
fi
log "Default VPC: $DEFAULT_VPC"
# Get subnets in the default VPC
SUBNETS=$(aws ec2 describe-subnets \
--filters "Name=vpc-id,Values=$DEFAULT_VPC" \
--query 'Subnets[*].SubnetId' \
--output text)
if [ -z "$SUBNETS" ]; then
log "ERROR: No subnets found in default VPC"
exit 1
fi
# Convert tab/space-separated subnets to JSON array format
SUBNET_ARRAY=$(echo "$SUBNETS" | tr '\t ' '\n' | sed 's/^/"/;s/$/"/' | paste -sd ',' -)
log "Subnets: $SUBNETS"
log "Subnet array: [$SUBNET_ARRAY]"
# Get default security group for the VPC
DEFAULT_SG=$(aws ec2 describe-security-groups \
--filters "Name=vpc-id,Values=$DEFAULT_VPC" "Name=group-name,Values=default" \
--query 'SecurityGroups[0].GroupId' \
--output text)
if [ "$DEFAULT_SG" = "None" ] || [ "$DEFAULT_SG" = "null" ]; then
log "ERROR: No default security group found in VPC"
exit 1
fi
log "Default security group: $DEFAULT_SG"
# Step 1: Create IAM execution role
log "Step 1: Creating IAM execution role..."
# Create trust policy document
cat > "$TRUST_POLICY_FILE" << EOF
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ecs-tasks.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
CREATED_RESOURCES+=("FILE:$TRUST_POLICY_FILE")
# Create the role
aws iam create-role \
--role-name "$ROLE_NAME" \
--assume-role-policy-document "file://$TRUST_POLICY_FILE"
CREATED_RESOURCES+=("IAM_ROLE:$ROLE_NAME")
# Attach policy
aws iam attach-role-policy \
--role-name "$ROLE_NAME" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
log "IAM role created: $ROLE_NAME"
# FIXED: Wait for IAM role propagation
log "Waiting for IAM role propagation (15 seconds)..."
sleep 15
# Step 2: Create compute environment
log "Step 2: Creating Fargate compute environment..."
aws batch create-compute-environment \
--compute-environment-name "$COMPUTE_ENV_NAME" \
--type MANAGED \
--state ENABLED \
--compute-resources "{
\"type\": \"FARGATE\",
\"maxvCpus\": 256,
\"subnets\": [$SUBNET_ARRAY],
\"securityGroupIds\": [\"$DEFAULT_SG\"]
}"
CREATED_RESOURCES+=("COMPUTE_ENV:$COMPUTE_ENV_NAME")
# Wait for compute environment to be ready
wait_for_compute_env "$COMPUTE_ENV_NAME"
# Step 3: Create job queue
log "Step 3: Creating job queue..."
aws batch create-job-queue \
--job-queue-name "$JOB_QUEUE_NAME" \
--state ENABLED \
--priority 900 \
--compute-environment-order order=1,computeEnvironment="$COMPUTE_ENV_NAME"
CREATED_RESOURCES+=("JOB_QUEUE:$JOB_QUEUE_NAME")
# Wait for job queue to be ready
wait_for_job_queue "$JOB_QUEUE_NAME"
# Step 4: Create job definition
log "Step 4: Creating job definition..."
aws batch register-job-definition \
--job-definition-name "$JOB_DEF_NAME" \
--type container \
--platform-capabilities FARGATE \
--container-properties "{
\"image\": \"busybox\",
\"resourceRequirements\": [
{\"type\": \"VCPU\", \"value\": \"0.25\"},
{\"type\": \"MEMORY\", \"value\": \"512\"}
],
\"command\": [\"echo\", \"hello world\"],
\"networkConfiguration\": {
\"assignPublicIp\": \"ENABLED\"
},
\"executionRoleArn\": \"arn:aws:iam::${ACCOUNT_ID}:role/${ROLE_NAME}\"
}"
log "Job definition created: $JOB_DEF_NAME"
# Step 5: Submit job
log "Step 5: Submitting job..."
JOB_ID=$(aws batch submit-job \
--job-name "$JOB_NAME" \
--job-queue "$JOB_QUEUE_NAME" \
--job-definition "$JOB_DEF_NAME" \
--query 'jobId' \
--output text)
log "Job submitted with ID: $JOB_ID"
# Step 6: Wait for job completion and view output
log "Step 6: Waiting for job completion..."
wait_for_job "$JOB_ID"
# Get log stream name
log "Getting job logs..."
LOG_STREAM=$(aws batch describe-jobs \
--jobs "$JOB_ID" \
--query 'jobs[0].attempts[0].taskProperties.containers[0].logStreamName' \
--output text)
if [ "$LOG_STREAM" != "None" ] && [ "$LOG_STREAM" != "null" ]; then
log "Log stream: $LOG_STREAM"
log "Job output:"
aws logs get-log-events \
--log-group-name "/aws/batch/job" \
--log-stream-name "$LOG_STREAM" \
--query 'events[*].message' \
--output text | tee -a "$LOG_FILE"
else
log "No log stream available for job"
fi
log "Tutorial completed successfully!"
# Show created resources
echo ""
echo "==========================================="
echo "CREATED RESOURCES"
echo "==========================================="
echo "The following resources were created:"
for resource in "${CREATED_RESOURCES[@]}"; do
echo " - $resource"
done
echo ""
echo "==========================================="
echo "CLEANUP CONFIRMATION"
echo "==========================================="
echo "Do you want to clean up all created resources? (y/n): "
read -r CLEANUP_CHOICE
if [[ "$CLEANUP_CHOICE" =~ ^[Yy]$ ]]; then
cleanup_resources
log "All resources have been cleaned up"
else
log "Resources left intact. You can clean them up manually later."
echo "To clean up manually, run the following commands:"
echo "aws batch update-job-queue --job-queue $JOB_QUEUE_NAME --state DISABLED"
echo "aws batch delete-job-queue --job-queue $JOB_QUEUE_NAME"
echo "aws batch update-compute-environment --compute-environment $COMPUTE_ENV_NAME --state DISABLED"
echo "aws batch delete-compute-environment --compute-environment $COMPUTE_ENV_NAME"
echo "aws iam detach-role-policy --role-name $ROLE_NAME --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
echo "aws iam delete-role --role-name $ROLE_NAME"
fi
}
# Run main function
main "$@"
```
+ Per informazioni dettagliate sull’API, consulta i seguenti argomenti nella *documentazione di riferimento dei comandi della AWS CLI *.
+ [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/CreateComputeEnvironment)
+ [CreateJobQueue](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/CreateJobQueue)
+ [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/DeleteComputeEnvironment)
+ [DeleteJobQueue](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/DeleteJobQueue)
+ [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/DescribeComputeEnvironments)
+ [DescribeJobQueues](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/DescribeJobQueues)
+ [DescribeJobs](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/DescribeJobs)
+ [RegisterJobDefinition](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/RegisterJobDefinition)
+ [SubmitJob](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/SubmitJob)
+ [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/UpdateComputeEnvironment)
+ [UpdateJobQueue](https://docs.aws.amazon.com/goto/aws-cli/batch-2016-08-10/UpdateJobQueue)
------