本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# Amazon ECS 任務定義使用案例
<a name="use-cases"></a>

進一步了解如何撰寫各種 AWS 服務和功能的任務定義。

您需要根據工作負載設定某些任務定義參數。若採用 EC2，則必須選擇為該工作負載專門設計的執行個體類型。

**Topics**
+ [GPU 工作負載的 Amazon ECS 任務定義](ecs-gpu.md)
+ [影片轉碼工作負載的 Amazon ECS 任務定義](ecs-vt1.md)
+ [AWS Neuron 機器學習工作負載的 Amazon ECS 任務定義](ecs-inference.md)
+ [深度學習執行個體的 Amazon ECS 任務定義](ecs-dl1.md)
+ [64 位元 ARM 工作負載的 Amazon ECS 任務定義](ecs-arm64.md)
+ [將 Amazon ECS 日誌傳送至 CloudWatch](using_awslogs.md)
+ [將 Amazon ECS 日誌傳送至 AWS 服務或 AWS Partner](using_firelens.md)
+ [在 Amazon ECS 中使用非AWS 容器映像](private-auth.md)
+ [使用容器重新啟動政策在 Amazon ECS 任務中重新啟動個別容器](container-restart-policy.md)
+ [將敏感資料傳遞至 Amazon ECS 容器](specifying-sensitive-data.md)

# GPU 工作負載的 Amazon ECS 任務定義
<a name="ecs-gpu"></a>

您建立具有支援 GPU 容器執行個體的叢集時，Amazon ECS 支援使用 GPU 的工作負載。使用 p2、p3、p5、g3、g4 和 g5 執行個體類型的 Amazon EC2 GPU 型容器執行個體可讓您存取 NVIDIA GPU。如需詳細資訊，請參閱 *Amazon EC2 Instance Types guide* 中的 [Linux Accelerated Computing Instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html)。

Amazon ECS 提供的 GPU 最佳化 AMI 可與預先設定的 NVIDIA 核心驅動程式和 Docker GPU 執行時間搭配使用。如需詳細資訊，請參閱[Amazon ECS 最佳化 Linux AMI](ecs-optimized_AMI.md)。

您可以在容器定義中指定 GPU 數量，以便在容器層級考量任務放置。Amazon ECS 會對支援 GPU 的可用容器執行個體排程並將實體 GPU 固定至適當容器以獲得最佳效能。

支援下列 Amazon EC2 GPU 型執行個體類型。如需詳細資訊，請參閱 [Amazon EC2 P2 執行個體](https://aws.amazon.com/ec2/instance-types/p2/)、[Amazon EC2 P3 執行個體](https://aws.amazon.com/ec2/instance-types/p3/)、[Amazon EC2 P4d 執行個體](https://aws.amazon.com/ec2/instance-types/p4/)、[Amazon EC2 P5 執行個體](https://aws.amazon.com/ec2/instance-types/p5/)、[Amazon EC2 G3 執行個體](https://aws.amazon.com/ec2/instance-types/g3/)、[Amazon EC2 G4 執行個體](https://aws.amazon.com/ec2/instance-types/g4/)、[Amazon EC2 G5 執行個體](https://aws.amazon.com/ec2/instance-types/g5/)、[Amazon EC2 G6 執行個體](https://aws.amazon.com/ec2/instance-types/g6/)與 [Amazon EC2 G6e 執行個體](https://aws.amazon.com/ec2/instance-types/g6e/)。


|  執行個體類型  |  GPU  |  GPU 記憶體 (GiB)  |  vCPUs  |  記憶體 (GiB)  | 
| --- | --- | --- | --- | --- | 
|  p3.2xlarge  |  1  |  16  |  8  |  61  | 
|  p3.8xlarge  |  4  |  64  |  32  |  244  | 
|  p3.16xlarge  |  8  |  128  |  64  |  488  | 
|  p3dn.24xlarge  |  8  |  256  |  96  |  768  | 
|  p4d.24xlarge  | 8 | 320 | 96 | 1152 | 
| p5.48xlarge | 8 | 640 | 192 | 2048 | 
|  g3s.xlarge  |  1  |  8  |  4  |  30.5  | 
|  g3.4xlarge  |  1  |  8  |  16  |  122  | 
|  g3.8xlarge  |  2  |  16  |  32  |  244  | 
|  g3.16xlarge  |  4  |  32  |  64  |  488  | 
|  g4dn.xlarge  |  1  |  16  |  4  |  16  | 
|  g4dn.2xlarge  |  1  |  16  |  8  |  32  | 
|  g4dn.4xlarge  |  1  |  16  |  16  |  64  | 
|  g4dn.8xlarge  |  1  |  16  |  32  |  128  | 
|  g4dn.12xlarge  |  4  |  64  |  48  |  192  | 
|  g4dn.16xlarge  |  1  |  16  |  64  |  256  | 
|  g5.xlarge  |  1  |  24  |  4  |  16  | 
|  g5.2xlarge  |  1  |  24  |  8  |  32  | 
|  g5.4xlarge  |  1  |  24  |  16  |  64  | 
|  g5.8xlarge  |  1  |  24  |  32  |  128  | 
|  g5.16xlarge  |  1  |  24  |  64  |  256  | 
|  g5.12xlarge  |  4  |  96  |  48  |  192  | 
|  g5.24xlarge  |  4  |  96  |  96  |  384  | 
|  g5.48xlarge  |  8  |  192  |  192  |  768  | 
| g6.xlarge | 1 | 24 | 4 | 16 | 
| g6.2xlarge | 1 | 24 | 8 | 32 | 
| g6.4xlarge | 1 | 24 | 16 | 64 | 
| g6.8xlarge | 1 | 24 | 32 | 128 | 
| g6.16.xlarge | 1 | 24 | 64 | 256 | 
| g6.12xlarge | 4 | 96 | 48 | 192 | 
| g6.24xlarge | 4 | 96 | 96 | 384 | 
| g6.48xlarge | 8 | 192 | 192 | 768 | 
| g6.metal | 8 | 192 | 192 | 768 | 
| gr6.4xlarge | 1 | 24 | 16 | 128 | 
| g6e.xlarge | 1 | 48 | 4 | 32 | 
| g6e.2xlarge | 1 | 48 | 8 | 64 | 
| g6e.4xlarge | 1 | 48 | 16 | 128 | 
| g6e.8xlarge | 1 | 48 | 32 | 256 | 
| g6e16.xlarge | 1 | 48 | 64 | 512 | 
| g6e12.xlarge | 4 | 192 | 48 | 384 | 
| g6e24.xlarge | 4 | 192 | 96 | 768 | 
| g6e48.xlarge | 8 | 384 | 192 | 1536 | 
| gr6.8xlarge | 1 | 24 | 32 | 256 | 

您可以查詢 AWS Systems Manager 參數存放區 API，擷取 Amazon ECS 最佳化 AMIs) ID。若使用此參數，您無需手動查詢 Amazon ECS 最佳化 AMI ID。如需 Systems Manager 參數存放區 API 的詳細資訊，請參閱 [GetParameter](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html)。您使用的使用者必須擁有 `ssm:GetParameter` IAM 許可，才能擷取 Amazon ECS 最佳化 AMI 中繼資料。

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```

# 搭配 Amazon ECS 受管執行個體使用 GPU
<a name="managed-instances-gpu"></a>

Amazon ECS 受管執行個體透過下列 Amazon EC2 執行個體類型，支援適用於機器學習、高效能運算與影片處理等工作負載的 GPU 加速運算。如需有關 Amazon ECS 受管執行個體支援之執行個體類型的詳細資訊，請參閱 [Amazon ECS 受管執行個體的執行個體類型](managed-instances-instance-types.md)。

以下是 Amazon ECS 受管執行個體上支援的 GPU 型執行個體類型的子集：
+ `g4dn`：採用 NVIDIA T4 GPUs 技術，適用於機器學習推論、電腦視覺與圖形密集型應用程式。
+ `g5`：採用 NVIDIA A10G GPUs 技術，為圖形密集型應用程式與機器學習工作負載提供更高的效能。
+ `p3`：採用 NVIDIA V100 GPUs 技術，專為高效能運算與深度學習訓練而設計。
+ `p4d`：採用 NVIDIA A100 GPUs 技術，為機器學習訓練與高效能運算提供最高效能。

在搭配 Amazon ECS 受管執行個體使用已啟用 GPU 的執行個體類型時，執行個體上會預先安裝 NVIDIA 驅動程式與 CUDA 工具組，讓執行 GPU 加速工作負載更加輕鬆。

## 啟用 GPU 的執行個體選擇
<a name="managed-instances-gpu-instance-selection"></a>

若要為 Amazon ECS 受管執行個體工作負載選取已啟用 GPU 的執行個體類型，請在容量提供者的啟動範本中使用 `instanceRequirements` 物件。下列程式碼片段展示了可用於選取已啟用 GPU 的執行個體的屬性。

```
{
  "instanceRequirements": {
    "acceleratorTypes": "gpu",
    "acceleratorCount": 1,
    "acceleratorManufacturers": ["nvidia"]
  }
}
```

下列程式碼片段展示了可用於在啟動範本中指定已啟用 GPU 的執行個體類型的屬性。

```
{
  "instanceRequirements": {
    "allowedInstanceTypes": ["g4dn.xlarge", "p4de.24xlarge"]
  }
}
```

## 啟用 GPU 的容器映像
<a name="managed-instances-gpu-container-images"></a>

若要在容器中使用 GPU，則需使用包含必要 GPU 程式庫與工具的容器映像。NVIDIA 提供數個預先建置的容器映像 (可作為 GPU 工作負載的基礎映像)，包括下列項目：
+ `nvidia:cuda`：具有 CUDA 工具組的基礎映像，用於 GPU 運算。
+ `tensorflow/tensorflow:latest-gpu`：支援 GPU 的 TensorFlow。
+ `pytorch/pytorch:latest-cuda`：支援 GPU 的 PyTorch。

如需有關 Amazon ECS 受管執行個體上涉及使用 GPU 的 Amazon ECS 任務定義範例，請參閱[在 Amazon ECS 任務定義中指定 GPU](ecs-gpu-specifying.md)。

## 考量事項
<a name="gpu-considerations"></a>

**注意**  
對 g2 執行個體系列類型的支援已被棄用。  
p2 執行個體系列類型僅在早於 Amazon ECS GPU 最佳化 AMI `20230912` 之前的版本上支援。如果您需要繼續使用 p2 執行個體，請參閱 [您需要 P2 執行個體時要採取的動作](#p2-instance)。  
在這兩種執行個體系列類型上就地更新 NVIDIA/CUDA 驅動程式，將導致潛在的 GPU 工作負載失敗。

建議您開始在 Amazon ECS 上使用 GPU 前考量下列事項。
+ 您的叢集可以混合 GPU 和非 GPU 容器執行個體。
+ 您可在外部執行個體上執行 GPU 工作負載。在您叢集中註冊外部執行個體時，請確保安裝指令碼中包含 `--enable-gpu` 標記。如需詳細資訊，請參閱[將外部執行個體註冊到 Amazon ECS 叢集](ecs-anywhere-registration.md)。
+ 您必須在代理程式組態檔案中將 `ECS_ENABLE_GPU_SUPPORT` 設定為 `true`。如需詳細資訊，請參閱[Amazon ECS 容器代理程式組態](ecs-agent-config.md)。
+ 執行任務或建立服務時，您可以在設定任務放置限制條件時使用執行個體類型屬性，來決定任務在哪個容器執行個體啟動。這樣便可更有效地使用您的資源。如需詳細資訊，請參閱[Amazon ECS 如何在容器執行個體上置放任務](task-placement.md)。

  以下範例會在預設叢集的 `g4dn.xlarge` 容器執行個體啟動任務。

  ```
  aws ecs run-task --cluster default --task-definition ecs-gpu-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type ==  g4dn.xlarge" --region us-east-2
  ```
+ 對於在容器定義中指定 GPU 資源需求的每個容器，Amazon ECS 將容器執行時間設定為 NVIDIA 容器執行時間。
+ NVIDIA 容器執行時間需要在容器中設定一些環境變數才能正常運作。如需這些環境變數的清單，請參閱 [Specialized Configurations with Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html?highlight=environment%20variable)。Amazon ECS 將 `NVIDIA_VISIBLE_DEVICES` 環境變數值設定為 Amazon ECS 指派給容器的 GPU 裝置 ID 清單。對於其他必要的環境變數，Amazon ECS 不會對其進行設定。因此，請確保容器映像會設定它們，或在容器定義中設定它們。
+ Amazon ECS GPU 最佳化 AMI 版本 `20230929` 和更新版本支援 p5 執行個體類型系列。
+ Amazon ECS GPU 最佳化 AMI 版本 `20230913` 和更新版本支援 g4 執行個體類型系列。如需詳細資訊，請參閱[Amazon ECS 最佳化 Linux AMI](ecs-optimized_AMI.md)。Amazon ECS 主控台的 Create Cluster (建立叢集) 工作流程中不支援此系列。若要使用這些執行個體類型，您必須使用 Amazon EC2 主控台 AWS CLI或 API，並將執行個體手動註冊到您的叢集。
+ p4d.24xlarge 執行個體類型僅適用於 CUDA 11 或更新版本。
+ Amazon ECS GPU 最佳化 AMI 已啟用 IPv6，這會在使用 `yum` 時導致問題。透過設定 `yum` 以搭配使用 IPv4 與下列命令，可解決此問題。

  ```
  echo "ip_resolve=4" >> /etc/yum.conf
  ```
+  在建置一個不使用 NVIDIA/CUDA 基礎映像的容器映像時，必須將 `NVIDIA_DRIVER_CAPABILITIES` 容器執行時間變數設定為下列其中一個值：
  + `utility,compute`
  + `all`

  如需如何設定變數的詳細資訊，請參閱 NVIDIA 網站上的[控制 NVIDIA 容器執行時間](https://sarus.readthedocs.io/en/stable/user/custom-cuda-images.html#controlling-the-nvidia-container-runtime)。
+ Windows 容器不支援 GPU。

# 為 Amazon ECS 啟動 GPU 容器執行個體
<a name="gpu-launch"></a>

若要在 Amazon EC2 上的 Amazon ECS 中使用 GPU 執行個體，您需要建立啟動範本、使用者資料檔案並啟動執行個體。

然後，您便可執行使用為 GPU 設定之任務定義的任務。

## 使用啟動範本
<a name="gpu-launch-template"></a>

您可以建立啟動範本。
+ 建立使用 AMI 的 Amazon ECS 最佳化 GPU AMI ID 的啟動範本。如需有關如何建立啟動範本的資訊，請參閱 *Amazon EC2 User Guide* 中的 [Create a new launch template using parameters you define](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-define-parameters)。

  將從前一步驟取得的 AMI ID 用於 **Amazon Machine Image**。如需有關如何使用 Systems Manager 參數指定 AMI ID 的資訊，請參閱 *Amazon EC2 User Guide* 中的 [Specify a Systems Manager parameter in a launch template](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id)。

  將下列內容新增至啟動範本中的**使用者資料**。以您的叢集名稱取代 *cluster-name*。

  ```
  #!/bin/bash
  echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
  echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
  ```

## 使用 AWS CLI
<a name="gpu-launch-cli"></a>

您可以使用 AWS CLI 來啟動容器執行個體。

1. 建立稱為 `userdata.toml` 的檔案。此檔案會用於執行個體使用者資料。以您的叢集名稱取代 *cluster-name*。

   ```
   #!/bin/bash
   echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
   echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
   ```

1. 執行下列命令，取得 GPU AMI ID。您會在以下步驟中使用此 ID。

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
   ```

1. 執行下列命令，啟動 GPU 執行個體。請記得替換以下參數：
   + 將*子網路*替換為執行個體將在其中啟動的私有或公有子網路的 ID。
   + 將 *bottlerocket\$1ami* 取代為從前一步驟取得的 AMI ID。
   + 將 *t3.large* 替換為您要使用的執行個體類型。
   + 將 *region* 替換為區域代碼。

   ```
   aws ec2 run-instances --key-name ecs-gpu-example \
      --subnet-id subnet \
      --image-id gpu_ami \
      --instance-type t3.large \
      --region region \
      --tag-specifications 'ResourceType=instance,Tags=[{Key=GPU,Value=example}]' \
      --user-data file://userdata.toml \
      --iam-instance-profile Name=ecsInstanceRole
   ```

1. 執行下列命令來驗證容器執行個體是否已註冊至叢集。當您執行此命令時，請記得替代下列參數：
   + 將 *cluster* 替代為叢集名稱。
   + 將 *region* 替換為您的區域代碼。

   ```
   aws ecs list-container-instances --cluster cluster-name --region region
   ```

# 在 Amazon ECS 任務定義中指定 GPU
<a name="ecs-gpu-specifying"></a>

若要使用容器執行個體的 GPU 和 Docker GPU 執行時間，確保您在任務定義中指定容器所需的 GPU 數量。放置支援 GPU 的容器後，Amazon ECS 容器代理程式會將所需數量的實體 GPU 固定至適當的容器。為任務中所有容器保留的 GPU 數量不可超過任務啟動所在之容器執行個體上可用的 GPU 數量。如需詳細資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

**重要**  
如果未在任務定義中指定 GPU 要求，該任務會使用預設 Docker 執行時間。

下列顯示任務定義中 GPU 要求的 JSON 格式：

```
{
  "containerDefinitions": [
     {
        ...
        "resourceRequirements" : [
            {
               "type" : "GPU", 
               "value" : "2"
            }
        ],
     },
...
}
```

以下範例會示範指定 GPU 要求的 Docker 容器語法。此容器會使用 2 個 GPU，執行 `nvidia-smi` 公用程式，然後結束。

```
{
  "containerDefinitions": [
    {
      "memory": 80,
      "essential": true,
      "name": "gpu",
      "image": "nvidia/cuda:11.0.3-base",
      "resourceRequirements": [
         {
           "type":"GPU",
           "value": "2"
         }
      ],
      "command": [
        "sh",
        "-c",
        "nvidia-smi"
      ],
      "cpu": 100
    }
  ],
  "family": "example-ecs-gpu"
}
```

下列任務定義範例展示了可列印可用 GPU 數量的 TensorFlow 容器。在 Amazon ECS 受管執行個體上執行的任務，需要一個 GPU，並使用 `g4dn.xlarge` 執行個體。

