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);
}
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 다음 주제를 참조하세요.
+ [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)
------
# AWS SDKs AWS Batch 를 사용하기 위한 작업
다음 코드 예제에서는 AWS SDKs를 사용하여 개별 AWS Batch 작업을 수행하는 방법을 보여줍니다. 각 예제에는 GitHub에 대한 링크가 포함되어 있습니다. 여기에서 코드 설정 및 실행에 대한 지침을 찾을 수 있습니다.
이러한 발췌문은 AWS Batch API를 호출하며 컨텍스트에서 실행해야 하는 더 큰 프로그램에서 발췌한 코드입니다. [AWS SDKs AWS Batch 사용 시나리오](batch_code_examples_scenarios.md)에서 컨텍스트에 맞는 작업을 볼 수 있습니다.
다음 예제에는 가장 일반적으로 사용되는 작업만 포함되어 있습니다. 전체 목록은 [AWS Batch API 참조](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)
# AWS SDK 또는 CLI와 `CreateComputeEnvironment` 함께 사용
다음 코드 예시는 `CreateComputeEnvironment`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**온디맨드 인스턴스를 사용하여 관리형 컴퓨팅 환경을 생성하는 방법**
이 예제에서는 온디맨드 방식으로 시작되는 특정 C4 인스턴스 유형을 사용하여 관리형 컴퓨팅 환경을 생성합니다. 이 컴퓨팅 환경을 C4OnDemand라고 합니다.
명령:
```
aws batch create-compute-environment --cli-input-json file:///C4OnDemand.json
```
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"
}
```
출력:
```
{
"computeEnvironmentName": "C4OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/C4OnDemand"
}
```
**스팟 인스턴스를 사용하여 관리형 컴퓨팅 환경을 생성하는 방법**
이 예제에서는 스팟 입찰 가격이 인스턴스 유형에 대한 온디맨드 가격의 20% 이하일 때 시작되는 M4 인스턴스 유형을 사용하여 관리형 컴퓨팅 환경을 생성합니다. 이 컴퓨팅 환경을 M4Spot이라고 합니다.
명령:
```
aws batch create-compute-environment --cli-input-json file:///M4Spot.json
```
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"
}
```
출력:
```
{
"computeEnvironmentName": "M4Spot",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/M4Spot"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [CreateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-compute-environment.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [CreateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateComputeEnvironment)를 참조하세요.
------
# AWS SDK 또는 CLI와 `CreateJobQueue` 함께 사용
다음 코드 예시는 `CreateJobQueue`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**단일 컴퓨팅 환경을 사용하여 낮은 우선순위 작업 대기열을 생성하는 방법**
이 예제에서는 M4Spot 컴퓨팅 환경을 사용하는 LowPriority라고 하는 작업 대기열을 생성합니다.
명령:
```
aws batch create-job-queue --cli-input-json file:///LowPriority.json
```
JSON 파일 형식:
```
{
"jobQueueName": "LowPriority",
"state": "ENABLED",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "M4Spot"
}
]
}
```
출력:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/LowPriority",
"jobQueueName": "LowPriority"
}
```
**두 개의 컴퓨팅 환경을 사용하여 높은 우선순위 작업 대기열을 생성하는 방법**
이 예제에서는 순서가 1인 C4OnDemand 컴퓨팅 환경과 순서가 2인 M4Spot 컴퓨팅 환경을 사용하는 HighPriority라고 하는 작업 대기열을 생성합니다. 스케줄러는 먼저 C4OnDemand 컴퓨팅 환경에 작업을 배치하려고 시도합니다.
명령:
```
aws batch create-job-queue --cli-input-json file:///HighPriority.json
```
JSON 파일 형식:
```
{
"jobQueueName": "HighPriority",
"state": "ENABLED",
"priority": 1,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "C4OnDemand"
},
{
"order": 2,
"computeEnvironment": "M4Spot"
}
]
}
```
출력:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/HighPriority",
"jobQueueName": "HighPriority"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [CreateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/create-job-queue.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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);
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [CreateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/CreateJobQueue)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DeleteComputeEnvironment` 함께 사용
다음 코드 예시는 `DeleteComputeEnvironment`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**컴퓨팅 환경을 삭제하는 방법**
이 예제에서는 P2OnDemand 컴퓨팅 환경을 삭제합니다.
명령:
```
aws batch delete-compute-environment --compute-environment P2OnDemand
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DeleteComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-compute-environment.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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);
}
}
});
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DeleteComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteComputeEnvironment)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DeleteJobQueue` 함께 사용
다음 코드 예시는 `DeleteJobQueue`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**대기열을 삭제하는 방법**
이 예제에서는 GPGPU 작업 대기열을 삭제합니다.
명령:
```
aws batch delete-job-queue --job-queue GPGPU
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DeleteJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/delete-job-queue.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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);
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DeleteJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeleteJobQueue)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DeregisterJobDefinition` 함께 사용
다음 코드 예시는 `DeregisterJobDefinition`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업 정의의 등록을 취소하는 방법**
이 예제에서는 sleep10이라고 하는 작업 정의의 등록을 취소합니다.
명령:
```
aws batch deregister-job-definition --job-definition sleep10
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DeregisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/deregister-job-definition.html)을 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DeregisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DeregisterJobDefinition)을 참조하세요.
------
# AWS SDK 또는 CLI와 `DescribeComputeEnvironments` 함께 사용
다음 코드 예시는 `DescribeComputeEnvironments`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**컴퓨팅 환경을 설명하는 방법**
이 예시에서는 P2Ondemand 컴퓨팅 환경을 설명합니다.
명령:
```
aws batch describe-compute-environments --compute-environments P2OnDemand
```
출력:
```
{
"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"
}
]
}
```
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeComputeEnvironments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-compute-environments.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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"));
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeComputeEnvironments](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeComputeEnvironments)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DescribeJobQueues` 함께 사용
다음 코드 예시는 `DescribeJobQueues`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업 대기열을 설명하는 방법**
이 예제에서는 HighPriority 작업 대기열을 설명합니다.
명령:
```
aws batch describe-job-queues --job-queues HighPriority
```
출력:
```
{
"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"
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DescribeJobQueues](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-job-queues.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
});
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeJobQueues](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobQueues)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DescribeJobs` 함께 사용
다음 코드 예시는 `DescribeJobs`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업을 설명하는 방법**
다음 `describe-jobs` 예제에서는 지정된 작업 ID가 있는 작업을 설명합니다.
```
aws batch describe-jobs \
--jobs bcf0b186-a532-4122-842e-2ccab8d54efb
```
출력:
```
{
"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
}
]
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DescribeJobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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());
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeJobs](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/DescribeJobs)을 참조하세요.
------
# AWS SDK와 `ListJobsPaginator` 함께 사용
다음 코드 예시는 `ListJobsPaginator`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서 컨텍스트 내 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [ListJobsPaginator](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/ListJobsPaginator)를 참조하세요.
------
# AWS SDK 또는 CLI와 `RegisterJobDefinition` 함께 사용
다음 코드 예시는 `RegisterJobDefinition`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업 정의를 등록하는 방법**
이 예제에서는 간단한 컨테이너 작업에 대한 작업 정의를 등록합니다.
명령:
```
aws batch register-job-definition --job-definition-name sleep30 --type container --container-properties '{ "image": "busybox", "vcpus": 1, "memory": 128, "command": [ "sleep", "30"]}'
```
출력:
```
{
"jobDefinitionArn": "arn:aws:batch:us-east-1:012345678910:job-definition/sleep30:1",
"jobDefinitionName": "sleep30",
"revision": 1
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [RegisterJobDefinition](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/register-job-definition.html)을 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [RegisterJobDefinition](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/RegisterJobDefinition)을 참조하세요.
------
# AWS SDK 또는 CLI와 `SubmitJob` 함께 사용
다음 코드 예시는 `SubmitJob`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업을 제출하는 방법**
이 예제에서는 예제라고 하는 간단한 컨테이너 작업을 HighPriority 작업 대기열에 제출합니다.
명령:
```
aws batch submit-job --job-name example --job-queue HighPriority --job-definition sleep60
```
출력:
```
{
"jobName": "example",
"jobId": "876da822-4198-45f2-a252-6cea32512ea8"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [SubmitJob](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/submit-job.html)을 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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);
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [SubmitJob](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/SubmitJob)을 참조하세요.
------
# AWS SDK 또는 CLI와 `UpdateComputeEnvironment` 함께 사용
다음 코드 예시는 `UpdateComputeEnvironment`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**컴퓨팅 환경을 업데이트하는 방법**
이 예제에서는 P2OnDemand 컴퓨팅 환경이 삭제될 수 있도록 이 환경을 비활성화합니다.
명령:
```
aws batch update-compute-environment --compute-environment P2OnDemand --state DISABLED
```
출력:
```
{
"computeEnvironmentName": "P2OnDemand",
"computeEnvironmentArn": "arn:aws:batch:us-east-1:012345678910:compute-environment/P2OnDemand"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [UpdateComputeEnvironment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-compute-environment.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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;
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [UpdateComputeEnvironment](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateComputeEnvironment)를 참조하세요.
------
# AWS SDK 또는 CLI와 `UpdateJobQueue` 함께 사용
다음 코드 예시는 `UpdateJobQueue`의 사용 방법을 보여 줍니다.
작업 예시는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [기본 사항 알아보기](batch_example_batch_Scenario_section.md)
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
------
#### [ CLI ]
**AWS CLI**
**작업 대기열을 업데이트하는 방법**
이 예제에서는 작업 대기열이 삭제될 수 있도록 이 작업 대기열을 비활성화합니다.
명령:
```
aws batch update-job-queue --job-queue GPGPU --state DISABLED
```
출력:
```
{
"jobQueueArn": "arn:aws:batch:us-east-1:012345678910:job-queue/GPGPU",
"jobQueueName": "GPGPU"
}
```
+ API 세부 정보는 *AWS CLI 명령 참조*의 [UpdateJobQueue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/update-job-queue.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [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);
}
```
+ API 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [UpdateJobQueue](https://docs.aws.amazon.com/goto/SdkForJavaV2/batch-2016-08-10/UpdateJobQueue)를 참조하세요.
------
# AWS SDKs AWS Batch 사용 시나리오
다음 코드 예제에서는 AWS SDKs를 사용하여에서 AWS Batch 일반적인 시나리오를 구현하는 방법을 보여줍니다. 이러한 시나리오에서는 내부 AWS Batch 또는 다른 함수와 결합된 여러 함수를 호출하여 특정 작업을 수행하는 방법을 보여줍니다 AWS 서비스. 각 시나리오에는 전체 소스 코드에 대한 링크가 포함되어 있습니다. 여기에서 코드를 설정 및 실행하는 방법에 대한 지침을 찾을 수 있습니다.
시나리오는 컨텍스트에 맞는 서비스 작업을 이해하는 데 도움이 되도록 중급 수준의 경험을 대상으로 합니다.
**Topics**
+ [Batch 및 Fargate 시작하기](batch_example_fargate_GettingStarted_section.md)
# CLI를 사용하여 Batch 및 Fargate 시작하기
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ ECS 태스크의 IAM 실행 역할 생성
+ 관리형 Fargate 컴퓨팅 환경 생성
+ 우선 순위 설정을 사용하여 작업 대기열 생성
+ 컨테이너화된 워크로드에 대한 작업 정의 등록
+ 배치 작업 실행 제출 및 모니터링
+ CloudWatch Logs에서 작업 출력 보기
+ 적절한 종속성 순서로 리소스 정리
------
#### [ Bash ]
**AWS CLI Bash 스크립트 사용**
GitHub에 더 많은 내용이 있습니다. [샘플 개발자 튜토리얼](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 "$@"
```
+ API 세부 정보는 **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)
------