Doc AWS SDK 예제 GitHub 리포지토리에서 더 많은 SDK 예제를 사용할 수 있습니다. [AWS](https://github.com/awsdocs/aws-doc-sdk-examples)
기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# AWS SDKs를 사용하는 Amazon ECS의 코드 예제
다음 코드 예제에서는 Amazon Elastic Container Service를 AWS 소프트웨어 개발 키트(SDK)와 함께 사용하는 방법을 보여줍니다.
*작업*은 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 작업은 개별 서비스 함수를 직접 호출하는 방법을 보여주며, 관련 시나리오의 컨텍스트에 맞는 작업을 볼 수 있습니다.
*시나리오*는 동일한 서비스 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 태스크를 수행하는 방법을 보여주는 코드 예제입니다.
**추가 리소스**
+ **[Amazon ECS 개발자 가이드](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html)** - Amazon ECS에 대한 자세한 정보입니다.
+ **[Amazon ECS API 참조](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/Welcome.html)** - 사용 가능한 모든 Amazon ECS 작업에 대한 세부 정보입니다.
+ **[AWS 개발자 센터](https://aws.amazon.com/developer/code-examples/?awsf.sdk-code-examples-product=product%23elastic-container-service)** - 범주 또는 전체 텍스트 검색을 기준으로 필터링할 수 있는 코드 예제입니다.
+ **[AWS SDK 예제](https://github.com/awsdocs/aws-doc-sdk-examples)** - 기본 설정 언어로 된 전체 코드가 포함된 GitHub 리포지토리. 코드 설정 및 실행을 위한 지침이 포함되어 있습니다.
**Contents**
+ [기본 사항](ecs_code_examples_basics.md)
+ [Hello Amazon ECS](ecs_example_ecs_Hello_section.md)
+ [작업](ecs_code_examples_actions.md)
+ [`CreateCluster`](ecs_example_ecs_CreateCluster_section.md)
+ [`CreateService`](ecs_example_ecs_CreateService_section.md)
+ [`DeleteCluster`](ecs_example_ecs_DeleteCluster_section.md)
+ [`DeleteService`](ecs_example_ecs_DeleteService_section.md)
+ [`DescribeClusters`](ecs_example_ecs_DescribeClusters_section.md)
+ [`DescribeServices`](ecs_example_ecs_DescribeServices_section.md)
+ [`DescribeTasks`](ecs_example_ecs_DescribeTasks_section.md)
+ [`ListClusters`](ecs_example_ecs_ListClusters_section.md)
+ [`ListServices`](ecs_example_ecs_ListServices_section.md)
+ [`ListTasks`](ecs_example_ecs_ListTasks_section.md)
+ [`UpdateClusterSettings`](ecs_example_ecs_UpdateClusterSettings_section.md)
+ [`UpdateService`](ecs_example_ecs_UpdateService_section.md)
+ [시나리오](ecs_code_examples_scenarios.md)
+ [클러스터, 서비스, 작업에 대한 ARN 정보 가져오기](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
# AWS SDKs 사용한 Amazon ECS의 기본 예제
다음 코드 예제에서는 AWS SDK를 통해 Amazon Elastic Container Service의 기본 기능을 사용하는 방법을 보여줍니다.
**Contents**
+ [Hello Amazon ECS](ecs_example_ecs_Hello_section.md)
+ [작업](ecs_code_examples_actions.md)
+ [`CreateCluster`](ecs_example_ecs_CreateCluster_section.md)
+ [`CreateService`](ecs_example_ecs_CreateService_section.md)
+ [`DeleteCluster`](ecs_example_ecs_DeleteCluster_section.md)
+ [`DeleteService`](ecs_example_ecs_DeleteService_section.md)
+ [`DescribeClusters`](ecs_example_ecs_DescribeClusters_section.md)
+ [`DescribeServices`](ecs_example_ecs_DescribeServices_section.md)
+ [`DescribeTasks`](ecs_example_ecs_DescribeTasks_section.md)
+ [`ListClusters`](ecs_example_ecs_ListClusters_section.md)
+ [`ListServices`](ecs_example_ecs_ListServices_section.md)
+ [`ListTasks`](ecs_example_ecs_ListTasks_section.md)
+ [`UpdateClusterSettings`](ecs_example_ecs_UpdateClusterSettings_section.md)
+ [`UpdateService`](ecs_example_ecs_UpdateService_section.md)
# Hello Amazon ECS
다음 코드 예제에서는 Amazon ECS 사용을 시작하는 방법을 보여줍니다.
------
#### [ .NET ]
**SDK for .NET (v4)**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/ECS#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
using Amazon.ECS;
using Amazon.ECS.Model;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Logging.Debug;
namespace ECSActions;
///
/// A class that introduces the Amazon ECS Client by listing the
/// cluster ARNs for the account.
///
public class HelloECS
{
static async System.Threading.Tasks.Task Main(string[] args)
{
// Use the AWS .NET Core Setup package to set up dependency injection for the Amazon ECS client.
// Use your AWS profile name, or leave it blank to use the default profile.
using var host = Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
logging.AddFilter("System", LogLevel.Debug)
.AddFilter("Microsoft", LogLevel.Information)
.AddFilter("Microsoft", LogLevel.Trace))
.ConfigureServices((_, services) =>
services.AddAWSService()
)
.Build();
var amazonECSClient = host.Services.GetRequiredService();
Console.WriteLine($"Hello Amazon ECS! Following are some cluster ARNS available in the your account");
Console.WriteLine();
var clusters = new List();
var clustersPaginator = amazonECSClient.Paginators.ListClusters(new ListClustersRequest());
await foreach (var response in clustersPaginator.Responses)
{
clusters.AddRange(response.ClusterArns);
}
if (clusters.Count > 0)
{
clusters.ForEach(cluster =>
{
Console.WriteLine($"\tARN: {cluster}");
Console.WriteLine($"Cluster Name: {cluster.Split("/").Last()}");
Console.WriteLine();
});
}
else
{
Console.WriteLine("No clusters were found.");
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for .NET API 참조*의 [ListClusters](https://docs.aws.amazon.com/goto/DotNetSDKV4/ecs-2014-11-13/ListClusters)를 참조하세요.
------
# AWS SDKs를 사용한 Amazon ECS 작업
다음 코드 예제에서는 AWS SDKs를 사용하여 개별 Amazon ECS 작업을 수행하는 방법을 보여줍니다. 각 예제에는 GitHub에 대한 링크가 포함되어 있습니다. 여기에서 코드 설정 및 실행에 대한 지침을 찾을 수 있습니다.
Amazon ECS API를 직접적으로 호출하는 이들 발췌문은 컨텍스트에서 실행되어야 하는 더 큰 프로그램에서 발췌한 코드입니다. [AWS SDKs를 사용한 Amazon ECS 시나리오](ecs_code_examples_scenarios.md)에서 컨텍스트에 맞는 작업을 볼 수 있습니다.
다음 예제에는 가장 일반적으로 사용되는 작업만 포함되어 있습니다. 전체 목록은 [Amazon Elastic Container Service API 참조](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/Welcome.html)에서 확인하세요.
**Topics**
+ [`CreateCluster`](ecs_example_ecs_CreateCluster_section.md)
+ [`CreateService`](ecs_example_ecs_CreateService_section.md)
+ [`DeleteCluster`](ecs_example_ecs_DeleteCluster_section.md)
+ [`DeleteService`](ecs_example_ecs_DeleteService_section.md)
+ [`DescribeClusters`](ecs_example_ecs_DescribeClusters_section.md)
+ [`DescribeServices`](ecs_example_ecs_DescribeServices_section.md)
+ [`DescribeTasks`](ecs_example_ecs_DescribeTasks_section.md)
+ [`ListClusters`](ecs_example_ecs_ListClusters_section.md)
+ [`ListServices`](ecs_example_ecs_ListServices_section.md)
+ [`ListTasks`](ecs_example_ecs_ListTasks_section.md)
+ [`UpdateClusterSettings`](ecs_example_ecs_UpdateClusterSettings_section.md)
+ [`UpdateService`](ecs_example_ecs_UpdateService_section.md)
# AWS SDK 또는 CLI와 `CreateCluster` 함께 사용
다음 코드 예시는 `CreateCluster`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예 1: 새 클러스터를 생성하는 방법**
다음 `create-cluster` 예제에서는 `MyCluster`라는 클러스터를 만들고 향상된 관찰성을 갖춘 CloudWatch Container Insights를 사용 설정합니다.
```
aws ecs create-cluster \
--cluster-name MyCluster \
--settings name=containerInsights,value=enhanced
```
출력:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"clusterName": "MyCluster",
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"pendingTasksCount": 0,
"runningTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"settings": [
{
"name": "containerInsights",
"value": "enhanced"
}
],
"tags": []
}
}
```
자세한 내용은 **Amazon ECS 개발자 안내서의 [클러스터 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html)을 참조하세요.
**예 2: 용량 공급자를 사용하여 새 클러스터를 생성하는 방법**
다음 `create-cluster` 예시에서는 클러스터를 생성하고 기존 용량 공급자 2개를 클러스터에 연결합니다. `create-capacity-provider` 명령을 사용하여 용량 공급자를 생성합니다. 기본 용량 공급자 전략을 지정하는 것은 선택 사항이지만 권장됩니다. 이 예시에서는 이름이 `MyCluster`인 클러스터를 생성하고 여기에 `MyCapacityProvider1` 및 `MyCapacityProvider2` 용량 공급자를 연결합니다. 기본 용량 공급자 전략이 지정되어 태스크를 두 용량 공급자 모두에 균등하게 분산합니다.
```
aws ecs create-cluster \
--cluster-name MyCluster \
--capacity-providers MyCapacityProvider1 MyCapacityProvider2 \
--default-capacity-provider-strategy capacityProvider=MyCapacityProvider1,weight=1 capacityProvider=MyCapacityProvider2,weight=1
```
출력:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"clusterName": "MyCluster",
"status": "PROVISIONING",
"registeredContainerInstancesCount": 0,
"pendingTasksCount": 0,
"runningTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"settings": [
{
"name": "containerInsights",
"value": "enabled"
}
],
"capacityProviders": [
"MyCapacityProvider1",
"MyCapacityProvider2"
],
"defaultCapacityProviderStrategy": [
{
"capacityProvider": "MyCapacityProvider1",
"weight": 1,
"base": 0
},
{
"capacityProvider": "MyCapacityProvider2",
"weight": 1,
"base": 0
}
],
"attachments": [
{
"id": "0fb0c8f4-6edd-4de1-9b09-17e470ee1918",
"type": "asp",
"status": "PRECREATED",
"details": [
{
"name": "capacityProviderName",
"value": "MyCapacityProvider1"
},
{
"name": "scalingPlanName",
"value": "ECSManagedAutoScalingPlan-a1b2c3d4-5678-90ab-cdef-EXAMPLE11111"
}
]
},
{
"id": "ae592060-2382-4663-9476-b015c685593c",
"type": "asp",
"status": "PRECREATED",
"details": [
{
"name": "capacityProviderName",
"value": "MyCapacityProvider2"
},
{
"name": "scalingPlanName",
"value": "ECSManagedAutoScalingPlan-a1b2c3d4-5678-90ab-cdef-EXAMPLE22222"
}
]
}
],
"attachmentsStatus": "UPDATE_IN_PROGRESS"
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Cluster capacity providers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-capacity-providers.html)(클러스터 쿼리 언어)를 참조하세요.
**예 3: 여러 태그가 포함된 새 클러스터를 생성하는 방법**
다음 `create-cluster` 예시에서는 여러 태그가 있는 클러스터를 만듭니다. 간편 구문을 사용하여 태그를 추가하는 방법에 대한 자세한 내용은 *AWS CLI 사용 설명서*의 [AWS 명령줄 인터페이스에서 간편 구문 사용을](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html) 참조하세요.
```
aws ecs create-cluster \
--cluster-name MyCluster \
--tags key=key1,value=value1 key=key2,value=value2
```
출력:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"clusterName": "MyCluster",
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"pendingTasksCount": 0,
"runningTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [
{
"key": "key1",
"value": "value1"
},
{
"key": "key2",
"value": "value2"
}
]
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [클러스터 생성](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [CreateCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/create-cluster.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.ExecuteCommandConfiguration;
import software.amazon.awssdk.services.ecs.model.ExecuteCommandLogging;
import software.amazon.awssdk.services.ecs.model.ClusterConfiguration;
import software.amazon.awssdk.services.ecs.model.CreateClusterResponse;
import software.amazon.awssdk.services.ecs.model.EcsException;
import software.amazon.awssdk.services.ecs.model.CreateClusterRequest;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateCluster {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
clusterName - The name of the ECS cluster to create.
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String clusterName = args[0];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
String clusterArn = createGivenCluster(ecsClient, clusterName);
System.out.println("The cluster ARN is " + clusterArn);
ecsClient.close();
}
public static String createGivenCluster(EcsClient ecsClient, String clusterName) {
try {
ExecuteCommandConfiguration commandConfiguration = ExecuteCommandConfiguration.builder()
.logging(ExecuteCommandLogging.DEFAULT)
.build();
ClusterConfiguration clusterConfiguration = ClusterConfiguration.builder()
.executeCommandConfiguration(commandConfiguration)
.build();
CreateClusterRequest clusterRequest = CreateClusterRequest.builder()
.clusterName(clusterName)
.configuration(clusterConfiguration)
.build();
CreateClusterResponse response = ecsClient.createCluster(clusterRequest);
return response.cluster().clusterArn();
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [CreateCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/CreateCluster)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 cmdlet은 새 Amazon ECS 클러스터를 생성합니다. **
```
New-ECSCluster -ClusterName "LAB-ECS-CL" -Setting @{Name="containerInsights"; Value="enabled"}
```
**출력:**
```
ActiveServicesCount : 0
Attachments : {}
AttachmentsStatus :
CapacityProviders : {}
ClusterArn : arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
ClusterName : LAB-ECS-CL
DefaultCapacityProviderStrategy : {}
PendingTasksCount : 0
RegisteredContainerInstancesCount : 0
RunningTasksCount : 0
Settings : {containerInsights}
Statistics : {}
Status : ACTIVE
Tags : {}
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [CreateCluster](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 cmdlet은 새 Amazon ECS 클러스터를 생성합니다. **
```
New-ECSCluster -ClusterName "LAB-ECS-CL" -Setting @{Name="containerInsights"; Value="enabled"}
```
**출력:**
```
ActiveServicesCount : 0
Attachments : {}
AttachmentsStatus :
CapacityProviders : {}
ClusterArn : arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
ClusterName : LAB-ECS-CL
DefaultCapacityProviderStrategy : {}
PendingTasksCount : 0
RegisteredContainerInstancesCount : 0
RunningTasksCount : 0
Settings : {containerInsights}
Statistics : {}
Status : ACTIVE
Tags : {}
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [CreateCluster](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
#### [ Rust ]
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
async fn make_cluster(client: &aws_sdk_ecs::Client, name: &str) -> Result<(), aws_sdk_ecs::Error> {
let cluster = client.create_cluster().cluster_name(name).send().await?;
println!("cluster created: {:?}", cluster);
Ok(())
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [CreateCluster](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.create_cluster)를 참조하세요.
------
# AWS SDK 또는 CLI와 `CreateService` 함께 사용
다음 코드 예시는 `CreateService`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예 1: Fargate 태스크를 사용하여 서비스를 생성하는 방법**
다음 `create-service` 예시에서는 Fargate 태스크를 사용하여 서비스를 생성하는 방법을 보여줍니다.
```
aws ecs create-service \
--cluster MyCluster \
--service-name MyService \
--task-definition sample-fargate:1 \
--desired-count 2 \
--launch-type FARGATE \
--platform-version LATEST \
--network-configuration 'awsvpcConfiguration={subnets=[subnet-12344321],securityGroups=[sg-12344321],assignPublicIp=ENABLED}' \
--tags key=key1,value=value1 key=key2,value=value2 key=key3,value=value3
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/MyCluster/MyService",
"serviceName": "MyService",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 0,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/sample-fargate:1",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 100
},
"deployments": [
{
"id": "ecs-svc/1234567890123456789",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/sample-fargate:1",
"desiredCount": 2,
"pendingCount": 0,
"runningCount": 0,
"createdAt": 1557119253.821,
"updatedAt": 1557119253.821,
"launchType": "FARGATE",
"platformVersion": "1.3.0",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
}
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [],
"createdAt": 1557119253.821,
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"schedulingStrategy": "REPLICA",
"tags": [
{
"key": "key1",
"value": "value1"
},
{
"key": "key2",
"value": "value2"
},
{
"key": "key3",
"value": "value3"
}
],
"enableECSManagedTags": false,
"propagateTags": "NONE"
}
}
```
자세한 정보는 *Amazon ECS 개발자 안내서*의 [서비스 생성하기](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)를 참조하세요.
**예 2: EC2 시작 유형을 사용하여 서비스를 생성하는 방법**
다음 `create-service` 예시에서는 EC2 시작 유형을 사용하는 태스크로 `ecs-simple-service`라는 서비스를 호출하는 방법을 보여줍니다. 이 서비스는 `sleep360` 태스크 정의를 사용하며 태스크의 인스턴스화 1개를 유지 관리합니다.
```
aws ecs create-service \
--cluster MyCluster \
--service-name ecs-simple-service \
--task-definition sleep360:2 \
--desired-count 1
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/MyCluster/ecs-simple-service",
"serviceName": "ecs-simple-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 1,
"runningCount": 0,
"pendingCount": 0,
"launchType": "EC2",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/sleep360:2",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 100
},
"deployments": [
{
"id": "ecs-svc/1234567890123456789",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/sleep360:2",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 0,
"createdAt": 1557206498.798,
"updatedAt": 1557206498.798,
"launchType": "EC2"
}
],
"events": [],
"createdAt": 1557206498.798,
"placementConstraints": [],
"placementStrategy": [],
"schedulingStrategy": "REPLICA",
"enableECSManagedTags": false,
"propagateTags": "NONE"
}
}
```
자세한 정보는 *Amazon ECS 개발자 안내서*의 [서비스 생성하기](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)를 참조하세요.
**예 3: 외부 배포 컨트롤러를 사용하는 서비스를 생성하는 방법**
다음 `create-service` 예시에서는 외부 배포 컨트롤러를 사용하는 서비스를 생성합니다.
```
aws ecs create-service \
--cluster MyCluster \
--service-name MyService \
--deployment-controller type=EXTERNAL \
--desired-count 1
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/MyCluster/MyService",
"serviceName": "MyService",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 1,
"runningCount": 0,
"pendingCount": 0,
"launchType": "EC2",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 100
},
"taskSets": [],
"deployments": [],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [],
"createdAt": 1557128207.101,
"placementConstraints": [],
"placementStrategy": [],
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "EXTERNAL"
},
"enableECSManagedTags": false,
"propagateTags": "NONE"
}
}
```
자세한 정보는 *Amazon ECS 개발자 안내서*의 [서비스 생성하기](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html)를 참조하세요.
**예 4: 로드 밸런서 뒤에 새 서비스를 생성하는 방법**
다음 `create-service` 예시에서는 로드 밸런서 뒤에 있는 서비스를 생성하는 방법을 보여줍니다. 컨테이너 인스턴스와 동일한 리전에 로드 밸런서가 구성되어 있어야 합니다. 이 예시에서는 `--cli-input-json` 옵션과 다음 콘텐츠가 포함된 `ecs-simple-service-elb.json`이라는 JSON 입력 파일을 사용합니다.
```
aws ecs create-service \
--cluster MyCluster \
--service-name ecs-simple-service-elb \
--cli-input-json file://ecs-simple-service-elb.json
```
`ecs-simple-service-elb.json`의 콘텐츠:
```
{
"serviceName": "ecs-simple-service-elb",
"taskDefinition": "ecs-demo",
"loadBalancers": [
{
"loadBalancerName": "EC2Contai-EcsElast-123456789012",
"containerName": "simple-demo",
"containerPort": 80
}
],
"desiredCount": 10,
"role": "ecsServiceRole"
}
```
출력:
```
{
"service": {
"status": "ACTIVE",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/ecs-demo:1",
"pendingCount": 0,
"loadBalancers": [
{
"containerName": "ecs-demo",
"containerPort": 80,
"loadBalancerName": "EC2Contai-EcsElast-123456789012"
}
],
"roleArn": "arn:aws:iam::123456789012:role/ecsServiceRole",
"desiredCount": 10,
"serviceName": "ecs-simple-service-elb",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/ecs-simple-service-elb",
"deployments": [
{
"status": "PRIMARY",
"pendingCount": 0,
"createdAt": 1428100239.123,
"desiredCount": 10,
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/ecs-demo:1",
"updatedAt": 1428100239.123,
"id": "ecs-svc/1234567890123456789",
"runningCount": 0
}
],
"events": [],
"runningCount": 0
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [로드 밸런싱을 사용하여 Amazon ECS 서비스 트래픽 분산](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html)을 참조하세요.
**예시 5: 서비스 생성 시 Amazon EBS 볼륨 구성**
다음 `create-service` 예시에서는 서비스에서 관리하는 각 작업에 대해 Amazon EBS 볼륨을 구성하는 방법을 보여줍니다. `AmazonECSInfrastructureRolePolicyForVolumes` 관리형 정책과 연결된 Amazon ECS 인프라 역할이 구성되어 있어야 합니다. `create-service` 요청에서와 동일한 볼륨 이름으로 작업 정의를 지정해야 합니다. 이 예시에서는 `--cli-input-json` 옵션과 다음 콘텐츠가 포함된 `ecs-simple-service-ebs.json`이라는 JSON 입력 파일을 사용합니다.
```
aws ecs create-service \
--cli-input-json file://ecs-simple-service-ebs.json
```
`ecs-simple-service-ebs.json`의 콘텐츠:
```
{
"cluster": "mycluster",
"taskDefinition": "mytaskdef",
"serviceName": "ecs-simple-service-ebs",
"desiredCount": 2,
"launchType": "FARGATE",
"networkConfiguration":{
"awsvpcConfiguration":{
"assignPublicIp": "ENABLED",
"securityGroups": ["sg-12344321"],
"subnets":["subnet-12344321"]
}
},
"volumeConfigurations": [
{
"name": "myEbsVolume",
"managedEBSVolume": {
"roleArn":"arn:aws:iam::123456789012:role/ecsInfrastructureRole",
"volumeType": "gp3",
"sizeInGiB": 100,
"iops": 3000,
"throughput": 125,
"filesystemType": "ext4"
}
}
]
}
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/mycluster/ecs-simple-service-ebs",
"serviceName": "ecs-simple-service-ebs",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/mycluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 0,
"pendingCount": 0,
"launchType": "EC2",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:3",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": false,
"rollback": false
},
"maximumPercent": 200,
"minimumHealthyPercent": 100
},
"deployments": [
{
"id": "ecs-svc/7851020056849183687",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:3",
"desiredCount": 0,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": "2025-01-21T11:32:38.034000-06:00",
"updatedAt": "2025-01-21T11:32:38.034000-06:00",
"launchType": "EC2",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "DISABLED"
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/7851020056849183687 in progress.",
"volumeConfigurations": [
{
"name": "myEBSVolume",
"managedEBSVolume": {
"volumeType": "gp3",
"sizeInGiB": 100,
"iops": 3000,
"throughput": 125,
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRole",
"filesystemType": "ext4"
}
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [],
"createdAt": "2025-01-21T11:32:38.034000-06:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "DISABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:user/AIDACKCEVSQ6C2EXAMPLE",
"enableECSManagedTags": false,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "DISABLED"
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS에서 Amazon EBS 볼륨 사용](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ebs-volumes.html)을 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [CreateService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/create-service.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.AwsVpcConfiguration;
import software.amazon.awssdk.services.ecs.model.NetworkConfiguration;
import software.amazon.awssdk.services.ecs.model.CreateServiceRequest;
import software.amazon.awssdk.services.ecs.model.LaunchType;
import software.amazon.awssdk.services.ecs.model.CreateServiceResponse;
import software.amazon.awssdk.services.ecs.model.EcsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class CreateService {
public static void main(String[] args) {
final String usage = """
Usage:
Where:
clusterName - The name of the ECS cluster.
serviceName - The name of the ECS service to create.
securityGroups - The name of the security group.
subnets - The name of the subnet.
taskDefinition - The name of the task definition.
""";
if (args.length != 5) {
System.out.println(usage);
System.exit(1);
}
String clusterName = args[0];
String serviceName = args[1];
String securityGroups = args[2];
String subnets = args[3];
String taskDefinition = args[4];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
String serviceArn = createNewService(ecsClient, clusterName, serviceName, securityGroups, subnets,
taskDefinition);
System.out.println("The ARN of the service is " + serviceArn);
ecsClient.close();
}
public static String createNewService(EcsClient ecsClient,
String clusterName,
String serviceName,
String securityGroups,
String subnets,
String taskDefinition) {
try {
AwsVpcConfiguration vpcConfiguration = AwsVpcConfiguration.builder()
.securityGroups(securityGroups)
.subnets(subnets)
.build();
NetworkConfiguration configuration = NetworkConfiguration.builder()
.awsvpcConfiguration(vpcConfiguration)
.build();
CreateServiceRequest serviceRequest = CreateServiceRequest.builder()
.cluster(clusterName)
.networkConfiguration(configuration)
.desiredCount(1)
.launchType(LaunchType.FARGATE)
.serviceName(serviceName)
.taskDefinition(taskDefinition)
.build();
CreateServiceResponse response = ecsClient.createService(serviceRequest);
return response.service().serviceArn();
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
return "";
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [CreateService](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/CreateService)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 예제 명령에서는 `ecs-simple-service`라는 서비스를 기본 클러스터에 생성합니다. 이 서비스는 `ecs-demo` 태스크 정의를 사용하며 태스크의 인스턴스화 10회를 유지 관리합니다.**
```
New-ECSService -ServiceName ecs-simple-service -TaskDefinition ecs-demo -DesiredCount 10
```
**예제 2: 이 예제 명령에서는 `ecs-simple-service`라는 기본 클러스터의 로드 밸런서 뒤에 서비스를 생성합니다. 이 서비스는 `ecs-demo` 태스크 정의를 사용하며 태스크의 인스턴스화 10회를 유지 관리합니다.**
```
$lb = @{
LoadBalancerName = "EC2Contai-EcsElast-S06278JGSJCM"
ContainerName = "simple-demo"
ContainerPort = 80
}
New-ECSService -ServiceName ecs-simple-service -TaskDefinition ecs-demo -DesiredCount 10 -LoadBalancer $lb
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [CreateService](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 예제 명령에서는 `ecs-simple-service`라는 서비스를 기본 클러스터에 생성합니다. 이 서비스는 `ecs-demo` 태스크 정의를 사용하며 태스크의 인스턴스화 10회를 유지 관리합니다.**
```
New-ECSService -ServiceName ecs-simple-service -TaskDefinition ecs-demo -DesiredCount 10
```
**예제 2: 이 예제 명령에서는 `ecs-simple-service`라는 기본 클러스터의 로드 밸런서 뒤에 서비스를 생성합니다. 이 서비스는 `ecs-demo` 태스크 정의를 사용하며 태스크의 인스턴스화 10회를 유지 관리합니다.**
```
$lb = @{
LoadBalancerName = "EC2Contai-EcsElast-S06278JGSJCM"
ContainerName = "simple-demo"
ContainerPort = 80
}
New-ECSService -ServiceName ecs-simple-service -TaskDefinition ecs-demo -DesiredCount 10 -LoadBalancer $lb
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [CreateService](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DeleteCluster` 함께 사용
다음 코드 예시는 `DeleteCluster`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**빈 클러스터를 삭제하는 방법**
다음 `delete-cluster` 예시에서는 지정된 빈 클러스터를 삭제합니다.
```
aws ecs delete-cluster --cluster MyCluster
```
출력:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/MyCluster",
"status": "INACTIVE",
"clusterName": "MyCluster",
"registeredContainerInstancesCount": 0,
"pendingTasksCount": 0,
"runningTasksCount": 0,
"activeServicesCount": 0
"statistics": [],
"tags": []
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [클러스터 삭제](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/delete_cluster.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DeleteCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/delete-cluster.html)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 cmdlet은 지정된 ECS 클러스터를 삭제합니다. 삭제하기 전에 이 클러스터에서 모든 컨테이너 인스턴스의 등록을 취소해야 합니다. **
```
Remove-ECSCluster -Cluster "LAB-ECS"
```
**출력:**
```
Confirm
Are you sure you want to perform this action?
Performing the operation "Remove-ECSCluster (DeleteCluster)" on target "LAB-ECS".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): Y
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [DeleteCluster](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 cmdlet은 지정된 ECS 클러스터를 삭제합니다. 삭제하기 전에 이 클러스터에서 모든 컨테이너 인스턴스의 등록을 취소해야 합니다. **
```
Remove-ECSCluster -Cluster "LAB-ECS"
```
**출력:**
```
Confirm
Are you sure you want to perform this action?
Performing the operation "Remove-ECSCluster (DeleteCluster)" on target "LAB-ECS".
[Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): Y
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [DeleteCluster](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
#### [ Rust ]
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
async fn remove_cluster(
client: &aws_sdk_ecs::Client,
name: &str,
) -> Result<(), aws_sdk_ecs::Error> {
let cluster_deleted = client.delete_cluster().cluster(name).send().await?;
println!("cluster deleted: {:?}", cluster_deleted);
Ok(())
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [DeleteCluster](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.delete_cluster)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DeleteService` 함께 사용
다음 코드 예시는 `DeleteService`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**서비스를 삭제하는 방법**
다음 `ecs delete-service` 예시에서는 클러스터에서 지정된 서비스를 삭제합니다. `--force` 파라미터를 포함하면 태스크가 없도록 축소되지 않은 서비스도 삭제할 수 있습니다.
```
aws ecs delete-service --cluster MyCluster --service MyService1 --force
```
자세한 정보는 *Amazon ECS 개발자 안내서*의 [서비스 삭제하기](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/delete-service.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DeleteService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/delete-service.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.DeleteServiceRequest;
import software.amazon.awssdk.services.ecs.model.EcsException;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DeleteService {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
clusterName - The name of the ECS cluster.
serviceArn - The ARN of the ECS service.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String clusterName = args[0];
String serviceArn = args[1];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
deleteSpecificService(ecsClient, clusterName, serviceArn);
ecsClient.close();
}
public static void deleteSpecificService(EcsClient ecsClient, String clusterName, String serviceArn) {
try {
DeleteServiceRequest serviceRequest = DeleteServiceRequest.builder()
.cluster(clusterName)
.service(serviceArn)
.build();
ecsClient.deleteService(serviceRequest);
System.out.println("The Service was successfully deleted");
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DeleteService](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/DeleteService)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 기본 클러스터에서 'my-http-service'라는 서비스를 삭제합니다. 서비스를 삭제하려면 먼저 원하는 개수와 실행 개수가 0이어야 합니다. 명령이 실행되기 전에 확인 프롬프트가 표시됩니다. 확인 프롬프트를 우회하려면 명령에 -Force 스위치를 추가합니다.**
```
Remove-ECSService -Service my-http-service
```
**예제 2: 명명된 클러스터에서 'my-http-service'라는 서비스를 삭제합니다.**
```
Remove-ECSService -Cluster myCluster -Service my-http-service
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [DeleteService](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 기본 클러스터에서 'my-http-service'라는 서비스를 삭제합니다. 서비스를 삭제하려면 먼저 원하는 개수와 실행 개수가 0이어야 합니다. 명령이 실행되기 전에 확인 프롬프트가 표시됩니다. 확인 프롬프트를 우회하려면 명령에 -Force 스위치를 추가합니다.**
```
Remove-ECSService -Service my-http-service
```
**예제 2: 명명된 클러스터에서 'my-http-service'라는 서비스를 삭제합니다.**
```
Remove-ECSService -Cluster myCluster -Service my-http-service
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [DeleteService](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DescribeClusters` 함께 사용
다음 코드 예시는 `DescribeClusters`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예 1: 클러스터를 설명하는 방법**
다음 `describe-clusters` 예시에서는 지정된 클러스터에 대한 세부 정보를 검색합니다.
```
aws ecs describe-clusters \
--cluster default
```
출력:
```
{
"clusters": [
{
"status": "ACTIVE",
"clusterName": "default",
"registeredContainerInstancesCount": 0,
"pendingTasksCount": 0,
"runningTasksCount": 0,
"activeServicesCount": 1,
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/default"
}
],
"failures": []
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS 클러스터](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_clusters.html)를 참조하세요.
**예 2: 첨부 파일 옵션을 사용하여 클러스터를 설명하는 방법**
다음 `describe-clusters` 예시에서는 ATTACHMENTS 옵션을 지정합니다. 지정된 클러스터에 대한 세부 정보와 클러스터에 연결된 리소스 목록을 첨부 파일 형식으로 검색합니다. 클러스터와 함께 용량 공급자를 사용하는 경우 AutoScaling 계획 또는 크기 조정 정책과 같은 리소스는 asp 또는 as\$1policy ATCHEMENTS로 표시됩니다.
```
aws ecs describe-clusters \
--include ATTACHMENTS \
--clusters sampleCluster
```
출력:
```
{
"clusters": [
{
"clusterArn": "arn:aws:ecs:af-south-1:123456789222:cluster/sampleCluster",
"clusterName": "sampleCluster",
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [],
"capacityProviders": [
"sampleCapacityProvider"
],
"defaultCapacityProviderStrategy": [],
"attachments": [
{
"id": "a1b2c3d4-5678-901b-cdef-EXAMPLE22222",
"type": "as_policy",
"status": "CREATED",
"details": [
{
"name": "capacityProviderName",
"value": "sampleCapacityProvider"
},
{
"name": "scalingPolicyName",
"value": "ECSManagedAutoScalingPolicy-3048e262-fe39-4eaf-826d-6f975d303188"
}
]
}
],
"attachmentsStatus": "UPDATE_COMPLETE"
}
],
"failures": []
}
```
자세한 내용은 **Amazon ECS 개발자 안내서의 [Amazon ECS 클러스터](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_clusters.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/describe-clusters.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.DescribeClustersRequest;
import software.amazon.awssdk.services.ecs.model.DescribeClustersResponse;
import software.amazon.awssdk.services.ecs.model.Cluster;
import software.amazon.awssdk.services.ecs.model.EcsException;
import java.util.List;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DescribeClusters {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
clusterArn - The ARN of the ECS cluster to describe.
""";
if (args.length != 1) {
System.out.println(usage);
System.exit(1);
}
String clusterArn = args[0];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
descCluster(ecsClient, clusterArn);
}
public static void descCluster(EcsClient ecsClient, String clusterArn) {
try {
DescribeClustersRequest clustersRequest = DescribeClustersRequest.builder()
.clusters(clusterArn)
.build();
DescribeClustersResponse response = ecsClient.describeClusters(clustersRequest);
List clusters = response.clusters();
for (Cluster cluster : clusters) {
System.out.println("The cluster name is " + cluster.clusterName());
}
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/DescribeClusters)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 cmdlet은 하나 이상의 ECS 클러스터를 설명합니다.**
```
Get-ECSClusterDetail -Cluster "LAB-ECS-CL" -Include SETTINGS | Select-Object *
```
**출력:**
```
LoggedAt : 12/27/2019 9:27:41 PM
Clusters : {LAB-ECS-CL}
Failures : {}
ResponseMetadata : Amazon.Runtime.ResponseMetadata
ContentLength : 396
HttpStatusCode : OK
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [DescribeClusters](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 cmdlet은 하나 이상의 ECS 클러스터를 설명합니다.**
```
Get-ECSClusterDetail -Cluster "LAB-ECS-CL" -Include SETTINGS | Select-Object *
```
**출력:**
```
LoggedAt : 12/27/2019 9:27:41 PM
Clusters : {LAB-ECS-CL}
Failures : {}
ResponseMetadata : Amazon.Runtime.ResponseMetadata
ContentLength : 396
HttpStatusCode : OK
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [DescribeClusters](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
#### [ Rust ]
**SDK for Rust**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
async fn show_clusters(client: &aws_sdk_ecs::Client) -> Result<(), aws_sdk_ecs::Error> {
let resp = client.list_clusters().send().await?;
let cluster_arns = resp.cluster_arns();
println!("Found {} clusters:", cluster_arns.len());
let clusters = client
.describe_clusters()
.set_clusters(Some(cluster_arns.into()))
.send()
.await?;
for cluster in clusters.clusters() {
println!(" ARN: {}", cluster.cluster_arn().unwrap());
println!(" Name: {}", cluster.cluster_name().unwrap());
}
Ok(())
}
```
+ API 세부 정보는 *AWS SDK for Rust API 참조*의 [DescribeClusters](https://docs.rs/aws-sdk-ecs/latest/aws_sdk_ecs/client/struct.Client.html#method.describe_clusters)를 참조하세요.
------
# CLI로 `DescribeServices` 사용
다음 코드 예시는 `DescribeServices`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**서비스를 설명하려면**
다음 `describe-services` 예시에서는 기본 클러스터의 `my-http-service` 서비스에 대한 세부 정보를 검색합니다.
```
aws ecs describe-services --services my-http-service
```
출력:
```
{
"services": [
{
"status": "ACTIVE",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/amazon-ecs-sample:1",
"pendingCount": 0,
"loadBalancers": [],
"desiredCount": 10,
"createdAt": 1466801808.595,
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/default",
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/my-http-service",
"deployments": [
{
"status": "PRIMARY",
"pendingCount": 0,
"createdAt": 1466801808.595,
"desiredCount": 10,
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/amazon-ecs-sample:1",
"updatedAt": 1428326312.703,
"id": "ecs-svc/1234567890123456789",
"runningCount": 10
}
],
"events": [
{
"message": "(service my-http-service) has reached a steady state.",
"id": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"createdAt": 1466801812.435
}
],
"runningCount": 10
}
],
"failures": []
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [서비스](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)를 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [DescribeServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/describe-services.html)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 예제에서는 기본 클러스터에서 지정된 서비스의 세부 정보를 검색하는 방법을 보여줍니다.**
```
Get-ECSService -Service my-hhtp-service
```
**예제 2: 이 예제에서는 명명된 클러스터에서 실행되는 지정된 서비스의 세부 정보를 검색하는 방법을 보여줍니다.**
```
Get-ECSService -Cluster myCluster -Service my-hhtp-service
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [DescribeServices](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 예제에서는 기본 클러스터에서 지정된 서비스의 세부 정보를 검색하는 방법을 보여줍니다.**
```
Get-ECSService -Service my-hhtp-service
```
**예제 2: 이 예제에서는 명명된 클러스터에서 실행되는 지정된 서비스의 세부 정보를 검색하는 방법을 보여줍니다.**
```
Get-ECSService -Cluster myCluster -Service my-hhtp-service
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [DescribeServices](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDK 또는 CLI와 `DescribeTasks` 함께 사용
다음 코드 예시는 `DescribeTasks`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예제 1: 단일 태스크를 설명하는 방법**
다음 `describe-tasks` 예시에서는 클러스터의 태스크 세부 정보를 검색합니다. 태스크의 ID 또는 전체 ARN을 사용하여 태스크를 지정할 수 있습니다. 이 예시에서는 태스크의 전체 ARN을 사용합니다.
```
aws ecs describe-tasks \
--cluster MyCluster \
--tasks arn:aws:ecs:us-east-1:123456789012:task/MyCluster/4d590253bb114126b7afa7b58EXAMPLE
```
출력:
```
{
"tasks": [
{
"attachments": [],
"attributes": [
{
"name": "ecs.cpu-architecture",
"value": "x86_64"
}
],
"availabilityZone": "us-east-1b",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
"connectivity": "CONNECTED",
"connectivityAt": "2021-08-11T12:21:26.681000-04:00",
"containerInstanceArn": "arn:aws:ecs:us-east-1:123456789012:container-instance/test/025c7e2c5e054a6790a29fc1fEXAMPLE",
"containers": [
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/MyCluster/4d590253bb114126b7afa7b58eea9221/a992d1cc-ea46-474a-b6e8-24688EXAMPLE",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/4d590253bb114126b7afa7b58EXAMPLE",
"name": "simple-app",
"image": "httpd:2.4",
"runtimeId": "91251eed27db90006ad67b1a08187290869f216557717dd5c39b37c94EXAMPLE",
"lastStatus": "RUNNING",
"networkBindings": [
{
"bindIP": "0.0.0.0",
"containerPort": 80,
"hostPort": 80,
"protocol": "tcp"
}
],
"networkInterfaces": [],
"healthStatus": "UNKNOWN",
"cpu": "10",
"memory": "300"
}
],
"cpu": "10",
"createdAt": "2021-08-11T12:21:26.681000-04:00",
"desiredStatus": "RUNNING",
"enableExecuteCommand": false,
"group": "service:testupdate",
"healthStatus": "UNKNOWN",
"lastStatus": "RUNNING",
"launchType": "EC2",
"memory": "300",
"overrides": {
"containerOverrides": [
{
"name": "simple-app"
}
],
"inferenceAcceleratorOverrides": []
},
"pullStartedAt": "2021-08-11T12:21:28.234000-04:00",
"pullStoppedAt": "2021-08-11T12:21:33.793000-04:00",
"startedAt": "2021-08-11T12:21:34.945000-04:00",
"startedBy": "ecs-svc/968695068243EXAMPLE",
"tags": [],
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/4d590253bb114126b7afa7b58eea9221",
"taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/console-sample-app-static2:1",
"version": 2
}
],
"failures": []
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS 태스크 정의](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html)를 참조하세요.
**예제 2: 여러 태스크를 설명하는 방법**
다음 `describe-tasks` 예시에서는 클러스터에 있는 여러 태스크의 세부 정보를 검색합니다. 태스크의 ID 또는 전체 ARN을 사용하여 태스크를 지정할 수 있습니다. 이 예시에서는 태스크의 전체 ID를 사용합니다.
```
aws ecs describe-tasks \
--cluster MyCluster \
--tasks "74de0355a10a4f979ac495c14EXAMPLE" "d789e94343414c25b9f6bd59eEXAMPLE"
```
출력:
```
{
"tasks": [
{
"attachments": [
{
"id": "d9e7735a-16aa-4128-bc7a-b2d51EXAMPLE",
"type": "ElasticNetworkInterface",
"status": "ATTACHED",
"details": [
{
"name": "subnetId",
"value": "subnet-0d0eab1bb3EXAMPLE"
},
{
"name": "networkInterfaceId",
"value": "eni-0fa40520aeEXAMPLE"
},
{
"name": "macAddress",
"value": "0e:89:76:28:07:b3"
},
{
"name": "privateDnsName",
"value": "ip-10-0-1-184.ec2.internal"
},
{
"name": "privateIPv4Address",
"value": "10.0.1.184"
}
]
}
],
"attributes": [
{
"name": "ecs.cpu-architecture",
"value": "x86_64"
}
],
"availabilityZone": "us-east-1b",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
"connectivity": "CONNECTED",
"connectivityAt": "2021-12-20T12:13:37.875000-05:00",
"containers": [
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/MyCluster/74de0355a10a4f979ac495c14EXAMPLE/aad3ba00-83b3-4dac-84d4-11f8cEXAMPLE",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/74de0355a10a4f979ac495c14EXAMPLE",
"name": "web",
"image": "nginx",
"runtimeId": "74de0355a10a4f979ac495c14EXAMPLE-265927825",
"lastStatus": "RUNNING",
"networkBindings": [],
"networkInterfaces": [
{
"attachmentId": "d9e7735a-16aa-4128-bc7a-b2d51EXAMPLE",
"privateIpv4Address": "10.0.1.184"
}
],
"healthStatus": "UNKNOWN",
"cpu": "99",
"memory": "100"
}
],
"cpu": "256",
"createdAt": "2021-12-20T12:13:20.226000-05:00",
"desiredStatus": "RUNNING",
"enableExecuteCommand": false,
"group": "service:tdsevicetag",
"healthStatus": "UNKNOWN",
"lastStatus": "RUNNING",
"launchType": "FARGATE",
"memory": "512",
"overrides": {
"containerOverrides": [
{
"name": "web"
}
],
"inferenceAcceleratorOverrides": []
},
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"pullStartedAt": "2021-12-20T12:13:42.665000-05:00",
"pullStoppedAt": "2021-12-20T12:13:46.543000-05:00",
"startedAt": "2021-12-20T12:13:48.086000-05:00",
"startedBy": "ecs-svc/988401040018EXAMPLE",
"tags": [],
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/74de0355a10a4f979ac495c14EXAMPLE",
"taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/webserver:2",
"version": 3,
"ephemeralStorage": {
"sizeInGiB": 20
}
},
{
"attachments": [
{
"id": "214eb5a9-45cd-4bf8-87bc-57fefEXAMPLE",
"type": "ElasticNetworkInterface",
"status": "ATTACHED",
"details": [
{
"name": "subnetId",
"value": "subnet-0d0eab1bb3EXAMPLE"
},
{
"name": "networkInterfaceId",
"value": "eni-064c7766daEXAMPLE"
},
{
"name": "macAddress",
"value": "0e:76:83:01:17:a9"
},
{
"name": "privateDnsName",
"value": "ip-10-0-1-41.ec2.internal"
},
{
"name": "privateIPv4Address",
"value": "10.0.1.41"
}
]
}
],
"attributes": [
{
"name": "ecs.cpu-architecture",
"value": "x86_64"
}
],
"availabilityZone": "us-east-1b",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
"connectivity": "CONNECTED",
"connectivityAt": "2021-12-20T12:13:35.243000-05:00",
"containers": [
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/MyCluster/d789e94343414c25b9f6bd59eEXAMPLE/9afef792-609b-43a5-bb6a-3efdbEXAMPLE",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/d789e94343414c25b9f6bd59eEXAMPLE",
"name": "web",
"image": "nginx",
"runtimeId": "d789e94343414c25b9f6bd59eEXAMPLE-265927825",
"lastStatus": "RUNNING",
"networkBindings": [],
"networkInterfaces": [
{
"attachmentId": "214eb5a9-45cd-4bf8-87bc-57fefEXAMPLE",
"privateIpv4Address": "10.0.1.41"
}
],
"healthStatus": "UNKNOWN",
"cpu": "99",
"memory": "100"
}
],
"cpu": "256",
"createdAt": "2021-12-20T12:13:20.226000-05:00",
"desiredStatus": "RUNNING",
"enableExecuteCommand": false,
"group": "service:tdsevicetag",
"healthStatus": "UNKNOWN",
"lastStatus": "RUNNING",
"launchType": "FARGATE",
"memory": "512",
"overrides": {
"containerOverrides": [
{
"name": "web"
}
],
"inferenceAcceleratorOverrides": []
},
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"pullStartedAt": "2021-12-20T12:13:44.611000-05:00",
"pullStoppedAt": "2021-12-20T12:13:48.251000-05:00",
"startedAt": "2021-12-20T12:13:49.326000-05:00",
"startedBy": "ecs-svc/988401040018EXAMPLE",
"tags": [],
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/MyCluster/d789e94343414c25b9f6bd59eEXAMPLE",
"taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/webserver:2",
"version": 3,
"ephemeralStorage": {
"sizeInGiB": 20
}
}
],
"failures": []
}
```
자세한 내용은 **Amazon ECS 개발자 안내서의 [Amazon ECS 태스크 정의](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [DescribeTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/describe-tasks.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.DescribeTasksRequest;
import software.amazon.awssdk.services.ecs.model.DescribeTasksResponse;
import software.amazon.awssdk.services.ecs.model.EcsException;
import software.amazon.awssdk.services.ecs.model.Task;
import java.util.List;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ListTaskDefinitions {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
clusterArn - The ARN of an ECS cluster.
taskId - The task Id value.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String clusterArn = args[0];
String taskId = args[1];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
getAllTasks(ecsClient, clusterArn, taskId);
ecsClient.close();
}
public static void getAllTasks(EcsClient ecsClient, String clusterArn, String taskId) {
try {
DescribeTasksRequest tasksRequest = DescribeTasksRequest.builder()
.cluster(clusterArn)
.tasks(taskId)
.build();
DescribeTasksResponse response = ecsClient.describeTasks(tasksRequest);
List tasks = response.tasks();
for (Task task : tasks) {
System.out.println("The task ARN is " + task.taskDefinitionArn());
}
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [DescribeTasks](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/DescribeTasks)를 참조하세요.
------
# AWS SDK 또는 CLI와 `ListClusters` 함께 사용
다음 코드 예시는 `ListClusters`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [클러스터, 서비스, 작업에 대한 ARN 정보 가져오기](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/ECS#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
///
/// List cluster ARNs available.
///
/// The ARN list of clusters.
public async Task> GetClusterARNSAsync()
{
Console.WriteLine("Getting a list of all the clusters in your AWS account...");
List clusterArnList = new List();
// Get a list of all the clusters in your AWS account
try
{
var listClustersResponse = _ecsClient.Paginators.ListClusters(new ListClustersRequest
{
});
var clusterArns = listClustersResponse.ClusterArns;
// Print the ARNs of the clusters
await foreach (var clusterArn in clusterArns)
{
clusterArnList.Add(clusterArn);
}
if (clusterArnList.Count == 0)
{
_logger.LogWarning("No clusters found in your AWS account.");
}
return clusterArnList;
}
catch (Exception e)
{
_logger.LogError($"An error occurred while getting a list of all the clusters in your AWS account. {e.InnerException}");
throw new Exception($"An error occurred while getting a list of all the clusters in your AWS account. {e.InnerException}");
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for .NET API 참조*의 [ListClusters](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListClusters)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**사용 가능한 클러스터를 나열하는 방법**
다음 `list-clusters` 예시에서는 사용 가능한 클러스터를 모두 나열합니다.
```
aws ecs list-clusters
```
출력:
```
{
"clusterArns": [
"arn:aws:ecs:us-west-2:123456789012:cluster/MyECSCluster1",
"arn:aws:ecs:us-west-2:123456789012:cluster/AnotherECSCluster"
]
}
```
자세한 내용은 **Amazon ECS 개발자 안내서의 [Amazon ECS 클러스터](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_clusters.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [ListClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/list-clusters.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.ListClustersResponse;
import software.amazon.awssdk.services.ecs.model.EcsException;
import java.util.List;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class ListClusters {
public static void main(String[] args) {
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
listAllClusters(ecsClient);
ecsClient.close();
}
public static void listAllClusters(EcsClient ecsClient) {
try {
ListClustersResponse response = ecsClient.listClusters();
List clusters = response.clusterArns();
for (String cluster : clusters) {
System.out.println("The cluster arn is " + cluster);
}
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [ListClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/ListClusters)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 cmdlet은 기존 ECS 클러스터 목록을 반환합니다.**
```
Get-ECSClusterList
```
**출력:**
```
arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [ListClusters](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 cmdlet은 기존 ECS 클러스터 목록을 반환합니다.**
```
Get-ECSClusterList
```
**출력:**
```
arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [ListClusters](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDK 또는 CLI와 `ListServices` 함께 사용
다음 코드 예시는 `ListServices`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [클러스터, 서비스, 작업에 대한 ARN 정보 가져오기](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/ECS#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
///
/// List service ARNs available.
///
/// The arn of the ECS cluster.
/// The ARN list of services in given cluster.
public async Task> GetServiceARNSAsync(string clusterARN)
{
List serviceArns = new List();
var request = new ListServicesRequest
{
Cluster = clusterARN
};
// Call the ListServices API operation and get the list of service ARNs
var serviceList = _ecsClient.Paginators.ListServices(request);
await foreach (var serviceARN in serviceList.ServiceArns)
{
if (serviceARN is null)
continue;
serviceArns.Add(serviceARN);
}
if (serviceArns.Count == 0)
{
_logger.LogWarning($"No services found in cluster {clusterARN} .");
}
return serviceArns;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ListServices](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListServices)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**클러스터의 서비스를 나열하는 방법**
다음 `list-services` 예시에서는 클러스터에서 실행되는 서비스를 나열하는 방법을 보여줍니다.
```
aws ecs list-services --cluster MyCluster
```
출력:
```
{
"serviceArns": [
"arn:aws:ecs:us-west-2:123456789012:service/MyCluster/MyService"
]
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [서비스](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [ListServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/list-services.html)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 예제에서는 기본 클러스터에서 실행 중인 모든 서비스를 나열합니다.**
```
Get-ECSClusterService
```
**예제 2: 이 예제에서는 지정된 클러스터에서 실행 중인 모든 서비스를 나열합니다.**
```
Get-ECSClusterService -Cluster myCluster
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [ListServices](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 예제에서는 기본 클러스터에서 실행 중인 모든 서비스를 나열합니다.**
```
Get-ECSClusterService
```
**예제 2: 이 예제에서는 지정된 클러스터에서 실행 중인 모든 서비스를 나열합니다.**
```
Get-ECSClusterService -Cluster myCluster
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [ListServices](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDK 또는 CLI와 `ListTasks` 함께 사용
다음 코드 예시는 `ListTasks`의 사용 방법을 보여 줍니다.
작업 예제는 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 다음 코드 예제에서는 컨텍스트 내에서 이 작업을 확인할 수 있습니다.
+ [클러스터, 서비스, 작업에 대한 ARN 정보 가져오기](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/ECS#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
///
/// List task ARNs available.
///
/// The arn of the ECS cluster.
/// The ARN list of tasks in given cluster.
public async Task> GetTaskARNsAsync(string clusterARN)
{
// Set up the request to describe the tasks in the service
var listTasksRequest = new ListTasksRequest
{
Cluster = clusterARN
};
List taskArns = new List();
// Call the ListTasks API operation and get the list of task ARNs
var tasks = _ecsClient.Paginators.ListTasks(listTasksRequest);
await foreach (var task in tasks.TaskArns)
{
if (task is null)
continue;
taskArns.Add(task);
}
if (taskArns.Count == 0)
{
_logger.LogWarning("No tasks found in cluster: " + clusterARN);
}
return taskArns;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ListTasks](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListTasks)를 참조하세요.
------
#### [ CLI ]
**AWS CLI**
**예 1: 클러스터의 태스크를 나열하는 방법**
다음 `list-tasks` 예시에서는 클러스터의 모든 태스크를 나열합니다.
```
aws ecs list-tasks --cluster default
```
출력:
```
{
"taskArns": [
"arn:aws:ecs:us-west-2:123456789012:task/a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"arn:aws:ecs:us-west-2:123456789012:task/a1b2c3d4-5678-90ab-cdef-22222EXAMPLE"
]
}
```
**예 2: 특정 컨테이너 인스턴스의 태스크를 나열하는 방법**
다음 `list-tasks` 예시에서는 컨테이너 인스턴스 UUID를 필터로 사용하여 컨테이너 인스턴스의 태스크를 나열합니다.
```
aws ecs list-tasks --cluster default --container-instance a1b2c3d4-5678-90ab-cdef-33333EXAMPLE
```
출력:
```
{
"taskArns": [
"arn:aws:ecs:us-west-2:123456789012:task/a1b2c3d4-5678-90ab-cdef-44444EXAMPLE"
]
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS 태스크 정의](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html)를 참조하세요.
+ API 세부 정보는 **AWS CLI 명령 참조의 [ListTasks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/list-tasks.html)를 참조하세요.
------
# CLI로 `UpdateClusterSettings` 사용
다음 코드 예시는 `UpdateClusterSettings`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**클러스터의 설정을 수정하려면**
다음 `update-cluster-settings` 예제에서는 `MyCluster`라는 클러스터를 만들고 향상된 관찰성을 갖춘 CloudWatch Container Insights를 사용 설정합니다.
```
aws ecs update-cluster-settings \
--cluster MyCluster \
--settings name=containerInsights,value=enhanced
```
출력:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-esat-1:123456789012:cluster/MyCluster",
"clusterName": "default",
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [
{
"name": "containerInsights",
"value": "enhanced"
}
]
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [계정 설정 수정](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-modifying-longer-id-settings.html) 섹션을 참조하세요.
+ API 세부 정보는 *AWS CLI 명령 참조*의 [UpdateClusterSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/update-cluster-settings.html) 섹션을 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 cmdlet은 ECS 클러스터에 사용할 설정을 수정합니다.**
```
Update-ECSClusterSetting -Cluster "LAB-ECS-CL" -Setting @{Name="containerInsights"; Value="disabled"}
```
**출력:**
```
ActiveServicesCount : 0
Attachments : {}
AttachmentsStatus :
CapacityProviders : {}
ClusterArn : arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
ClusterName : LAB-ECS-CL
DefaultCapacityProviderStrategy : {}
PendingTasksCount : 0
RegisteredContainerInstancesCount : 0
RunningTasksCount : 0
Settings : {containerInsights}
Statistics : {}
Status : ACTIVE
Tags : {}
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [UpdateClusterSettings](https://docs.aws.amazon.com/powershell/v4/reference)을 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 cmdlet은 ECS 클러스터에 사용할 설정을 수정합니다.**
```
Update-ECSClusterSetting -Cluster "LAB-ECS-CL" -Setting @{Name="containerInsights"; Value="disabled"}
```
**출력:**
```
ActiveServicesCount : 0
Attachments : {}
AttachmentsStatus :
CapacityProviders : {}
ClusterArn : arn:aws:ecs:us-west-2:012345678912:cluster/LAB-ECS-CL
ClusterName : LAB-ECS-CL
DefaultCapacityProviderStrategy : {}
PendingTasksCount : 0
RegisteredContainerInstancesCount : 0
RunningTasksCount : 0
Settings : {containerInsights}
Statistics : {}
Status : ACTIVE
Tags : {}
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [UpdateClusterSettings](https://docs.aws.amazon.com/powershell/v5/reference)을 참조하세요.
------
# AWS SDK 또는 CLI와 `UpdateService` 함께 사용
다음 코드 예시는 `UpdateService`의 사용 방법을 보여 줍니다.
------
#### [ CLI ]
**AWS CLI**
**예 1: 서비스에 사용되는 태스크 정의를 변경하는 방법**
다음 `update-service` 예시에서는 `amazon-ecs-sample` 태스크 정의를 사용하도록 `my-http-service` 서비스를 업데이트합니다.
```
aws ecs update-service \
--cluster test \
--service my-http-service \
--task-definition amazon-ecs-sample
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/test/my-http-service",
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/test",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 2,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/amazon-ecs-sample:2",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": true,
"rollback": true
},
"maximumPercent": 200,
"minimumHealthyPercent": 100,
"alarms": {
"alarmNames": [],
"rollback": false,
"enable": false
}
},
"deployments": [
{
"id": "ecs-svc/7419115625193919142",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/amazon-ecs-sample:2",
"desiredCount": 0,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": "2025-02-21T13:26:02.734000-06:00",
"updatedAt": "2025-02-21T13:26:02.734000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/7419115625193919142 in progress."
},
{
"id": "ecs-svc/1709597507655421668",
"status": "ACTIVE",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/old-amazon-ecs-sample:4",
"desiredCount": 2,
"pendingCount": 0,
"runningCount": 2,
"failedTasks": 0,
"createdAt": "2025-01-24T11:13:07.621000-06:00",
"updatedAt": "2025-02-02T16:11:30.838000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "COMPLETED",
"rolloutStateReason": "ECS deployment ecs-svc/1709597507655421668 completed."
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [
{
"id": "e40b4d1c-80d9-4834-aaf3-6a268e530e17",
"createdAt": "2025-02-21T10:31:26.037000-06:00",
"message": "(my-http-service) has reached a steady state."
},
{
"id": "6ac069ad-fc8b-4e49-a35d-b5574a964c8e",
"createdAt": "2025-02-21T04:31:22.703000-06:00",
"message": "(my-http-service) has reached a steady state."
},
{
"id": "265f7d37-dfd1-4880-a846-ec486f341919",
"createdAt": "2025-02-20T22:31:22.514000-06:00",
"message": "(my-http-service) has reached a steady state."
}
],
"createdAt": "2024-10-30T17:12:43.218000-05:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321",
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:role/AIDACKCEVSQ6C2EXAMPLE",
"enableECSManagedTags": true,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "DISABLED"
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [콘솔을 사용하여 Amazon ECS 서비스 업데이트](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service-console-v2.html)를 참조하세요.
**예 2: 서비스의 태스크 수를 변경하는 방법**
다음 `update-service` 예시에서는 `my-http-service` 서비스의 원하는 작업 수를 2로 업데이트합니다.
```
aws ecs update-service \
--cluster MyCluster \
--service my-http-service \
--desired-count 2
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/my-http-service",
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 1,
"pendingCount": 0,
"capacityProviderStrategy": [
{
"capacityProvider": "FARGATE",
"weight": 1,
"base": 0
}
],
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-east-1:123456789012:task-definition/MyTaskDefinition",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": true,
"rollback": true
},
"maximumPercent": 200,
"minimumHealthyPercent": 100,
"alarms": {
"alarmNames": [],
"rollback": false,
"enable": false
}
},
"deployments": [
{
"id": "ecs-svc/1976744184940610707",
"status": "PRIMARY",
"taskkDefinition": "arn:aws:ecs:us-east-1:123456789012:task-definition/MyTaskDefinition",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 1,
"failedTasks": 0,
"createdAt": "2024-12-03T16:24:25.225000-05:00",
"updatedAt": "2024-12-03T16:25:15.837000-05:00",
"capacityProviderStrategy": [
{
"capacityProvider": "FARGATE",
"weight": 1,
"base": 0
}
],
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-0d0eab1bb38d5ca64",
"subnet-0db5010045995c2d5"
],
"securityGroups": [
"sg-02556bf85a191f59a"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "COMPLETED",
"rolloutStateReason": "ECS deployment ecs-svc/1976744184940610707 completed."
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [
{
"id": "f27350b9-4b2a-4e2e-b72e-a4b68380de45",
"createdAt": "2024-12-30T13:24:07.345000-05:00",
"message": "(service my-http-service) has reached a steady state."
},
{
"id": "e764ec63-f53f-45e3-9af2-d99f922d2957",
"createdAt": "2024-12-30T12:32:21.600000-05:00",
"message": "(service my-http-service) has reached a steady state."
},
{
"id": "28444756-c2fa-47f8-bd60-93a8e05f3991",
"createdAt": "2024-12-08T19:26:10.367000-05:00",
"message": "(service my-http-service) has reached a steady state."
}
],
"createdAt": "2024-12-03T16:24:25.225000-05:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-0d0eab1bb38d5ca64",
"subnet-0db5010045995c2d5"
],
"securityGroups": [
"sg-02556bf85a191f59a"
],
"assignPublicIp": "ENABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:role/Admin",
"enableECSManagedTags": true,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "ENABLED"
}
}
```
자세한 내용을 알아보려면 *Amazon ECS 개발자 안내서*의 [콘솔을 사용하여 Amazon ECS 서비스 업데이트](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service-console-v2.html) 섹션을 참조하시기 바랍니다.
**예시 3: 서비스 업데이트 시 연결하도록 Amazon EBS 볼륨 구성**
다음 `update-service` 예시에서는 Amazon EBS 볼륨을 사용하도록 `my-http-service` 서비스를 업데이트합니다. `AmazonECSInfrastructureRolePolicyForVolumes` 관리형 정책과 연결된 Amazon ECS 인프라 역할이 구성되어 있어야 합니다. 또한 `update-service` 요청에서와 동일한 볼륨 이름을 사용하고 `configuredAtLaunch`를 `true`로 설정하여 작업 정의를 지정해야 합니다. 이 예시에서는 `--cli-input-json` 옵션과 `ebs.json`이라는 JSON 입력 파일을 사용합니다.
```
aws ecs update-service \
--cli-input-json file://ebs.json
```
`ebs.json`의 콘텐츠:
```
{
"cluster": "mycluster",
"taskDefinition": "mytaskdef",
"service": "my-http-service",
"desiredCount": 2,
"volumeConfigurations": [
{
"name": "myEbsVolume",
"managedEBSVolume": {
"roleArn":"arn:aws:iam::123456789012:role/ecsInfrastructureRole",
"volumeType": "gp3",
"sizeInGiB": 100,
"iops": 3000,
"throughput": 125,
"filesystemType": "ext4"
}
}
]
}
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/mycluster/my-http-service",
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/mycluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 2,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:1",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": true,
"rollback": true
},
"maximumPercent": 200,
"minimumHealthyPercent": 100,
"alarms": {
"alarmNames": [],
"rollback": false,
"enable": false
}
},
"deployments": [
{
"id": "ecs-svc/2420458347226626275",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:1",
"desiredCount": 0,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": "2025-02-21T15:07:20.519000-06:00",
"updatedAt": "2025-02-21T15:07:20.519000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321",
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/2420458347226626275 in progress.",
"volumeConfigurations": [
{
"name": "ebs-volume",
"managedEBSVolume": {
"volumeType": "gp3",
"sizeInGiB": 100,
"iops": 3000,
"throughput": 125,
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRole",
"filesystemType": "ext4"
}
}
]
},
{
"id": "ecs-svc/5191625155316533644",
"status": "ACTIVE",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:2",
"desiredCount": 2,
"pendingCount": 0,
"runningCount": 2,
"failedTasks": 0,
"createdAt": "2025-02-21T14:54:48.862000-06:00",
"updatedAt": "2025-02-21T14:57:22.502000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "COMPLETED",
"rolloutStateReason": "ECS deployment ecs-svc/5191625155316533644 completed."
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [
{
"id": "b5823113-c2c5-458e-9649-8c2ed38f23a5",
"createdAt": "2025-02-21T14:57:22.508000-06:00",
"message": "(service my-http-service) has reached a steady state."
},
{
"id": "b05a48e8-da35-4074-80aa-37ceb3167357",
"createdAt": "2025-02-21T14:57:22.507000-06:00",
"message": "(service my-http-service) (deployment ecs-svc/5191625155316533644) deployment completed."
},
{
"id": "a10cd55d-4ba6-4cea-a655-5a5d32ada8a0",
"createdAt": "2025-02-21T14:55:32.833000-06:00",
"message": "(service my-http-service) has started 1 tasks: (task fb9c8df512684aec92f3c57dc3f22361)."
},
],
"createdAt": "2025-02-21T14:54:48.862000-06:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:role/AIDACKCEVSQ6C2EXAMPLE",
"enableECSManagedTags": true,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "ENABLED"
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS에서 Amazon EBS 볼륨 사용](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ebs-volumes.html)을 참조하세요.
**예시 4: Amazon EBS 볼륨을 더 이상 사용하지 않도록 서비스 업데이트**
다음 `update-service` 예시에서는 Amazon EBS 볼륨을 더 이상 사용하지 않도록 `my-http-service` 서비스를 업데이트합니다. `configuredAtLaunch`를 `false`로 설정하여 작업 정의 개정을 지정해야 합니다.
```
aws ecs update-service \
--cluster mycluster \
--task-definition mytaskdef \
--service my-http-service \
--desired-count 2 \
--volume-configurations "[]"
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/mycluster/my-http-service",
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/mycluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 2,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:3",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": true,
"rollback": true
},
"maximumPercent": 200,
"minimumHealthyPercent": 100,
"alarms": {
"alarmNames": [],
"rollback": false,
"enable": false
}
},
"deployments": [
{
"id": "ecs-svc/7522791612543716777",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/mytaskdef:3",
"desiredCount": 0,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": "2025-02-21T15:25:38.598000-06:00",
"updatedAt": "2025-02-21T15:25:38.598000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/7522791612543716777 in progress."
},
{
"id": "ecs-svc/2420458347226626275",
"status": "ACTIVE",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/myoldtaskdef:1",
"desiredCount": 2,
"pendingCount": 0,
"runningCount": 2,
"failedTasks": 0,
"createdAt": "2025-02-21T15:07:20.519000-06:00",
"updatedAt": "2025-02-21T15:10:59.955000-06:00",
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "COMPLETED",
"rolloutStateReason": "ECS deployment ecs-svc/2420458347226626275 completed.",
"volumeConfigurations": [
{
"name": "ebs-volume",
"managedEBSVolume": {
"volumeType": "gp3",
"sizeInGiB": 100,
"iops": 3000,
"throughput": 125,
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRole",
"filesystemType": "ext4"
}
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [
{
"id": "4f2c3ca1-7800-4048-ba57-bba210ada2ad",
"createdAt": "2025-02-21T15:10:59.959000-06:00",
"message": "(service my-http-service) has reached a steady state."
},
{
"id": "4b36a593-2d40-4ed6-8be8-b9b699eb6198",
"createdAt": "2025-02-21T15:10:59.958000-06:00",
"message": "(service my-http-service) (deployment ecs-svc/2420458347226626275) deployment completed."
},
{
"id": "88380089-14e2-4ef0-8dbb-a33991683371",
"createdAt": "2025-02-21T15:09:39.055000-06:00",
"message": "(service my-http-service) has stopped 1 running tasks: (task fb9c8df512684aec92f3c57dc3f22361)."
},
{
"id": "97d84243-d52f-4255-89bb-9311391c61f6",
"createdAt": "2025-02-21T15:08:57.653000-06:00",
"message": "(service my-http-service) has stopped 1 running tasks: (task 33eff090ad2c40539daa837e6503a9bc)."
},
{
"id": "672ece6c-e2d0-4021-b5da-eefb14001687",
"createdAt": "2025-02-21T15:08:15.631000-06:00",
"message": "(service my-http-service) has started 1 tasks: (task 996c02a66ff24f3190a4a8e0c841740f)."
},
{
"id": "a3cf9bea-9be6-4175-ac28-4c68360986eb",
"createdAt": "2025-02-21T15:07:36.931000-06:00",
"message": "(service my-http-service) has started 1 tasks: (task d5d23c39f89e46cf9a647b9cc6572feb)."
},
{
"id": "b5823113-c2c5-458e-9649-8c2ed38f23a5",
"createdAt": "2025-02-21T14:57:22.508000-06:00",
"message": "(service my-http-service) has reached a steady state."
},
{
"id": "b05a48e8-da35-4074-80aa-37ceb3167357",
"createdAt": "2025-02-21T14:57:22.507000-06:00",
"message": "(service my-http-service) (deployment ecs-svc/5191625155316533644) deployment completed."
},
{
"id": "a10cd55d-4ba6-4cea-a655-5a5d32ada8a0",
"createdAt": "2025-02-21T14:55:32.833000-06:00",
"message": "(service my-http-service) has started 1 tasks: (task fb9c8df512684aec92f3c57dc3f22361)."
},
{
"id": "42da91fa-e26d-42ef-88c3-bb5965c56b2f",
"createdAt": "2025-02-21T14:55:02.703000-06:00",
"message": "(service my-http-service) has started 1 tasks: (task 33eff090ad2c40539daa837e6503a9bc)."
}
],
"createdAt": "2025-02-21T14:54:48.862000-06:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-12344321"
],
"securityGroups": [
"sg-12344321"
],
"assignPublicIp": "ENABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:role/AIDACKCEVSQ6C2EXAMPLE",
"enableECSManagedTags": true,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "ENABLED"
}
}
```
자세한 내용은 *Amazon ECS 개발자 안내서*의 [Amazon ECS에서 Amazon EBS 볼륨 사용](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ebs-volumes.html)을 참조하세요.
**예시 5: 서비스에 대한 가용 영역 리밸런싱 켜기**
다음 `update-service` 예제에서는 `my-http-service` 서비스에 대해 가용 영역 리밸런싱을 켭니다.
```
aws ecs update-service \
--cluster MyCluster \
--service my-http-service \
--availability-zone-rebalancing ENABLED
```
출력:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/my-http-service",
"serviceName": "my-http-service",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 2,
"runningCount": 1,
"pendingCount": 0,
"capacityProviderStrategy": [
{
"capacityProvider": "FARGATE",
"weight": 1,
"base": 0
}
],
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-east-1:123456789012:task-definition/MyTaskDefinition",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": true,
"rollback": true
},
"maximumPercent": 200,
"minimumHealthyPercent": 100,
"alarms": {
"alarmNames": [],
"rollback": false,
"enable": false
}
},
"deployments": [
{
"id": "ecs-svc/1976744184940610707",
"status": "PRIMARY",
"taskkDefinition": "arn:aws:ecs:us-east-1:123456789012:task-definition/MyTaskDefinition",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 1,
"failedTasks": 0,
"createdAt": "2024-12-03T16:24:25.225000-05:00",
"updatedAt": "2024-12-03T16:25:15.837000-05:00",
"capacityProviderStrategy": [
{
"capacityProvider": "FARGATE",
"weight": 1,
"base": 0
}
],
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-0d0eab1bb38d5ca64",
"subnet-0db5010045995c2d5"
],
"securityGroups": [
"sg-02556bf85a191f59a"
],
"assignPublicIp": "ENABLED"
}
},
"rolloutState": "COMPLETED",
"rolloutStateReason": "ECS deployment ecs-svc/1976744184940610707 completed."
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"events": [],
"createdAt": "2024-12-03T16:24:25.225000-05:00",
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"subnets": [
"subnet-0d0eab1bb38d5ca64",
"subnet-0db5010045995c2d5"
],
"securityGroups": [
"sg-02556bf85a191f59a"
],
"assignPublicIp": "ENABLED"
}
},
"healthCheckGracePeriodSeconds": 0,
"schedulingStrategy": "REPLICA",
"deploymentController": {
"type": "ECS"
},
"createdBy": "arn:aws:iam::123456789012:role/Admin",
"enableECSManagedTags": true,
"propagateTags": "NONE",
"enableExecuteCommand": false,
"availabilityZoneRebalancing": "ENABLED"
}
}
```
자세한 내용을 알아보려면 *Amazon ECS 개발자 안내서*의 [콘솔을 사용하여 Amazon ECS 서비스 업데이트](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/update-service-console-v2.html) 섹션을 참조하시기 바랍니다.
+ API 세부 정보는 **AWS CLI 명령 참조의 [UpdateService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecs/update-service.html)를 참조하세요.
------
#### [ Java ]
**SDK for Java 2.x**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/ecs#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ecs.EcsClient;
import software.amazon.awssdk.services.ecs.model.EcsException;
import software.amazon.awssdk.services.ecs.model.UpdateServiceRequest;
/**
* Before running this Java V2 code example, set up your development
* environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class UpdateService {
public static void main(String[] args) {
final String usage = """
Usage:
\s
Where:
clusterName - The cluster name.
serviceArn - The service ARN value.
""";
if (args.length != 2) {
System.out.println(usage);
System.exit(1);
}
String clusterName = args[0];
String serviceArn = args[1];
Region region = Region.US_EAST_1;
EcsClient ecsClient = EcsClient.builder()
.region(region)
.build();
updateSpecificService(ecsClient, clusterName, serviceArn);
ecsClient.close();
}
public static void updateSpecificService(EcsClient ecsClient, String clusterName, String serviceArn) {
try {
UpdateServiceRequest serviceRequest = UpdateServiceRequest.builder()
.cluster(clusterName)
.service(serviceArn)
.desiredCount(0)
.build();
ecsClient.updateService(serviceRequest);
System.out.println("The service was modified");
} catch (EcsException e) {
System.err.println(e.awsErrorDetails().errorMessage());
System.exit(1);
}
}
}
```
+ API에 대한 세부 정보는 *AWS SDK for Java 2.x API 참조*의 [UpdateService](https://docs.aws.amazon.com/goto/SdkForJavaV2/ecs-2014-11-13/UpdateService)를 참조하세요.
------
#### [ PowerShell ]
**Tools for PowerShell V4**
**예제 1: 이 예제 명령에서는 `amazon-ecs-sample` 태스크 정의를 사용하도록 `my-http-service` 서비스를 업데이트합니다.**
```
Update-ECSService -Service my-http-service -TaskDefinition amazon-ecs-sample
```
**예제 2: 이 예제 명령에서는 `my-http-service` 서비스의 원하는 개수를 10으로 업데이트합니다.**
```
Update-ECSService -Service my-http-service -DesiredCount 10
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V4)*의 [UpdateService](https://docs.aws.amazon.com/powershell/v4/reference)를 참조하세요.
**Tools for PowerShell V5**
**예제 1: 이 예제 명령에서는 `amazon-ecs-sample` 태스크 정의를 사용하도록 `my-http-service` 서비스를 업데이트합니다.**
```
Update-ECSService -Service my-http-service -TaskDefinition amazon-ecs-sample
```
**예제 2: 이 예제 명령에서는 `my-http-service` 서비스의 원하는 개수를 10으로 업데이트합니다.**
```
Update-ECSService -Service my-http-service -DesiredCount 10
```
+ API 세부 정보는 *AWS Tools for PowerShell Cmdlet 참조(V5)*의 [UpdateService](https://docs.aws.amazon.com/powershell/v5/reference)를 참조하세요.
------
# AWS SDKs를 사용한 Amazon ECS 시나리오
다음 코드 예제에서는 Amazon ECS AWS SDKs에서 일반적인 시나리오를 구현하는 방법을 보여줍니다. 이러한 시나리오에서는 Amazon ECS 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 작업을 수행하는 방법을 보여줍니다. 각 시나리오에는 전체 소스 코드에 대한 링크가 포함되어 있습니다. 여기에서 코드를 설정 및 실행하는 방법에 대한 지침을 찾을 수 있습니다.
시나리오는 컨텍스트에 맞는 서비스 작업을 이해하는 데 도움이 되도록 중급 수준의 경험을 대상으로 합니다.
**Topics**
+ [클러스터, 서비스, 작업에 대한 ARN 정보 가져오기](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
# AWS SDK를 사용하여 Amazon ECS 클러스터, 서비스 및 작업에 대한 ARN 정보 가져오기
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ 모든 클러스터 목록을 가져옵니다.
+ 클러스터에 대한 서비스를 가져옵니다.
+ 클러스터에 대한 작업을 가져옵니다.
------
#### [ .NET ]
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/ECS#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
명령 프롬프트에서 대화형 시나리오를 실행합니다.
```
using Amazon.ECS;
using ECSActions;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Console;
using Microsoft.Extensions.Logging.Debug;
namespace ECSScenario;
public class ECSScenario
{
/*
Before running this .NET code example, set up your development environment, including your credentials.
This .NET example performs the following tasks:
1. List ECS Cluster ARNs.
2. List services in every cluster
3. List Task ARNs in every cluster.
*/
private static ILogger logger = null!;
private static ECSWrapper _ecsWrapper = null!;
static async Task Main(string[] args)
{
// Set up dependency injection for the Amazon service.
using var host = Host.CreateDefaultBuilder(args)
.ConfigureLogging(logging =>
logging.AddFilter("System", LogLevel.Debug)
.AddFilter("Microsoft", LogLevel.Information)
.AddFilter("Microsoft", LogLevel.Trace))
.Build();
ILoggerFactory loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddConsole();
});
logger = LoggerFactory.Create(builder => { builder.AddConsole(); })
.CreateLogger();
var loggerECSWarpper = LoggerFactory.Create(builder => { builder.AddConsole(); })
.CreateLogger();
var amazonECSClient = new AmazonECSClient();
_ecsWrapper = new ECSWrapper(amazonECSClient, loggerECSWarpper);
Console.WriteLine(new string('-', 80));
Console.WriteLine("Welcome to the Amazon ECS example scenario.");
Console.WriteLine(new string('-', 80));
try
{
await ListClusterARNs();
await ListServiceARNs();
await ListTaskARNs();
}
catch (Exception ex)
{
logger.LogError(ex, "There was a problem executing the scenario.");
}
}
///
/// List ECS Cluster ARNs
///
private static async Task ListClusterARNs()
{
Console.WriteLine(new string('-', 80));
Console.WriteLine($"1. List Cluster ARNs from ECS.");
var arns = await _ecsWrapper.GetClusterARNSAsync();
foreach (var arn in arns)
{
Console.WriteLine($"Cluster arn: {arn}");
Console.WriteLine($"Cluster name: {arn.Split("/").Last()}");
}
Console.WriteLine(new string('-', 80));
}
///
/// List services in every cluster
///
private static async Task ListServiceARNs()
{
Console.WriteLine(new string('-', 80));
Console.WriteLine($"2. List Service ARNs in every cluster.");
var clusterARNs = await _ecsWrapper.GetClusterARNSAsync();
foreach (var clusterARN in clusterARNs)
{
Console.WriteLine($"Getting services for cluster name: {clusterARN.Split("/").Last()}");
Console.WriteLine(new string('.', 5));
var serviceARNs = await _ecsWrapper.GetServiceARNSAsync(clusterARN);
foreach (var serviceARN in serviceARNs)
{
Console.WriteLine($"Service arn: {serviceARN}");
Console.WriteLine($"Service name: {serviceARN.Split("/").Last()}");
}
}
Console.WriteLine(new string('-', 80));
}
///
/// List tasks in every cluster
///
private static async Task ListTaskARNs()
{
Console.WriteLine(new string('-', 80));
Console.WriteLine($"3. List Task ARNs in every cluster.");
var clusterARNs = await _ecsWrapper.GetClusterARNSAsync();
foreach (var clusterARN in clusterARNs)
{
Console.WriteLine($"Getting tasks for cluster name: {clusterARN.Split("/").Last()}");
Console.WriteLine(new string('.', 5));
var taskARNs = await _ecsWrapper.GetTaskARNsAsync(clusterARN);
foreach (var taskARN in taskARNs)
{
Console.WriteLine($"Task arn: {taskARN}");
}
}
Console.WriteLine(new string('-', 80));
}
}
```
Amazon ECS 작업을 관리하기 위해 시나리오가 호출하는 래퍼 메서드.
```
using Amazon.ECS;
using Amazon.ECS.Model;
using Microsoft.Extensions.Logging;
namespace ECSActions;
public class ECSWrapper
{
private readonly AmazonECSClient _ecsClient;
private readonly ILogger _logger;
///
/// Constructor for the ECS wrapper.
///
/// The injected ECS client.
/// The injected logger for the wrapper.
public ECSWrapper(AmazonECSClient ecsClient, ILogger logger)
{
_logger = logger;
_ecsClient = ecsClient;
}
///
/// List cluster ARNs available.
///
/// The ARN list of clusters.
public async Task> GetClusterARNSAsync()
{
Console.WriteLine("Getting a list of all the clusters in your AWS account...");
List clusterArnList = new List();
// Get a list of all the clusters in your AWS account
try
{
var listClustersResponse = _ecsClient.Paginators.ListClusters(new ListClustersRequest
{
});
var clusterArns = listClustersResponse.ClusterArns;
// Print the ARNs of the clusters
await foreach (var clusterArn in clusterArns)
{
clusterArnList.Add(clusterArn);
}
if (clusterArnList.Count == 0)
{
_logger.LogWarning("No clusters found in your AWS account.");
}
return clusterArnList;
}
catch (Exception e)
{
_logger.LogError($"An error occurred while getting a list of all the clusters in your AWS account. {e.InnerException}");
throw new Exception($"An error occurred while getting a list of all the clusters in your AWS account. {e.InnerException}");
}
}
///
/// List service ARNs available.
///
/// The arn of the ECS cluster.
/// The ARN list of services in given cluster.
public async Task> GetServiceARNSAsync(string clusterARN)
{
List serviceArns = new List();
var request = new ListServicesRequest
{
Cluster = clusterARN
};
// Call the ListServices API operation and get the list of service ARNs
var serviceList = _ecsClient.Paginators.ListServices(request);
await foreach (var serviceARN in serviceList.ServiceArns)
{
if (serviceARN is null)
continue;
serviceArns.Add(serviceARN);
}
if (serviceArns.Count == 0)
{
_logger.LogWarning($"No services found in cluster {clusterARN} .");
}
return serviceArns;
}
///
/// List task ARNs available.
///
/// The arn of the ECS cluster.
/// The ARN list of tasks in given cluster.
public async Task> GetTaskARNsAsync(string clusterARN)
{
// Set up the request to describe the tasks in the service
var listTasksRequest = new ListTasksRequest
{
Cluster = clusterARN
};
List taskArns = new List();
// Call the ListTasks API operation and get the list of task ARNs
var tasks = _ecsClient.Paginators.ListTasks(listTasksRequest);
await foreach (var task in tasks.TaskArns)
{
if (task is null)
continue;
taskArns.Add(task);
}
if (taskArns.Count == 0)
{
_logger.LogWarning("No tasks found in cluster: " + clusterARN);
}
return taskArns;
}
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 다음 주제를 참조하세요.
+ [ListClusters](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListClusters)
+ [ListServices](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListServices)
+ [ListTasks](https://docs.aws.amazon.com/goto/DotNetSDKV3/ecs-2014-11-13/ListTasks)
------