```
{
  "family": "tensorflow-gpu",
  "networkMode": "awsvpc",
  "executionRoleArn": "arn:aws:iam::account-id:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "tensorflow",
      "image": "tensorflow/tensorflow:latest-gpu",
      "essential": true,
      "command": [
        "python",
        "-c",
        "import tensorflow as tf; print('Num GPUs Available: ', len(tf.config.list_physical_devices('GPU')))"
      ],
      "resourceRequirements": [
        {
          "type": "GPU",
          "value": "1"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/tensorflow-gpu",
          "awslogs-region": "region",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ],
  "requiresCompatibilities": [
    "MANAGED_INSTANCES"
  ],
  "cpu": "4096",
  "memory": "8192",
}
```

## 共用 GPU
<a name="share-gpu"></a>

若想共用 GPU，您需要設定下列項目。

1. 從任務定義中移除 GPU 資源需求，如此一來，Amazon ECS 無需保留任何應共用的 GPU。

1. 若想共用 GPU，請將下列使用者資料新增至執行個體。此舉會使 nvidia 成為容器執行個體上的預設 Docker 容器執行時期，如此一來，所有 Amazon ECS 容器都可以使用 GPU。如需詳細資訊，請參閱 *Amazon EC2 User Guide* 中的 [Run commands when you launch an EC2 instance with user data input](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html)。

   ```
   const userData = ec2.UserData.forLinux();
    userData.addCommands(
    'sudo rm /etc/sysconfig/docker',
    'echo DAEMON_MAXFILES=1048576 | sudo tee -a /etc/sysconfig/docker',
    'echo OPTIONS="--default-ulimit nofile=32768:65536 --default-runtime nvidia" | sudo tee -a /etc/sysconfig/docker',
    'echo DAEMON_PIDFILE_TIMEOUT=10 | sudo tee -a /etc/sysconfig/docker',
    'sudo systemctl restart docker',
   );
   ```

