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);
}
}
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit 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)
------
# Actions d' AWS Batch utilisation AWS SDKs
Les exemples de code suivants montrent comment effectuer des AWS Batch actions individuelles avec AWS SDKs. Chaque exemple inclut un lien vers GitHub, où vous pouvez trouver des instructions pour configurer et exécuter le code.
Ces extraits appellent l' AWS Batch API et sont des extraits de code de programmes plus volumineux qui doivent être exécutés en contexte. Vous pouvez voir les actions dans leur contexte dans [Scénarios d' AWS Batch utilisation AWS SDKs](batch_code_examples_scenarios.md).
Les exemples suivants incluent uniquement les actions les plus couramment utilisées. Pour obtenir la liste complète, consultez la [Référence des 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)
# Utilisation `CreateComputeEnvironment` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `CreateComputeEnvironment`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour créer un environnement de calcul géré avec des instances à la demande**
Cet exemple crée un environnement de calcul géré avec des types d’instances C4 spécifiques lancées à la demande. L'environnement informatique s'appelle C4OnDemand.
Commande :
```
aws batch create-compute-environment --cli-input-json file:///C4OnDemand.json
```
Format du fichier 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"
}
```
Sortie :
```
{
"computeEnvironmentName": "C4OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand"
}
```
**Pour créer un environnement de calcul géré avec des instances Spot**
Cet exemple crée un environnement de calcul géré avec le type d’instance M4 lancé lorsque le tarif de l’offre Spot est égal ou inférieur de 20 % au tarif à la demande pour le type d’instance. L’environnement de calcul s’appelle M4Spot.
Commande :
```
aws batch create-compute-environment --cli-input-json file:///M4Spot.json
```
Format du fichier 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"
}
```
Sortie :
```
{
"computeEnvironmentName": "M4Spot",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/M4Spot"
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-compute-environment.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateComputeEnvironment)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `CreateJobQueue` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `CreateJobQueue`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour créer une file d’attente de tâches à faible priorité avec un environnement de calcul unique**
Cet exemple crée une file d'attente de tâches appelée LowPriority qui utilise l'environnement informatique M4Spot.
Commande :
```
aws batch create-job-queue --cli-input-json file:///LowPriority.json
```
Format du fichier JSON :
```
{
"jobQueueName": "LowPriority",
"state": "ENABLED",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "M4Spot"
}
]
}
```
Sortie :
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/LowPriority",
"jobQueueName": "LowPriority"
}
```
**Pour créer une file d’attente de tâches à priorité élevée avec deux environnements de calcul**
Cet exemple crée une file d'attente de tâches appelée HighPriority qui utilise l'environnement OnDemand informatique C4 avec un ordre de 1 et l'environnement de calcul M4Spot avec un ordre de 2. Le planificateur essaiera d'abord de placer les tâches dans l'environnement OnDemand informatique C4.
Commande :
```
aws batch create-job-queue --cli-input-json file:///HighPriority.json
```
Format du fichier JSON :
```
{
"jobQueueName": "HighPriority",
"state": "ENABLED",
"priority": 1,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "C4OnDemand"
},
{
"order": 2,
"computeEnvironment": "M4Spot"
}
]
}
```
Sortie :
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"jobQueueName": "HighPriority"
}
```
+ Pour plus de détails sur l'API, reportez-vous [CreateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-job-queue.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [CreateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateJobQueue)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DeleteComputeEnvironment` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DeleteComputeEnvironment`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour supprimer un environnement de calcul**
Cet exemple supprime l'environnement de OnDemand calcul P2.
Commande :
```
aws batch delete-compute-environment --compute-environment P2OnDemand
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-compute-environment.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
}
});
}
```
+ Pour plus de détails sur l'API, voir [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteComputeEnvironment)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DeleteJobQueue` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DeleteJobQueue`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour supprimer une file d’attente de tâches**
Cet exemple supprime la file d’attente de tâches GPGPU.
Commande :
```
aws batch delete-job-queue --job-queue GPGPU
```
+ Pour plus de détails sur l'API, reportez-vous [DeleteJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-job-queue.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [DeleteJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteJobQueue)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DeregisterJobDefinition` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DeregisterJobDefinition`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](batch_example_batch_Scenario_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour annuler l’enregistrement d’une définition de tâche**
Cet exemple annule l’enregistrement d’une définition de tâche appelée sleep10.
Commande :
```
aws batch deregister-job-definition --job-definition sleep10
```
+ Pour plus de détails sur l'API, reportez-vous [DeregisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/deregister-job-definition.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [DeregisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeregisterJobDefinition)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DescribeComputeEnvironments` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeComputeEnvironments`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour décrire un environnement de calcul**
Cet exemple décrit l'environnement de OnDemand calcul P2.
Commande :
```
aws batch describe-compute-environments --compute-environments P2OnDemand
```
Sortie :
```
{
"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"
}
]
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeComputeEnvironments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-compute-environments.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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"));
}
```
+ Pour plus de détails sur l'API, voir [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeComputeEnvironments)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DescribeJobQueues` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeJobQueues`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour décrire une file d’attente de tâches**
Cet exemple décrit la file HighPriority d'attente des tâches.
Commande :
```
aws batch describe-job-queues --job-queues HighPriority
```
Sortie :
```
{
"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"
}
]
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeJobQueues](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-queues.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
});
}
```
+ Pour plus de détails sur l'API, voir [DescribeJobQueues](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobQueues)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `DescribeJobs` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `DescribeJobs`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour décrire une tâche**
L’exemple `describe-jobs` suivant décrit une tâche avec l’ID de tâche spécifié.
```
aws batch describe-jobs \
--jobs bcf0b186-a532-4122-842e-2ccab8d54efb
```
Sortie :
```
{
"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
}
]
}
```
+ Pour plus de détails sur l'API, reportez-vous [DescribeJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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());
}
```
+ Pour plus de détails sur l'API, voir [DescribeJobs](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobs)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `ListJobsPaginator` avec un AWS SDK
L'exemple de code suivant montre comment utiliser`ListJobsPaginator`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :
+ [Principes de base](batch_example_batch_Scenario_section.md)
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [ListJobsPaginator](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/ListJobsPaginator)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `RegisterJobDefinition` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `RegisterJobDefinition`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour enregistrer une définition de tâche**
Cet exemple enregistre une définition pour une tâche de conteneur simple.
Commande :
```
aws batch register-job-definition --job-definition-name sleep30 --type container --container-properties '{ "image": "busybox", "vcpus": 1, "memory": 128, "command": [ "sleep", "30"]}'
```
Sortie :
```
{
"jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep30:1",
"jobDefinitionName": "sleep30",
"revision": 1
}
```
+ Pour plus de détails sur l'API, reportez-vous [RegisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/register-job-definition.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [RegisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/RegisterJobDefinition)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `SubmitJob` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `SubmitJob`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour soumettre une tâche**
Cet exemple soumet une tâche de conteneur simple appelée example à la file d'attente des HighPriority tâches.
Commande :
```
aws batch submit-job --job-name example --job-queue HighPriority --job-definition sleep60
```
Sortie :
```
{
"jobName": "example",
"jobId": "876da822-4198-45f2-a252-6cea32512ea8"
}
```
+ Pour plus de détails sur l'API, reportez-vous [SubmitJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/submit-job.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [SubmitJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/SubmitJob)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `UpdateComputeEnvironment` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `UpdateComputeEnvironment`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour mettre à jour un environnement de calcul**
Cet exemple désactive l'environnement OnDemand informatique P2 afin qu'il puisse être supprimé.
Commande :
```
aws batch update-compute-environment --compute-environment P2OnDemand --state DISABLED
```
Sortie :
```
{
"computeEnvironmentName": "P2OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand"
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-compute-environment.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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;
}
```
+ Pour plus de détails sur l'API, voir [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateComputeEnvironment)la section *Référence des AWS SDK for Java 2.x API*.
------
# Utilisation `UpdateJobQueue` avec un AWS SDK ou une CLI
Les exemples de code suivants illustrent comment utiliser `UpdateJobQueue`.
Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans les exemples de code suivants :
+ [Principes de base](batch_example_batch_Scenario_section.md)
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**Pour mettre à jour une file d’attente de tâches**
Cet exemple désactive une file d’attente de tâches afin de pouvoir la supprimer.
Commande :
```
aws batch update-job-queue --job-queue GPGPU --state DISABLED
```
Sortie :
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/GPGPU",
"jobQueueName": "GPGPU"
}
```
+ Pour plus de détails sur l'API, reportez-vous [UpdateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-job-queue.html)à la section *Référence des AWS CLI commandes*.
------
#### [ Java ]
**SDK pour Java 2.x**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code 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);
}
```
+ Pour plus de détails sur l'API, voir [UpdateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateJobQueue)la section *Référence des AWS SDK for Java 2.x API*.
------
# Scénarios d' AWS Batch utilisation AWS SDKs
Les exemples de code suivants vous montrent comment implémenter des scénarios courants dans AWS Batch with AWS SDKs. Ces scénarios vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions AWS Batch ou en les combinant avec d'autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code.
Les scénarios ciblent un niveau d’expérience intermédiaire pour vous aider à comprendre les actions de service dans leur contexte.
**Topics**
+ [Mise en route avec Batch et Fargate](batch_example_fargate_GettingStarted_section.md)
# Mise en route avec Batch et Fargate à l’aide de l’interface de ligne de commande (CLI)
L’exemple de code suivant illustre comment :
+ créer un rôle d’exécution IAM pour les tâches ECS ;
+ créer un environnement de calcul Fargate géré ;
+ créer une file d’attente de tâches avec des paramètres de priorité ;
+ enregistrer une définition de tâche pour les charges de travail conteneurisées ;
+ soumettre et surveiller l’exécution d’une tâche par lot ;
+ Afficher le résultat du travail dans CloudWatch les journaux
+ nettoyer les ressources dans le bon ordre de dépendance.
------
#### [ Bash ]
**AWS CLI avec le script Bash**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code](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 "$@"
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des commandes de l’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)
------