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);
}
}
```
+ Para obter detalhes da API, consulte os tópicos a seguir na *Referência da 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)
------
# Ações para AWS Batch usar AWS SDKs
Os exemplos de código a seguir demonstram como realizar AWS Batch ações individuais com AWS SDKs. Cada exemplo inclui um link para GitHub, onde você pode encontrar instruções para configurar e executar o código.
Esses trechos chamam a AWS Batch API e são trechos de código de programas maiores que devem ser executados em contexto. É possível ver as ações em contexto em [Cenários para AWS Batch usar AWS SDKs](batch_code_examples_scenarios.md).
Os exemplos a seguir incluem apenas as ações mais utilizadas. Para obter uma lista completa, consulte a [Referência de APIs do 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)
# Use `CreateComputeEnvironment` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `CreateComputeEnvironment`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para criar um ambiente computacional gerenciado com instâncias sob demanda**
Este exemplo cria um ambiente computacional gerenciado com tipos específicos de instância C4 que são executados sob demanda. O ambiente computacional é chamado de OnDemand C4.
Comando:
```
aws batch create-compute-environment --cli-input-json file:///C4OnDemand.json
```
Formato de arquivo 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"
}
```
Saída:
```
{
"computeEnvironmentName": "C4OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand"
}
```
**Para criar um ambiente de computação gerenciado com instâncias spot**
Este exemplo cria um ambiente de computação gerenciado com o tipo de instância M4 que é executado quando a sugestão de preço do Spot é igual ou inferior a 20% do preço sob demanda do tipo de instância. O ambiente computacional é chamado de M4Spot.
Comando:
```
aws batch create-compute-environment --cli-input-json file:///M4Spot.json
```
Formato de arquivo 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"
}
```
Saída:
```
{
"computeEnvironmentName": "M4Spot",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/M4Spot"
}
```
+ Para obter detalhes da API, consulte [CreateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-compute-environment.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateComputeEnvironment)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `CreateJobQueue` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `CreateJobQueue`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para criar uma fila de trabalhos de baixa prioridade com um único ambiente computacional**
Este exemplo cria uma fila de trabalhos chamada LowPriority que usa o ambiente de computação M4Spot.
Comando:
```
aws batch create-job-queue --cli-input-json file:///LowPriority.json
```
Formato de arquivo JSON:
```
{
"jobQueueName": "LowPriority",
"state": "ENABLED",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "M4Spot"
}
]
}
```
Saída:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/LowPriority",
"jobQueueName": "LowPriority"
}
```
**Para criar uma fila de trabalhos de alta prioridade com dois ambientes computacionais**
Este exemplo cria uma fila de trabalhos chamada HighPriority que usa o ambiente de OnDemand computação C4 com uma ordem de 1 e o ambiente de computação M4Spot com uma ordem de 2. O programador tentará primeiro colocar trabalhos no ambiente OnDemand computacional C4.
Comando:
```
aws batch create-job-queue --cli-input-json file:///HighPriority.json
```
Formato de arquivo JSON:
```
{
"jobQueueName": "HighPriority",
"state": "ENABLED",
"priority": 1,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "C4OnDemand"
},
{
"order": 2,
"computeEnvironment": "M4Spot"
}
]
}
```
Saída:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"jobQueueName": "HighPriority"
}
```
+ Para obter detalhes da API, consulte [CreateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-job-queue.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
```
+ Para obter detalhes da API, consulte [CreateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateJobQueue)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DeleteComputeEnvironment` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DeleteComputeEnvironment`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para excluir um ambiente de computação**
Este exemplo exclui o ambiente OnDemand computacional P2.
Comando:
```
aws batch delete-compute-environment --compute-environment P2OnDemand
```
+ Para obter detalhes da API, consulte [DeleteComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-compute-environment.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
}
});
}
```
+ Para obter detalhes da API, consulte [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteComputeEnvironment)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DeleteJobQueue` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DeleteJobQueue`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para excluir uma fila de trabalhos**
Este exemplo exclui a fila de trabalho GPGPU.
Comando:
```
aws batch delete-job-queue --job-queue GPGPU
```
+ Para obter detalhes da API, consulte [DeleteJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-job-queue.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
```
+ Para obter detalhes da API, consulte [DeleteJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteJobQueue)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DeregisterJobDefinition` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DeregisterJobDefinition`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
------
#### [ CLI ]
**AWS CLI**
**Como cancelar o registro de uma definição de trabalho**
Este exemplo cancela o registro de uma definição de trabalho chamada sleep10.
Comando:
```
aws batch deregister-job-definition --job-definition sleep10
```
+ Para obter detalhes da API, consulte [DeregisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/deregister-job-definition.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [DeregisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeregisterJobDefinition)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DescribeComputeEnvironments` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DescribeComputeEnvironments`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Como descrever um ambiente de computação**
Este exemplo descreve o ambiente OnDemand computacional P2.
Comando:
```
aws batch describe-compute-environments --compute-environments P2OnDemand
```
Saída:
```
{
"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"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeComputeEnvironments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-compute-environments.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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"));
}
```
+ Para obter detalhes da API, consulte [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeComputeEnvironments)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DescribeJobQueues` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DescribeJobQueues`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para descrever uma fila de trabalhos**
Este exemplo descreve a fila HighPriority de trabalhos.
Comando:
```
aws batch describe-job-queues --job-queues HighPriority
```
Saída:
```
{
"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"
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeJobQueues](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-queues.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
});
}
```
+ Para obter detalhes da API, consulte [DescribeJobQueues](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobQueues)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `DescribeJobs` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DescribeJobs`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para descrever um trabalho**
O exemplo `describe-jobs` a seguir descreve um trabalho com o ID de trabalho especificado.
```
aws batch describe-jobs \
--jobs bcf0b186-a532-4122-842e-2ccab8d54efb
```
Saída:
```
{
"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
}
]
}
```
+ Para obter detalhes da API, consulte [DescribeJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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());
}
```
+ Para obter detalhes da API, consulte [DescribeJobs](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobs)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `ListJobsPaginator` com um AWS SDK
O código de exemplo a seguir mostra como usar `ListJobsPaginator`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [ListJobsPaginator](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/ListJobsPaginator)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `RegisterJobDefinition` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `RegisterJobDefinition`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para registrar uma definição de trabalho**
Este exemplo registra uma definição de trabalho para um trabalho de contêiner simples.
Comando:
```
aws batch register-job-definition --job-definition-name sleep30 --type container --container-properties '{ "image": "busybox", "vcpus": 1, "memory": 128, "command": [ "sleep", "30"]}'
```
Saída:
```
{
"jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep30:1",
"jobDefinitionName": "sleep30",
"revision": 1
}
```
+ Para obter detalhes da API, consulte [RegisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/register-job-definition.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [RegisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/RegisterJobDefinition)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `SubmitJob` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `SubmitJob`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Como enviar um trabalho**
Este exemplo envia um trabalho de contêiner simples chamado example para a fila de HighPriority trabalhos.
Comando:
```
aws batch submit-job --job-name example --job-queue HighPriority --job-definition sleep60
```
Saída:
```
{
"jobName": "example",
"jobId": "876da822-4198-45f2-a252-6cea32512ea8"
}
```
+ Para obter detalhes da API, consulte [SubmitJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/submit-job.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
```
+ Para obter detalhes da API, consulte [SubmitJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/SubmitJob)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `UpdateComputeEnvironment` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `UpdateComputeEnvironment`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para atualizar um ambiente de computação**
Este exemplo desativa o ambiente OnDemand computacional P2 para que ele possa ser excluído.
Comando:
```
aws batch update-compute-environment --compute-environment P2OnDemand --state DISABLED
```
Saída:
```
{
"computeEnvironmentName": "P2OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand"
}
```
+ Para obter detalhes da API, consulte [UpdateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-compute-environment.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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;
}
```
+ Para obter detalhes da API, consulte [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateComputeEnvironment)a *Referência AWS SDK for Java 2.x da API*.
------
# Use `UpdateJobQueue` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `UpdateJobQueue`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto nos seguintes exemplos de código:
+ [Conheça os conceitos básicos](batch_example_batch_Scenario_section.md)
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Para atualizar uma fila de trabalhos**
Este exemplo desabilita uma fila de trabalhos para que ela possa ser excluída.
Comando:
```
aws batch update-job-queue --job-queue GPGPU --state DISABLED
```
Saída:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/GPGPU",
"jobQueueName": "GPGPU"
}
```
+ Para obter detalhes da API, consulte [UpdateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-job-queue.html)em *Referência de AWS CLI Comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](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);
}
```
+ Para obter detalhes da API, consulte [UpdateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateJobQueue)a *Referência AWS SDK for Java 2.x da API*.
------
# Cenários para AWS Batch usar AWS SDKs
Os exemplos de código a seguir mostram como implementar cenários comuns em AWS Batch with AWS SDKs. Esses cenários mostram como realizar tarefas específicas chamando várias funções internas AWS Batch ou combinadas com outras Serviços da AWS. Cada cenário inclui um link para o código-fonte completo, onde podem ser encontradas instruções sobre como configurar e executar o código.
Os cenários têm como alvo um nível intermediário de experiência para ajudar você a compreender ações de serviço em contexto.
**Topics**
+ [Conceitos básicos do Batch e do Fargate](batch_example_fargate_GettingStarted_section.md)
# Conceitos básicos do Batch e do Fargate usando a CLI
O exemplo de código a seguir mostra como:
+ Criar um perfil de execução do IAM para tarefas do ECS.
+ Criar um ambiente de computação gerenciado do Fargate.
+ Criar uma fila de trabalhos com configurações de prioridade.
+ Registrar uma definição de tarefa para workloads em contêineres.
+ Enviar e monitorar a execução de um trabalho em lote.
+ Exibir a saída do trabalho em CloudWatch Logs
+ Limpar os recursos na ordem de dependência adequada.
------
#### [ Bash ]
**AWS CLI com script Bash**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório [Sample developer tutorials](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 "$@"
```
+ Consulte detalhes da API nos tópicos a seguir na *Referência de comandos da 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)
------