1. 在容器上設定 `NVIDIA_VISIBLE_DEVICES` 環境變數。您可在任務定義中指定該環境變數來完成此操作。如需有效值的相關資訊，請參閱 NVIDIA 文件網站上的 [GPU Enumeration](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html#gpu-enumeration)。

## 您需要 P2 執行個體時要採取的動作
<a name="p2-instance"></a>

如果您需要使用 P2 執行個體，您可以使用下列其中一個選項來繼續使用執行個體。

您必須修改這兩個選項的執行個體使用者資料。如需詳細資訊，請參閱 *Amazon EC2 User Guide* 中的 [Run commands when you launch an EC2 instance with user data input](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html)。

**使用最新支援的 GPU 最佳化 AMI**

您可以使用 GPU 最佳化 AMI 的 `20230906` 版本，並將下列項目新增至執行個體使用者資料。

以您的叢集名稱取代 cluster-name。

```
#!/bin/bash
echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```

**使用最新的 GPU 最佳化 AMI，並更新使用者資料**

您可以將下列內容新增至執行個體使用者資料。這將解除安裝 Nvidia 535/Cuda12.2 驅動程式，然後安裝 Nvidia 470/Cuda11.4 驅動程式並修復該版本。

```
#!/bin/bash
yum remove -y cuda-toolkit* nvidia-driver-latest-dkms*
tmpfile=$(mktemp)
cat >$tmpfile <<EOF
[amzn2-nvidia]
name=Amazon Linux 2 Nvidia repository
mirrorlist=\$awsproto://\$amazonlinux.\$awsregion.\$awsdomain/\$releasever/amzn2-nvidia/latest/\$basearch/mirror.list
priority=20
gpgcheck=1
gpgkey=https://developer.download.nvidia.com/compute/cuda/repos/rhel7/x86_64/7fa2af80.pub
enabled=1
exclude=libglvnd-*
EOF

mv $tmpfile /etc/yum.repos.d/amzn2-nvidia-tmp.repo
yum install -y system-release-nvidia cuda-toolkit-11-4 nvidia-driver-latest-dkms-470.182.03
yum install -y libnvidia-container-1.4.0 libnvidia-container-tools-1.4.0 nvidia-container-runtime-hook-1.4.0 docker-runtime-nvidia-1

echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
nvidia-smi
```

**建立您自己的 P2 相容 GPU 最佳化 AMI**

您可以建立與 P2 執行個體相容的自訂 Amazon ECS GPU 最佳化 AMI，然後使用 AMI 啟動 P2 執行個體。

1. 執行下列命令以複製 `amazon-ecs-ami repo`。

   ```
   git clone https://github.com/aws/amazon-ecs-ami
   ```

1. 設定所需的 Amazon ECS 代理程式，並在 `release.auto.pkrvars.hcl` 或 `overrides.auto.pkrvars.hcl` 中取得 Amazon Linux AMI 版本。

1. 執行以下命令建立私有 P2 相容的 EC2 AMI。

   將區域替換為具有執行個體區域的區域。

   ```
   REGION=region make al2keplergpu
   ```

1. 將 AMI 與下列執行個體使用者資料搭配使用，以連線至 Amazon ECS 叢集。

   以您的叢集名稱取代 cluster-name。

   ```
   #!/bin/bash
   echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
   ```

# 影片轉碼工作負載的 Amazon ECS 任務定義
<a name="ecs-vt1"></a>

若要在 Amazon ECS 上使用影片轉碼工作負載，請註冊 [Amazon EC2 VT1](https://aws.amazon.com/ec2/instance-types/vt1/) 執行個體。註冊這些執行個體後，您可以在 Amazon ECS 將即時和預先渲染的影片轉碼工作負載作為任務執行。Amazon EC2 VT1 執行個體使用 Xilinx U30 媒體轉碼卡來加速即時和預先渲染的影片轉碼工作負載。

**注意**  
如需如何在 Amazon ECS 以外的容器中執行影片轉碼工作負載的說明，請參閱 [Xilinx 文件](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#working-with-docker-vt1)。

## 考量事項
<a name="ecs-vt1-considerations"></a>

當您開始在 Amazon ECS 上部署 VT1 之前，請考量下列事項：
+ 您的叢集可包含 VT1 和非 VT1 執行個體組合。
+ 您需要使用具有加速 AVC (H.264) 和 HEVC (H.265) 解碼器的 Xilinx U30 媒體轉碼卡的 Linux 應用程式。
**重要**  
使用其他解碼器的應用程式在 VT1 執行個體上可能沒有提升效能。
+ U30 卡上只能執行一個轉碼任務。每張卡都有兩個與其關聯的裝置。只要您的每個 VT1 執行個體都有轉碼卡，您就可以執行所需數量的轉碼任務。
+ 建立服務或執行獨立任務時，您可以在設定任務置放限制條件時使用執行個體類型屬性。這可確保在您指定的容器執行個體上啟動任務。此舉有助於確保您有效地運用資源，並確保您的影片轉碼工作負載任務位於 VT1 執行個體上。如需詳細資訊，請參閱[Amazon ECS 如何在容器執行個體上置放任務](task-placement.md)。

  在以下範例中，在您的 `default` 叢集的 `vt1.3xlarge` 執行個體上執行任務。

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition vt1-3xlarge-xffmpeg-processor \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == vt1.3xlarge"
  ```
+ 您可以設定容器，以便在主機容器執行個體上使用可用的特定 U30 卡。您可使用 `linuxParameters` 參數並指定裝置詳細資訊來實現這一操作。如需詳細資訊，請參閱[任務定義需求](#ecs-vt1-requirements)。

## 使用 VT1 AMI
<a name="ecs-vt1-ami"></a>

您有兩種可選的選項，在 Amazon EC2 上執行 Amazon ECS 容器執行個體的 AMI。第一個選項是使用 AWS Marketplace上的 Xilinx 正式 AMI。第二個選項是從範本儲存庫建置自己的 AMI。
+ [Xilinx 在 上提供 AMIs AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-phvk6d4mq3hh6)。
+ Amazon ECS 提供了一個範本儲存庫，您可以使用該範本儲存庫為影片轉碼工作負載建置 AMI。此 AMI 隨附 Xilinx U30 驅動程式。您可以在 [GitHub](https://github.com/aws-samples/aws-vt-baseami-pipeline) 上找到包含 Packer 指令碼的儲存庫。如需 Packer 的詳細資訊，請參閱 [Packer documentation](https://developer.hashicorp.com/packer/docs) (《Packer 文件》)。

## 任務定義需求
<a name="ecs-vt1-requirements"></a>

若要在 Amazon ECS 上執行視影片轉碼容器，您的任務定義必須包含使用加速 H.264/AVC 和 H.265/HEVC 解碼器的影片轉碼應用程式。您可以遵循 [Xilinx GitHub](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage) 的步驟，建置容器映像。

任務定義必須根據執行個體類型專門設定。執行個體類型為 3xlarge、6xlarge 和 24xlarge。您必須設定容器，以便在主機容器執行個體上使用可用的特定 Xilinx U30 裝置。您可以使用 `linuxParameters` 參數進行該動作。下表詳細說明特定於每種執行個體類型的卡和裝置 SoC。


| 執行個體類型 | vCPUs | RAM (GiB) | U30 加速器卡 | 可定址 XCU30 SoC 裝置 | 裝置路徑 | 
| --- | --- | --- | --- | --- | --- | 
| vt1.3xlarge | 12 | 24 | 1 | 2 | /dev/dri/renderD128,/dev/dri/renderD129 | 
| vt1.6xlarge | 24 | 48 | 2 | 4 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131 | 
| vt1.24xlarge | 96 | 182 | 8 | 16 | /dev/dri/renderD128,/dev/dri/renderD129,/dev/dri/renderD130,/dev/dri/renderD131,/dev/dri/renderD132,/dev/dri/renderD133,/dev/dri/renderD134,/dev/dri/renderD135,/dev/dri/renderD136,/dev/dri/renderD137,/dev/dri/renderD138,/dev/dri/renderD139,/dev/dri/renderD140,/dev/dri/renderD141,/dev/dri/renderD142,/dev/dri/renderD143 | 

**重要**  
如果任務定義列出 EC2 執行個體沒有的裝置，則任務無法執行。當任務失敗時，下列錯誤訊息會出現在 `stoppedReason`：`CannotStartContainerError: Error response from daemon: error gathering device information while adding custom device "/dev/dri/renderD130": no such file or directory`

# 在 Amazon ECS 任務定義中指定影片轉碼
<a name="task-def-video-transcode"></a>

在以下範例中，提供了用於 Amazon EC2 上 Linux 容器的任務定義的語法。此任務定義適用於遵循 [Xilinx 文件](https://xilinx.github.io/video-sdk/v1.5/container_setup.html#creating-a-docker-image-for-vt1-usage)提供的程序建置的容器映像。如果您使用此範例，請用自己的映像替換 `image`，接著將影片檔案複製到 `/home/ec2-user` 目錄的執行個體。

------
#### [ vt1.3xlarge ]

1. 使用下列內容建立名為 `vt1-3xlarge-ffmpeg-linux.json` 的文字檔案。

   ```
   {
       "family": "vt1-3xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.3xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. 註冊任務定義。

   ```
   aws ecs register-task-definition --family vt1-3xlarge-xffmpeg-processor --cli-input-json file://vt1-3xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.6xlarge ]

1. 使用下列內容建立名為 `vt1-6xlarge-ffmpeg-linux.json` 的文字檔案。

   ```
   {
       "family": "vt1-6xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.6xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. 註冊任務定義。

   ```
   aws ecs register-task-definition --family vt1-6xlarge-xffmpeg-processor --cli-input-json file://vt1-6xlarge-xffmpeg-linux.json --region us-east-1
   ```

------
#### [ vt1.24xlarge ]

1. 使用下列內容建立名為 `vt1-24xlarge-ffmpeg-linux.json` 的文字檔案。

   ```
   {
       "family": "vt1-24xlarge-xffmpeg-processor",
       "requiresCompatibilities": ["EC2"],
       "placementConstraints": [
           {
               "type": "memberOf",
               "expression": "attribute:ecs.os-type == linux"
           },
           {
               "type": "memberOf",
               "expression": "attribute:ecs.instance-type == vt1.24xlarge"
           }
       ],
       "containerDefinitions": [
           {
               "entryPoint": [
                   "/bin/bash",
                   "-c"
               ],
               "command": ["/video/ecs_ffmpeg_wrapper.sh"],
               "linuxParameters": {
                   "devices": [
                       {
                           "containerPath": "/dev/dri/renderD128",
                           "hostPath": "/dev/dri/renderD128",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD129",
                           "hostPath": "/dev/dri/renderD129",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD130",
                           "hostPath": "/dev/dri/renderD130",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD131",
                           "hostPath": "/dev/dri/renderD131",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD132",
                           "hostPath": "/dev/dri/renderD132",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD133",
                           "hostPath": "/dev/dri/renderD133",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD134",
                           "hostPath": "/dev/dri/renderD134",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD135",
                           "hostPath": "/dev/dri/renderD135",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD136",
                           "hostPath": "/dev/dri/renderD136",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD137",
                           "hostPath": "/dev/dri/renderD137",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD138",
                           "hostPath": "/dev/dri/renderD138",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD139",
                           "hostPath": "/dev/dri/renderD139",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD140",
                           "hostPath": "/dev/dri/renderD140",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD141",
                           "hostPath": "/dev/dri/renderD141",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD142",
                           "hostPath": "/dev/dri/renderD142",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       },
                       {
                           "containerPath": "/dev/dri/renderD143",
                           "hostPath": "/dev/dri/renderD143",
                           "permissions": [
                               "read",
                               "write"
                           ]
                       }
                   ]
               },
               "mountPoints": [
                   {
                       "containerPath": "/video",
                       "sourceVolume": "video_file"
                   }
               ],
               "cpu": 0,
               "memory": 12000,
               "image": "0123456789012.dkr.ecr.us-west-2.amazonaws.com/aws/xilinx-xffmpeg",
               "essential": true,
               "name": "xilinix-xffmpeg"
           }
       ],
       "volumes": [
           {
               "name": "video_file",
               "host": {"sourcePath": "/home/ec2-user"}
           }
       ]
   }
   ```

1. 註冊任務定義。

   ```
   aws ecs register-task-definition --family vt1-24xlarge-xffmpeg-processor --cli-input-json file://vt1-24xlarge-xffmpeg-linux.json --region us-east-1
   ```

------

# AWS Neuron 機器學習工作負載的 Amazon ECS 任務定義
<a name="ecs-inference"></a>

您可以將 [Amazon EC2 Trn1](https://aws.amazon.com/ec2/instance-types/trn1/)、[Amazon EC2 Trn2](https://aws.amazon.com/ec2/instance-types/trn2/)、[Amazon EC2 Inf1 ](https://aws.amazon.com/ec2/instance-types/inf1/)和 [Amazon EC2 Inf2](https://aws.amazon.com/ec2/instance-types/inf2/) 執行個體註冊到您的叢集，以用於機器學習工作負載。

Amazon EC2 Trn1 和 Trn2 執行個體採用 [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) 晶片。這些執行個體為雲端中的機器學習提供高效能和低成本的訓練。您可以使用機器學習架構搭配 Trn1 或 Trn2 執行個體上的 AWS Neuron 來訓練機器學習推論模型。然後，您可以在 Inf1 執行個體或 Inf2 執行個體上執行模型，以使用 AWS Inferentia 晶片的加速。

Amazon EC2 Inf1 執行個體和 Inf2 執行個體由 [AWS Inferentia](https://aws.amazon.com/ai/machine-learning/inferentia/) 晶片提供支援。這些晶片在雲端提供高效能和最低成本的推論。

機器學習模型使用 [AWS Neuron](https://aws.amazon.com/ai/machine-learning/neuron/) 部署至容器，這是一款特殊軟體開發套件 (SDK)。SDK 包含編譯器、執行時間和分析工具，可最佳化機器學習晶片的 AWS 機器學習效能。 AWS Neuron 支援熱門的機器學習架構，例如 TensorFlow、PyTorch 和 Apache MXNet。

## 考量事項
<a name="ecs-inference-considerations"></a>

當您開始在 Amazon ECS 上部署 Neuron 之前，請考量下列事項：
+ 您的叢集可以包含 Trn1, Trn2, Inf1, Inf2 和其他執行個體的混合。
+ 您需要容器中使用支援 AWS Neuron 的機器學習架構的 Linux 應用程式。
**重要**  
使用其他架構的應用程式可能無法改善 Trn1, Trn2, Inf1 和 Inf2 執行個體的效能。
+ 每個 [AWS Trainium](https://aws.amazon.com/ai/machine-learning/trainium/) 或 [AWS Inferentia](https://aws.amazon.com/ai/machine-learning/inferentia/) 晶片一次僅可執行一個推論或推論訓練任務。若為 Inf1，每個晶片具有 4 個 NeuronCores。對於 Trn1, Trn2 和 Inf2，每個晶片都有 2 NeuronCores。您可以對每個 Trn1, Trn2, Inf1 和 Inf2 執行個體執行任意數量的任務。
+ 建立服務或執行獨立任務時，您可以在設定任務置放限制條件時使用執行個體類型屬性。這可確保在您指定的容器執行個體上啟動任務。這樣做可協助您最佳化整體資源使用率，並確保推論工作負載的任務位於 Trn1, Trn2, Inf1 和 Inf2 執行個體上。如需詳細資訊，請參閱[Amazon ECS 如何在容器執行個體上置放任務](task-placement.md)。

  在以下範例中，在您的 `default` 叢集的 `Inf1.xlarge` 執行個體上執行任務。

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-inference-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == Inf1.xlarge"
  ```
+ 無法在任務定義中定義 Neuron 資源需求。反之，您可以將容器設定為使用主機容器執行個體上可用的特定 AWS Trainium 或 AWS Inferentia 晶片。您可使用 `linuxParameters` 參數並指定裝置詳細資訊來執行此動作。如需詳細資訊，請參閱[任務定義需求](#ecs-inference-requirements)。

## 使用 Amazon ECS 最佳化 Amazon Linux 2023 (Neuron) AMI
<a name="ecs-inference-ami2023"></a>

Amazon ECS 提供以 Amazon Linux 2023 為基礎的 Amazon ECS 最佳化 AMI，適用於 AWS Trainium 和 AWS Inferentia 工作負載。它隨附 Docker 的 AWS Neuron 驅動程式和執行期。此 AMI 使得在 Amazon ECS 上執行機器學習推論工作負載更輕鬆。

建議在啟動 Amazon EC2 Trn1、Inf1 和 Inf2 執行個體時，使用 Amazon ECS 最佳化 Amazon Linux 2023 (Neuron) AMI。

您可以使用 AWS CLI 搭配下列命令，擷取目前的 Amazon ECS 最佳化 Amazon Linux 2023 (Neuron) AMI。

```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2023/neuron/recommended
```

## 任務定義需求
<a name="ecs-inference-requirements"></a>

要在 Amazon ECS 上部署 Neuron，您的任務定義必須包含預先構建的容器的容器定義，該容器為TensorFlow 提供推論模型。它由 AWS 深度學習容器提供。此容器包含 AWS Neuron 執行期和 TensorFlow Serving 應用程式。啟動時，此容器會從 Amazon S3 中擷取您的模型、使用儲存的模型啟動 Neuron TensorFlow Serving，並等待預測請求。在以下範例中，容器映像擁有 TensorFlow 1.15 和 Ubuntu 18.04。在 GitHub 上維護為 Neuron 最佳化的預先建置的 Deep Learning Containers 完整清單。如需詳細資訊，請參閱[使用 AWS Neuron TensorFlow Serving](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-inferentia-tf-neuron-serving.html)。

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04
```

或者，您可以建置自己的 Neuron 附屬容器映像。如需詳細資訊，請參閱《AWS 深度學習 AMIs 開發人員指南》**中的[教學課程：Neuron TensorFlow Serving](https://github.com/aws-neuron/aws-neuron-sdk/blob/master/frameworks/tensorflow/tensorflow-neuron/tutorials/tutorials-tensorflow-utilizing-neuron-capabilities.rst)。

任務定義必須根據單一執行個體類型專門設定。您必須將容器設定為使用主機容器執行個體上可用的特定 AWS Trainium 或 AWS Inferentia 裝置。您可以使用 `linuxParameters` 參數進行該動作。如需範例任務定義，請參閱 [在 Amazon ECS 任務定義中指定 AWS Neuron 機器學習](ecs-inference-task-def.md)。下表詳細說明特定於每種執行個體類型的晶片。


| 執行個體類型 | vCPUs | RAM (GiB) | AWS ML 加速器晶片 | 裝置路徑 | 
| --- | --- | --- | --- | --- | 
| trn1.2xlarge | 8 | 32 | 1 | /dev/neuron0 | 
| trn1.32xlarge | 128 | 512 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| trn2.48xlarge | 192 | 1536 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf1.xlarge | 4 | 8 | 1 | /dev/neuron0 | 
| inf1.2xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf1.6xlarge | 24 | 48 | 4 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3 | 
| inf1.24xlarge | 96 | 192 | 16 |  /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11, /dev/neuron12, /dev/neuron13, /dev/neuron14, /dev/neuron15  | 
| inf2.xlarge | 8 | 16 | 1 | /dev/neuron0 | 
| inf2.8xlarge | 32 | 64 | 1 | /dev/neuron0 | 
| inf2.24xlarge | 96 | 384 | 6 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5,  | 
| inf2.48xlarge | 192 | 768 | 12 | /dev/neuron0, /dev/neuron1, /dev/neuron2, /dev/neuron3, /dev/neuron4, /dev/neuron5, /dev/neuron6, /dev/neuron7, /dev/neuron8, /dev/neuron9, /dev/neuron10, /dev/neuron11 | 

# 在 Amazon ECS 任務定義中指定 AWS Neuron 機器學習
<a name="ecs-inference-task-def"></a>

以下是 `inf1.xlarge` 的 Linux 任務定義範例，顯示要使用的語法。

```
{
    "family": "ecs-neuron",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == inf1.xlarge"
        }
    ],
    "executionRoleArn": "${YOUR_EXECUTION_ROLE}",
    "containerDefinitions": [
        {
            "entryPoint": [
                "/usr/local/bin/entrypoint.sh",
                "--port=8500",
                "--rest_api_port=9000",
                "--model_name=resnet50_neuron",
                "--model_base_path=s3://amzn-s3-demo-bucket/resnet50_neuron/"
            ],
            "portMappings": [
                {
                    "hostPort": 8500,
                    "protocol": "tcp",
                    "containerPort": 8500
                },
                {
                    "hostPort": 8501,
                    "protocol": "tcp",
                    "containerPort": 8501
                },
                {
                    "hostPort": 0,
                    "protocol": "tcp",
                    "containerPort": 80
                }
            ],
            "linuxParameters": {
                "devices": [
                    {
                        "containerPath": "/dev/neuron0",
                        "hostPath": "/dev/neuron0",
                        "permissions": [
                            "read",
                            "write"
                        ]
                    }
                ],
                "capabilities": {
                    "add": [
                        "IPC_LOCK"
                    ]
                }
            },
            "cpu": 0,
            "memoryReservation": 1000,
            "image": "763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-inference-neuron:1.15.4-neuron-py37-ubuntu18.04",
            "essential": true,
            "name": "resnet50"
        }
    ]
}
```

# 深度學習執行個體的 Amazon ECS 任務定義
<a name="ecs-dl1"></a>

若要在 Amazon ECS 上使用深度學習工作負載，請將 [Amazon EC2 DL1](https://aws.amazon.com/ec2/instance-types/dl1/) 執行個體註冊到您的叢集。Amazon EC2 DL1 執行個體由 Habana 實驗室 (Intel 公司) 的 Gaudi 加速器提供。使用 Habana SynapseAI SDK 連線到 Habana Gaudi 加速器。SDK 支援流行的機器學習架構、TensorFlow 和 PyTorch。

## 考量事項
<a name="ecs-dl1-considerations"></a>

當您開始在 Amazon ECS 上部署 DL1 之前，請考量下列事項：
+ 您的叢集可包含 DL1 和非 DL1 執行個體組合。
+ 建立服務或執行獨立任務時，您可以在設定任務置放限制條件時使用執行個體類型屬性，以確定任務於指定的容器執行個體啟動。藉此可確保您的資源得到有效利用，並確保深度學習工作負載的任務位於 DL1 執行個體上。如需詳細資訊，請參閱[Amazon ECS 如何在容器執行個體上置放任務](task-placement.md)。

  以下範例在 `default` 叢集的 `dl1.24xlarge` 執行個體上執行任務。

  ```
  aws ecs run-task \
       --cluster default \
       --task-definition ecs-dl1-task-def \
       --placement-constraints type=memberOf,expression="attribute:ecs.instance-type == dl1.24xlarge"
  ```

## 使用 DL1 AMI
<a name="ecs-dl1-ami"></a>

對於在 Amazon EC2 DL1 執行個體上執行 Amazon ECS 的 AMI，您有三個選項：
+ Habana AWS Marketplace AMIs[https://aws.amazon.com/marketplace/pp/prodview-h24gzbgqu75zq](https://aws.amazon.com/marketplace/pp/prodview-h24gzbgqu75zq)。
+ 由 Amazon Web Services 提供的 Habana 深度學習 AMI。由於其不包含在內，您需要單獨安裝 Amazon ECS 容器代理程式。
+ 使用 Packer 建置由 [GitHub 儲存庫](https://github.com/aws-samples/aws-habana-baseami-pipeline)提供的自訂 AMI。如需詳細資訊，請參閱 [Packer documentation](https://developer.hashicorp.com/packer/docs) (《Packer 文件》)。

# 在 Amazon ECS 任務定義中指定深度學習
<a name="ecs-dl1-requirements"></a>

若要在 Amazon ECS 上執行 Habana Gaudi 加速深度學習容器，您的任務定義必須包含預先建置容器的容器定義，該容器使用 AWS 深度學習容器提供的 Habana SynapseAI 為 TensorFlow 或 PyTorch 提供深度學習模型。

以下容器映像擁有 TensorFlow 2.7.0 和 Ubuntu 20.04。在 GitHub 上維護為 Habana Gaudi 加速器最佳化的預先建置的 Deep Learning Containers 完整清單。如需詳細資訊，請參閱 [Habana Training Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#habana-training-containers) (Habana 訓練容器)。

```
763104351884.dkr.ecr.us-east-1.amazonaws.com/tensorflow-training-habana:2.7.0-hpu-py38-synapseai1.2.0-ubuntu20.04
```

以下是 Amazon EC2 上的 Linux 容器任務定義範例，顯示了要使用的語法。此範例使用包含 Habana 實驗室系統管理介面工具 (HL-SMI) 的映像，請參閱：`vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614`

```
{
    "family": "dl-test",
    "requiresCompatibilities": ["EC2"],
    "placementConstraints": [
        {
            "type": "memberOf",
            "expression": "attribute:ecs.os-type == linux"
        },
        {
            "type": "memberOf",
            "expression": "attribute:ecs.instance-type == dl1.24xlarge"
        }
    ],
    "networkMode": "host",
    "cpu": "10240",
    "memory": "1024",
    "containerDefinitions": [
        {
            "entryPoint": [
                "sh",
                "-c"
            ],
            "command": ["hl-smi"],
            "cpu": 8192,
            "environment": [
                {
                    "name": "HABANA_VISIBLE_DEVICES",
                    "value": "all"
                }
            ],
            "image": "vault.habana.ai/gaudi-docker/1.1.0/ubuntu20.04/habanalabs/tensorflow-installer-tf-cpu-2.6.0:1.1.0-614",
            "essential": true,
            "name": "tensorflow-installer-tf-hpu"
        }
    ]
}
```

# 64 位元 ARM 工作負載的 Amazon ECS 任務定義
<a name="ecs-arm64"></a>

Amazon ECS 支援使用 64 位元 ARM 應用程式。您可以在由 [AWS Graviton 處理器](https://aws.amazon.com/ec2/graviton/)提供支援的平台上執行應用程式。該平台適用多種工作負載。其包括各種工作負載，例如應用程式伺服器、微型服務、高效能運算、CPU 型機器學習推論、影片編碼、電子設計自動化、遊戲、開放原始碼資料庫和記憶體內快取。

## 考量事項
<a name="ecs-arm64-considerations"></a>

在您開始部署使用 64 位元 ARM 架構的任務定義之前，請考量下列事項：
+ 應用程式可使用 Fargate 或 EC2。
+ 應用程式僅能使用 Linux 作業系統。
+ 對於 Fargate 類型，應用程式必須使用 Fargate 平台版本 `1.4.0` 或更新版本。
+ 應用程式可使用 Fluent Bit 或 CloudWatch 進行監控。
+ 對於 Fargate，以下 AWS 區域 不支援 64 位元 ARM 工作負載：
  + 美國東部 (維吉尼亞北部)、`use1-az3` 可用區域
+  對於 EC2，請參閱以下內容，驗證所在區域是否支援要使用的執行個體類型：
  + [Amazon EC2 M6g 執行個體](https://aws.amazon.com/ec2/instance-types/m6)
  +  [Amazon EC2 T4g 執行個體](https://aws.amazon.com/ec2/instance-types/t4/)
  +  [Amazon EC2 C6g 執行個體](https://aws.amazon.com/ec2/instance-types/c6g/)
  +  [Amazon EC2 R6gd 執行個體](https://aws.amazon.com/ec2/instance-types/r6/)
  +  [Amazon EC2 X2gd 執行個體](https://aws.amazon.com/ec2/instance-types/x2/)

  您也可以使用 Amazon EC2 `describe-instance-type-offerings` 命令搭配篩選條件，查看您所在區域的執行個體優惠。

  ```
  aws ec2 describe-instance-type-offerings --filters Name=instance-type,Values=instance-type --region region
  ```

  以下範例檢查美國東部 (維吉尼亞北部) (us-east-1) 區域中的 M6 執行個體類型可用性。

  ```
  aws ec2 describe-instance-type-offerings --filters "Name=instance-type,Values=m6*" --region us-east-1
  ```

  如需詳細資訊，請參閱《Amazon EC2 命令列參考》**中的 [describe-instance-type-offerings](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-type-offerings.html)。

# 在 Amazon ECS 任務定義中指定 ARM 架構
<a name="ecs-arm-specifying"></a>

若要使用 ARM 架構，請為 `cpuArchitecture` 任務定義參數指定 `ARM64`。

在以下範例中，ARM 架構是在任務定義中指定的。其為 JSON 格式。

```
{
    "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
    },
...
}
```

以下為顯示"hello world" 的 ARM 架構的任務定義範例。

```
{
 "family": "arm64-testapp",
 "networkMode": "awsvpc",
 "containerDefinitions": [
    {
        "name": "arm-container",
        "image": "public.ecr.aws/docker/library/busybox:latest",
        "cpu": 100,
        "memory": 100,
        "essential": true,
        "command": [ "echo hello world" ],
        "entryPoint": [ "sh", "-c" ]
    }
 ],
 "requiresCompatibilities": [ "EC2" ],
 "cpu": "256",
 "memory": "512",
 "runtimePlatform": {
        "operatingSystemFamily": "LINUX",
        "cpuArchitecture": "ARM64"
  },
 "executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole"
}
```

# 將 Amazon ECS 日誌傳送至 CloudWatch
<a name="using_awslogs"></a>

您可以在任務中設定容器，將日誌資訊傳送給 CloudWatch Logs。如果正為任務使用 Fargate，您可檢視容器的日誌。如果正使用 EC2，您可在單一便利位置檢視容器的不同日誌，並防止容器日誌佔用容器執行個體的磁碟空間。

**注意**  
任務中容器所記錄的資訊類型，絕大部分取決於其 `ENTRYPOINT` 命令。在預設情況下，擷取的日誌會顯示您在本機執行容器時，通常會在互動式終端機中看見的命令輸出，其為 `STDOUT` 和 `STDERR` I/O 串流。`awslogs` 日誌驅動程式只會將這些日誌從 Docker 傳遞至 CloudWatch Logs。如需 Docker 日誌處理方式 (包括擷取不同檔案資料或串流的替代方法) 的詳細資訊，請參閱 Docker 文件中的[檢視容器或服務的日誌](https://docs.docker.com/engine/logging/)。

若要將系統日誌從 Amazon ECS 容器執行個體傳送至 CloudWatch Logs，請參閱《Amazon CloudWatch Logs 使用者指南》**中的[監控日誌檔案](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatchLogs.html)和 [CloudWatch Logs 配額](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html)。

## Fargate
<a name="enable_awslogs"></a>

如果正為任務使用 Fargate，您需要將所需的 `logConfiguration` 參數新增至任務定義，以開啟 `awslogs` 日誌驅動程式。如需詳細資訊，請參閱[Amazon ECS 任務定義範例：將日誌路由至 CloudWatch](specify-log-config.md)。

對於 Fargate 上的 Windows 容器，當任務定義參數包含特殊字元 (例如 `& \ < > ^ |`) 時，請執行下列任一選項：
+ 在整個參數字串前後加上雙引號，並新增逸出字元 (`\`)

  範例

  ```
  "awslogs-multiline-pattern": "\"^[|DEBUG|INFO|WARNING|ERROR\"",
  ```
+ 在每個特殊字元前後加上逸出字元 (`^`)

  範例

  ```
  "awslogs-multiline-pattern": "^^[^|DEBUG^|INFO^|WARNING^|ERROR",
  ```

## EC2
<a name="ec2-considerations"></a>

如果對任務使用 EC2，並且想要開啟 `awslogs` 日誌驅動程式，則 Amazon ECS 容器執行個體需要至少 1.9.0 版的容器代理程式。如需如何檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。

**注意**  
您必須使用 Amazon ECS 最佳化 AMI，或至少具有 `1.9.0-1` 版 `ecs-init` 套件的自訂 AMI。使用自訂 AMI 時，您必須透過在 **docker run** 陳述式或環境變數檔案中使用下列環境變數，確保啟動代理程式時 Amazon EC2 執行個體上可使用 `awslogs` 記錄驅動程式。  

```
ECS_AVAILABLE_LOGGING_DRIVERS=["json-file","awslogs"]
```

您的 Amazon ECS 容器執行個體也需要可用來啟動容器執行個體之 IAM 角色的 `logs:CreateLogStream` 和 `logs:PutLogEvents` 許可。在 Amazon ECS 中啟用 `awslogs` 日誌驅動程式支援前，如果您已建立 Amazon ECS 容器執行個體角色，您可能需要新增此許可。`ecsTaskExecutionRole` 在其被指派給任務時使用，且應該包含正確的許可。如需有關任務執行角色的資訊，請參閱 [Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。如果您的容器執行個體使用容器執行個體的受管 IAM 政策，則您的容器執行個體應該具有正確的許可。如需有關容器執行個體受管 IAM 政策的資訊，請參閱 [Amazon ECS 容器執行個體 IAM 角色](instance_IAM_role.md)。

# Amazon ECS 任務定義範例：將日誌路由至 CloudWatch
<a name="specify-log-config"></a>

您必須先在任務定義中指定容器的 `awslogs` 日誌驅動程式，容器才能將日誌傳送至 CloudWatch。如需有關日誌參數的詳細資訊，請參閱[儲存與記錄](task_definition_parameters.md#container_definition_storage)

隨後的任務定義 JSON 具有為每個容器指定的 `logConfiguration` 物件。一個是用於 WordPress 容器，該容器將日誌發送到名為 `awslogs-wordpress` 的日誌群組。另一個用於 MySQL 容器，該容器將日誌發送到名為 `awslogs-mysql` 的日誌群組。兩個容器使用的日誌串流前綴皆為 `awslogs-example`。

```
{
    "containerDefinitions": [
        {
            "name": "wordpress",
            "links": [
                "mysql"
            ],
            "image": "public.ecr.aws/docker/library/wordpress:latest",
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-wordpress",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example"
                }
            },
            "memory": 500,
            "cpu": 10
        },
        {
            "environment": [
                {
                    "name": "MYSQL_ROOT_PASSWORD",
                    "value": "password"
                }
            ],
            "name": "mysql",
            "image": "public.ecr.aws/docker/library/mysql:latest",
            "cpu": 10,
            "memory": 500,
            "essential": true,
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "awslogs-mysql",
                    "awslogs-region": "us-west-2",
                    "awslogs-stream-prefix": "awslogs-example",
                    "mode": "non-blocking", 
                    "max-buffer-size": "25m" 
                }
            }
        }
    ],
    "family": "awslogs-example"
}
```

## 後續步驟
<a name="specify-log-config-next-steps"></a>
+ 您可以使用 CloudWatch AWS CLI 或 API，選擇性地設定日誌群組的保留政策。如需詳細資訊，請參閱 *AWS Command Line Interface Reference* 中的 [put-retention-policy](https://docs.aws.amazon.com/cli/latest/reference/logs/put-retention-policy.html)。
+ 當您在容器定義日誌組態中將任務定義註冊到 `awslogs` 日誌驅動程式後，就可以執行任務，或使用該任務定義建立服務，以開始將日誌傳送至 CloudWatch Logs。如需詳細資訊，請參閱[將應用程式作為 Amazon ECS 任務執行](standalone-task-create.md)及[建立 Amazon ECS 滾動更新部署](create-service-console-v2.md)。

# 將 Amazon ECS 日誌傳送至 AWS 服務或 AWS Partner
<a name="using_firelens"></a>

您可以使用 FireLens for Amazon ECS 來使用任務定義參數，將日誌路由到 AWS 服務或 AWS Partner Network (APN) 目的地，以進行日誌儲存和分析。 AWS Partner Network 是一個全球合作夥伴社群，利用計劃、專業知識和資源來建置、行銷和銷售客戶產品。如需詳細資訊，請參閱 [AWS Partner](https://aws.amazon.com/partners/work-with-partners/)。FireLens 使用 [Fluentd](https://www.fluentd.org/) 和 [Fluent Bit](https://fluentbit.io/)。我們提供 AWS for Fluent Bit 映像，或者您也可以使用自己的 Fluentd 或 Fluent Bit 映像。

依預設，Amazon ECS 會設定容器相依性，確保 Firelens 容器先於所有使用它的容器啟動，並於所有使用它的容器停止後才停止。

若要使用此功能，您必須為任務建立 IAM 角色，以提供使用任務所需的任何 AWS 服務所需的許可。例如，若容器正在將日誌路由至 Firehose，則任務需要呼叫 `firehose:PutRecordBatch` API 的許可。如需詳細資訊，請參閱 *《IAM 使用者指南》*中的[新增和移除 IAM 身分許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)。

在下列情況下，任務可能也需要 Amazon ECS 任務執行角色。如需詳細資訊，請參閱[Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。
+ 如果您的任務託管在 Fargate 上，而且您要從 Amazon ECR 提取容器映像，或在日誌組態 AWS Secrets Manager 中參考來自 的敏感資料，則必須包含任務執行 IAM 角色。
+ 在使用 Amazon S3 中託管的自訂組態檔案時，任務執行 IAM 角色必須包含 `s3:GetObject` 許可。

使用 FireLens for Amazon ECS 時，請考量下列事項：
+ 建議將 `my_service_` 新增至日誌容器名稱，以便在主控台中輕鬆區分容器名稱。
+ Amazon ECS 預設會在應用程式容器與 FireLens 容器之間新增啟動容器順序相依性。在應用程式容器與 FireLens 容器之間指定容器順序時，會覆寫預設的啟動容器順序。
+ 託管於 Linux 上的 AWS Fargate 和 Linux 上的 Amazon EC2 的任務支援 Amazon ECS 的 FireLens。Windows 容器不支援 FireLens。

  如需如何為 Windows 容器設定集中式記錄的相關資訊，請參閱 [Centralized logging for Windows containers on Amazon ECS using Fluent Bit](https://aws.amazon.com/blogs/containers/centralized-logging-for-windows-containers-on-amazon-ecs-using-fluent-bit/) (《使用 Fluent Bit 為 Amazon ECS 上的 Windows 容器設定集中式記錄》)。
+ 您可以使用 CloudFormation 範本來設定 Amazon ECS FireLens的 。如需詳細資訊，請參閱《AWS CloudFormation 使用者指南》**中的 [AWS::ECS::TaskDefinition FirelensConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-firelensconfiguration.html)。
+ FireLens 在連接埠上監聽 `24224`，因此為了確保 FireLens 日誌路由器無法在任務之外連線，您不能在允許任務使用的安全群組中連接埠 `24224` 上的傳入流量。對於使用 `awsvpc` 網路模式的任務，這是與任務相關聯的安全群組。對於使用 `host` 網路模式的任務，這是與託管任務的 Amazon EC2 執行個體相關聯的安全群組。對於使用 `bridge` 網路模式的任務，請不要建立使用連接埠 `24224` 的任何連接埠映射。
+ 對於使用 `bridge` 網路模式的工作，具有 FireLens 配置的容器必須在任何依賴該模式的應用程式容器啟動之前啟動。若要控制容器的起始順序，請在工作定義中使用相依性條件。如需詳細資訊，請參閱[容器相依性](task_definition_parameters.md#container_definition_dependson)。
**注意**  
如果您在使用 FireLens 配置的容器定義中使用相依性條件參數，請確定每個容器都有 `START` 或 `HEALTHY` 條件需求。
+ 根據預設，FireLens 將叢集和任務定義名稱以及叢集的 Amazon Resource Name (ARN) 作為中繼資料索引鍵新增到 stout/stderr 容器紀錄。以下是中繼資料格式的範例。

  ```
  "ecs_cluster": "cluster-name",
  "ecs_task_arn": "arn:aws:ecs:region:111122223333:task/cluster-name/f2ad7dba413f45ddb4EXAMPLE",
  "ecs_task_definition": "task-def-name:revision",
  ```

  如果您不想在紀錄中使用中繼資料，請在任務定義 `firelensConfiguration` 部分中將 `false` 設定為 `enable-ecs-log-metadata`。

  ```
  "firelensConfiguration":{
     "type":"fluentbit",
     "options":{
        "enable-ecs-log-metadata":"false",
        "config-file-type":"file",
        "config-file-value":"/extra.conf"
  }
  ```

您可以設定FireLens容器以非根使用者身分執行。考慮下列各項：
+  若要將FireLens容器設定為以非根使用者身分執行，您必須以下列其中一種格式指定使用者：
  + `uid`
  + `uid:gid`
  + `uid:group`

  如需在容器定義中指定使用者的詳細資訊，請參閱《*Amazon Elastic Container Service API 參考*》中的 [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html)。

  FireLens 容器會透過UNIX通訊端接收應用程式日誌。Amazon ECS 代理程式使用 `uid`將通訊端目錄的擁有權指派給FireLens容器。
+ Amazon ECS Agent 版本 `1.96.0`和更新版本以及 Amazon ECS 最佳化 AMI 版本 `v20250716` 和更新版本支援將FireLens容器設定為以非根使用者身分執行。
+ 當您為FireLens容器指定使用者時， `uid` 必須是唯一的，且不會用於任務或容器執行個體中屬於其他容器的其他程序。

如需有關如何搭配 Amazon ECS 使用多個組態檔案 (包括您託管的或 Amazon S3 中的檔案) 的資訊，請參閱 [Init process for Fluent Bit on ECS, multi-config support](https://github.com/aws/aws-for-fluent-bit/tree/mainline/use_cases/init-process-for-fluent-bit)。

如需範例組態的詳細資訊，請參閱 [Amazon ECS 任務定義範例：將日誌路由至 FireLens](firelens-taskdef.md)。

如需設定高輸送量日誌的詳細資訊，請參閱 [為高輸送量設定 Amazon ECS 日誌](firelens-docker-buffer-limit.md)。

# 為高輸送量設定 Amazon ECS 日誌
<a name="firelens-docker-buffer-limit"></a>

對於高日誌輸送量案例，我們建議搭配 FireLens 和 使用`awsfirelens`日誌驅動程式Fluent Bit。 Fluent Bit 是一種輕量型日誌處理器，可有效處理 資源，並可處理數百萬筆日誌記錄。不過，大規模實現最佳效能需要調校其組態。

本節涵蓋處理高日誌輸送量的進階Fluent Bit最佳化技術，同時維持系統穩定性並確保不會遺失資料。

如需如何搭配 FireLens 使用自訂組態檔案的詳細資訊，請參閱 [使用自訂組態檔案](firelens-taskdef.md#firelens-taskdef-customconfig)。如需其他範例，請參閱 GitHub 上的 [Amazon ECS FireLens 範例](https://github.com/aws-samples/amazon-ecs-firelens-examples)。

**注意**  
本節中的某些組態選項，例如 `workers`和 `threaded`， AWS 需要 第 3 Fluent Bit版或更新版本。如需可用版本的資訊，請參閱 [AWS 以取得 Fluent Bit 版本](https://github.com/aws/aws-for-fluent-bit/releases)。

## 了解區塊
<a name="firelens-understanding-chunks"></a>

Fluent Bit 會以稱為*區塊的*單位處理資料。當 INPUT 外掛程式接收資料時，引擎會建立區塊，在傳送至 OUTPUT 目的地之前儲存在記憶體或檔案系統上。

緩衝行為取決於 INPUT 區段中的`storage.type`設定。根據預設， Fluent Bit會使用記憶體緩衝。對於高輸送量或生產案例，檔案系統緩衝可提供更好的彈性。

如需詳細資訊，請參閱 Fluent Bit 文件中的[區塊](https://docs.fluentbit.io/manual/administration/buffering-and-storage#chunks)和《》中的[什麼是區塊？](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#what-is-a-chunk) AWS 》以取得Fluent Bit範例儲存庫。

## 記憶體緩衝 （預設）
<a name="firelens-memory-buffering"></a>

根據預設， Fluent Bit會使用記憶體緩衝 (`storage.type memory`)。您可以使用 `Mem_Buf_Limit` 參數限制每個 INPUT 外掛程式的記憶體用量。

下列範例顯示記憶體緩衝的輸入組態：

```
[INPUT]
    Name          tcp
    Tag           ApplicationLogs
    Port          5170
    storage.type  memory
    Mem_Buf_Limit 5MB
```

**重要**  
`Mem_Buf_Limit` 超過外掛程式的 時， 會Fluent Bit暫停輸入，並遺失新記錄。這可能會導致背壓並拖慢您的應用程式。Fluent Bit 日誌中會顯示下列警告：  

```
[input] tcp.1 paused (mem buf overlimit)
```

記憶體緩衝適用於日誌輸送量低至中等的簡單使用案例。對於需要資料遺失的高輸送量或生產案例，請改用檔案系統緩衝。

如需詳細資訊，請參閱 Fluent Bit 文件中的[緩衝和記憶體](https://docs.fluentbit.io/manual/administration/buffering-and-storage#buffering-and-memory)，以及 中的[僅限記憶體緩衝](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-1-memory-buffering-only-default-or-storagetype-memory) AWS ，以取得Fluent Bit範例儲存庫。

## 檔案系統緩衝
<a name="firelens-filesystem-buffering"></a>

對於高輸送量案例，建議使用檔案系統緩衝。如需有關 如何Fluent Bit管理緩衝和儲存的詳細資訊，請參閱 Fluent Bit 文件中的[緩衝和儲存](https://docs.fluentbit.io/manual/administration/buffering-and-storage)。

檔案系統緩衝提供下列優點：
+ **較大的緩衝容量** – 磁碟空間通常比記憶體更豐富。
+ **持久性** – 緩衝的資料在Fluent Bit重新啟動後仍然存在。
+ **緩慢降級** – 在輸出失敗期間，資料累積在磁碟上，而不是導致記憶體耗盡。

若要啟用檔案系統緩衝，請提供自訂Fluent Bit組態檔案。下列範例顯示建議的組態：

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

金鑰組態參數：

`storage.path`  
在磁碟上Fluent Bit存放緩衝區塊的目錄。

`storage.backlog.flush_on_shutdown`  
啟用時， 會Fluent Bit嘗試在關閉期間將所有待處理日誌檔案系統區塊排清至其目的地。這有助於確保資料在Fluent Bit停止之前交付，但可能會增加關閉時間。

`storage.max_chunks_up`  
保留在記憶體中的區塊數量。預設值為 128 個區塊，這可能會耗用 500 MB\$1 的記憶體，因為每個區塊最多可使用 4–5 MB。在記憶體受限的環境中，降低此值。例如，如果您有 50 MB 可用於緩衝，請將此設為 8–10 個區塊。

`storage.type filesystem`  
啟用輸入外掛程式的檔案系統儲存。儘管名稱為 ， 還是Fluent Bit使用 `mmap`將區塊映射到記憶體和磁碟，在不犧牲效能的情況下提供持久性。

`storage.total_limit_size`  
特定 OUTPUT 外掛程式緩衝資料的最大磁碟空間。達到此限制時，會捨棄該輸出的最舊記錄。如需調整大小的詳細資訊，請參閱 [了解 `storage.total_limit_size`](#firelens-storage-sizing)。

`threaded true`  
在自己的執行緒中執行輸入，與 Fluent Bit的主要事件迴圈分開。這可防止慢速輸入封鎖整個管道。

如需詳細資訊，請參閱 Fluent Bit 文件中的[檔案系統緩衝](https://docs.fluentbit.io/manual/administration/buffering-and-storage#filesystem-buffering)，以及 AWS 中Fluent Bit的範例儲存庫中的[檔案系統和記憶體緩衝](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/oomkill-prevention#case-2-filesystem-and-memory-buffering-storagetype-filesystem)。

## 了解 `storage.total_limit_size`
<a name="firelens-storage-sizing"></a>

每個 OUTPUT 外掛程式上的 `storage.total_limit_size` 參數會控制該輸出緩衝資料的最大磁碟空間。達到此限制時，會捨棄該輸出的最舊記錄，為新資料騰出空間。當磁碟空間完全用盡時， Fluent Bit 無法將記錄排入佇列，而且會遺失。

使用以下公式`storage.total_limit_size`，根據您的日誌速率和所需的復原時段計算適當的 ：

```
If log rate is in KB/s, convert to MB/s first:
log_rate (MB/s) = log_rate (KB/s) / 1000

storage.total_limit_size (GB) = log_rate (MB/s) × duration (hours) × 3600 (seconds/hour) / 1000 (MB to GB)
```

下表顯示常見日誌速率和復原時段的範例計算：


| 日誌速率 | 1 小時 | 6 小時 | 12 小時 | 24 小時 | 
| --- | --- | --- | --- | --- | 
| 0.25 MB/s | 0.9 GB | 5.4 GB | 10.8 GB | 21.6 GB | 
| 0.5 MB/s | 1.8 GB | 10.8 GB | 21.6 GB | 43.2 GB | 
| 1 MB/s | 3.6 GB | 21.6 GB | 43.2 GB | 86.4 GB | 
| 5 MB/s | 18 GB | 108 GB | 216 GB | 432 GB | 
| 10 MB/s | 36 GB | 216 GB | 432 GB | 864 GB | 

若要觀察尖峰輸送量並選擇適當的緩衝區大小，請使用[量值輸送量 FireLens 範例](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/measure-throughput)。

使用公式、範例計算和基準測試，選擇適合`storage.total_limit_size`的執行通道，以便在中斷期間進行最佳復原。

## Amazon ECS 任務儲存需求
<a name="firelens-storage-task-requirements"></a>

在 OUTPUT 區段中加總所有`storage.total_limit_size`值，並新增額外負荷緩衝區。此總計會決定 Amazon ECS 任務定義中所需的儲存空間。例如，3 個輸出 × 10 GB，每個 = 30 GB \$1 緩衝 (5–10 GB) = 總共需要 35–40 GB。如果總計超過可用儲存體， Fluent Bit可能無法將記錄排入佇列，而且它們將會遺失。

下列儲存選項可供使用：

綁定掛載 （暫時性儲存）  
+ 對於 AWS Fargate，預設值為 20 GB 的暫時性儲存 （上限為 200 GB)。在任務定義`ephemeralStorage`中使用 設定 。如需詳細資訊，請參閱*AWS CloudFormation 《 使用者指南*》中的 [EphemeralStorage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-ephemeralstorage.html)。
+ 對於 EC2，使用 Amazon ECS 最佳化 AMI （在作業系統和 Docker 之間共用） 時，預設值為 30 GB。透過變更根磁碟區大小來增加 。

Amazon EBS 磁碟區  
+ 提供高可用性、耐用、高效能的區塊儲存。
+ 需要磁碟區組態，並在任務定義`mountPoint`中指向 `storage.path`（預設：`/var/log/flb-storage/`)。
+ 如需詳細資訊，請參閱[在 Amazon ECS 任務定義中將磁碟區組態延至啟動時進行](specify-ebs-config.md)。

Amazon EFS 磁碟區  
+ 提供簡單、可擴展的檔案儲存。
+ 需要磁碟區組態，並在任務定義`mountPoint`中指向 `storage.path`（預設：`/var/log/flb-storage/`)。
+ 如需詳細資訊，請參閱[在 Amazon ECS 任務定義中指定 Amazon EFS 檔案系統](specify-efs-config.md)。

如需資料磁碟區的詳細資訊，請參閱 [Amazon ECS 任務的儲存選項](using_data_volumes.md)。

## 最佳化輸出組態
<a name="firelens-output-optimization"></a>

網路問題、服務中斷和目的地限流可防止日誌交付。適當的輸出組態可確保彈性而不會遺失資料。

當輸出排清失敗時， Fluent Bit可以重試 操作。下列參數控制重試行為：

`retry_limit`  
捨棄記錄之前，初次嘗試後的重試次數上限。預設為 1。例如， `retry_limit 3`表示總共 4 次嘗試 (1 次初始 \$1 3 次重試）。對於生產環境，我們建議使用 15 或更高版本，這涵蓋了幾分鐘的中斷和指數退避。  
將`False`無限次重試設為 `no_limits`或 ：  
+ 透過記憶體緩衝，無限次重試會導致輸入外掛程式在達到記憶體限制時暫停。
+ 使用檔案系統緩衝時，最舊的記錄會在達到 `storage.total_limit_size` 時捨棄。
耗盡所有重試嘗試 (1 次初始 \$1 `retry_limit` 重試） 後，會捨棄記錄。 AWS 具有 `auto_retry_requests true`（預設） 的外掛程式會在 Fluent Bit的重試機制之前提供額外的重試層。如需詳細資訊，請參閱 Fluent Bit 文件中的[設定重試](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-retries)。  
例如，`retry_limit 3`使用預設設定 (`scheduler.base 5`、`scheduler.cap 2000`、`net.connect_timeout 10s`) 提供大約 70 秒的排程器等待時間 (10 秒 \$1 20 秒 \$1 40 秒）、40 秒的網路連線逾時 (4 次嘗試 × 10 秒），加上 AWS 外掛程式重試，根據網路條件和作業系統 TCP 逾時，總計大約 2–10 分鐘。

`scheduler.base`  
重試之間的基本秒數 （預設值：5)。我們建議 10 秒。

`scheduler.cap`  
重試之間的秒數上限 （預設值：2000)。我們建議 60 秒。

重試之間的等待時間使用指數退避與抖動：

```
wait_time = random(base, min(base × 2^retry_number, cap))
```

例如，使用 `scheduler.base 10`和 `scheduler.cap 60`：
+ 第一次重試：隨機等待 10-20 秒
+ 第二次重試：隨機等待 10-40 秒
+ 第三次重試和更新時間：隨機等待 10-60 秒 （上限）

如需詳細資訊，請參閱 Fluent Bit 文件中的[設定重試和聯網的等待時間](https://docs.fluentbit.io/manual/administration/scheduling-and-retries#configure-wait-time-for-retry)。 [https://docs.fluentbit.io/manual/administration/networking](https://docs.fluentbit.io/manual/administration/networking)

`workers`  
平行輸出處理的執行緒數目。多個工作者允許並行排清，在處理許多區塊時提高輸送量。

`auto_retry_requests`  
 AWS 外掛程式特定的設定，可在 的Fluent Bit內建重試機制之前提供額外的重試層。預設值為 `true`。啟用時， AWS 輸出外掛程式會在內部重試失敗的請求，再將請求視為失敗的排清並受`retry_limit`組態約束。

`[SERVICE]` 區段中的 `Grace` 參數會設定關機期間Fluent Bit等待的時間，以排清緩衝的資料。`Grace` 期間必須與容器的 協調`stopTimeout`。在接收 之前，請確定 `stopTimeout`超過允許 Fluent Bit完成排清的`Grace`期間`SIGKILL`。例如，如果 `Grace`是 120 秒，請將 `stopTimeout`設定為 150 秒。

下列範例顯示完整Fluent Bit組態，其中包含高輸送量案例的所有建議設定：

```
[SERVICE]
    # Flush logs every 1 second
    Flush 1
    # Wait 120 seconds during shutdown to flush remaining logs
    Grace 120
    # Directory for filesystem buffering
    storage.path             /var/log/flb-storage/
    # Limit chunks stored 'up' in memory (reduce for memory-constrained environments)
    storage.max_chunks_up    32
    # Flush backlog chunks to destinations during shutdown (prevents log loss)
    storage.backlog.flush_on_shutdown On
    # Minimum seconds between retries
    scheduler.base           10
    # Maximum seconds between retries (exponential backoff cap)
    scheduler.cap            60

[INPUT]
    Name forward
    unix_path /var/run/fluent.sock
    # Run input in separate thread to prevent blocking
    threaded true
    # Enable filesystem buffering for persistence
    storage.type filesystem

[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    # Use multiple workers for parallel processing
    workers 2
    # Retry failed flushes up to 15 times
    retry_limit 15
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 10G
```

## 了解資料遺失案例
<a name="firelens-record-loss-scenarios"></a>

長時間中斷或輸出目的地發生問題時，記錄可能會遺失。本指南中的組態建議是將資料遺失降至最低的最佳方法，但無法保證長時間故障期間的零遺失。了解這些案例可協助您設定 Fluent Bit以最大化彈性。

記錄可能會以兩種方式遺失：儲存填滿時捨棄最舊的記錄，或在系統無法接受更多資料時捨棄最新的記錄。

### 捨棄的最早記錄
<a name="firelens-record-loss-oldest-dropped"></a>

當重試嘗試用盡或`storage.total_limit_size`填滿且需要為新資料騰出空間時，會捨棄最舊的緩衝記錄。

超過重試限制  
在 AWS 外掛程式重試 （如果 `auto_retry_requests true`) 加上 1 次初始Fluent Bit嘗試加上`retry_limit`重試後發生。若要緩解，`retry_limit no_limits`為每個 OUTPUT 外掛程式設定無限次重試：  

```
[OUTPUT]
    Name                        cloudwatch_logs
    Match                       ApplicationLogs
    retry_limit                 no_limits
    auto_retry_requests         true
```
無限次重試可防止因重試耗盡而捨棄記錄，但可能導致 `storage.total_limit_size` 填滿。

已達到儲存限制 （檔案系統緩衝）  
當輸出目的地無法使用的時間超過您設定的 `storage.total_limit_size` 緩衝時間時，便會發生。例如，以 1 MB/s 日誌速率的 10 GB 緩衝區可提供大約 2.7 小時的緩衝時間。若要緩解、增加`storage.total_limit_size`每個 OUTPUT 外掛程式並佈建足夠的 Amazon ECS 任務儲存：  

```
[OUTPUT]
    Name                        cloudwatch_logs
    Match                       ApplicationLogs
    storage.total_limit_size    10G
```

### 拒絕的最新記錄
<a name="firelens-record-loss-newest-rejected"></a>

當磁碟空間耗盡或輸入因 而暫停時，會捨棄最新的記錄`Mem_Buf_Limit`。

磁碟空間用盡 （檔案系統緩衝）  
當磁碟空間完全用盡時，便會發生。 Fluent Bit 無法將新記錄排入佇列並遺失。若要緩解，請加總所有`storage.total_limit_size`值並佈建足夠的 Amazon ECS 任務儲存體。如需詳細資訊，請參閱[Amazon ECS 任務儲存需求](#firelens-storage-task-requirements)。

已達到記憶體限制 （記憶體緩衝）  
當輸出目的地無法使用且記憶體緩衝區填滿時，便會發生。暫停的輸入外掛程式會停止接受新記錄。若要緩解，請使用 `storage.type filesystem`以獲得更好的彈性，或增加 `Mem_Buf_Limit`。

### 將資料遺失降至最低的最佳實務
<a name="firelens-record-loss-best-practices"></a>

請考慮下列最佳實務，將資料遺失降至最低：
+ **使用檔案系統緩衝 –** 設定 `storage.type filesystem`以在中斷期間獲得更好的彈性。
+ **適當大小儲存** – 根據`storage.total_limit_size`日誌速率和所需的復原時段計算。
+ **佈建足夠的磁碟** – 確保 Amazon ECS 任務有足夠的暫時性儲存、Amazon EBS 或 Amazon EFS。
+ **設定重試行為** – 平衡 `retry_limit`（耗盡重試後捨棄記錄） 和 `no_limits`（無限期重試，但可能會填滿儲存體）。

## 使用多目的地記錄來確保可靠性
<a name="firelens-multi-destination"></a>

將日誌傳送至多個目的地可消除單一失敗點。例如，如果 CloudWatch Logs 遇到中斷，則日誌仍會到達 Amazon S3。

多目的地記錄可提供下列優點。Amazon S3 輸出外掛程式也支援壓縮選項，例如 gzip 和 Parquet 格式，這可以降低儲存成本。如需詳細資訊，請參閱 Fluent Bit 文件中的 [S3 壓縮](https://docs.fluentbit.io/manual/pipeline/outputs/s3#compression)。

多目的地記錄可提供下列優點：
+ **備援** – 如果一個目的地失敗，日誌仍會到達另一個目的地。
+ **復原** – 從另一個系統重建一個系統中的差距。
+ **耐用性** – 在 Amazon S3 中封存日誌以進行長期保留。
+ **成本最佳化** – 在 CloudWatch Logs 等快速查詢服務中保留最近的日誌，保留時間較短，同時將所有日誌存檔到成本較低的 Amazon S3 儲存，以便長期保留。

下列Fluent Bit組態會將日誌傳送至 CloudWatch Logs 和 Amazon S3：

```
[OUTPUT]
    Name cloudwatch_logs
    Match *
    region us-west-2
    log_group_name /aws/ecs/my-app
    log_stream_name $(ecs_task_id)
    workers 2
    retry_limit 15

[OUTPUT]
    Name s3
    Match *
    bucket my-logs-bucket
    region us-west-2
    total_file_size 100M
    s3_key_format /fluent-bit-logs/$(ecs_task_id)/%Y%m%d/%H/%M/$UUID
    upload_timeout 10m
    # Maximum disk space for buffered data for this output
    storage.total_limit_size 5G
```

兩個輸出都使用相同的`Match *`模式，因此所有記錄都會獨立傳送至兩個目的地。在某個目的地中斷期間，日誌會繼續流向另一個目的地，而失敗的排清會在檔案系統緩衝區中累積以供稍後重試。

## 搭配尾端輸入外掛程式使用檔案型記錄
<a name="firelens-tail-input"></a>

對於日誌遺失是重大考量的高輸送量案例，您可以使用替代方法：讓應用程式將日誌寫入磁碟上的檔案，並設定 Fluent Bit 使用`tail`輸入外掛程式讀取它們。此方法完全略過 Docker 記錄驅動程式層。

使用尾端外掛程式以檔案為基礎的記錄可提供下列優點：
+ **位移追蹤** – 尾端外掛程式可以將檔案位移存放在資料庫檔案中 （使用 `DB`選項），在Fluent Bit重新啟動時提供耐用性。這有助於防止在容器重新啟動期間日誌遺失。
+ **輸入層級緩衝** – 您可以使用 直接在輸入外掛程式上設定記憶體緩衝區限制`Mem_Buf_Limit`，以更精細地控制記憶體用量。
+ **避免 Docker 額外負荷** – 日誌會直接從檔案移至 ，Fluent Bit而不會傳遞 Docker 的日誌緩衝區。

若要使用此方法，您的應用程式必須將日誌寫入檔案，而不是 `stdout`。應用程式容器和Fluent Bit容器都會掛載存放日誌檔案的共用磁碟區。

下列範例顯示具有最佳實務的尾端輸入組態：

```
[INPUT]
    Name tail
    # File path or glob pattern to tail
    Path /var/log/app.log
    # Database file for storing file offsets (enables resuming after restart)
    DB /var/log/flb_tail.db
    # when true, controls that only fluent-bit will access the database (improves performance)
    DB.locking true
    # Skip long lines instead of skipping the entire file
    Skip_Long_Lines On
    # How often (in seconds) to check for new files matching the glob pattern
    Refresh_Interval 10
    # Extra seconds to monitor a file after rotation to account for pending flush
    Rotate_Wait 30
    # Maximum size of the buffer for a single line
    Buffer_Max_Size 10MB
    # Initial allocation size for reading file data
    Buffer_Chunk_Size 1MB
    # Maximum memory buffer size (tail pauses when full)
    Mem_Buf_Limit 75MB
```

使用尾端輸入外掛程式時，請考慮下列事項：
+ 為您的應用程式日誌實作日誌輪換，以防止磁碟耗盡。監控基礎磁碟區指標以衡量效能。
+ 根據您的日誌格式考慮設定`Ignore_Older`，例如 `Read_from_Head`、 和多行剖析器。

如需詳細資訊，請參閱 Fluent Bit 文件中的 [Tail](https://docs.fluentbit.io/manual/pipeline/inputs/tail)。如需最佳實務，請參閱《》中的 [Tail config with best practices](https://github.com/aws/aws-for-fluent-bit/blob/mainline/troubleshooting/debugging.md#tail-config-with-best-practices) AWS for Fluent Bit troubleshooting guide。

## 直接記錄到 FireLens
<a name="firelens-environment-variables"></a>

在任務定義中指定 `awsfirelens` 日誌驅動程式時，Amazon ECS 代理程式會將下列環境變數插入容器中：

`FLUENT_HOST`  
指派給 FireLens 容器的 IP 位址。  
如果搭配 `bridge` 網路模式使用 EC2，應用程式容器中的 `FLUENT_HOST` 環境變數可能會在重新啟動 FireLens 日誌路由器容器 (容器定義中具有 `firelensConfiguration` 物件的容器) 之後變得不準確。這是因為 `FLUENT_HOST` 是動態 IP 位址，重新啟動之後可能發生變更。從應用程式容器直接向 `FLUENT_HOST` IP 位址寫入日誌的操作，可能會在該位址變更後開始失敗。如需有關重新啟動個別容器的詳細資訊，請參閱[使用容器重新啟動政策在 Amazon ECS 任務中重新啟動個別容器](container-restart-policy.md)。

`FLUENT_PORT`  
流利轉送通訊協定正在接聽的連接埠。

您可以使用這些環境變數，使用 Fluent Forward 通訊協定直接從應用程式程式碼登入Fluent Bit日誌路由器，而不是寫入 `stdout`。此方法略過 Docker 記錄驅動程式層，可提供下列優點：
+ **低延遲** – 日誌會直接傳送至 ，Fluent Bit而不會傳遞 Docker 的記錄基礎設施。
+ **結構化記錄** – 原生傳送結構化日誌資料，無需 JSON 編碼開銷。
+ **更好的控制** – 您的應用程式可以實作自己的緩衝和錯誤處理邏輯。

下列 Fluent 記錄程式庫支援 Fluent Forward 通訊協定，可用於將日誌直接傳送到 Fluent Bit：
+ **Go** – [fluent-logger-golang](https://github.com/fluent/fluent-logger-golang)
+ **Python** – [fluent-logger-python](https://github.com/fluent/fluent-logger-python)
+ **Java** – [fluent-logger-java](https://github.com/fluent/fluent-logger-java)
+ **Node.js** – [fluent-logger-node](https://github.com/fluent/fluent-logger-node)
+ **Ruby** – [fluent-logger-ruby](https://github.com/fluent/fluent-logger-ruby)

## 設定 Docker 緩衝區限制
<a name="firelens-buffer-limit"></a>

建立任務定義時，您可以透過在 中指定 值，來指定在記憶體中緩衝的日誌行數`log-driver-buffer-limit`。這會控制 Docker 和 之間的緩衝區Fluent Bit。如需詳細資訊，請參閱 Docker 文件中的 [Fluentd 登入驅動程式](https://docs.docker.com/engine/logging/drivers/fluentd/)。

請在有高輸送量時使用此選項，原因是 Docker 可能會耗盡緩衝區記憶體，並捨棄緩衝區訊息，以便新增新訊息。

使用此選項時，請考慮下列事項：
+ EC2 與具有平台版本 `1.4.0` 或更新版本的 Fargate 類型支援此選項。
+ 只有在 `logDriver` 設定為 `awsfirelens` 時，此選項才有效。
+ 預設的緩衝區上限為 `1048576` 日誌行。
+ 緩衝區限制必須大於或等於 `0` 且小於 `536870912` 日誌行。
+ 此緩衝區使用的記憶體容量上限，為每個日誌行大小與緩衝區大小的乘積。例如，如果應用程式的日誌行是平均 `2` KiB，緩衝區限制為 4096 最多會使用 `8` MiB。在任務層級配置的記憶體總量，應大於為所有容器配置的記憶體容量與日誌驅動程式記憶體緩衝區用量的總和。

下列任務定義顯示如何設定 `log-driver-buffer-limit`：

```
{
    "containerDefinitions": [
        {
            "name": "my_service_log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "essential": true,
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
        {
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:latest",
            "name": "app",
            "logConfiguration": {
                "logDriver": "awsfirelens",
                "options": {
                    "Name": "firehose",
                    "region": "us-west-2",
                    "delivery_stream": "my-stream",
                    "log-driver-buffer-limit": "52428800"
                }
            },
            "dependsOn": [
                {
                    "containerName": "my_service_log_router",
                    "condition": "START"
                }
            ],
            "memoryReservation": 100
        }
    ]
}
```

# AWS 適用於 Amazon ECS Fluent Bit的影像儲存庫
<a name="firelens-using-fluentbit"></a>

AWS 為 CloudWatch Logs 和 Firehose 提供具有外掛程式Fluent Bit的影像。我們建議您將 Fluent Bit 用作日誌路由器，因為它的資源使用率低於 Fluentd。如需詳細資訊，請參閱 [CloudWatch Logs for Fluent Bit](https://github.com/aws/amazon-cloudwatch-logs-for-fluent-bit) 和 [Amazon Kinesis Firehose for Fluent Bit](https://github.com/aws/amazon-kinesis-firehose-for-fluent-bit)。

**AWS for Fluent Bit** 映像可在 Amazon ECR Public Gallery 和 Amazon ECR 儲存庫的 Amazon ECR 上取得，以獲得高可用性。

## Amazon ECR Public Gallery
<a name="firelens-image-ecrpublic"></a>

 AWS 適用於Fluent Bit映像的 可在 Amazon ECR Public Gallery 上取得。這是下載 AWS 適用於Fluent Bit映像的 的建議位置，因為它是公有儲存庫，可從所有 使用 AWS 區域。如需詳細資訊，請參閱 Amazon ECR Public Gallery 上的 [aws-for-fluent-bit](https://gallery.ecr.aws/aws-observability/aws-for-fluent-bit)。

### Linux
<a name="firelens-image-ecrpublic-linux"></a>

Amazon ECR Public Gallery 中的 AWS for Fluent Bit映像支援具有 `ARM64`或 `x86-64`架構的 Amazon Linux 作業系統。

您可以透過指定具有所需Fluent Bit映像標籤 AWS 的儲存庫 URL，從 Amazon ECR Public Gallery 提取映像的 。在 Amazon ECR Public Gallery 的**映像標籤**索引標籤中可找到可用的映像標籤。

以下顯示 Docker CLI 要使用的語法。

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

例如，您可以使用此 Docker CLI 命令 AWS 為Fluent Bit版本提取「3.x」系列中的最新映像。

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

**注意**  
允許未經驗證的提取，但速率限制低於已驗證的提取。若要在提取之前使用 AWS 您的帳戶進行身分驗證，請使用下列命令。  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

#### AWS 適用於 Fluent Bit 3.0.0
<a name="firelens-image-ecrpublic-linux-3.0.0"></a>

除了 AWS Fluent Bit版本的現有 之外`2.x`， AWS Fluent Bit還支援新的主要版本 `3.x`。新的主要版本包括將映像從 Amazon Linux 2 升級至 Amazon Linux 2023，並將Fluent Bit版本`1.9.10`升級至 `4.1.1`。如需詳細資訊，請參閱 上[AWS 儲存Fluent Bit庫](https://github.com/aws/aws-for-fluent-bit/blob/mainline/VERSIONS.md)的 GitHub。

下列範例示範 Fluent Bit `3.x` 映像 AWS 的更新標籤：

您可以針對 AWS Fluent Bit映像的 使用多架構標籤。

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:3
```

### Windows
<a name="firelens-image-ecrpublic-windows"></a>

Amazon ECR Public Gallery 中的 AWS for Fluent Bit映像支援具有下列作業系統的`AMD64`架構：
+ Windows Server 2022 Full
+ Windows Server 2022 Core
+ Windows Server 2019 Full
+ Windows Server 2019 Core

 AWS Fargate 上的 Windows 容器不支援 FireLens。

您可以透過指定具有所需Fluent Bit映像標籤 AWS 的儲存庫 URL，從 Amazon ECR Public Gallery 提取映像的 。在 Amazon ECR Public Gallery 的**映像標籤**索引標籤中可找到可用的映像標籤。

以下顯示 Docker CLI 要使用的語法。

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:tag
```

例如，您可以使用此 Docker AWS CLI 命令提取影像的最新穩定 Fluent Bit 。

```
docker pull public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-stable
```

**注意**  
允許未經驗證的提取，但速率限制低於已驗證的提取。若要在提取之前使用 AWS 您的帳戶進行身分驗證，請使用下列命令。  

```
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws
```

## Amazon ECR
<a name="firelens-image-ecr"></a>

 AWS for Fluent Bit 映像可在 Amazon ECR 上使用，以獲得高可用性。下列命令可用來擷取映像 URIs並在指定的 中建立映像可用性 AWS 區域。

### Linux
<a name="firelens-image-ecr-linux"></a>

您可以使用下列命令擷取最新穩定的 AWS Fluent Bit 映像 URI。

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/stable \
      --region us-east-1
```

您可以使用下列命令來查詢 Systems Manager 參數存放區參數，列出所有版本的 AWS for Fluent Bit 映像。

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit \
      --region us-east-1
```

您可以在範本中 CloudFormation 參考 Systems Manager 參數存放區名稱，以參考最新穩定的 AWS Fluent Bit 映像。以下是範例：

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/stable
```

**注意**  
如果命令失敗或沒有輸出，則呼叫命令 AWS 區域 的 中無法使用映像。

### Windows
<a name="firelens-image-ecr-windows"></a>

您可以使用下列命令擷取最新穩定的 AWS Fluent Bit 映像 URI。

```
aws ssm get-parameters \
      --names /aws/service/aws-for-fluent-bit/windowsservercore-stable \
      --region us-east-1
```

您可以使用下列命令來查詢 Systems Manager 參數存放區參數，列出所有版本的 AWS for Fluent Bit 映像。

```
aws ssm get-parameters-by-path \
      --path /aws/service/aws-for-fluent-bit/windowsservercore \
      --region us-east-1
```

您可以在範本中 CloudFormation 參考 Systems Manager 參數存放區名稱，以參考最新穩定的 AWS Fluent Bit 映像。以下是範例：

```
Parameters:
  FireLensImage:
    Description: Fluent Bit image for the FireLens Container
    Type: AWS::SSM::Parameter::Value<String>
    Default: /aws/service/aws-for-fluent-bit/windowsservercore-stable
```

# Amazon ECS 任務定義範例：將日誌路由至 FireLens
<a name="firelens-taskdef"></a>

若要搭配 FireLens 使用自訂日誌路由，您必須在工作定義中指定下列項目：
+ 包含 FireLens 組態的日誌路由器容器。我們建議將容器標示為 `essential`。
+ 包含指定日誌驅動程式的日誌配置的一或多個應用 `awsfirelens` 程式容器。
+ 任務IAM 角色 Amazon Resource Name (ARN)，其中包含路由日誌所需的任務許可。

使用 建立新的任務定義時 AWS 管理主控台，有一個 FireLens 整合區段，可讓您輕鬆地新增日誌路由器容器。如需詳細資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

Amazon ECS 轉換日誌組態並產生 Fluentd 或 Fluent Bit 輸出組態。輸出配置掛載在流利位和 `/fluentd/etc/fluent.conf` 流利位 `/fluent-bit/etc/fluent-bit.conf` 的日誌路由容器中。

**重要**  
FireLens 會監聽連接埠 `24224`。因此為了確保 FireLens 日誌路由器無法在任務之外連線，您不能在任務使用的安全群組中允許連接埠 `24224` 上的傳入流量。對於使用 `awsvpc` 網路模式的任務，這是與任務相關聯的安全群組。對於使用 `host` 網路模式的任務，這是與託管任務的 Amazon EC2 執行個體相關聯的安全群組。對於使用 `bridge` 網路模式的任務，請不要建立使用連接埠 `24224` 的任何連接埠映射。

根據預設，Amazon ECS 會在日誌項目中新增其他欄位，以協助識別日誌的來源。
+ `ecs_cluster` - 任務所屬叢集的名稱。
+ `ecs_task_arn` – 容器所屬任務的完整 Amazon Resource Name (ARN)。
+ `ecs_task_definition` - 任務正在使用的任務定義名稱和修訂版本。
+ `ec2_instance_id`：託管容器的 Amazon EC2 執行個體 ID。此欄位僅用於使用 EC2 啟動類型的任務。

如果不想要中繼資料，您可以將 `enable-ecs-log-metadata` 設定為 `false`。

以下任務定義範例定義了一個日誌路由器容器，其使用 Fluent Bit，將其日誌路由至 CloudWatch Logs。其還定義了一個應用程式容器，該容器使用日誌組態將日誌路由至 Amazon Data Firehose，並將用於緩衝事件的記憶體設定為 2 MiB。

**注意**  
如需更多任務定義範例，請參閱 GitHub 上的 [Amazon ECS FireLens 範例](https://github.com/aws-samples/amazon-ecs-firelens-examples)。

```
{
  "family": "firelens-example-firehose",
  "taskRoleArn": "arn:aws:iam::123456789012:role/ecs_task_iam_role",
  "containerDefinitions": [
    {
            "name": "log_router",
            "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:3",
            "cpu": 0,
            "memoryReservation": 51,
            "portMappings": [],
            "essential": true,
            "environment": [],
            "mountPoints": [],
            "volumesFrom": [],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-group": "/ecs/ecs-aws-firelens-sidecar-container",
                    "mode": "non-blocking",
                    "awslogs-create-group": "true",
                    "max-buffer-size": "25m",
                    "awslogs-region": "us-east-1",
                    "awslogs-stream-prefix": "firelens"
                },
                "secretOptions": []
            },
            "systemControls": [],
            "firelensConfiguration": {
                "type": "fluentbit"
            }
        },
    {
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:latest",
      "name": "app",
      "logConfiguration": {
        "logDriver": "awsfirelens",
        "options": {
          "Name": "firehose",
          "region": "us-west-2",
          "delivery_stream": "my-stream",
          "log-driver-buffer-limit": "1048576"
        }
      },
      "memoryReservation": 100
    }
  ]
}
```

在 `logConfiguration` 物件中指定為選項的索引鍵值組，用來產生 Fluentd 或 Fluent Bit 輸出組態。以下是來自 Fluent Bit 輸出定義的程式碼範例。

```
[OUTPUT]
    Name   firehose
    Match  app-firelens*
    region us-west-2
    delivery_stream my-stream
```

**注意**  
FireLens 管理 `match` 組態。您無需在任務定義中指定 `match` 組態。

## 使用自訂組態檔案
<a name="firelens-taskdef-customconfig"></a>

您可以指定自訂組態檔案。組態檔格式是您所使用日誌路由器的原生格式。如需詳細資訊，請參閱 [Fluentd Config File Syntax](https://docs.fluentd.org/configuration/config-file) 與 [YAML Configuration](https://docs.fluentbit.io/manual/administration/configuring-fluent-bit/yaml)。

在您的自訂組態檔案中，對於使用 `bridge` 或 `awsvpc` 網路模式的任務，不要透過 TCP 設定 Fluentd 或 Fluent Bit 向前輸入，因為 FireLens 將其新增到輸入組態中。

您的 FireLens 組態必須包含下列選項，才能指定自訂組態檔案：

`config-file-type`  
自訂組態檔案的來源位置。可用選項為 `s3` 或 `file`。  
上託管的任務 AWS Fargate 僅支援`file`組態檔案類型。不過，您可以使用 for Fluent Bit init 容器，使用 AWS Fargate 上 Amazon S3 中託管 AWS 的組態檔案。如需詳細資訊，請參閱 [ECS 上的 Fluent Bit 的 Init 程序、GitHub 上的多組態支援](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md)。 GitHub

`config-file-value`  
自訂組態檔案的來源。如果使用 `s3` 組態檔案類型，則組態檔案值是 Amazon S3 儲存貯體和檔案的完整 ARN。如果使用 `file` 組態檔案類型，組態檔案值就是容器映像中或掛載在容器中的磁碟區上的組態檔案的完整路徑。  
使用自訂組態檔案時，您必須指定與 FireLens 使用的路徑不同的路徑。Amazon ECS 會為 Fluent Bit 保留 `/fluent-bit/etc/fluent-bit.conf` filepath，並為 Fluentd 保留 `/fluentd/etc/fluent.conf`。

下列範例顯示指定自訂組態時所需的語法。

**重要**  
若要指定託管於 Amazon S3 的自訂組態檔案，請確定您已建立具有適當許可的任務執行 IAM 角色。

以下顯示指定自訂組態時所需的語法。

```
{
  "containerDefinitions": [
    {
      "essential": true,
      "image": "906394416424.dkr.ecr.us-west-2.amazonaws.com/aws-for-fluent-bit:3",
      "name": "log_router",
      "firelensConfiguration": {
        "type": "fluentbit",
        "options": {
          "config-file-type": "s3 | file",
          "config-file-value": "arn:aws:s3:::amzn-s3-demo-bucket/fluent.conf | filepath"
        }
      }
    }
  ]
}
```

**注意**  
上託管的任務 AWS Fargate 僅支援`file`組態檔案類型。不過，您可以使用 for Fluent Bit init 容器，使用 AWS Fargate 上 Amazon S3 中託管 AWS 的組態檔案。如需詳細資訊，請參閱 [ECS 上的 Fluent Bit 的 Init 程序、GitHub 上的多組態支援](https://github.com/aws/aws-for-fluent-bit/blob/mainline/use_cases/init-process-for-fluent-bit/README.md)。 GitHub

# 在 Amazon ECS 中使用非AWS 容器映像
<a name="private-auth"></a>

使用私有登錄檔將您的登入資料存放在 中 AWS Secrets Manager，然後在任務定義中參考它們。這可讓您參考 外部私有登錄檔中存在的容器映像 AWS ，這些登錄檔需要在您的任務定義中進行身分驗證。託管於 Fargate、Amazon EC2 執行個體以及使用 Amazon ECS Anywhere 的外部執行個體上的任務支援此功能。

**重要**  
如果您的任務定義參考存放在 Amazon ECR 中的映像，則此主題不適用。如需詳細資訊，請參閱 *Amazon Elastic Container Registry User Guide* 中的 [Using Amazon ECR Images with Amazon ECS](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_ECS.html)。

對於託管於 Amazon EC2 執行個體上的任務，此功能要求具備版本 `1.19.0` 或更新的容器代理程式。不過，我們建議您使用最新版的容器代理。如需如何檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。

對於託管於 Fargate 上的任務，此功能需要平台版本 `1.2.0` 或更新版本。如需相關資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。

在您的容器定義內，使用您所建立的秘密的詳細資訊來指定 `repositoryCredentials` 物件。參考的秘密可以來自與使用它的任務不同的 AWS 區域 或不同的 帳戶。

**注意**  
使用 Amazon ECS API AWS CLI或 AWS SDK 時，如果秘密與您啟動 AWS 區域 的任務位於相同的 中，您可以使用秘密的完整 ARN 或名稱。如果此秘密已存在於不同帳戶中，則必須指定秘密的完整 ARN。使用 時 AWS 管理主控台，一律必須指定秘密的完整 ARN。

以下是任務定義的程式碼片段，其會顯示所需的參數：

替代下列參數：
+ 將 *private-repo* 取代為私有儲存庫的主機名稱 
+ 將 *private-image* 取代為映像名稱
+ 將 *arn：aws：secretsmanager：region：aws\$1account\$1id：secret：secret\$1name* 取代為秘密的 Amazon Resource Name (ARN)

```
"containerDefinitions": [
    {
        "image": "private-repo/private-image",
        "repositoryCredentials": {
            "credentialsParameter": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name"
        }
    }
]
```

**注意**  
啟用私有登錄檔身分驗證的另一個方法，是使用 Amazon ECS 容器代理程式環境變數來向私有登錄檔進行身分驗證。只有託管於 Amazon EC2 執行個體上的任務才支援此方法。如需詳細資訊，請參閱[為私有 Docker 映像檔設定 Amazon ECS 容器執行個體](private-auth-container-instances.md)。

**使用私有登錄檔**

1. 任務定義必須具有任務執行角色。這可讓容器代理程式提取容器映像。如需詳細資訊，請參閱[Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。

   私有登錄檔身分驗證可讓您的 Amazon ECS 任務從需要身分驗證憑證的 AWS （例如 Docker Hub、Quay.io 或您自己的私有登錄檔） 外部的私有登錄檔提取容器映像。此功能透過 Secrets Manager 安全地儲存登錄檔憑證，這些憑證隨後會在任務定義中透過 `repositoryCredentials` 參數進行引用。

   如需設定私有登錄檔身分驗證的詳細資訊，請參閱[在 Amazon ECS 中使用非AWS 容器映像](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html)。

   若要存取內含私有登錄檔憑證的秘密，請將以下許可以內嵌政策形式新增至任務執行角色。如需詳細資訊，請參閱[新增和移除 IAM 政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)。
   + `secretsmanager:GetSecretValue` – 從 Secrets Manager 擷取私有登錄檔憑證時需要。
   + `kms:Decrypt` - 只有在您的秘密使用自訂 KMS 金鑰而非預設金鑰時，才需要此項目。您的自訂金鑰的 Amazon Resource Name (ARN) 必須新增為資源。

   下列為新增許可的內嵌政策範例。

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "kms:Decrypt",
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
                   "arn:aws:secretsmanager:us-east-1:111122223333:secret:secret_name",
                   "arn:aws:kms:us-east-1:111122223333:key/key_id"
               ]
           }
       ]
   }
   ```

------

1. 使用 AWS Secrets Manager 為您的私有登錄檔登入資料建立秘密。如需有關如何建立秘密的資訊，請參閱 *AWS Secrets Manager User Guide* 中的 [Create an AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。

   按照下列格式輸入私有登錄檔憑證：

   ```
   {
     "username" : "privateRegistryUsername",
     "password" : "privateRegistryPassword"
   }
   ```

1. 註冊任務定義。如需詳細資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

# 使用容器重新啟動政策在 Amazon ECS 任務中重新啟動個別容器
<a name="container-restart-policy"></a>

您可以為任務定義中定義的每個必要與非必要容器啟用重新啟動政策，以更快地克服暫時性故障並維持任務可用性。在為容器啟用重新啟動政策後，如果容器結束，Amazon ECS 可以重新啟動容器，無需取代任務。

容器預設不會啟用重新啟動政策。在為容器啟用重新啟動政策後，您可以指定不會重新啟動容器的結束代碼。這些可以是指示成功的結束代碼，例如不需要重新啟動的 `0` 結束代碼。您亦可指定容器必須持續成功執行多久之後才可嘗試重新啟動。如需這些參數的相關資訊，請參閱 [重新啟動政策](task_definition_parameters.md#container_definition_restart_policy)。如需指定這些值的任務定義範例，請參閱[在 Amazon ECS 任務定義中指定容器重新啟動政策](container-restart-policy-example.md)。

您可以使用 Amazon ECS 任務中繼資料端點或 CloudWatch Container Insights 來監控容器重新啟動的次數。如需有關任務中繼資料端點的詳細資訊，請參閱 [Amazon ECS 任務中繼資料端點第 4 版](task-metadata-endpoint-v4.md)與[Fargate 上任務的 Amazon ECS 任務中繼資料端點第 4 版](task-metadata-endpoint-v4-fargate.md)。如需有關 Amazon ECS Container Insights 指標的詳細資訊，請參閱 *Amazon CloudWatch User Guide* 中的 [Amazon ECS Container Insights metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-ECS.html)。

託管於 Fargate、Amazon EC2 執行個體以及使用 Amazon ECS Anywhere 的外部執行個體上的任務，皆支援容器重新啟動政策。

## 考量事項
<a name="container-restart-policy-considerations"></a>

為容器啟用重新啟動政策之前，請考量下列事項：
+ Fargate 上的 Windows 容器不支援重新啟動政策。
+ 對於託管於 Amazon EC2 執行個體上的任務，此功能要求具備版本 `1.86.0` 或更新的容器代理程式。不過，我們建議您使用最新版的容器代理。如需如何檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。
+ 如果搭配 `bridge` 網路模式使用 EC2，應用程式容器中的 `FLUENT_HOST` 環境變數可能會在重新啟動 FireLens 日誌路由器容器 (容器定義中具有 `firelensConfiguration` 物件的容器) 之後變得不準確。這是因為 `FLUENT_HOST` 是動態 IP 位址，重新啟動之後可能發生變更。從應用程式容器直接向 `FLUENT_HOST` IP 位址寫入日誌的操作，可能會在該位址變更後開始失敗。如需 `FLUENT_HOST` 的相關資訊，請參閱 [為高輸送量設定 Amazon ECS 日誌](firelens-docker-buffer-limit.md)。
+ Amazon ECS 代理程式會處理容器重新啟動政策。如果某些非預期原因導致 Amazon ECS 代理程式失敗或不再執行，容器將不會重新啟動。
+  政策中定義的重啟嘗試週期，決定容器在 Amazon ECS 重新啟動容器之前必須執行的時長 (以秒為單位)。

# 在 Amazon ECS 任務定義中指定容器重新啟動政策
<a name="container-restart-policy-example"></a>

若要在任務定義中指定容器重新啟動政策，需在容器定義中指定 `restartPolicy` 物件。如需有關 `restartPolicy` 物件的詳細資訊，請參閱[重新啟動政策](task_definition_parameters.md#container_definition_restart_policy)。

以下是使用 Fargate 上 Linux 容器並設定 Web 伺服器的任務定義。容器定義包含 `restartPolicy` 物件，並將 `enabled` 設定為 true 以啟用容器重新啟動政策。容器必須先執行 180 秒，才能重新啟動；若容器以表示成功的結束代碼 `0` 結束，則不會被重新啟動。

```
{
  "containerDefinitions": [
    {
      "command": [
        "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
      ],
      "entryPoint": ["sh", "-c"],
      "essential": true,
      "image": "public.ecr.aws/docker/library/httpd:2.4",
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/fargate-task-definition",
          "awslogs-region": "us-east-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "name": "sample-fargate-app",
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80,
          "protocol": "tcp"
        }
      ],
      "restartPolicy": {
        "enabled": true,
        "ignoredExitCodes": [0],
        "restartAttemptPeriod": 180
      }
    }
  ],
  "cpu": "256",
  "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
  "family": "fargate-task-definition",
  "memory": "512",
  "networkMode": "awsvpc",
  "runtimePlatform": {
    "operatingSystemFamily": "LINUX"
  },
  "requiresCompatibilities": ["FARGATE"]
}
```

在容器定義中註冊包含 `restartPolicy` 物件的任務定義後，您可以使用該任務定義來執行任務或建立服務。如需詳細資訊，請參閱[將應用程式作為 Amazon ECS 任務執行](standalone-task-create.md)及[建立 Amazon ECS 滾動更新部署](create-service-console-v2.md)。

# 將敏感資料傳遞至 Amazon ECS 容器
<a name="specifying-sensitive-data"></a>

您可以安全地將敏感資料 (例如資料庫憑證) 傳遞至容器。

秘密 (例如 API 金鑰和資料庫憑證) 經常被應用程式用來存取其他系統。其通常由使用者名稱和密碼、憑證或 API 金鑰組成。對這些秘密的存取應限制在使用 IAM 的特定 IAM 主體，並在執行期插入容器。

秘密可以從 AWS Secrets Manager 和 Amazon EC2 Systems Manager 參數存放區無縫注入容器。這些秘密可以在您的任務中引用為以下任何內容。

1. 被引用為使用 `secrets` 容器定義參數的環境變數。

1. 如果您的日誌平台需要驗證，則被引用為 `secretOptions`。如需詳細資訊，請參閱[紀錄組態選項](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html#API_LogConfiguration_Contents)。

1. 如果從中提取容器的登錄檔需要驗證，則使用 `repositoryCredentials` 容器定義參數的映像會將其參照為提取的秘密。從 Amazon ECR Public Gallery 提取映像時使用此方法。如需詳細資訊，請參閱[任務的私有登錄檔身分驗證](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html)。

建議您在設定秘密管理時執行下列動作。

## 使用 AWS Secrets Manager 或 AWS Systems Manager 參數存放區來存放秘密資料
<a name="security-secrets-management-recommendations-storing-secret-materials"></a>

您應該將 API 金鑰、資料庫憑證與其他秘密資料安全儲存在 Secrets Manager 中，或將其作為加密參數安全儲存在 Systems Manager Parameter Store 中。這些服務類似，因為它們都是 AWS KMS 用於加密敏感資料的受管金鑰值存放區。不過，Secrets Manager 還具備自動輪換秘密、產生隨機秘密及跨帳戶共用秘密的能力。若要使用這些功能，可選擇 Secrets Manager。反之，則可在 Systems Manager Parameter Store 中使用加密參數。

**重要**  
如果您的秘密發生變更，您必須強制執行新部署或啟動新任務，才能擷取最新的秘密值。如需詳細資訊，請參閱下列主題：  
任務 – 先停止任務，再重新啟動。如需詳細資訊，請參閱[停止 Amazon ECS 任務](standalone-task-stop.md)及[將應用程式作為 Amazon ECS 任務執行](standalone-task-create.md)。
服務 – 更新服務並使用「強制執行新部署」選項。如需詳細資訊，請參閱[更新 Amazon ECS 服務](update-service-console-v2.md)。

## 從加密的 Amazon S3 儲存貯體擷取資料
<a name="security-secrets-management-recommendations-encrypted-s3-buckets"></a>

您應該將秘密儲存於加密的 Amazon S3 儲存貯體中，並使用任務角色來限制對這些秘密的存取。此舉可防止環境變數的值在日誌中意外洩漏，或在執行 `docker inspect` 時遭到暴露。執行此動作時，必須寫入應用程式，才能讀取 Amazon S3 儲存貯體中的秘密。如需說明，請參閱[對 Amazon S3 儲存貯體設定預設伺服器端加密行為](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html)。

## 使用附屬容器將秘密掛載至磁碟區
<a name="security-secrets-management-recommendations-mount-secret-volumes"></a>

由於環境變數的資料外洩風險較高，因此您應該執行附屬容器，從 讀取秘密 AWS Secrets Manager 並將其寫入共用磁碟區。透過使用 [Amazon ECS 容器排序](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html)，此容器可以在應用程式容器之前執行和結束。執行此操作時，應用程式容器隨後會掛載寫入秘密的磁碟區。就像 Amazon S3 儲存貯體方法一樣，必須寫入您的應用程式才能從共用磁碟區讀取秘密。由於磁碟區的範圍限定在任務，因此會在任務停止後自動刪除磁碟區。如需範例，請參閱 [task-def.json](https://github.com/aws-samples/aws-secret-sidecar-injector/blob/master/ecs-task-def/task-def.json) 專案。

在 Amazon EC2 上，寫入秘密的磁碟區可以使用 AWS KMS 客戶受管金鑰加密。在 上 AWS Fargate，磁碟區儲存會使用服務受管金鑰自動加密。

# 將個別環境變數傳遞至 Amazon ECS 容器
<a name="taskdef-envfiles"></a>

**重要**  
建議您將敏感資料儲存在 AWS Secrets Manager 秘密或 AWS Systems Manager 參數存放區參數中。如需詳細資訊，請參閱[將敏感資料傳遞至 Amazon ECS 容器](specifying-sensitive-data.md)。  
任務定義中指定的環境變數可供所有使用者和角色讀取，系統允許這些使用者和角色對任務定義執行 `DescribeTaskDefinition` 動作。

您可以將環境變數透過下列方式傳遞至容器：
+ 個別方式：使用 `environment` 容器定義參數。這會映射到 [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/) 的 `--env` 選項。
+ 大批方式：使用 `environmentFiles` 容器定義參數列出內含環境變數的一個或多個檔案。檔案必須託管在 Amazon S3 中。這會映射到 [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/) 的 `--env-file` 選項。

以下任務定義片段示範如何指定個別環境變數。

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environment": [
                {
                    "name": "variable",
                    "value": "value"
                }
            ],
            ...
        }
    ],
    ...
}
```

# 將環境變數傳遞至 Amazon ECS 容器
<a name="use-environment-file"></a>

**重要**  
建議您將敏感資料儲存在 AWS Secrets Manager 秘密或 AWS Systems Manager 參數存放區參數中。如需詳細資訊，請參閱[將敏感資料傳遞至 Amazon ECS 容器](specifying-sensitive-data.md)。  
環境變數檔案是 Simple Storage Service (Amazon S3) 中的物件，所有 Amazon S3 安全考量事項均適用。  
Windows 容器與 Fargate 上的 Windows 容器不支援使用 `environmentFiles` 參數。

您可以建立環境變數檔案，並將其儲存於 Amazon S3 中，將環境變數傳遞至您的容器。

透過在檔案中指定環境變數，您可以批次導入環境變數。在容器定義中指定 `environmentFiles` 物件，其中具有內含環境變數檔案的 Amazon S3 儲存貯體清單。

Amazon ECS 不會對環境變數強制執行大小限制，但是大型環境變數檔案可能會填滿磁碟空間。使用環境變數檔案的每個任務都會導致檔案複本下載到磁碟。Amazon ECS 會在任務清理過程中移除該檔案。

如需有關支援之環境變數的資訊，請參閱[進階容器定義參數 - 環境](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_environment)。

在容器定義中指定環境變數檔案時，請考量下列事項。
+ 對於 Amazon EC2 上的 Amazon ECS 任務，您的容器執行個體需要版本 `1.39.0` 或更新的容器代理程式，才能使用此功能。如需如何檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。
+ 對於 AWS Fargate 上的 Amazon ECS 任務，您的任務必須使用平台版本 `1.4.0` 或更新版本 (Linux) 才能使用此功能。如需詳細資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。

  驗證作業系統平台是否支援該變數。如需詳細資訊，請參閱[容器定義](task_definition_parameters.md#container_definitions)及[其他任務定義參數](task_definition_parameters.md#other_task_definition_params)。
+ 檔案必須使用 `.env` 副檔名和 UTF-8 編碼。
+ 此功能需搭配任務執行角色使用，且該角色必須具備額外的 Amazon S3 許可。這可讓容器代理程式從 Amazon S3 中提取環境變數檔案。如需詳細資訊，請參閱[Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。
+ 每個任務定義限制 10 個檔案。
+ 環境檔案中的每一行都必須包含 `VARIABLE=VALUE` 格式的環境變數。空格或引號**會**包含為 Amazon ECS 檔案值的一部分。以 `#` 開頭的行會被視為註解，而忽略。如需有關環境變數檔案語法的詳細資訊，請參閱 Docker 文件中的 [Set environment variables (-e, --env, --env-file)](https://docs.docker.com/reference/cli/docker/container/run/#env)。

  下列為適當的語法。

  ```
  #This is a comment and will be ignored
  VARIABLE=VALUE
  ENVIRONMENT=PRODUCTION
  ```
+ 如果有在容器定義中使用 `environment` 參數指定的環境變數，它們的優先順序高於環境檔案中包含的變數。
+ 如果指定內含相同變數的多個環境檔案，則處理順序為先進入者為優先。這表示會使用變數的第一個值，並忽略重複變數的後續值。建議您使用唯一的變數名稱。
+ 如果將環境檔案指定為容器覆寫，則會使用該檔案。此外，在容器定義中指定的任何其他環境檔案都將被忽略。
+ 下列規則適用於 Fargate：
  + 檔案的處理方式與本機 Docker 環境檔案類似。
  + 若容器定義所引用的環境變數值為空白且儲存於 Amazon S3 中，則容器定義將不會出現在容器中。
  + 不支援 Shell 逸出處理。
  + 容器進入點會解譯 `VARIABLE` 值。

## 範例
<a name="environment-file-example"></a>

以下任務定義片段示範如何指定環境變數檔案。

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environmentFiles": [
                {
                    "value": "arn:aws:s3:::amzn-s3-demo-bucket/envfile_object_name.env",
                    "type": "s3"
                }
            ],
            ...
        }
    ],
    ...
}
```

# 在 Amazon ECS 中以程式設計方式傳遞 Secrets Manager 秘密
<a name="secrets-app-secrets-manager"></a>

您可以使用 Secrets Manager 來儲存敏感資料，不必在應用程式中以純文字硬編碼敏感資訊。

我們建議使用這種方法擷取敏感資料，因為使用這種方法後，隨後如果 Secrets Manager 秘密有更新，應用程式會自動擷取最新版本的秘密。

在 Secrets Manager 中建立秘密。建立 Secret Manager 秘密後，更新應用程式程式碼即可擷取秘密。

保護 Secrets Manager 中的敏感資料之前，請先檢閱下列考量事項。
+ 僅支援存放文字資料的秘密，這些秘密是使用 [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html) API 的 `SecretString` 參數建立的。不支援儲存二進位資料的秘密，即透過 [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html) API 的 `SecretBinary` 參數建立的秘密。
+ 使用介面 VPC 端點來增強安全控制。您必須建立 Secrets Manager 的介面 VPC 端點。如需有關 VPC 端點的資訊，請參閱《AWS Secrets Manager 使用者指南》**中的[建立VPC 端點](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html)。
+ 任務所使用的 VPC 必須使用 DNS 解析。
+ 任務定義必須使用具備 Secrets Manager 額外許可的任務角色。如需詳細資訊，請參閱[Amazon ECS 任務 IAM 角色](task-iam-roles.md)。

## 建立 Secrets Manager 秘密
<a name="secrets-app-secrets-manager-create-secret"></a>

您可以使用 Secrets Manager 主控台為您的敏感資料建立秘密。如需有關如何建立秘密的詳細資訊，請參閱《AWS Secrets Manager 使用者指南》**中的[建立 AWS Secrets Manager 秘密](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。

## 更新應用程式以程式設計方式擷取 Secrets Manager 秘密
<a name="secrets-app-secrets-manager-update-app"></a>

您可以直接從應用程式呼叫 Secrets Manager API 來擷取秘密。如需詳細資訊，請參閱 *AWS Secrets Manager User Guide* 中的 [Retrieve secrets from AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html)。

若要擷取存放在 中的敏感資料 AWS Secrets Manager，請參閱 SDK [程式碼範例程式碼庫中的使用 AWS SDKs的 AWS Secrets Manager](https://docs.aws.amazon.com/code-library/latest/ug/secrets-manager_code_examples.html)程式碼範例。 *AWS *

# 在 Amazon ECS 中以程式設計方式傳遞 Systems Manager Parameter Store 秘密
<a name="secrets-app-ssm-paramstore"></a>

Systems Manager Parameter Store 提供安全的秘密儲存和管理。您可以將密碼、資料庫字串、EC2 執行個體 ID、AMI ID、授權碼等資料作為參數值儲存，不必在應用程式中硬編碼此類資訊。您存放的值可以是純文字或加密資料。

建議使用這種方法擷取敏感資料，因為使用這種方法後，隨後如果 Systems Manager Parameter Store 參數有更新，應用程式會自動擷取最新版本。

在保護 Systems Manager Parameter Store 中的敏感資料之前，請先檢閱以下考量事項。
+ 僅支援儲存文字資料的秘密。不支援儲存二進位資料的秘密。
+ 使用介面 VPC 端點來增強安全控制。
+ 任務所使用的 VPC 必須使用 DNS 解析。
+ 對於使用 EC2 的任務，您必須使用 Amazon ECS 代理程式組態變數 `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE=true`，才能使用此功能。您可以在建立容器執行個體期間將其新增至 `/etc/ecs/ecs.config` 檔案，也可以將其新增至現有的執行個體，然後重新啟動 ECS 代理程式。如需詳細資訊，請參閱[Amazon ECS 容器代理程式組態](ecs-agent-config.md)。
+ 任務定義必須使用具備 Systems Manager Parameter Store 額外許可的任務角色。如需詳細資訊，請參閱[Amazon ECS 任務 IAM 角色](task-iam-roles.md)。

## 建立參數
<a name="secrets-app-ssm-paramstore-create-secret"></a>

您可以使用 Systems Manager 主控台為您的敏感資料建立 Systems Manager Parameter Store 參數。如需詳細資訊，請參閱《AWS Systems Manager 使用者指南》**中的[建立 Systems Manager 參數 (主控台)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) 或[建立 Systems Manager 參數 (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html)。

## 更新應用程式，以程式設計方式擷取 Systems Manager Parameter Store 秘密
<a name="secrets-app-ssm-paramstore-update-app"></a>

若要擷取儲存在 Systems Manager 參數存放區參數中的敏感資料，請參閱 SDK [程式碼範例程式碼庫中的使用 AWS SDKs的 Systems Manager](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) 程式碼範例。 *AWS *

# 透過 Amazon ECS 環境變數傳遞 Secrets Manager 秘密
<a name="secrets-envvar-secrets-manager"></a>

在將秘密作為環境變數插入時，可指定秘密的完整內容、秘密內的特定 JSON 金鑰。這可協助您控制向容器公開的敏感資料。如需有關秘密版本控制的詳細資訊，請參閱 *AWS Secrets Manager User Guide* 中的 [What's in a Secrets Manager secret?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html#term_version) 章節。

使用環境變數將 Secrets Manager 秘密插入容器時應考量下列事項。
+ 敏感資料會在初次啟動容器時，嵌入您的容器。如果後續更新或輪換秘密，則容器不會自動收到更新的值。您必須啟動新的任務，或如果任務是服務的一部分，您可以更新服務，並使用 **Force new deployment (強制新的部署)** 選項強制服務來啟動新的任務。
+ 容器上執行的應用程式、容器日誌及偵錯工具皆能存取環境變數。
+ 對於 上的 Amazon ECS 任務 AWS Fargate，請考慮下列事項：
  + 若要將秘密的完整內容作為環境變數或在日誌組態中插入，您必須使用平台版本 `1.3.0` 或更新版本。如需相關資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。
  + 若要將特定 JSON 金鑰或秘密版本作為環境變數或在日誌組態中插入，您必須使用平台版本 `1.4.0` 或更新版本 (Linux)，或者 `1.0.0` (Windows)。如需相關資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。
+ 對於 EC2 上的 Amazon ECS 任務，應考慮下列事項：
  + 若要使用秘密的特定 JSON 索引鍵或版本插入秘密，您的容器執行個體必須有 `1.37.0` 版或更新版本的容器代理程式。不過，我們建議您使用最新版的容器代理。如需檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。

    若要插入秘密的完整內容做為環境變數，或在日誌組態中插入秘密，則容器執行個體必須有 `1.22.0` 版或更新版本的容器代理程式。
+ 使用介面 VPC 端點來增強安全控制能力，並透過私有子網路連線至 Secrets Manager。您必須建立 Secrets Manager 的介面 VPC 端點。如需有關 VPC 端點的資訊，請參閱《AWS Secrets Manager 使用者指南》**中的[建立VPC 端點](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html)。如需有關使用 Secrets Manager 與 Amazon VPC 的詳細資訊，請參閱 [How to connect to Secrets Manager service within a Amazon VPC](https://aws.amazon.com/blogs//security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/)。
+ 對於設定為使用 `awslogs` 日誌記錄驅動程式的 Windows 任務，您也必須在容器執行個體上設定 `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` 環境變數。使用下列語法：

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```
+ 任務定義必須使用具備 Secrets Manager 額外許可的任務執行角色。如需詳細資訊，請參閱[Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。

## 建立 AWS Secrets Manager 秘密
<a name="secrets-envvar-secrets-manager-create-secret"></a>

您可以使用 Secrets Manager 主控台為您的敏感資料建立秘密。如需詳細資訊，請參閱*AWS Secrets Manager 《 使用者指南*》中的[建立 AWS Secrets Manager 秘密](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。

## 將環境變數新增至容器定義
<a name="secrets-envvar-secrets-manager-update-container-definition"></a>

您可以在容器定義中指定下列項目：
+ 包含要在容器中設定之環境變數名稱的 `secrets` 物件
+ Secrets Manager 秘密的 Amazon Resource Name (ARN)
+ 包含要提供給容器之敏感資料的其他參數

下列範例示範了必須為 Secrets Manager 秘密指定的完整語法。

```
arn:aws:secretsmanager:region:aws_account_id:secret:secret-name:json-key:version-stage:version-id
```

以下部分說明其他參數。這些參數雖然是選用，但如果您不使用，則必須包含冒號 `:` 來使用預設值。以下提供範例深入說明。

`json-key`  
使用您要設為環境變數值的值，來指定金鑰/值對中的金鑰名稱。僅支援 JSON 格式的值。如果您沒有指定 JSON 金鑰，則會使用秘密的完整內容。

`version-stage`  
指定您要使用之秘密版本的預備標籤。如果指定了版本預備標籤，就無法指定版本 ID。如果未指定版本階段，則預設會擷取具有 `AWSCURRENT` 階段標籤的秘密。  
預備標籤會用來在不同版本的秘密更新或輪換時加以追蹤。每個版本的秘密都有一或多個預備標籤和 ID。

`version-id`  
針對您要使用的秘密版本，指定其唯一識別符。如果指定了版本 ID，就無法指定版本預備標籤。如果未指定版本 ID，則預設會擷取具有 `AWSCURRENT` 階段標籤的秘密。  
版本 ID 會用來在不同版本的秘密更新或輪換時加以追蹤。每個版本的秘密都有 ID。如需詳細資訊，請參閱 *《AWS Secrets Manager 使用者指南》*中的 [AWS Secrets Manager的重要術語和概念](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html#term_secret)。

### 容器定義範例
<a name="secrets-examples"></a>

下列範例示範您可以在容器定義中參考 Secrets Manager 秘密的方法。

**Example 參考完整秘密**  
以下是任務定義的程式碼片段，顯示參考 Secrets Manager 秘密全文時的格式。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
    }]
  }]
}
```
若要從容器內存取此秘密的值，您需要呼叫 `$environment_variable_name`。

**Example 引用完整秘密**  
以下是任務定義的程式碼片段，顯示引用多個 Secrets Manager 秘密全文時的格式。  

```
{
  "containerDefinitions": [{
     "secrets": [
      {
        "name": "environment_variable_name1",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      },
      {
        "name": "environment_variable_name2",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-abcdef"
      },
      {
        "name": "environment_variable_name3",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-ABCDEF"
      }
    ]
  }]
}
```
若要從容器內存取此秘密的值，您需要呼叫 `$environment_variable_name1`、`$environment_variable_name2`、`$environment_variable_name3`。

**Example 參考秘密中的特定金鑰**  
以下示範 [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html) 命令的範例輸出，會顯示秘密的內容，以及與其相關的版本預備標籤和版本 ID。  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "VersionId": "871d9eca-18aa-46a9-8785-981ddEXAMPLE",
    "SecretString": "{\"username1\":\"password1\",\"username2\":\"password2\",\"username3\":\"password3\"}",
    "VersionStages": [
        "AWSCURRENT"
    ],
    "CreatedDate": 1581968848.921
}
```
在 ARN 結尾指定金鑰名稱，來在容器定義中參考上一個輸出的特定金鑰。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::"
    }]
  }]
}
```

**Example 參考特定秘密版本**  
以下示範 [describe-secret](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html) 命令的範例輸出，會顯示秘密的未加密內容，以及所有版本秘密的中繼資料。  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "Description": "Example of a secret containing application authorization data.",
    "RotationEnabled": false,
    "LastChangedDate": 1581968848.926,
    "LastAccessedDate": 1581897600.0,
    "Tags": [],
    "VersionIdsToStages": {
        "871d9eca-18aa-46a9-8785-981ddEXAMPLE": [
            "AWSCURRENT"
        ],
        "9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE": [
            "AWSPREVIOUS"
        ]
    }
}
```
在 ARN 結尾指定金鑰名稱，來在容器定義中參考上一個輸出的特定版本預備標籤。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf::AWSPREVIOUS:"
    }]
  }]
}
```
在 ARN 結尾指定金鑰名稱，來在容器定義中參考上一個輸出的特定版本 ID。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

**Example 參考秘密的特定金鑰和版本預備標籤**  
以下說明如何參考秘密中的特定金鑰和特定版本預備標籤。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1:AWSPREVIOUS:"
    }]
  }]
}
```
若要指定特定的金鑰和版本 ID，請使用下列語法。  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

如需有關如何使用環境變數中指定的秘密建立任務定義的資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

# 透過 Amazon ECS 環境變數傳遞 Systems Manager 參數
<a name="secrets-envvar-ssm-paramstore"></a>

Amazon ECS 可讓您將敏感資料儲存在 AWS Systems Manager 參數存放區參數中，然後在容器定義中參考，藉此將敏感資料注入容器。

使用環境變數將 Systems Manager 秘密插入容器時，應考量下列事項。
+ 敏感資料會在初次啟動容器時，嵌入您的容器。如果後續更新或輪換秘密，則容器不會自動收到更新的值。您必須啟動新的任務，或如果任務是服務的一部分，您可以更新服務，並使用 **Force new deployment (強制新的部署)** 選項強制服務來啟動新的任務。
+ 對於 上的 Amazon ECS 任務 AWS Fargate，應考慮下列事項：
  + 若要將秘密的完整內容作為環境變數或在日誌組態中插入，您必須使用平台版本 `1.3.0` 或更新版本。如需相關資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。
  + 若要將特定 JSON 金鑰或秘密版本作為環境變數或在日誌組態中插入，您必須使用平台版本 `1.4.0` 或更新版本 (Linux)，或者 `1.0.0` (Windows)。如需相關資訊，請參閱[適用於 Amazon ECS 的 Fargate 平台版本](platform-fargate.md)。
+ 對於 EC2 上的 Amazon ECS 任務，應考慮下列事項：
  + 若要使用秘密的特定 JSON 索引鍵或版本插入秘密，您的容器執行個體必須有 `1.37.0` 版或更新版本的容器代理程式。不過，我們建議您使用最新版的容器代理。如需檢查代理程式版本及更新至最新版本的資訊，請參閱「[更新 Amazon ECS 容器代理程式](ecs-agent-update.md)」。

    若要插入秘密的完整內容做為環境變數，或在日誌組態中插入秘密，則容器執行個體必須有 `1.22.0` 版或更新版本的容器代理程式。
+ 使用介面 VPC 端點來增強安全控制。您必須為 Systems Manager 建立介面 VPC 端點。如需有關 VPC 端點的資訊，請參閱 *AWS Systems Manager User Guide* 中的 [Improve the security of EC2 instances by using VPC endpoints for Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-create-vpc.html)。
+ 任務定義必須使用具備 Systems Manager Parameter Store 額外許可的任務執行角色。如需詳細資訊，請參閱[Amazon ECS 任務執行 IAM 角色](task_execution_IAM_role.md)。
+ 對於設定為使用 `awslogs` 日誌記錄驅動程式的 Windows 任務，您也必須在容器執行個體上設定 `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE` 環境變數。使用下列語法：

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```

## 建立 Systems Manager 參數
<a name="secrets-envvar-ssm-paramstore-create-parameter"></a>

您可以使用 Systems Manager 主控台為您的敏感資料建立 Systems Manager Parameter Store 參數。如需詳細資訊，請參閱《AWS Systems Manager 使用者指南》**中的[建立 Systems Manager 參數 (主控台)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) 或[建立 Systems Manager 參數 (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html)。

## 將環境變數新增至容器定義
<a name="secrets-ssm-paramstore-update-container-definition"></a>

在任務定義的容器定義內，為 `secrets` 指定要在容器中設定的環境變數名稱，以及 Systems Manager Parameter Store 參數 (含有要提供給容器的敏感資料) 的完整 ARN。如需詳細資訊，請參閱[secrets](task_definition_parameters.md#ContainerDefinition-secrets)。

以下是任務定義的程式碼片段，顯示參考 Systems Manager 參數存放區參數的格式。如果 Systems Manager 參數存放區參數與您要啟動的任務位於相同區域中，則您可以使用參數的完整 ARN 或名稱。如果參數存在於不同區域，則請指定完整 ARN。

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

如需有關如何使用環境變數中指定的秘密建立任務定義的資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

## 更新應用程式，以程式設計方式擷取 Systems Manager Parameter Store 秘密
<a name="secrets-ssm-paramstore-update-app"></a>

若要擷取儲存在 Systems Manager 參數存放區參數中的敏感資料，請參閱 SDK [程式碼範例程式碼庫中的使用 AWS SDKs的 Systems Manager](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) 程式碼範例。 *AWS *

# 為 Amazon ECS 記錄組態傳遞秘密
<a name="secrets-logconfig"></a>

您可以使用 `logConfiguration` 中的 `secretOptions` 參數，傳遞用於記錄的敏感資料。

您可以將秘密儲存於 Secrets Manager 或 Systems Manager 中。

## 使用 Secrets Manager
<a name="secrets-logconfig-secrets-manager"></a>

在您的容器定義內，指定 `logConfiguration` 時，您可指定 `secretOptions`，在該參數中，需提供要在容器中設定的日誌驅動程式選項名稱，以及含有要呈現給容器之敏感資料的 Secrets Manager 秘密之完整 ARN。如需有關建立秘密的詳細資訊，請參閱 [Create an AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。

以下是任務定義的程式碼片段，顯示參考 Secrets Manager 秘密時的格式。

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "splunk",
      "options": {
        "splunk-url": "https://your_splunk_instance:8088"
      },
      "secretOptions": [{
        "name": "splunk-token",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      }]
    }]
  }]
}
```

## 將環境變數新增至容器定義
<a name="secrets-envvar-ssm-paramstore-update-container-definition"></a>

在您的容器定義內，將 `secrets` 指定為要在容器中設定的環境變數名稱，以及 Systems Manager 參數存放區參數 (含有要呈現給容器的敏感資料) 的完整 ARN。如需詳細資訊，請參閱[secrets](task_definition_parameters.md#ContainerDefinition-secrets)。

以下是任務定義的程式碼片段，顯示參考 Systems Manager 參數存放區參數的格式。如果 Systems Manager 參數存放區參數與您要啟動的任務位於相同區域中，則您可以使用參數的完整 ARN 或名稱。如果參數存在於不同區域，則請指定完整 ARN。

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

如需有關如何使用環境變數中指定的秘密建立任務定義的資訊，請參閱[使用主控台建立 Amazon ECS 任務定義](create-task-definition.md)。

## 使用 Systems Manager
<a name="secrets-logconfig-ssm-paramstore"></a>

您可以將敏感資料插入日誌組態。在您的容器定義內，指定 `logConfiguration` 時，您可用要在容器中設定的日誌驅動程式選項名稱指定 `secretOptions`，以及 Systems Manager 參數存放區參數 (含有要呈現給容器的敏感資料) 的完整 ARN。

**重要**  
如果 Systems Manager 參數存放區參數與您要啟動的任務位於相同區域中，則您可以使用參數的完整 ARN 或名稱。如果參數存在於不同區域，則請指定完整 ARN。

以下是任務定義的程式碼片段，顯示參考 Systems Manager 參數存放區參數的格式。

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "fluentd",
      "options": {
        "tag": "fluentd demo"
      },
      "secretOptions": [{
        "name": "fluentd-address",
        "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter:/parameter_name"
      }]
    }]
  }]
}
```

# 在 Amazon ECS 中使用 Secrets Manager 秘密指定敏感資料
<a name="specifying-sensitive-data-tutorial"></a>

Amazon ECS 可讓您將敏感資料存放在 AWS Secrets Manager 秘密中，然後在容器定義中參考，藉此將敏感資料注入容器。如需詳細資訊，請參閱[將敏感資料傳遞至 Amazon ECS 容器](specifying-sensitive-data.md)。

了解如何建立 Secrets Manager 秘密、引用 Amazon ECS 任務定義中的秘密，然後查詢容器內顯示秘密內容的環境變數，驗證其是否能運作。

## 先決條件
<a name="specifying-sensitive-data-tutorial-prereqs"></a>

本教學課程假設已完成下列先決條件：
+ 已完成「[設定以使用 Amazon ECS。](get-set-up-for-amazon-ecs.md)」中的步驟。
+ 您的使用者具有必要的 IAM 許可，可建立 Secrets Manager 與 Amazon ECS 資源。

## 步驟 1：建立 Secrets Manager 機密
<a name="specifying-sensitive-data-tutorial-create-secret"></a>

您可以使用 Secrets Manager 主控台為您的敏感資料建立秘密。在本教學課程中，我們將建立基本秘密，以供存放容器中稍後參考的使用者名稱和密碼。如需詳細資訊，請參閱*AWS Secrets Manager 《 使用者指南*》中的[建立 AWS Secrets Manager 秘密](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)。

**要儲存在此秘密中的鍵/值對**是教學課程結尾處容器中的環境變量值。

儲存**秘密 ARN**，以在後續步驟的任務執行 IAM 政策和任務定義中參考。

## 步驟 2：將秘密許可新增至任務執行角色
<a name="specifying-sensitive-data-tutorial-update-iam"></a>

若要讓 Amazon ECS 從 Secrets Manager 秘密擷取敏感資料，您必須擁有任務執行角色的秘密許可。如需詳細資訊，請參閱[Secrets Manager 或 Systems Manager 許可](task_execution_IAM_role.md#task-execution-secrets)。

## 步驟 3：建立任務定義
<a name="specifying-sensitive-data-tutorial-create-taskdef"></a>

您可以使用 Amazon ECS 主控台來建立一個參考 Secrets Manager 秘密的任務定義。

**建立一個指定秘密的任務定義**

使用 IAM 主控台，以所需的許可更新您的任務執行角色。

1. 開啟主控台，網址為 [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2)。

1. 在導覽窗格中，選擇 **Task Definitions** (任務定義)。

1. 選擇 **Create new task definitio** (建立新任務定義)、**Create new task definition with JSON** (使用 JSON 建立新的任務定義)。

1. 在 JSON 編輯器方塊中輸入以下任務定義 JSON 文字，確保為在步驟 1 建立的 Secrets Manager 秘密以及在步驟 2 中更新的任務執行角色，指定完整的 ARN。選擇**儲存**。

1. 

   ```
   {
       "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "entryPoint": [
                   "sh",
                   "-c"
               ],
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ],
               "command": [
                   "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
               ],
               "cpu": 10,
               "secrets": [
                   {
                       "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:username_value",
                       "name": "username_value"
                   }
               ],
               "memory": 300,
               "image": "public.ecr.aws/docker/library/httpd:2.4",
               "essential": true,
               "name": "ecs-secrets-container"
           }
       ],
       "family": "ecs-secrets-tutorial"
   }
   ```

1. 選擇**建立**。

## 步驟 4：建立叢集
<a name="specifying-sensitive-data-tutorial-create-cluster"></a>

您可以使用 Amazon ECS 主控台建立一個叢集，其中包含要執行任務的容器執行個體。如果您的現有叢集有至少一個向其註冊的容器執行個體，並有可用資源可執行為此教學課程建立的一個任務定義執行個體，您可以跳到下一個步驟。

在本教學課程中，我們將使用 Amazon ECS 最佳化 Amazon Linux 2 AMI 建立具有一個 `t2.micro` 容器執行個體的叢集。

如需有關如何建立 EC2 叢集的資訊，請參閱[為 Amazon EC2 工作負載建立 Amazon ECS 叢集](create-ec2-cluster-console-v2.md)。

## 步驟 5：執行任務
<a name="specifying-sensitive-data-tutorial-run-task"></a>

您可以透過 Amazon ECS 主控台，使用您建立的任務定義來執行任務。在本教學課程中，我們將會執行使用 EC2 的任務，並使用我們在前一個步驟中建立的叢集。

如需有關如何執行任務的資訊，請參閱 [將應用程式作為 Amazon ECS 任務執行](standalone-task-create.md)。

## 步驟 6：驗證
<a name="specifying-sensitive-data-tutorial-verify"></a>

您可以使用下列步驟，驗證是否已成功完成所有步驟，以及是否已在您的容器中正確建立環境變數。

**驗證是否已建立環境變數**

1. 尋找您容器執行個體的公有 IP 或 DNS 地址。

   1. 開啟主控台，網址為 [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2)。

   1. 在導覽窗格中，選擇**叢集**，然後選擇建立的叢集。

   1. 選擇**基礎設施**，然後選擇容器執行個體。

   1. 記錄您執行個體的**公有 IP** 或**公有 DNS**。

1. 如果您使用的是 macOS 或 Linux 電腦，請使用下列命令連線到您的執行個體，並替換為您私有金鑰的路徑及執行個體的公有地址：

   ```
   $ ssh -i /path/to/my-key-pair.pem ec2-user@ec2-198-51-100-1.compute-1.amazonaws.com
   ```

   如需有關使用 Windows 電腦的詳細資訊，請參閱 *Amazon EC2 User Guide* 中的 [Connect to your Linux instance using PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-from-windows.html)。
**重要**  
如需有關執行個體連線問題的詳細資訊，請參閱 *Amazon EC2 User Guide* 中的 [Troubleshooting Connecting to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html)。

1. 列出在執行個體上執行的容器。請記下 `ecs-secrets-tutorial` 容器的容器 ID。

   ```
   docker ps
   ```

1. 使用上一個步驟輸出中的容器 ID，連接到 `ecs-secrets-tutorial` 容器。

   ```
   docker exec -it container_ID /bin/bash
   ```

1. 使用 `echo` 命令來列印環境變數的值。

   ```
   echo $username_value
   ```

   如果教學課程成功，您應該會看到以下輸出：

   ```
   password_value
   ```
**注意**  
或者，您可以使用 `env` (或 `printenv`) 命令列出您容器中的所有環境變數。

## 步驟 7：清除
<a name="specifying-sensitive-data-tutorial-cleanup"></a>

完成此教學課程時，建議您清除相關聯的資源，以免未使用的資源產生費用。

**清除資源**

1. 開啟主控台，網址為 [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2)。

1. 在導覽窗格中，選擇**叢集**。

1. 在**叢集**頁面上，選擇叢集。

1. 選擇 **Delete Cluster (刪除叢集)**。

1. 在確認方塊中，輸入 **delete *叢集名稱***，然後選擇**刪除**。

1. 在以下網址開啟 IAM 主控台：[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。

1. 在導覽窗格中，選擇**角色**。

1. 搜尋 `ecsTaskExecutionRole` 的角色清單並加以選取。

1. 選擇**許可**，然後選擇 **ECSSecretsTutorial** 旁邊的 **X**。選擇**移除**。

1. 開啟位於的 Secrets Manager 主控台[https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)。

1. 選取您所建立的 **username\$1value** 秘密，然後選擇 **Actions (動作)**、**Delete secret (刪除秘密)**。