文件 AWS 開發套件範例 GitHub 儲存庫中有更多可用的 [AWS SDK 範例](https://github.com/awsdocs/aws-doc-sdk-examples)。
本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 使用 AWS SDKs Amazon ECS 程式碼範例
下列程式碼範例示範如何使用 Amazon Elastic Container Service 搭配 AWS 軟體開發套件 (SDK)。
*Actions* 是大型程式的程式碼摘錄，必須在內容中執行。雖然動作會告訴您如何呼叫個別服務函數，但您可以在其相關情境中查看內容中的動作。
*案例*是向您展示如何呼叫服務中的多個函數或與其他 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 ]
**適用於 .NET 的 SDK (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 詳細資訊，請參閱《適用於 .NET 的 AWS SDK 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)
# `CreateCluster` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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` 範例會建立叢集，並將兩個現有容量提供者與其建立關聯。使用 `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 開發人員指南》**的[叢集容量提供者](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 ]
**適用於 Rust 的 SDK**
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)。
------
# `CreateService` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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 磁碟區。您必須將 Amazon ECS 基礎設施角色設定為已連接的 `AmazonECSInfrastructureRolePolicyForVolumes` 受管政策。您必須以和 `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 EBS 磁碟區和 Amazon ECS](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)。
------
# `DeleteCluster` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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 ]
**適用於 Rust 的 SDK**
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)。
------
# `DeleteService` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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)。
------
# `DescribeClusters` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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 選項。範例中擷取指定叢集的詳細資訊，並以附件形式擷取連接至叢集的資源清單。將容量提供者與叢集搭配使用時，資源以 asp 或 as\$1policy ATTACHMENTS 表示，可以是 AutoScaling 計畫或擴展政策。
```
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 ]
**適用於 Rust 的 SDK**
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)。
------
# 搭配使用 `DescribeServices` 與 CLI
下列程式碼範例示範如何使用 `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)。
------
# `DescribeTasks` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `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)。
------
# `ListClusters` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `ListClusters`。
動作範例是大型程式的程式碼摘錄，必須在內容中執行。您可以在下列程式碼範例的內容中看到此動作：
+ [取得叢集、服務和任務的 ARN 資訊](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**適用於 .NET 的 SDK**
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 詳細資訊，請參閱《適用於 .NET 的 AWS SDK 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)。
------
# `ListServices` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `ListServices`。
動作範例是大型程式的程式碼摘錄，必須在內容中執行。您可以在下列程式碼範例的內容中看到此動作：
+ [取得叢集、服務和任務的 ARN 資訊](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**適用於 .NET 的 SDK**
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 詳細資訊，請參閱《適用於 .NET 的 AWS SDK 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)。
------
# `ListTasks` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `ListTasks`。
動作範例是大型程式的程式碼摘錄，必須在內容中執行。您可以在下列程式碼範例的內容中看到此動作：
+ [取得叢集、服務和任務的 ARN 資訊](ecs_example_ecs_Scenario_GetClustersServicesAndTasks_section.md)
------
#### [ .NET ]
**適用於 .NET 的 SDK**
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 詳細資訊，請參閱《適用於 .NET 的 AWS SDK 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)。
------
# 搭配使用 `UpdateClusterSettings` 與 CLI
下列程式碼範例示範如何使用 `UpdateClusterSettings`。
------
#### [ CLI ]
**AWS CLI**
**修改叢集的設定**
下列 `update-cluster-settings` 範例使 CloudWatch Container Insights 對 `MyCluster` 叢集具有增強的可觀測性。
```
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)。
------
# `UpdateService` 搭配 AWS SDK 或 CLI 使用
下列程式碼範例示範如何使用 `UpdateService`。
------
#### [ CLI ]
**AWS CLI**
**範例 1：變更服務中使用的任務定義**
下列 `update-service` 範例會更新 `my-http-service` 服務以使用 `amazon-ecs-sample` 任務定義。
```
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` 範例會將服務 `my-http-service` 更新為使用 Amazon EBS 磁碟區。您必須將 Amazon ECS 基礎設施角色設定為已連接的 `AmazonECSInfrastructureRolePolicyForVolumes` 受管政策。您也必須以和 `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 EBS 磁碟區和 Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ebs-volumes.html)。
**範例 4：更新服務以不再使用 Amazon EBS 磁碟區**
下列 `update-service` 範例會將服務 `my-http-service` 更新為不再使用 Amazon EBS 磁碟區。您必須指定任務定義修訂版，並將 `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 EBS 磁碟區和 Amazon ECS](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：此範例命令會更新 `my-http-service` 服務，以使用 `amazon-ecs-sample` 任務定義。**
```
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：此範例命令會更新 `my-http-service` 服務，以使用 `amazon-ecs-sample` 任務定義。**
```
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 ]
**適用於 .NET 的 SDK**
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 詳細資訊，請參閱《*適用於 .NET 的 AWS SDK 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)
------