Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Tutorial untuk Amazon ECS
<a name="ecs-tutorials"></a>

Tutorial berikut menunjukkan cara melakukan tugas-tugas umum saat menggunakan Amazon ECS.

Anda dapat menggunakan salah satu tutorial berikut untuk mempelajari lebih lanjut tentang memulai dengan Amazon ECS.


| Gambaran umum tutorial | Pelajari selengkapnya | 
| --- | --- | 
|  Mulailah dengan Amazon ECS di Fargate.  |  [Pelajari cara membuat tugas Amazon ECS Linux untuk Fargate](getting-started-fargate.md)  | 
|  Memulai dengan wadah Windows di Fargate.  |  [Pelajari cara membuat tugas Amazon ECS Windows untuk Fargate](Windows_fargate-getting_started.md)  | 
|  Memulai dengan wadah Windows untuk EC2.  |  [Pelajari cara membuat tugas Amazon ECS Windows untuk EC2](getting-started-ecs-ec2-v2.md)  | 

Anda dapat menggunakan salah satu tutorial berikut untuk menyebarkan tugas di Amazon ECS menggunakan AWS CLI


| Gambaran umum tutorial | Pelajari selengkapnya | 
| --- | --- | 
|  Buat tugas Linux untuk Fargate.  |  [Membuat tugas Amazon ECS Linux untuk Fargate dengan AWS CLI](ECS_AWSCLI_Fargate.md)  | 
|  Buat tugas Windows untuk Fargate.  |  [Membuat tugas Amazon ECS Windows untuk Fargate dengan AWS CLI](ECS_AWSCLI_Fargate_windows.md)  | 
|  Buat tugas Linux untuk EC2.  |  [Membuat tugas Amazon ECS untuk EC2 dengan AWS CLI](ECS_AWSCLI_EC2.md)  | 

Anda dapat menggunakan salah satu tutorial berikut untuk mempelajari lebih lanjut tentang pemantauan dan pencatatan.


| Gambaran umum tutorial | Pelajari selengkapnya | 
| --- | --- | 
|  Siapkan fungsi Lambda sederhana yang mendengarkan peristiwa tugas dan menuliskannya ke aliran CloudWatch log Log.  |  [Mengonfigurasi Amazon ECS untuk mendengarkan acara Acara CloudWatch](ecs_cwet.md)  | 
|  Konfigurasikan aturan EventBridge peristiwa Amazon yang hanya menangkap peristiwa tugas di mana tugas telah berhenti berjalan karena salah satu wadah pentingnya telah dihentikan.   |  [Mengirim peringatan Amazon Simple Notification Service untuk tugas Amazon ECS menghentikan peristiwa](ecs_cwet2.md)  | 
|  Menggabungkan pesan log yang awalnya milik satu konteks tetapi dibagi menjadi beberapa catatan atau baris log.  |  [Menggabungkan pesan log Amazon ECS multiline atau stack-trace](firelens-concatanate-multiline.md)  | 
|  Terapkan container Fluent Bit pada instance Windows mereka yang berjalan di Amazon ECS untuk mengalirkan log yang dihasilkan oleh tugas Windows ke Amazon CloudWatch untuk pencatatan terpusat.  |  [Menyebarkan Fluent Bit di Amazon ECS Windows container](tutorial-deploy-fluentbit-on-windows.md)  | 

Anda dapat menggunakan salah satu tutorial berikut untuk mempelajari lebih lanjut tentang cara menggunakan otentikasi Direktori Aktif dengan Akun Layanan Terkelola grup di Amazon ECS.


| Gambaran umum tutorial | Pelajari selengkapnya | 
| --- | --- | 
|  Gunakan Akun Layanan Terkelola grup dengan wadah Linux di EC2.  |  [Menggunakan gMSA untuk Linux wadah EC2 di Amazon ECS](linux-gmsa.md)  | 
|  Gunakan Akun Layanan Terkelola grup dengan wadah Windows di EC2.  |  [Pelajari cara menggunakan GMSAs untuk wadah Windows EC2 untuk Amazon ECS](windows-gmsa.md)  | 
|  Gunakan Akun Layanan Terkelola grup dengan wadah Linux di Fargate.  |  [Menggunakan gMSA untuk Linux wadah di Fargate](fargate-linux-gmsa.md)  | 
|  Buat tugas yang menjalankan wadah Windows yang memiliki kredensyal untuk mengakses Active Directory dengan akun layanan terkelola grup tanpa domain.  |  [Menggunakan Amazon ECS Windows container dengan domainless gMSA menggunakan AWS CLI](tutorial-gmsa-windows.md)  | 

# Membuat tugas Amazon ECS Linux untuk Fargate dengan AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

Langkah-langkah berikut membantu Anda menyiapkan klaster, mendaftarkan definisi tugas, menjalankan tugas Linux, dan melakukan skenario umum lainnya di Amazon ECS dengan. AWS CLI Gunakan versi terbaru dari AWS CLI. Untuk informasi selengkapnya tentang cara memutakhirkan ke versi terbaru, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**catatan**  
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Prasyarat
](#ECS_AWSCLI_Fargate_prereq)
+ [

## Langkah 1: Buat Klaster
](#ECS_AWSCLI_Fargate_create_cluster)
+ [

## Langkah 2: Daftarkan Definisi Tugas Linux
](#ECS_AWSCLI_Fargate_register_task_definition)
+ [

## Langkah 3: Cantumkan Ketentuan tugas
](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [

## Langkah 4: Buat Layanan
](#ECS_AWSCLI_Fargate_create_service)
+ [

## Langkah 5: Cantumkan Layanan
](#ECS_AWSCLI_Fargate_list_services)
+ [

## Langkah 6: Jelaskan Layanan yang Berjalan
](#ECS_AWSCLI_Fargate_describe_service)
+ [

## Langkah 7: Uji
](#ECS_AWSCLI_Fargate_test)
+ [

## Langkah 8: Bersihkan
](#ECS_AWSCLI_Fargate_clean_up)

## Prasyarat
<a name="ECS_AWSCLI_Fargate_prereq"></a>

Tutorial ini mengasumsikan bahwa prasyarat berikut telah diselesaikan.
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi lebih lanjut tentang menginstal atau memutakhirkan AWS CLI, [Menginstal atau memperbarui ke versi terbaru](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah diselesaikan.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda memiliki VPC dan grup keamanan yang dibuat untuk digunakan. Tutorial ini menggunakan gambar kontainer yang dihosting di Amazon ECR Public sehingga tugas Anda harus memiliki akses internet. Untuk memberikan tugas Anda rute ke internet, gunakan salah satu pilihan berikut ini.
  + Gunakan subnet privat dengan gateway NAT yang memiliki alamat IP elastis.
  + Gunakan subnet publik dan tetapkan alamat IP publik untuk tugas tersebut.

  Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Untuk informasi tentang grup dan aturan keamanan, lihat, [Grup keamanan default untuk aturan Anda VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) [dan Contoh](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) di *Panduan Pengguna Amazon Virtual Private Cloud*.
+  Jika Anda mengikuti tutorial ini menggunakan subnet pribadi, Anda dapat menggunakan Amazon ECS Exec untuk berinteraksi langsung dengan penampung Anda dan menguji penerapan. Anda akan perlu untuk membuat peran tugas IAM untuk menggunakan ECS Exec. Untuk informasi selengkapnya tentang peran IAM tugas dan prasyarat lainnya, lihat Memantau [kontainer Amazon ECS dengan Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Opsional) AWS CloudShell adalah alat yang memberi pelanggan baris perintah tanpa perlu membuat instance EC2 mereka sendiri. Untuk informasi lebih lanjut, lihat [Apa itu AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dalam *AWS CloudShell User Guide*.

## Langkah 1: Buat Klaster
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

Secara default, akun Anda menerima klaster `default`.

**catatan**  
Manfaat dari penggunaan klaster `default` yang disediakan untuk Anda adalah bahwa Anda tidak perlu menentukan properti pada pilihan `--cluster cluster_name` di perintah berikutnya. Jika Anda membuat klaster non-default sendiri, Anda harus menentukan `--cluster cluster_name` untuk setiap perintah yang ingin Anda gunakan dengan klaster itu.

Buat klaster Anda sendiri dengan nama yang unik menggunakan perintah berikut:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Output:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Langkah 2: Daftarkan Definisi Tugas Linux
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Sebelum Anda dapat menjalankan tugas di klaster ECS, Anda harus mendaftarkan ketentuan tugas. Ketentuan tugas merupakan daftar kontainer yang dikelompokkan bersama-sama. Contoh berikut adalah ketentuan tugas sederhana yang menciptakan sebuah aplikasi web PHP dengan menggunakan citra kontainer httpd yang di-hosting di Docker Hub. Untuk informasi selengkapnya tentang parameter ketentuan tugas yang tersedia, lihat [Definisi tugas Amazon ECS](task_definitions.md). Untuk tutorial ini, hanya `taskRoleArn` diperlukan jika Anda menerapkan tugas di subnet pribadi dan ingin menguji penerapan. Ganti `taskRoleArn` dengan peran tugas IAM yang Anda buat untuk menggunakan ECS Exec seperti yang disebutkan dalam. [Prasyarat](#ECS_AWSCLI_Fargate_prereq)

```
 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "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\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}
```

Simpan definisi tugas JSON sebagai file dan berikan dengan `--cli-input-json file://path_to_file.json` opsi. 

Untuk menggunakan file JSON untuk ketentuan kontainer:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Parameter perintah **register-task-definition** mengembalikan penjelasan pada ketentuan tugas setelah menyelesaikan pendaftarannya.

## Langkah 3: Cantumkan Ketentuan tugas
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Anda dapat mencantumkan daftar ketentuan tugas untuk akun Anda kapan saja dengan perintah **list-task-definitions**. Output dari perintah ini menunjukkan nilai `family` dan `revision` yang dapat Anda gunakan bersama saat memanggil **run-task** atau **start-task**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Langkah 4: Buat Layanan
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Setelah Anda telah mendaftarkan tugas untuk akun Anda, Anda dapat membuat layanan untuk tugas yang telah terdaftar di klaster Anda. Pada contoh ini, Anda membuat layanan dengan satu instans dari ketentuan tugas `sample-fargate:1` yang berjalan di klaster Anda. Tugas tersebut membutuhkan rute menuju internet, maka terdapat dua cara untuk Anda agar bisa mencapainya. Salah satu caranya adalah dengan menggunakan subnet privat yang dikonfigurasikan dengan gateway NAT dengan alamat IP elastis di subnet publik. Cara lainnya adalah dengan menggunakan subnet publik dan menetapkan alamat IP publik untuk tugas Anda. Kami menyediakan kedua contoh di bawah ini. 

Contoh menggunakan subnet privat. ` enable-execute-command `Opsi ini diperlukan untuk menggunakan Amazon ECS Exec.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}" --enable-execute-command
```

Contoh menggunakan subnet publik.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Perintah **create-service** mengembalikan penjelasan pada ketentuan tugas setelah menyelesaikan pendaftarannya.

## Langkah 5: Cantumkan Layanan
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Cantumkan layanan untuk klaster Anda. Anda seharusnya dapat melihat layanan yang Anda buat di bagian sebelumnya. Anda dapat mengambil nama layanan atau ARN penuh yang telah dikembalikan dari perintah ini serta menggunakannya untuk menjelaskan layanan nantinya.

```
aws ecs list-services --cluster fargate-cluster
```

Output:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Langkah 6: Jelaskan Layanan yang Berjalan
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Jelaskan layanan yang menggunakan nama layanan yang telah diambil sebelumnya untuk mendapatkan informasi lebih lanjut tentang tugas.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Jika berhasil, tugas akan mengembalikan deskripsi dari layanan yang gagal juga layanan. Misalnya, di ` services ` bagian ini, Anda akan menemukan informasi tentang penerapan, seperti status tugas sebagai berjalan atau tertunda. Anda juga dapat menemukan informasi tentang ketentuan tugas, konfigurasi jaringan dan peristiwa stempel waktu. Pada bagian kegagalan, Anda akan menemukan informasi tentang kegagalan, jika ada kegagalan tersebut, yang terkait dengan panggilan tersebut. Untuk pemecahan masalah, lihat [Pesan Peristiwa Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Untuk informasi selengkapnya tentang deskripsi layanan, lihat [Jelaskan layanan](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices).

```
{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}
```

## Langkah 7: Uji
<a name="ECS_AWSCLI_Fargate_test"></a>

### Tugas pengujian dikerahkan menggunakan subnet publik
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Jelaskan tugas dalam layanan sehingga Anda bisa mendapatkan Elastic Network Interface (ENI) untuk tugas tersebut. 

Pertama, dapatkan tugas ARN.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

Outputnya berisi tugas ARN.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Jelaskan tugas dan temukan ID ENI. Gunakan tugas ARN untuk parameter. `tasks`

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

Informasi lampiran tercantum dalam output. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Jelaskan ENI untuk mendapatkan alamat IP publik.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

Alamat IP publik ada di output. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Masukkan alamat IP publik di browser web Anda dan Anda akan melihat halaman web yang menampilkan contoh aplikasi **Amazon ECS**.

### Tugas pengujian yang digunakan menggunakan subnet pribadi
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Jelaskan tugas dan temukan `managedAgents` untuk memverifikasi bahwa `ExecuteCommandAgent` sedang berjalan. Perhatikan `privateIPv4Address` untuk digunakan nanti.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 Informasi agen terkelola tercantum dalam output. 

```
{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }
```

 Setelah memverifikasi bahwa ` ExecuteCommandAgent` sedang berjalan, Anda dapat menjalankan perintah berikut untuk menjalankan shell interaktif pada wadah dalam tugas. 

```
  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"
```

 Setelah shell interaktif berjalan, jalankan perintah berikut untuk menginstal cURL. 

```
apt update 
```

```
apt install curl 
```

 Setelah menginstal cURL, jalankan perintah berikut menggunakan alamat IP pribadi yang Anda peroleh sebelumnya.

```
 curl 10.0.143.156 
```

 Anda akan melihat HTML yang setara dengan halaman web aplikasi sampel **Amazon ECS**.

```
<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>
```

## Langkah 8: Bersihkan
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

Setelah Anda selesai dengan tutorial ini, Anda harus membersihkan sumber daya yang terkait untuk menghindari biaya sumber daya yang tidak terpakai.

Hapus layanan.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Hapus klaster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Membuat tugas Amazon ECS Windows untuk Fargate dengan AWS CLI
<a name="ECS_AWSCLI_Fargate_windows"></a>

Langkah-langkah berikut membantu Anda menyiapkan klaster, mendaftarkan definisi tugas, menjalankan tugas Windows, dan melakukan skenario umum lainnya di Amazon ECS dengan file. AWS CLI Pastikan bahwa Anda menggunakan versi terbaru AWS CLI. Untuk informasi selengkapnya tentang cara memutakhirkan ke versi terbaru, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**catatan**  
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Prasyarat
](#ECS_AWSCLI_Fargate_windows_prereq)
+ [

## Langkah 1: Buat Klaster
](#ECS_AWSCLI_Fargate_windows_create_cluster)
+ [

## Langkah 2: Daftarkan Definisi Tugas Windows
](#ECS_AWSCLI_Fargate_windows_register_task_definition)
+ [

## Langkah 3: Daftar definisi tugas
](#ECS_AWSCLI_Fargate_windows__list_task_definitions)
+ [

## Langkah 4: Buat layanan
](#ECS_AWSCLI_Fargate_windows_create_service)
+ [

## Langkah 5: Daftar layanan
](#ECS_AWSCLI_Fargate_windows_list_services)
+ [

## Langkah 6: Jelaskan Layanan yang Berjalan
](#ECS_AWSCLI_Fargate_windows_describe_service)
+ [

## Langkah 7: Bersihkan
](#ECS_AWSCLI_Fargate_windows_clean_up)

## Prasyarat
<a name="ECS_AWSCLI_Fargate_windows_prereq"></a>

Tutorial ini mengasumsikan bahwa prasyarat berikut telah diselesaikan.
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya tentang menginstal atau memutakhirkan AWS CLI, lihat [Menginstal atau memperbarui ke versi terbaru](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah diselesaikan.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda memiliki VPC dan grup keamanan yang telah dibuat untuk digunakan. Tutorial ini menggunakan citra kontainer yang di-host pada Docker Hub sehingga tugas Anda harus memiliki akses kepada internet. Untuk memberikan tugas Anda rute ke internet, gunakan salah satu pilihan berikut ini.
  + Gunakan subnet privat dengan gateway NAT yang memiliki alamat IP elastis.
  + Gunakan subnet publik dan tetapkan alamat IP publik untuk tugas tersebut.

  Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Untuk informasi tentang grup dan aturan keamanan, lihat, [Grup keamanan default untuk aturan Anda VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) [dan Contoh](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) di *Panduan Pengguna Amazon Virtual Private Cloud*.
+ (Opsional) AWS CloudShell adalah alat yang memberi pelanggan baris perintah tanpa perlu membuat instance EC2 mereka sendiri. Untuk informasi lebih lanjut, lihat [Apa itu AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dalam *AWS CloudShell User Guide*.

## Langkah 1: Buat Klaster
<a name="ECS_AWSCLI_Fargate_windows_create_cluster"></a>

Secara default, akun Anda menerima klaster `default`.

**catatan**  
Manfaat dari penggunaan klaster `default` yang disediakan untuk Anda adalah bahwa Anda tidak perlu menentukan properti pada pilihan `--cluster cluster_name` di perintah berikutnya. Jika Anda membuat klaster non-default sendiri, Anda harus menentukan `--cluster cluster_name` untuk setiap perintah yang ingin Anda gunakan dengan klaster itu.

Buat klaster Anda sendiri dengan nama yang unik menggunakan perintah berikut:

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Output:

```
{
    "cluster": {
        "status": "ACTIVE", 
        "statistics": [], 
        "clusterName": "fargate-cluster", 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Langkah 2: Daftarkan Definisi Tugas Windows
<a name="ECS_AWSCLI_Fargate_windows_register_task_definition"></a>

Sebelum Anda dapat menjalankan tugas Windows di cluster Amazon ECS Anda, Anda harus mendaftarkan definisi tugas. Ketentuan tugas adalah daftar kontainer yang dikelompokkan bersama. Contoh berikut adalah definisi tugas sederhana yang membuat aplikasi web. Untuk informasi selengkapnya tentang parameter ketentuan tugas yang tersedia, lihat [Definisi tugas Amazon ECS](task_definitions.md).

```
{
    "containerDefinitions": [
        {
            "command": ["New-Item -Path C:\\inetpub\\wwwroot\\index.html -Type file -Value '<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>'; C:\\ServiceMonitor.exe w3svc"],
            "entryPoint": [
                "powershell",
                "-Command"
            ],
            "essential": true,
            "cpu": 2048,
            "memory": 4096,
            "image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
            "name": "sample_windows_app",
            "portMappings": [
                {
                    "hostPort": 80,
                    "containerPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "memory": "4096",
    "cpu": "2048",
    "networkMode": "awsvpc",
    "family": "windows-simple-iis-2019-core",
    "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
    "runtimePlatform": {"operatingSystemFamily": "WINDOWS_SERVER_2019_CORE"},
    "requiresCompatibilities": ["FARGATE"]
}
```

Contoh di atas JSON dapat diteruskan ke AWS CLI dalam dua cara: Anda dapat menyimpan definisi tugas JSON sebagai file dan meneruskannya dengan opsi. `--cli-input-json file://path_to_file.json`

Untuk menggunakan file JSON untuk ketentuan kontainer:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

Parameter perintah **register-task-definition** mengembalikan penjelasan pada ketentuan tugas setelah menyelesaikan pendaftarannya.

## Langkah 3: Daftar definisi tugas
<a name="ECS_AWSCLI_Fargate_windows__list_task_definitions"></a>

Anda dapat mencantumkan daftar ketentuan tugas untuk akun Anda kapan saja dengan perintah **list-task-definitions**. Output dari perintah ini menunjukkan nilai `family` dan `revision` yang dapat Anda gunakan bersama saat memanggil **run-task** atau **start-task**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1"
    ]
}
```

## Langkah 4: Buat layanan
<a name="ECS_AWSCLI_Fargate_windows_create_service"></a>

Setelah Anda telah mendaftarkan tugas untuk akun Anda, Anda dapat membuat layanan untuk tugas yang telah terdaftar di klaster Anda. Pada contoh ini, Anda membuat layanan dengan satu instans dari ketentuan tugas `sample-fargate:1` yang berjalan di klaster Anda. Tugas tersebut membutuhkan rute menuju internet, maka terdapat dua cara untuk Anda agar bisa mencapainya. Salah satu caranya adalah dengan menggunakan subnet privat yang dikonfigurasikan dengan gateway NAT dengan alamat IP elastis di subnet publik. Cara lainnya adalah dengan menggunakan subnet publik dan menetapkan alamat IP publik untuk tugas Anda. Kami menyediakan kedua contoh di bawah ini. 

Contoh menggunakan subnet privat.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

Contoh menggunakan subnet publik.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

Perintah **create-service** mengembalikan penjelasan pada ketentuan tugas setelah menyelesaikan pendaftarannya.

## Langkah 5: Daftar layanan
<a name="ECS_AWSCLI_Fargate_windows_list_services"></a>

Cantumkan layanan untuk klaster Anda. Anda seharusnya dapat melihat layanan yang Anda buat di bagian sebelumnya. Anda dapat mengambil nama layanan atau ARN penuh yang telah dikembalikan dari perintah ini serta menggunakannya untuk menjelaskan layanan nantinya.

```
aws ecs list-services --cluster fargate-cluster
```

Output:

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-service"
    ]
}
```

## Langkah 6: Jelaskan Layanan yang Berjalan
<a name="ECS_AWSCLI_Fargate_windows_describe_service"></a>

Jelaskan layanan yang menggunakan nama layanan yang telah diambil sebelumnya untuk mendapatkan informasi lebih lanjut tentang tugas.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

Jika berhasil, tugas akan mengembalikan deskripsi dari layanan yang gagal juga layanan. Sebagai contoh, pada bagian layanan, Anda akan menemukan informasi tentang deployment, seperti menjelaskan status pada tugas berjalan atau tertundanya tugas tersebut. Anda juga dapat menemukan informasi tentang ketentuan tugas, konfigurasi jaringan dan peristiwa stempel waktu. Pada bagian kegagalan, Anda akan menemukan informasi tentang kegagalan, jika ada kegagalan tersebut, yang terkait dengan panggilan tersebut. Untuk pemecahan masalah, lihat [Pesan Peristiwa Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Untuk informasi selengkapnya tentang deskripsi layanan, lihat [Jelaskan layanan](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices). 

```
{
    "services": [
        {
            "status": "ACTIVE", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
            "pendingCount": 2, 
            "launchType": "FARGATE", 
            "loadBalancers": [], 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "placementConstraints": [], 
            "createdAt": 1510811361.128, 
            "desiredCount": 2, 
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "DISABLED"
                }
            }, 
            "platformVersion": "LATEST", 
            "serviceName": "fargate-service", 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "DISABLED"
                        }
                    }, 
                    "pendingCount": 2, 
                    "launchType": "FARGATE", 
                    "createdAt": 1510811361.128, 
                    "desiredCount": 2, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
                    "updatedAt": 1510811361.128, 
                    "platformVersion": "0.0.1", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "placementStrategy": []
        }
    ], 
    "failures": []
}
```

## Langkah 7: Bersihkan
<a name="ECS_AWSCLI_Fargate_windows_clean_up"></a>

Setelah Anda selesai dengan tutorial ini, Anda harus membersihkan sumber daya yang terkait untuk menghindari biaya sumber daya yang tidak terpakai.

Hapus layanan.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Hapus klaster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Membuat tugas Amazon ECS untuk EC2 dengan AWS CLI
<a name="ECS_AWSCLI_EC2"></a>

Langkah-langkah berikut membantu Anda menyiapkan klaster, mendaftarkan definisi tugas, menjalankan tugas, dan melakukan skenario umum lainnya di Amazon ECS dengan. AWS CLI Gunakan versi terbaru dari AWS CLI. Untuk informasi selengkapnya tentang cara memutakhirkan ke versi terbaru, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**catatan**  
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Prasyarat
](#AWSCLI_EC2_prereq)
+ [

## Buat klaster
](#AWSCLI_EC2_create_cluster)
+ [

## Luncurkan instance kontainer dengan Amazon ECS AMI
](#AWSCLI_EC2_launch_container_instance)
+ [

## Daftar contoh wadah
](#AWSCLI_EC2_list_container_instances)
+ [

## Jelaskan instance kontainer Anda
](#AWSCLI_EC2_describe_container_instance)
+ [

## Daftarkan definisi tugas
](#AWSCLI_EC2_register_task_definition)
+ [

## Daftar definisi tugas
](#AWSCLI_EC2_list_task_definitions)
+ [

## Membuat layanan
](#AWSCLI_EC2_run_task)
+ [

## Daftar layanan
](#AWSCLI_EC2_list_tasks)
+ [

## Jelaskan layanan
](#AWSCLI_EC2_describe_service)
+ [

## Jelaskan tugas yang sedang berjalan
](#AWSCLI_EC2_describe_task)
+ [

## Uji server web
](#AWSCLI_EC2_test_web_server)
+ [

## Pembersihan sumber daya
](#AWSCLI_EC2_clean_up_resources)

## Prasyarat
<a name="AWSCLI_EC2_prereq"></a>

Tutorial ini mengasumsikan bahwa prasyarat berikut telah diselesaikan:
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya tentang menginstal atau memutakhirkan AWS CLI, lihat [Menginstal atau memperbarui ke versi terbaru](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah diselesaikan.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda memiliki peran IAM instance container yang dibuat untuk digunakan. Untuk informasi lebih lanjut, lihat. [Peran IAM instans kontainer Amazon ECS](instance_IAM_role.md)
+ Anda memiliki VPC yang dibuat untuk digunakan. Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Opsional) AWS CloudShell adalah alat yang memberi pelanggan baris perintah tanpa perlu membuat instance EC2 mereka sendiri. Untuk informasi lebih lanjut, lihat [Apa itu AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dalam *AWS CloudShell User Guide*.

## Buat klaster
<a name="AWSCLI_EC2_create_cluster"></a>

Secara default, akun Anda menerima klaster `default` ketika Anda meluncurkan instans kontainer pertama Anda.

**catatan**  
Manfaat menggunakan klaster `default` yang disediakan untuk Anda adalah Anda tidak perlu menentukan opsi `--cluster cluster_name` dalam perintah berikutnya. Jika Anda membuat klaster non-default sendiri, Anda harus menentukan `--cluster cluster_name` untuk setiap perintah yang ingin Anda gunakan dengan klaster itu.

Buat klaster Anda sendiri dengan nama yang unik menggunakan perintah berikut:

```
aws ecs create-cluster --cluster-name MyCluster
```

Output:

```
{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}
```

## Luncurkan instance kontainer dengan Amazon ECS AMI
<a name="AWSCLI_EC2_launch_container_instance"></a>

Instans kontainer adalah instans EC2 yang menjalankan agen kontainer Amazon ECS dan telah terdaftar ke dalam klaster. Di bagian ini, Anda akan meluncurkan instans EC2 menggunakan AMI yang dioptimalkan ECS.

**Untuk meluncurkan instance kontainer dengan AWS CLI**

1. Ambil ID AMI Amazon Linux 2 terbaru yang dioptimalkan ECS untuk Wilayah AWS Anda menggunakan perintah berikut. Perintah ini menggunakan AWS Systems Manager Parameter Store untuk mendapatkan ID AMI terbaru yang dioptimalkan ECS. AMI mencakup agen kontainer Amazon ECS dan runtime Docker yang sudah diinstal sebelumnya.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
   ```

   Output:

   ```
   ami-abcd1234
   ```

1. Buat grup keamanan yang memungkinkan akses SSH untuk mengelola instance container Anda dan akses HTTP untuk server web.

   ```
   aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
   ```

   Output:

   ```
   {
       "GroupId": "sg-abcd1234"
   }
   ```

1. Tambahkan aturan masuk ke grup keamanan dengan menjalankan perintah berikut.

   ```
   aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0
   ```

   Output:

   ```
   {
       "Return": true,
       "SecurityGroupRules": [
           {
               "SecurityGroupRuleId": "sgr-efgh5678",
               "GroupId": "sg-abcd1234",
               "GroupOwnerId": "123456789012",
               "IsEgress": false,
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIpv4": "0.0.0.0/0"
           }
       ]
   }
   ```

   Grup keamanan sekarang memungkinkan akses SSH dari rentang IP yang ditentukan dan akses HTTP dari mana saja. Dalam lingkungan produksi, Anda harus membatasi akses SSH ke alamat IP spesifik Anda dan mempertimbangkan untuk membatasi akses HTTP sesuai kebutuhan.

1. Buat key pair EC2 untuk akses SSH ke instance container Anda.

   ```
   aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
   chmod 400 ecs-tutorial-key.pem
   ```

   Kunci pribadi disimpan ke mesin lokal Anda dengan izin yang sesuai untuk akses SSH.

1. Luncurkan instans EC2 menggunakan AMI yang dioptimalkan ECS dan konfigurasikan untuk bergabung dengan cluster Anda.

   ```
   aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
   echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
   {
       "Instances": [
           {
               "InstanceId": "i-abcd1234",
               "ImageId": "ami-abcd1234",
               "State": {
                   "Code": 0,
                   "Name": "pending"
               },
               "PrivateDnsName": "",
               "PublicDnsName": "",
               "StateReason": {
                   "Code": "pending",
                   "Message": "pending"
               },
               "InstanceType": "t3.micro",
               "KeyName": "ecs-tutorial-key",
               "LaunchTime": "2025-01-13T10:30:00.000Z"
           }
       ]
   }
   ```

   Skrip data pengguna mengonfigurasi agen Amazon ECS untuk mendaftarkan instans ke instans Anda. `MyCluster` Instance menggunakan peran `ecsInstanceRole` IAM, yang memberikan izin yang diperlukan untuk agen.

## Daftar contoh wadah
<a name="AWSCLI_EC2_list_container_instances"></a>

Dalam beberapa menit setelah meluncurkan instans penampung Anda, agen Amazon ECS mendaftarkan instans dengan klaster Anda MyCluster . Anda dapat membuat daftar instans kontainer dalam klaster dengan menjalankan perintah berikut:

```
aws ecs list-container-instances --cluster MyCluster
```

Output:

```
{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}
```

## Jelaskan instance kontainer Anda
<a name="AWSCLI_EC2_describe_container_instance"></a>

Setelah Anda memiliki ARN atau ID instans kontainer, Anda dapat menggunakan perintah **describe-container-instances** untuk mendapatkan informasi berharga terkait instans, seperti sumber daya CPU dan memori yang tersisa dan terdaftar.

```
aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID
```

Output:

```
{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}
```

Anda juga dapat menemukan ID instans Amazon EC2 yang dapat Anda gunakan untuk memantau instans di konsol Amazon EC2 atau dengan perintah. **aws ec2 describe-instances --instance-id *instance\$1id***

## Daftarkan definisi tugas
<a name="AWSCLI_EC2_register_task_definition"></a>

Sebelum Anda dapat menjalankan tugas di cluster Amazon ECS Anda, Anda harus mendaftarkan definisi tugas. Ketentuan tugas adalah daftar kontainer yang dikelompokkan bersama. Contoh berikut adalah definisi tugas sederhana yang menggunakan `nginx` gambar. Untuk informasi selengkapnya tentang parameter ketentuan tugas yang tersedia, lihat [Definisi tugas Amazon ECS](task_definitions.md).

```
{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}
```

Contoh di atas JSON dapat diteruskan ke AWS CLI dalam dua cara: Anda dapat menyimpan definisi tugas JSON sebagai file dan meneruskannya dengan opsi. `--cli-input-json file://path_to_file.json` Atau, Anda dapat menghindari tanda kutip di JSON dan meneruskan definisi wadah JSON pada baris perintah. Jika Anda memilih untuk meneruskan ketentuan kontainer pada baris perintah, maka perintah Anda juga memerlukan parameter `--family` yang digunakan untuk menjaga beberapa versi ketentuan tugas Anda yang terkait satu sama lain.

Untuk menggunakan file JSON untuk ketentuan kontainer:

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/nginx.json
```

**register-task-definition** mengembalikan deskripsi ketentuan tugas setelah menyelesaikan pendaftarannya.

```
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}
```

## Daftar definisi tugas
<a name="AWSCLI_EC2_list_task_definitions"></a>

Anda dapat membuat daftar ketentuan tugas untuk akun Anda kapan pun dengan perintah **list-task-definitions**. Output dari perintah ini menunjukkan `revision` nilai `family` dan yang dapat Anda gunakan bersama saat memanggil**create-service**.

```
aws ecs list-task-definitions
```

Output:

```
{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}
```

## Membuat layanan
<a name="AWSCLI_EC2_run_task"></a>

Setelah mendaftarkan tugas untuk akun dan meluncurkan instans penampung yang terdaftar ke klaster, Anda dapat membuat layanan Amazon ECS yang menjalankan dan mengelola sejumlah tugas yang diinginkan secara bersamaan menggunakan definisi tugas yang Anda daftarkan. Untuk contoh ini, Anda menempatkan satu instance definisi `nginx:1` tugas di MyCluster cluster Anda.

```
aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1
```

Output:

```
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}
```

## Daftar layanan
<a name="AWSCLI_EC2_list_tasks"></a>

Cantumkan layanan untuk klaster Anda. Anda seharusnya dapat melihat layanan yang Anda buat di bagian sebelumnya. Anda dapat mencatat ID layanan atau ARN lengkap yang dikembalikan dari perintah ini dan menggunakannya untuk menggambarkan layanan nanti.

```
aws ecs list-services --cluster MyCluster
```

Output:

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}
```

## Jelaskan layanan
<a name="AWSCLI_EC2_describe_service"></a>

Jelaskan layanan menggunakan perintah berikut untuk mendapatkan informasi lebih lanjut tentang layanan ini.

```
aws ecs describe-services --cluster MyCluster --services nginx-service
```

Output:

```
{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}
```

## Jelaskan tugas yang sedang berjalan
<a name="AWSCLI_EC2_describe_task"></a>

Setelah menjelaskan layanan, jalankan perintah berikut untuk mendapatkan informasi lebih lanjut tentang tugas yang berjalan sebagai bagian dari layanan Anda.

```
aws ecs list-tasks --cluster MyCluster --service-name nginx-service
```

 Output: 

```
{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}
```

## Uji server web
<a name="AWSCLI_EC2_test_web_server"></a>

**Untuk menguji server web**

1. Ambil alamat IP publik instance container Anda dengan menjalankan perintah berikut.

   ```
   aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text
   ```

   Output:

   ```
   203.0.113.25
   ```

1. Setelah mengambil alamat IP, jalankan `curl` perintah berikut dengan alamat IP.

   ```
   curl http://203.0.113.25
   ```

   Output:

   ```
   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   ...
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you can see this page, the nginx web server is successfully installed and working.</p>
   ...
   </body>
   </html>
   ```

   Halaman selamat datang nginx mengonfirmasi bahwa layanan Anda berjalan dengan sukses dan dapat diakses dari internet.

## Pembersihan sumber daya
<a name="AWSCLI_EC2_clean_up_resources"></a>

Untuk menghindari biaya yang timbul, bersihkan sumber daya yang Anda buat dalam tutorial ini.

**Untuk membersihkan sumber daya**

1. Perbarui layanan agar tidak memiliki tugas yang diinginkan, lalu hapus layanan.

   ```
   aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "desiredCount": 0,
           "runningCount": 1,
           "pendingCount": 0,
           "status": "ACTIVE"
       }
   }
   ```

1. Tunggu tugas yang berjalan berhenti, lalu hapus layanan.

   ```
   aws ecs delete-service --cluster MyCluster --service nginx-service
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "status": "DRAINING"
       }
   }
   ```

1. Hentikan instance container yang Anda buat.

   ```
   aws ec2 terminate-instances --instance-ids i-abcd1234
   {
       "TerminatingInstances": [
           {
               "InstanceId": "i-abcd1234",
               "CurrentState": {
                   "Code": 32,
                   "Name": "shutting-down"
               },
               "PreviousState": {
                   "Code": 16,
                   "Name": "running"
               }
           }
       ]
   }
   ```

1. Bersihkan grup keamanan dan key pair yang Anda buat.

   ```
   aws ec2 delete-security-group --group-id sg-abcd1234
   aws ec2 delete-key-pair --key-name ecs-tutorial-key
   rm ecs-tutorial-key.pem
   ```

1. Hapus cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster MyCluster
   {
       "cluster": {
           "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
           "clusterName": "MyCluster",
           "status": "INACTIVE"
       }
   }
   ```

# Mengonfigurasi Amazon ECS untuk mendengarkan acara Acara CloudWatch
<a name="ecs_cwet"></a>

Pelajari cara menyiapkan fungsi Lambda sederhana yang mendengarkan peristiwa tugas dan menuliskannya ke aliran CloudWatch log Log.

## Prasyarat: Atur klaster pengujian
<a name="cwet_step_1"></a>

Jika Anda tidak memiliki klaster yang berjalan untuk menangkap peristiwa, ikuti langkah-langkah dalam [Membuat cluster Amazon ECS untuk beban kerja Fargate](create-cluster-console-v2.md) untuk membuat klaster. Di akhir tutorial ini, Anda menjalankan tugas di cluster ini untuk menguji apakah Anda telah mengonfigurasi fungsi Lambda Anda dengan benar. 

## Langkah 1: Buat fungsi Lambda
<a name="cwet_step_2"></a>

Dalam prosedur ini, Anda membuat fungsi Lambda sederhana untuk berfungsi sebagai target pesan aliran acara Amazon ECS. 

1. Buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Pilih **Buat fungsi**. 

1. Pada layar **Tulis dari awal**, lakukan hal berikut:

   1. Untuk **Nama**, masukkan nilai. 

   1. Untuk **Runtime**, pilih versi Python Anda, misalnya, **Python** 3.9.

   1. Untuk **Peran**, pilih **Buat peran baru dengan izin Lambda dasar**.

1. Pilih **Buat fungsi**.

1. Di bagian **Kode fungsi**, edit kode sampel untuk mencocokkan contoh berikut:

   ```
   import json
   
   def lambda_handler(event, context):
       if event["source"] != "aws.ecs":
          raise ValueError("Function only supports input from events with a source type of: aws.ecs")
          
       print('Here is the event:')
       print(json.dumps(event))
   ```

   Ini adalah fungsi Python 3.9 sederhana yang mencetak acara yang dikirim oleh Amazon ECS. Jika semuanya dikonfigurasi dengan benar, di akhir tutorial ini, Anda melihat bahwa detail peristiwa muncul di aliran CloudWatch log Log yang terkait dengan fungsi Lambda ini.

1. Pilih **Simpan**.

## Langkah 2: Mendaftarkan aturan peristiwa
<a name="cwet_step_3"></a>

 Selanjutnya, Anda membuat aturan CloudWatch acara Acara yang menangkap peristiwa tugas yang berasal dari kluster Amazon ECS Anda. Aturan ini menangkap semua peristiwa dari semua klaster dalam akun yang ditentukan. Pesan tugas sendiri berisi informasi sumber peristiwa, termasuk klaster tempat klaster berada, yang dapat Anda gunakan untuk memfilter dan mengurutkan peristiwa secara terprogram. 

**catatan**  
Saat Anda menggunakan aturan Konsol Manajemen AWS untuk membuat acara, konsol secara otomatis menambahkan izin IAM yang diperlukan untuk memberikan izin CloudWatch Acara untuk memanggil fungsi Lambda Anda. Jika Anda membuat aturan acara menggunakan AWS CLI, Anda harus memberikan izin ini secara eksplisit. Untuk informasi selengkapnya, lihat [Peristiwa di Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) [dan pola EventBridge acara](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) *Amazon di Panduan EventBridge Pengguna Amazon*.

**Untuk merutekan acara ke fungsi Lambda Anda**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Di panel navigasi, pilih **Peristiwa**, **Aturan**, **Buat aturan**.

1. Untuk **Sumber Peristiwa**, pilih **ECS** sebagai sumber peristiwa. Secara default, aturan ini berlaku untuk semua peristiwa Amazon ECS untuk semua grup Amazon ECS Anda. Atau, Anda dapat memilih acara tertentu atau grup Amazon ECS tertentu.

1. Untuk **Target**, pilih **Tambah target**, untuk **jenis Target**, pilih fungsi **Lambda, lalu pilih fungsi** Lambda Anda.

1. Pilih **Konfigurasikan detail**.

1. Untuk **Definisi aturan**, tuliskan nama dan deskripsi untuk aturan Anda dan pilih **Buat aturan**.

## Langkah 3: Membuat sebuah penetapan tugas
<a name="cwet_step_task-def"></a>

Buat definisi tugas.

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Di panel navigasi, pilih **Ketentuan Tugas**.

1. Pilih **Buat Definisi Tugas baru**, **Buat revisi baru dengan JSON**.

1. Salin dan tempel contoh ketentuan tugas berikut ke dalam kotak dan kemudian pilih **Simpan**.

   ```
   {
      "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"
               }
            ]
         }
      ],
      "cpu": "256",
      "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family": "fargate-task-definition",
      "memory": "512",
      "networkMode": "awsvpc",
      "runtimePlatform": {
           "operatingSystemFamily": "LINUX"
       },
      "requiresCompatibilities": [ 
          "FARGATE" 
       ]
   }
   ```

1. Pilih **Buat**.

## Langkah 4: Uji aturan Anda
<a name="cwet_step_4"></a>

 Terakhir, Anda membuat aturan CloudWatch acara Acara yang menangkap peristiwa tugas yang berasal dari kluster Amazon ECS Anda. Aturan ini menangkap semua peristiwa dari semua klaster dalam akun yang ditentukan. Pesan tugas berisi informasi tentang sumber peristiwa, termasuk klaster tempat klaster berada, yang dapat Anda gunakan untuk memfilter dan mengurutkan peristiwa secara terprogram. 

**Menguji aturan Anda**

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Pilih **Definisi tugas**.

1. Pilih **console-sample-app-static**, lalu pilih **Deploy**, **Run new task**.

1. Untuk **Cluster**, pilih default, lalu pilih **Deploy**.

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Pada panel navigasi, pilih **Log dan pilih grup log** untuk fungsi Lambda Anda (misalnya**,** *my-function* /aws/lambda/).

1. Pilih stream log untuk melihat data peristiwa. 

# Mengirim peringatan Amazon Simple Notification Service untuk tugas Amazon ECS menghentikan peristiwa
<a name="ecs_cwet2"></a>

Konfigurasikan aturan EventBridge peristiwa Amazon yang hanya menangkap peristiwa tugas di mana tugas telah berhenti berjalan karena salah satu wadah pentingnya telah dihentikan. Acara hanya mengirimkan peristiwa tugas dengan `stoppedReason` properti tertentu ke topik Amazon SNS yang ditentukan.

## Prasyarat: Atur klaster pengujian
<a name="cwet2_step_1"></a>

 Jika Anda tidak memiliki cluster yang sedang berjalan untuk menangkap peristiwa, ikuti langkah-langkah di [Memulai konsol menggunakan kontainer Linux AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/getting-started-fargate.html#get-started-fargate-cluster) untuk membuatnya. Di akhir tutorial ini, Anda menjalankan tugas di cluster ini untuk menguji bahwa Anda telah mengonfigurasi topik dan EventBridge aturan Amazon SNS Anda dengan benar. 

## Prasyarat: Konfigurasikan izin untuk Amazon SNS
<a name="cwet2_step_1a"></a>

Untuk memungkinkan mempublikasikan EventBridge ke topik Amazon SNS, gunakan perintah aws sns get-topic-attributes dan aws sns. set-topic-attributes 

Untuk informasi tentang cara menambahkan izin, lihat izin [Amazon SNS di Panduan Pengembang Layanan](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html#eb-sns-permissions) *Pemberitahuan Sederhana Amazon*

Tambahkan izin berikut:

```
{
  "Sid": "PublishEventsToMyTopic",
  "Effect": "Allow",
  "Principal": {
     "Service": "events.amazonaws.com"
  },
  "Action": "sns: Publish",
  "Resource": "arn:aws:sns:region:account-id:TaskStoppedAlert",
}
```

## Langkah 1: Buat dan berlangganan ke topik Amazon SNS
<a name="cwet2_step_2"></a>

 Untuk tutorial ini, Anda mengonfigurasi topik Amazon SNS yang berfungsi sebagai target peristiwa untuk aturan peristiwa baru Anda. 

Untuk informasi tentang cara membuat dan berlangganan topik Amazon SNS, lihat [Memulai Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html#step-create-queue) di Panduan *Pengembang Layanan Pemberitahuan Sederhana Amazon* dan gunakan tabel berikut untuk menentukan opsi apa yang harus dipilih.


| Opsi | Nilai | 
| --- | --- | 
|  Tipe  | Standar | 
| Nama |  TaskStoppedAlert  | 
| Protokol | Email | 
| Titik akhir |  Alamat email yang saat ini Anda miliki akses  | 

## Langkah 2: Mendaftarkan aturan peristiwa
<a name="cwet2_step_3"></a>

 Selanjutnya, Anda mendaftarkan aturan peristiwa yang hanya menangkap peristiwa yang dihentikan tugas untuk tugas dengan kontainer yang dihentikan. 

Untuk informasi tentang cara membuat dan berlangganan topik Amazon SNS, lihat [Membuat aturan di Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) di *Panduan EventBridge Pengguna Amazon* dan gunakan tabel berikut untuk menentukan opsi apa yang harus dipilih.


| Opsi | Nilai | 
| --- | --- | 
|  Jenis aturan  |  Aturan dengan pola acara  | 
| Sumber peristiwa | AWS acara atau acara EventBridge mitra | 
| Pola peristiwa |  Pola kustom (editor JSON)  | 
| Pola peristiwa |  <pre>{<br />   "source":[<br />      "aws.ecs"<br />   ],<br />   "detail-type":[<br />      "ECS Task State Change"<br />   ],<br />   "detail":{<br />      "lastStatus":[<br />         "STOPPED"<br />      ],<br />      "stoppedReason":[<br />         "Essential container in task exited"<br />      ]<br />   }<br />}</pre> | 
| Tipe target |  AWS layanan  | 
| Target | Topik SNS | 
| Topik |  TaskStoppedAlert (Topik yang Anda buat di Langkah 1)  | 

## Langkah 3: Uji aturan Anda
<a name="cwet2_step_4"></a>

Verifikasi bahwa aturan bekerja dengan menjalankan tugas yang keluar segera setelah dimulai. Jika aturan peristiwa Anda dikonfigurasi dengan benar, Anda menerima pesan email dalam beberapa menit dengan teks peristiwa. Jika Anda memiliki ketentuan tugas yang sudah ada yang dapat memenuhi persyaratan aturan, jalankan tugas dengan menggunakannya. Jika tidak memilikinya, langkah-langkah berikut akan memandu Anda mendaftarkan ketentuan tugas Fargate dan menjalankannya.

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Di panel navigasi, pilih **Definisi tugas**.

1. Pilih **Buat definisi tugas baru**, **Buat definisi tugas baru dengan JSON**.

1. Di kotak editor JSON, edit file JSON Anda, salin yang berikut ini ke editor.

   ```
   {
      "containerDefinitions":[
         {
            "command":[
               "sh",
               "-c",
               "sleep 5"
            ],
            "essential":true,
            "image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
            "name":"test-sleep"
         }
      ],
      "cpu":"256",
      "executionRoleArn":"arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family":"fargate-task-definition",
      "memory":"512",
      "networkMode":"awsvpc",
      "requiresCompatibilities":[
         "FARGATE"
      ]
   }
   ```

1. Pilih **Buat**.

**Untuk menjalankan tugas dari konsol**

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Pada halaman **Clusters**, pilih cluster yang Anda buat dalam prasyarat.

1. Dari tab **Tugas**, pilih **Jalankan tugas baru**.

1. Untuk **Jenis aplikasi**, pilih **Tugas**.

1. Untuk **definisi Tugas**, pilih **fargate-task-definition**.

1. Untuk **tugas yang diinginkan**, masukkan jumlah tugas yang akan diluncurkan.

1. Pilih **Buat**.

# Menggabungkan pesan log Amazon ECS multiline atau stack-trace
<a name="firelens-concatanate-multiline"></a>

Dimulai dengan AWS untuk Fluent Bit versi 2.22.0, filter multiline disertakan. Filter multiline membantu menggabungkan pesan log yang awalnya milik satu konteks tetapi dibagi menjadi beberapa catatan atau baris log. Untuk informasi selengkapnya tentang filter multiline, lihat dokumentasi [Fluent Bit](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace). 

Contoh umum pesan log terpisah adalah:
+ Jejak tumpukan. 
+ Aplikasi yang mencetak log pada beberapa baris. 
+ Log pesan yang dibagi karena lebih panjang dari ukuran buffer maks runtime yang ditentukan. Anda dapat menggabungkan pesan log yang dibagi berdasarkan runtime container dengan mengikuti contoh di GitHub: [FireLens Contoh:](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/filter-multiline-partial-message-mode) Concatenate Container Logs. Partial/Split 

## Izin IAM yang diperlukan
<a name="iam-permissions"></a>

Anda memiliki izin IAM yang diperlukan untuk agen penampung untuk menarik gambar kontainer dari Amazon ECR dan wadah untuk merutekan log ke Log. CloudWatch 

Untuk izin ini, Anda harus memiliki peran berikut: 
+ Peran tugas IAM. 
+ Peran IAM eksekusi tugas. 

Anda memerlukan izin berikut:
+ `logs:CreateLogStream`
+ `logs:CreateLogGroup`
+ `logs:PutLogEvents`

## Tentukan kapan harus menggunakan pengaturan log multiline
<a name="determine-filter"></a>

Berikut ini adalah contoh cuplikan log yang Anda lihat di konsol CloudWatch Log dengan pengaturan log default. Anda dapat melihat garis yang dimulai dengan `log` untuk menentukan apakah Anda memerlukan filter multiline. Ketika konteksnya sama, Anda dapat menggunakan pengaturan log multiline, Dalam contoh ini, konteksnya adalah “com.myproject.model. MyProject”.

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "source=": "stdout", "log": ": "     at com.myproject.modele.(MyProject.badMethod.java:22)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.badMethod(MyProject.java:22)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout", "log": ": "     at com.myproject.modele.(MyProject.oneMoreMethod.java:18)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE,
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

Setelah Anda menggunakan pengaturan log multiline, output akan terlihat mirip dengan contoh di bawah ini. 

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout",...
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log:    "September 20, 2022 06:41:48 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    
    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at   
    at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18) com.myproject.module.MyProject.main(MyProject.java:6)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:2"
     }
```

## Parse dan concatenate pilihan
<a name="parse-multiline-log"></a>

Untuk mengurai log dan menggabungkan baris yang terbagi karena baris baru, Anda dapat menggunakan salah satu dari dua opsi ini.
+ Gunakan file parser Anda sendiri yang berisi aturan untuk mengurai dan menggabungkan baris yang termasuk dalam pesan yang sama.
+ Gunakan parser bawaan Fluent Bit. Untuk daftar bahasa yang didukung oleh parser bawaan Fluent Bit, lihat Dokumentasi Bit [Lancar](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace).

Tutorial berikut memandu Anda melalui langkah-langkah untuk setiap kasus penggunaan. Langkah-langkahnya menunjukkan cara menggabungkan multiline dan mengirim log ke Amazon. CloudWatch Anda dapat menentukan tujuan yang berbeda untuk log Anda.

### Contoh: Gunakan parser yang Anda buat
<a name="customer-parser"></a>

Dalam contoh ini, Anda akan menyelesaikan langkah-langkah berikut: 

1. Buat dan unggah gambar untuk wadah Fluent Bit. 

1. Buat dan unggah gambar untuk aplikasi multiline demo yang berjalan, gagal, dan menghasilkan jejak tumpukan multiline.

1. Buat definisi tugas dan jalankan tugas. 

1. Lihat log untuk memverifikasi bahwa pesan yang menjangkau beberapa baris tampak digabungkan. 

**Buat dan unggah gambar untuk wadah Fluent Bit**

Gambar ini akan menyertakan file parser tempat Anda menentukan ekspresi reguler dan file konfigurasi yang mereferensikan file parser. 

1. Buat folder dengan nama`FluentBitDockerImage`. 

1. Di dalam folder, buat file parser yang berisi aturan untuk mengurai log dan menggabungkan baris yang termasuk dalam pesan yang sama.

   1. Tempel konten berikut di file parser:

      ```
      [MULTILINE_PARSER]
          name          multiline-regex-test
          type          regex
          flush_timeout 1000
          #
          # Regex rules for multiline parsing
          # ---------------------------------
          #
          # configuration hints:
          #
          #  - first state always has the name: start_state
          #  - every field in the rule must be inside double quotes
          #
          # rules |   state name  | regex pattern                  | next state
          # ------|---------------|--------------------------------------------
          rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
          rule      "cont"          "/^\s+at.*/"                     "cont"
      ```

      Saat Anda menyesuaikan pola regex Anda, kami sarankan Anda menggunakan editor ekspresi reguler untuk menguji ekspresi.

   1. Simpan file sebagai `parsers_multiline.conf`. 

1. Di dalam `FluentBitDockerImage` folder, buat file konfigurasi khusus yang mereferensikan file parser yang Anda buat di langkah sebelumnya.

   Untuk informasi selengkapnya tentang file konfigurasi kustom, lihat [Menentukan file konfigurasi kustom](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) di Panduan *Pengembang Layanan Amazon Elastic Container* 

   1. Tempel konten berikut dalam file:

      ```
      [SERVICE]
          flush                 1
          log_level             info
          parsers_file          /parsers_multiline.conf
          
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      multiline-regex-test
      ```
**catatan**  
Anda harus menggunakan jalur absolut parser. 

   1. Simpan file sebagai `extra.conf`. 

1. Di dalam `FluentBitDockerImage` folder, buat Dockerfile dengan gambar Fluent Bit dan parser dan file konfigurasi yang Anda buat.

   1. Tempel konten berikut dalam file:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      
      ADD parsers_multiline.conf /parsers_multiline.conf
      ADD extra.conf /extra.conf
      ```

   1. Simpan file sebagai `Dockerfile`.

1. Menggunakan Dockerfile, buat gambar Fluent Bit kustom dengan parser dan file konfigurasi khusus disertakan.
**catatan**  
Anda dapat menempatkan file parser dan file konfigurasi di mana saja di gambar Docker kecuali `/fluent-bit/etc/fluent-bit.conf` karena jalur file ini digunakan oleh. FireLens

   1. Bangun gambar: `docker build -t fluent-bit-multiline-image.`

      Dimana: `fluent-bit-multiline-image` adalah nama untuk gambar dalam contoh ini.

   1. Verifikasi bahwa gambar telah dibuat dengan benar: `docker images —filter reference=fluent-bit-multiline-image` 

      Jika berhasil, output menunjukkan gambar dan `latest` tag.

1. Unggah gambar Fluent Bit kustom ke Amazon Elastic Container Registry.

   1. Buat repositori Amazon ECR untuk menyimpan gambar: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Dimana: `fluent-bit-multiline-repo` adalah nama untuk repositori dan `us-east-1` merupakan wilayah dalam contoh ini. 

      Output memberi Anda rincian repositori baru. 

   1. Tandai gambar Anda dengan `repositoryUri` nilai dari output sebelumnya: `docker tag fluent-bit-multiline-image repositoryUri` 

      Contoh: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Jalankan docker image untuk memverifikasi itu berjalan dengan benar: `docker images —filter reference=repositoryUri`

      Dalam output, nama repositori berubah dari fluent-bit-multiline-repo ke. `repositoryUri`

   1. Otentikasi ke Amazon ECR dengan menjalankan `aws ecr get-login-password` perintah dan menentukan ID registri yang ingin Anda autentikasi: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Contoh: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Pesan login yang berhasil muncul.

   1. Dorong gambar ke Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Contoh: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Membangun dan meng-upload gambar untuk aplikasi demo multiline**

Gambar ini akan mencakup file skrip Python yang menjalankan aplikasi dan file log sampel. 

Saat Anda menjalankan tugas, aplikasi mensimulasikan berjalan, lalu gagal dan membuat jejak tumpukan. 

1. Buat folder bernama`multiline-app`: `mkdir multiline-app` 

1. Buat file skrip Python.

   1. Di dalam `multiline-app` folder, buat file dan beri nama`main.py`.

   1. Tempel konten berikut dalam file:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Simpan file `main.py`.

1. Buat file log sampel. 

   1. Di dalam `multiline-app` folder, buat file dan beri nama`test.log`.

   1. Tempel konten berikut dalam file:

      ```
      single line...
      Dec 14 06:41:08 Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
          at com.myproject.module.MyProject.badMethod(MyProject.java:22)
          at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
          at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
          at com.myproject.module.MyProject.someMethod(MyProject.java:10)
          at com.myproject.module.MyProject.main(MyProject.java:6)
      another line...
      ```

   1. Simpan file `test.log`.

1. Di dalam `multiline-app` folder, buat Dockerfile.

   1. Tempel konten berikut dalam file:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Simpan file `Dockerfile`.

1. Menggunakan Dockerfile, buat gambar.

   1. Bangun gambar: `docker build -t multiline-app-image `

      Dimana: `multiline-app-image` adalah nama untuk gambar dalam contoh ini.

   1. Verifikasi bahwa gambar telah dibuat dengan benar: `docker images —filter reference=multiline-app-image` 

      Jika berhasil, output menunjukkan gambar dan `latest` tag.

1. Unggah gambar ke Amazon Elastic Container Registry.

   1. Buat repositori Amazon ECR untuk menyimpan gambar: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Dimana: `multiline-app-repo` adalah nama untuk repositori dan `us-east-1` merupakan wilayah dalam contoh ini. 

      Output memberi Anda rincian repositori baru. Perhatikan `repositoryUri` nilainya karena Anda akan membutuhkannya di langkah selanjutnya. 

   1. Tandai gambar Anda dengan `repositoryUri` nilai dari output sebelumnya: `docker tag multiline-app-image repositoryUri` 

      Contoh: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Jalankan docker image untuk memverifikasi itu berjalan dengan benar: `docker images —filter reference=repositoryUri`

      Dalam output, nama repositori berubah dari `multiline-app-repo` ke nilai. `repositoryUri`

   1. Dorong gambar ke Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Contoh: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Buat definisi tugas dan jalankan tugas**

1. Buat file definisi tugas dengan nama file`multiline-task-definition.json`. 

1. Tempel konten berikut dalam `multiline-task-definition.json` file: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Ganti yang berikut ini dalam definisi `multiline-task-definition.json` tugas:

   1. `task role ARN`

      Untuk menemukan peran tugas ARN, buka konsol IAM. Pilih **Peran** dan temukan peran `ecs-task-role-for-firelens` tugas yang Anda buat. Pilih peran dan salin **ARN** yang muncul di bagian **Ringkasan**.

   1. `execution role ARN`

      Untuk menemukan peran eksekusi ARN, buka konsol IAM. Pilih **Peran** dan temukan `ecsTaskExecutionRole` perannya. Pilih peran dan salin **ARN** yang muncul di bagian **Ringkasan**.

   1. `aws_account_id`

      Untuk menemukan Anda`aws_account_id`, masuk ke Konsol Manajemen AWS. Pilih nama pengguna Anda di kanan atas dan salin ID Akun Anda.

   1. `us-east-1`

      Ganti wilayah jika perlu.

1. Daftarkan file definisi tugas: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region region` 

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Di panel navigasi, pilih **Definisi Tugas** dan kemudian pilih `firelens-example-multiline` keluarga karena kami mendaftarkan definisi tugas ke keluarga ini di baris pertama definisi tugas di atas.

1. Pilih versi terbaru. 

1. Pilih **tugas **Deploy**, Run**. 

1. Pada halaman **Jalankan Tugas**, Untuk **Cluster**, pilih cluster, dan kemudian di bawah **Jaringan**, untuk **Subnet**, pilih subnet yang tersedia untuk tugas Anda. 

1. Pilih **Buat**. 

**Verifikasi bahwa pesan log multiline di Amazon CloudWatch tampak digabungkan**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dari panel navigasi, perluas **Log** dan pilih **Grup log**. 

1. Pilih grup `multiline-test/applicatio` log. 

1. Pilih log. Lihat pesan. Baris yang cocok dengan aturan dalam file parser digabungkan dan muncul sebagai pesan tunggal. 

   Cuplikan log berikut menunjukkan baris yang digabungkan dalam satu peristiwa jejak tumpukan Java: 

   ```
   {
       "container_id": "xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)\n    at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)\n    at com.myproject.module.MyProject.someMethod(MyProject.java:10)\n    at com.myproject.module.MyProject.main(MyProject.java:6)",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Cuplikan log berikut menunjukkan bagaimana pesan yang sama muncul hanya dengan satu baris jika Anda menjalankan wadah Amazon ECS yang tidak dikonfigurasi untuk menggabungkan pesan log multiline. 

   ```
   {
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   }
   ```

### Contoh: Gunakan parser bawaan Fluent Bit
<a name="fluent-bit-parser"></a>

Dalam contoh ini, Anda akan menyelesaikan langkah-langkah berikut: 

1. Buat dan unggah gambar untuk wadah Fluent Bit. 

1. Buat dan unggah gambar untuk aplikasi multiline demo yang berjalan, gagal, dan menghasilkan jejak tumpukan multiline.

1. Buat definisi tugas dan jalankan tugas. 

1. Lihat log untuk memverifikasi bahwa pesan yang menjangkau beberapa baris tampak digabungkan. 

**Buat dan unggah gambar untuk wadah Fluent Bit**

Gambar ini akan menyertakan file konfigurasi yang mereferensikan parser Fluent Bit. 

1. Buat folder dengan nama`FluentBitDockerImage`. 

1. Di dalam `FluentBitDockerImage` folder, buat file konfigurasi khusus yang mereferensikan file parser bawaan Fluent Bit.

   Untuk informasi selengkapnya tentang file konfigurasi kustom, lihat [Menentukan file konfigurasi kustom](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) di Panduan *Pengembang Layanan Amazon Elastic Container* 

   1. Tempel konten berikut dalam file:

      ```
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      go
      ```

   1. Simpan file sebagai `extra.conf`. 

1. Di dalam `FluentBitDockerImage` folder, buat Dockerfile dengan gambar Fluent Bit dan parser dan file konfigurasi yang Anda buat.

   1. Tempel konten berikut dalam file:

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      ADD extra.conf /extra.conf
      ```

   1. Simpan file sebagai `Dockerfile`.

1. Menggunakan Dockerfile, buat gambar Fluent Bit kustom dengan file konfigurasi khusus yang disertakan.
**catatan**  
Anda dapat menempatkan file konfigurasi di mana saja di gambar Docker kecuali `/fluent-bit/etc/fluent-bit.conf` karena jalur file ini digunakan oleh FireLens.

   1. Bangun gambar: `docker build -t fluent-bit-multiline-image.`

      Dimana: `fluent-bit-multiline-image` adalah nama untuk gambar dalam contoh ini.

   1. Verifikasi bahwa gambar telah dibuat dengan benar: `docker images —filter reference=fluent-bit-multiline-image` 

      Jika berhasil, output menunjukkan gambar dan `latest` tag.

1. Unggah gambar Fluent Bit kustom ke Amazon Elastic Container Registry.

   1. Buat repositori Amazon ECR untuk menyimpan gambar: `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Dimana: `fluent-bit-multiline-repo` adalah nama untuk repositori dan `us-east-1` merupakan wilayah dalam contoh ini. 

      Output memberi Anda rincian repositori baru. 

   1. Tandai gambar Anda dengan `repositoryUri` nilai dari output sebelumnya: `docker tag fluent-bit-multiline-image repositoryUri` 

      Contoh: `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Jalankan docker image untuk memverifikasi itu berjalan dengan benar: `docker images —filter reference=repositoryUri`

      Dalam output, nama repositori berubah dari fluent-bit-multiline-repo ke. `repositoryUri`

   1. Otentikasi ke Amazon ECR dengan menjalankan `aws ecr get-login-password` perintah dan menentukan ID registri yang ingin Anda autentikasi: `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Contoh: `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Pesan login yang berhasil muncul.

   1. Dorong gambar ke Amazon ECR: `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Contoh: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Membangun dan meng-upload gambar untuk aplikasi demo multiline**

Gambar ini akan mencakup file skrip Python yang menjalankan aplikasi dan file log sampel. 

1. Buat folder bernama`multiline-app`: `mkdir multiline-app` 

1. Buat file skrip Python.

   1. Di dalam `multiline-app` folder, buat file dan beri nama`main.py`.

   1. Tempel konten berikut dalam file:

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Simpan file `main.py`.

1. Buat file log sampel. 

   1. Di dalam `multiline-app` folder, buat file dan beri nama`test.log`.

   1. Tempel konten berikut dalam file:

      ```
      panic: my panic
      
      goroutine 4 [running]:
      panic(0x45cb40, 0x47ad70)
        /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c
      main.main.func1(0xc420024120)
        foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1
      created by main.main
        foo.go:5 +0x58
      
      goroutine 1 [chan receive]:
      runtime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c
      runtime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e
      runtime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)
        /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4
      runtime.chanrecv1(0xc420024120, 0x0)
        /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b
      main.main()
        foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef
      runtime.main()
        /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1
      
      goroutine 2 [force gc (idle)]:
      runtime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c
      runtime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e
      runtime.forcegchelper()
        /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1
      created by runtime.init.4
        /usr/local/go/src/runtime/proc.go:227 +0x35
      
      goroutine 3 [GC sweep wait]:
      runtime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c
      runtime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e
      runtime.bgsweep(0xc42001e150)
        /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1
      created by runtime.gcenable
        /usr/local/go/src/runtime/mgc.go:216 +0x58
      one more line, no multiline
      ```

   1. Simpan file `test.log`.

1. Di dalam `multiline-app` folder, buat Dockerfile.

   1. Tempel konten berikut dalam file:

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Simpan file `Dockerfile`.

1. Menggunakan Dockerfile, buat gambar.

   1. Bangun gambar: `docker build -t multiline-app-image `

      Dimana: `multiline-app-image` adalah nama untuk gambar dalam contoh ini.

   1. Verifikasi bahwa gambar telah dibuat dengan benar: `docker images —filter reference=multiline-app-image` 

      Jika berhasil, output menunjukkan gambar dan `latest` tag.

1. Unggah gambar ke Amazon Elastic Container Registry.

   1. Buat repositori Amazon ECR untuk menyimpan gambar: `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Dimana: `multiline-app-repo` adalah nama untuk repositori dan `us-east-1` merupakan wilayah dalam contoh ini. 

      Output memberi Anda rincian repositori baru. Perhatikan `repositoryUri` nilainya karena Anda akan membutuhkannya di langkah selanjutnya. 

   1. Tandai gambar Anda dengan `repositoryUri` nilai dari output sebelumnya: `docker tag multiline-app-image repositoryUri` 

      Contoh: `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Jalankan docker image untuk memverifikasi itu berjalan dengan benar: `docker images —filter reference=repositoryUri`

      Dalam output, nama repositori berubah dari `multiline-app-repo` ke nilai. `repositoryUri`

   1. Dorong gambar ke Amazon ECR: `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Contoh: `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Buat definisi tugas dan jalankan tugas**

1. Buat file definisi tugas dengan nama file`multiline-task-definition.json`. 

1. Tempel konten berikut dalam `multiline-task-definition.json` file: 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Ganti yang berikut ini dalam definisi `multiline-task-definition.json` tugas:

   1. `task role ARN`

      Untuk menemukan peran tugas ARN, buka konsol IAM. Pilih **Peran** dan temukan peran `ecs-task-role-for-firelens` tugas yang Anda buat. Pilih peran dan salin **ARN** yang muncul di bagian **Ringkasan**.

   1. `execution role ARN`

      Untuk menemukan peran eksekusi ARN, buka konsol IAM. Pilih **Peran** dan temukan `ecsTaskExecutionRole` perannya. Pilih peran dan salin **ARN** yang muncul di bagian **Ringkasan**.

   1. `aws_account_id`

      Untuk menemukan Anda`aws_account_id`, masuk ke Konsol Manajemen AWS. Pilih nama pengguna Anda di kanan atas dan salin ID Akun Anda.

   1. `us-east-1`

      Ganti wilayah jika perlu.

1. Daftarkan file definisi tugas: `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region us-east-1` 

1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).

1. Di panel navigasi, pilih **Definisi Tugas** dan kemudian pilih `firelens-example-multiline` keluarga karena kami mendaftarkan definisi tugas ke keluarga ini di baris pertama definisi tugas di atas.

1. Pilih versi terbaru. 

1. Pilih **tugas **Deploy**, Run**. 

1. Pada halaman **Jalankan Tugas**, Untuk **Cluster**, pilih cluster, dan kemudian di bawah **Jaringan**, untuk **Subnet**, pilih subnet yang tersedia untuk tugas Anda. 

1. Pilih **Buat**. 

**Verifikasi bahwa pesan log multiline di Amazon CloudWatch tampak digabungkan**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dari panel navigasi, perluas **Log** dan pilih **Grup log**. 

1. Pilih grup `multiline-test/applicatio` log. 

1. Pilih log dan lihat pesan. Baris yang cocok dengan aturan dalam file parser digabungkan dan muncul sebagai pesan tunggal. 

   Cuplikan log berikut menunjukkan jejak tumpukan Go yang digabungkan menjadi satu peristiwa: 

   ```
   {
       "log": "panic: my panic\n\ngoroutine 4 [running]:\npanic(0x45cb40, 0x47ad70)\n  /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c\nmain.main.func1(0xc420024120)\n  foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1\ncreated by main.main\n  foo.go:5 +0x58\n\ngoroutine 1 [chan receive]:\nruntime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c\nruntime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e\nruntime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)\n  /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4\nruntime.chanrecv1(0xc420024120, 0x0)\n  /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b\nmain.main()\n  foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef\nruntime.main()\n  /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1\n\ngoroutine 2 [force gc (idle)]:\nruntime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c\nruntime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e\nruntime.forcegchelper()\n  /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1\ncreated by runtime.init.4\n  /usr/local/go/src/runtime/proc.go:227 +0x35\n\ngoroutine 3 [GC sweep wait]:\nruntime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c\nruntime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e\nruntime.bgsweep(0xc42001e150)\n  /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1\ncreated by runtime.gcenable\n  /usr/local/go/src/runtime/mgc.go:216 +0x58",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   Cuplikan log berikut menunjukkan bagaimana peristiwa yang sama muncul jika Anda menjalankan wadah ECS yang tidak dikonfigurasi untuk menggabungkan pesan log multiline. Bidang log berisi satu baris.

   ```
   {
       "log": "panic: my panic",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   ```

**catatan**  
Jika log Anda masuk ke file log alih-alih output standar, kami sarankan untuk menentukan parameter `multiline.parser` dan `multiline.key_content` konfigurasi di [plugin input Tail](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-support) alih-alih Filter.

# Menyebarkan Fluent Bit di Amazon ECS Windows container
<a name="tutorial-deploy-fluentbit-on-windows"></a>

Fluent Bit adalah prosesor log dan router yang cepat dan fleksibel yang didukung oleh berbagai sistem operasi. Ini dapat digunakan untuk merutekan log ke berbagai AWS tujuan seperti Amazon CloudWatch Log, Firehose Amazon S3, dan Amazon Service. OpenSearch Fluent Bit mendukung solusi mitra umum seperti [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/), dan server HTTP kustom. Untuk informasi lebih lanjut tentang Fluent Bit, lihat [https://fluentbit.io/](https://fluentbit.io/)situs web.

Gambar **AWS for Fluent Bit** tersedia di Amazon ECR di Galeri Publik Amazon ECR dan di repositori ECR Amazon di sebagian besar Wilayah untuk ketersediaan tinggi. Untuk informasi lebih lanjut, lihat [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)di GitHub situs web.

Tutorial ini memandu Anda melalui cara menerapkan container Fluent Bit pada instance Windows mereka yang berjalan di Amazon ECS untuk mengalirkan log yang dihasilkan oleh tugas Windows ke Amazon CloudWatch untuk pencatatan terpusat. 

Tutorial ini menggunakan pendekatan berikut:
+ Fluent Bit berjalan sebagai layanan dengan strategi penjadwalan Daemon. Strategi ini memastikan bahwa satu instance Fluent Bit selalu berjalan pada instance container di cluster.
  + Mendengarkan pada port 24224 menggunakan plug-in input forward.
  + Ekspos port 24224 ke host sehingga runtime docker dapat mengirim log ke Fluent Bit menggunakan port yang terbuka ini.
  + Memiliki konfigurasi yang memungkinkan Fluent Bit untuk mengirim catatan log ke tujuan tertentu.
+ Luncurkan semua wadah tugas Amazon ECS lainnya menggunakan driver logging lancar. Untuk informasi selengkapnya, lihat [Driver logging fluentd di situs](https://docs.docker.com/engine/logging/drivers/fluentd/) web dokumentasi Docker.
  + Docker terhubung ke soket TCP 24224 di localhost di dalam namespace host.
  + Agen Amazon ECS menambahkan label ke wadah yang mencakup nama cluster, nama keluarga definisi tugas, nomor revisi definisi tugas, ARN tugas, dan nama penampung. Informasi yang sama ditambahkan ke catatan log menggunakan opsi label dari driver logging docker fluentd. Untuk informasi selengkapnya, lihat [label, labels-regex, env, dan env-regex di situs web dokumentasi](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) Docker.
  + Karena `async` opsi driver logging fluentd disetel ke`true`, ketika wadah Fluent Bit dimulai ulang, docker menyangga log hingga wadah Fluent Bit dimulai ulang. Anda dapat meningkatkan batas buffer dengan mengatur fluentd-buffer-limit opsi. Untuk informasi selengkapnya, lihat [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit)di situs web dokumentasi Docker.

 Alur kerja adalah sebagai berikut:
+ Kontainer Fluent Bit dimulai dan mendengarkan pada port 24224 yang diekspos ke host.
+ Fluent Bit menggunakan kredenal peran IAM tugas yang ditentukan dalam definisi tugasnya.
+ Tugas lain yang diluncurkan pada instance yang sama menggunakan driver logging docker fluentd untuk terhubung ke wadah Fluent Bit pada port 24224. 
+ Saat wadah aplikasi menghasilkan log, docker runtime menandai catatan tersebut, menambahkan metadata tambahan yang ditentukan dalam label, dan kemudian meneruskannya di port 24224 di namespace host. 
+ Fluent Bit menerima catatan log pada port 24224 karena terkena namespace host.
+ Fluent Bit melakukan pemrosesan internal dan merutekan log seperti yang ditentukan.

Tutorial ini menggunakan konfigurasi CloudWatch Fluent Bit default yang melakukan hal berikut:
+ Membuat grup log baru untuk setiap cluster dan keluarga definisi tugas.
+ Membuat aliran log baru untuk setiap wadah tugas di grup log yang dihasilkan di atas setiap kali tugas baru diluncurkan. Setiap aliran akan ditandai dengan id tugas tempat wadah berada.
+ Menambahkan metadata tambahan termasuk nama cluster, ARN tugas, nama wadah tugas, keluarga definisi tugas, dan nomor revisi definisi tugas di setiap entri log.

  Misalnya, jika Anda memiliki `task_1` dengan `container_1` dan `container_2` dan t `ask_2` dengan`container_3`, maka berikut ini adalah aliran CloudWatch log:
  + `/aws/ecs/windows.ecs_task_1`

    `task-out.TASK_ID.container_1`

    `task-out.TASK_ID.container_2`
  + `/aws/ecs/windows.ecs_task_2`

    `task-out.TASK_ID.container_3`

**catatan**  
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Prasyarat
](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [

## Langkah 1: Buat peran akses IAM
](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [

## Langkah 2: Buat instance penampung Amazon ECS Windows
](#tutorial-deploy-fluentbit-on-windows-instance)
+ [

## Langkah 3: Konfigurasikan Bit Lancar
](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [

## Langkah 4: Daftarkan definisi tugas Windows Fluent Bit yang merutekan log CloudWatch
](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [

## Langkah 5: Jalankan definisi `ecs-windows-fluent-bit` tugas sebagai layanan Amazon ECS menggunakan strategi penjadwalan daemon
](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [

## Langkah 6: Daftarkan definisi tugas Windows yang menghasilkan log
](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [

## Langkah 7: Jalankan definisi `windows-app-task` tugas
](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [

## Langkah 8: Verifikasi log CloudWatch
](#tutorial-deploy-fluentbit-on-windows-verify)
+ [

## Langkah 9: Membersihkan
](#tutorial-deploy-fluentbit-on-windows-cleanup)

## Prasyarat
<a name="tutorial-deploy-fluentbit-on-windows-prereqs"></a>

Tutorial ini mengasumsikan bahwa prasyarat berikut telah diselesaikan:
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Gambar `aws-for-fluent-bit` kontainer tersedia untuk sistem operasi Windows berikut:
  + Windows Server 2019 Core
  + Windows Server 2019 Full
  + Windows Server 2022 Inti
  + Windows Server 2022 Lengkap
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah diselesaikan.
+ Anda memiliki cluster. Dalam tutorial ini, nama cluster adalah **FluentBit-cluster**.
+ Anda memiliki VPC dengan subnet publik tempat instans EC2 akan diluncurkan. Anda dapat menggunakan VPC default Anda. Anda juga dapat menggunakan subnet pribadi yang memungkinkan CloudWatch titik akhir Amazon mencapai subnet. Untuk informasi selengkapnya tentang CloudWatch titik akhir Amazon, lihat [ CloudWatch titik akhir dan kuota Amazon](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) di. *Referensi Umum AWS* Untuk informasi tentang cara menggunakan wizard VPC Amazon untuk membuat VPC, lihat. [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc)

## Langkah 1: Buat peran akses IAM
<a name="tutorial-deploy-fluentbit-on-windows-iam-access-role"></a>

Buat peran Amazon ECS IAM.

1.  Buat peran instans penampung Amazon ECS bernama "ecsInstanceRole”. Untuk informasi selengkapnya, lihat peran [IAM instans penampung Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).

1. Buat peran IAM untuk tugas Fluent Bit bernama. `fluentTaskRole` Untuk informasi selengkapnya, lihat [Peran IAM tugas Amazon ECS](task-iam-roles.md).

    Izin IAM yang diberikan dalam peran IAM ini diasumsikan oleh wadah tugas. Untuk memungkinkan Bit Lancar mengirim log CloudWatch, Anda harus melampirkan izin berikut ke peran IAM tugas.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }
   ```

------

1. Lampirkan kebijakan pada peran tersebut.

   1. Simpan konten di atas dalam file bernama`fluent-bit-policy.json`.

   1. Jalankan perintah berikut untuk melampirkan kebijakan inline ke peran `fluentTaskRole` IAM.

      ```
      aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
      ```

## Langkah 2: Buat instance penampung Amazon ECS Windows
<a name="tutorial-deploy-fluentbit-on-windows-instance"></a>

Buat instance penampung Amazon ECS Windows.

**Untuk membuat instans Amazon ECS**

1. Gunakan `aws ssm get-parameters` perintah untuk mengambil ID AMI untuk Wilayah yang menghosting VPC Anda. Untuk informasi selengkapnya, lihat [Mengambil metadata AMI yang dioptimalkan Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).

1. Gunakan konsol Amazon EC2 untuk meluncurkan instans.

   1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)

   1. Dari bilah navigasi, pilih Wilayah untuk digunakan.

   1. Dari **Dasbor EC2**, pilih **Meluncurkan instans**.

   1. Untuk **Nama**, masukkan nama unik.

   1. Untuk **Gambar Aplikasi dan OS (Amazon Machine Image)**, pilih AMI yang Anda ambil pada langkah pertama.

   1. Untuk **jenis Instance**, pilih`t3.xlarge`.

   1. Untuk **Key pair (login)**, pilih key pair. 

   1. Di bawah **Pengaturan jaringan**, untuk **grup Keamanan**, pilih grup keamanan yang ada, atau buat yang baru.

   1. **Di bawah **Pengaturan jaringan**, untuk **Auto-assign IP Publik**, pilih Aktifkan.** 

   1. Di bawah **Detail lanjutan**, untuk **profil instans IAM**, pilih **ecsInstanceRole**.

   1. Konfigurasikan instans penampung Amazon ECS Anda dengan data pengguna berikut. Di bawah **Detail Lanjutan**, tempelkan skrip berikut ke bidang **Data pengguna**, ganti *cluster\$1name* dengan nama cluster Anda.

      ```
      <powershell>
      Import-Module ECSTools
      Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
      </powershell>
      ```

   1. Saat Anda siap, pilih bidang pengakuan, lalu pilih **Luncurkan Instans**. 

   1. Halaman konfirmasi memberi tahu Anda bahwa instans Anda akan diluncurkan. Pilih **Lihat Instans** untuk menutup halaman konfirmasi dan kembali ke konsol tersebut.

## Langkah 3: Konfigurasikan Bit Lancar
<a name="tutorial-deploy-fluentbit-on-windows-configure-fluentbit"></a>

Anda dapat menggunakan konfigurasi default berikut yang disediakan oleh AWS untuk memulai dengan cepat:
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf) yang didasarkan pada plug-in Fluent Bit untuk [Amazon CloudWatch](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) pada Manual Resmi *Fluent Bit*.

Atau, Anda dapat menggunakan konfigurasi default lain yang disediakan oleh AWS. Untuk informasi selengkapnya, lihat [Mengganti titik masuk untuk gambar Windows di situs web Github](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image)`aws-for-fluent-bit`.

Konfigurasi Amazon CloudWatch Fluent Bit default ditunjukkan di bawah ini.

Ganti variabel berikut:
+ *region*dengan Wilayah tempat Anda ingin mengirim CloudWatch log Amazon.

```
[SERVICE]
    Flush               5
    Log_Level           info
    Daemon              off

[INPUT]
    Name                forward
    Listen              0.0.0.0
    Port                24224
    Buffer_Chunk_Size   1M
    Buffer_Max_Size     6M
    Tag_Prefix          ecs.

# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
    Name                modify
    Match               ecs.*
    Rename              com.amazonaws.ecs.cluster ecs_cluster
    Rename              com.amazonaws.ecs.container-name ecs_container_name
    Rename              com.amazonaws.ecs.task-arn ecs_task_arn
    Rename              com.amazonaws.ecs.task-definition-family ecs_task_definition_family
    Rename              com.amazonaws.ecs.task-definition-version ecs_task_definition_version

[FILTER]
    Name                rewrite_tag
    Match               ecs.*
    Rule                $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$  out.$3.$ecs_container_name false
    Emitter_Name        re_emitted

[OUTPUT]
    Name                cloudwatch_logs
    Match               out.*
    region              region
    log_group_name      fallback-group
    log_group_template  /aws/ecs/$ecs_cluster.$ecs_task_definition_family
    log_stream_prefix   task-
    auto_create_group   On
```

Setiap log yang masuk ke Fluent Bit memiliki tag yang Anda tentukan, atau dibuat secara otomatis ketika Anda tidak menyediakannya. Tag dapat digunakan untuk merutekan log yang berbeda ke tujuan yang berbeda. Untuk informasi tambahan, lihat [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) di *Manual Resmi Fluent Bit*. 

Konfigurasi Fluent Bit yang dijelaskan di atas memiliki properti berikut:
+ Plug-in input maju mendengarkan lalu lintas masuk pada port TCP 24224. 
+ Setiap entri log yang diterima pada port tersebut memiliki tag yang dimodifikasi oleh plug-in input forward untuk mengawali catatan dengan string. `ecs.` 
+ Pipeline internal Fluent Bit merutekan entri log untuk memodifikasi filter menggunakan regex Match. Filter ini menggantikan kunci dalam catatan log JSON ke format yang dapat dikonsumsi Fluent Bit. 
+ Entri log yang dimodifikasi kemudian dikonsumsi oleh filter rewrite\$1tag. Filter ini mengubah tag catatan log ke format keluar. *TASK\$1ID*. *CONTAINER\$1NAME*. 
+ Tag baru akan dirutekan ke plug-in cloudwatch\$1logs keluaran yang membuat grup log dan aliran seperti yang dijelaskan sebelumnya dengan menggunakan opsi dan plug-in keluaran. `log_group_template` `log_stream_prefix` CloudWatch Untuk informasi tambahan, lihat [Parameter konfigurasi](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) di *Manual Resmi Bit Lancar*. 

## Langkah 4: Daftarkan definisi tugas Windows Fluent Bit yang merutekan log CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-register-task-definition"></a>

Daftarkan definisi tugas Windows Fluent Bit yang merutekan log ke CloudWatch.

**catatan**  
Definisi tugas ini mengekspos port kontainer Fluent Bit 24224 ke port host 24224. Pastikan port ini tidak terbuka di grup keamanan instans EC2 Anda untuk mencegah akses dari luar.

**Untuk mendaftarkan ketentuan tugas**

1. Buat file yang diberi nama `fluent-bit.json` dengan konten berikut ini.

   Ganti variabel berikut:
   + *task-iam-role*dengan Nama Sumber Daya Amazon (ARN) dari peran IAM tugas Anda
   + *region*dengan Wilayah tempat tugas Anda berjalan

   ```
   {
     "family": "ecs-windows-fluent-bit",
     "taskRoleArn": "task-iam-role",
     "containerDefinitions": [
       {
         "name": "fluent-bit",
         "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
         "cpu": 512,
         "portMappings": [
           {
             "hostPort": 24224,
             "containerPort": 24224,
             "protocol": "tcp"
           }
         ],
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
         ],
         "environment": [
           {
             "name": "AWS_REGION",
             "value": "region"
           }
         ],
         "memory": 512,
         "essential": true,
         "logConfiguration": {
           "logDriver": "awslogs",
           "options": {
             "awslogs-group": "/ecs/fluent-bit-logs",
             "awslogs-region": "region",
             "awslogs-stream-prefix": "flb",
             "awslogs-create-group": "true"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Jalankan perintah berikut untuk mendaftarkan definisi tugas.

   ```
   aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
   ```

   Anda dapat membuat daftar definisi tugas untuk akun Anda dengan menjalankan `list-task-definitions` perintah. Output menampilkan nilai keluarga dan revisi yang dapat Anda gunakan bersama dengan `run-task` atau`start-task`.

## Langkah 5: Jalankan definisi `ecs-windows-fluent-bit` tugas sebagai layanan Amazon ECS menggunakan strategi penjadwalan daemon
<a name="tutorial-deploy-fluentbit-on-windows-run-task"></a>

Setelah Anda mendaftarkan definisi tugas untuk akun Anda, Anda dapat menjalankan tugas di klaster. Untuk tutorial ini, Anda menjalankan satu contoh definisi `ecs-windows-fluent-bit:1` tugas di `FluentBit-cluster` cluster Anda. Jalankan tugas dalam layanan yang menggunakan strategi penjadwalan daemon, yang memastikan bahwa satu instance Fluent Bit selalu berjalan pada setiap instance container Anda.

**Untuk menjalankan tugas**

1. Jalankan perintah berikut untuk memulai definisi `ecs-windows-fluent-bit:1` tugas (terdaftar pada langkah sebelumnya) sebagai layanan.
**catatan**  
Definisi tugas ini menggunakan driver `awslogs` logging, instance container Anda harus memiliki izin yang diperlukan.

   Ganti variabel berikut:
   + *region*dengan Wilayah tempat layanan Anda berjalan

   ```
   aws ecs create-service \
       --cluster FluentBit-cluster \
       --service-name FluentBitForwardDaemonService \
       --task-definition ecs-windows-fluent-bit:1 \
       --launch-type EC2 \
       --scheduling-strategy DAEMON \
       --region region
   ```

1. Jalankan perintah berikut untuk membuat daftar tugas Anda.

   Ganti variabel berikut:
   + *region*dengan Wilayah tempat tugas layanan Anda berjalan

   ```
   aws ecs list-tasks --cluster FluentBit-cluster --region region
   ```

## Langkah 6: Daftarkan definisi tugas Windows yang menghasilkan log
<a name="tutorial-deploy-fluentbit-on-windows-register-task-def-logs"></a>

Daftarkan definisi tugas yang menghasilkan log. Definisi tugas ini menyebarkan gambar kontainer Windows yang akan menulis angka tambahan untuk `stdout` setiap detik.

Definisi tugas menggunakan driver logging lancar yang terhubung ke port 24224 yang didengarkan oleh plug-in Fluent Bit. Agen Amazon ECS memberi label pada setiap wadah Amazon ECS dengan tag termasuk nama cluster, ARN tugas, nama keluarga definisi tugas, nomor revisi definisi tugas, dan nama wadah tugas. Label nilai kunci ini diteruskan ke Fluent Bit.

**catatan**  
Tugas ini menggunakan mode `default` jaringan. Namun, Anda juga dapat menggunakan mode `awsvpc` jaringan dengan tugas tersebut.

**Untuk mendaftarkan ketentuan tugas**

1. Buat file yang diberi nama `windows-app-task.json` dengan konten berikut ini.

   ```
   {
     "family": "windows-app-task",
     "containerDefinitions": [
       {
         "name": "sample-container",
         "image": "mcr.microsoft.com/windows/servercore:ltsc2019",
         "cpu": 512,
         "memory": 512,
         "essential": true,
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
         ],
         "logConfiguration": {
           "logDriver": "fluentd",
           "options": {
             "fluentd-address": "localhost:24224",
             "tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
             "fluentd-async": "true",
             "labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Jalankan perintah berikut untuk mendaftarkan definisi tugas.

   Ganti variabel berikut:
   + *region*dengan Wilayah tempat tugas Anda berjalan

   ```
   aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
   ```

   Anda dapat membuat daftar definisi tugas untuk akun Anda dengan menjalankan `list-task-definitions` perintah. Output menampilkan nilai keluarga dan revisi yang dapat Anda gunakan bersama dengan `run-task` atau`start-task`.

## Langkah 7: Jalankan definisi `windows-app-task` tugas
<a name="tutorial-deploy-fluentbit-on-windows-run-task-fluentbit"></a>

Setelah Anda mendaftarkan definisi `windows-app-task` tugas, jalankan di `FluentBit-cluster` cluster Anda.

**Untuk menjalankan tugas**

1. Jalankan definisi `windows-app-task:1` tugas yang Anda daftarkan di langkah sebelumnya.

   Ganti variabel berikut:
   + *region*dengan Wilayah tempat tugas Anda berjalan

   ```
   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
   ```

1. Jalankan perintah berikut untuk membuat daftar tugas Anda.

   ```
   aws ecs list-tasks --cluster FluentBit-cluster
   ```

## Langkah 8: Verifikasi log CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-verify"></a>

Untuk memverifikasi penyiapan Fluent Bit Anda, periksa grup log berikut di CloudWatch konsol:
+ `/ecs/fluent-bit-logs`- Ini adalah grup log yang sesuai dengan wadah daemon Fluent Bit yang berjalan pada instance container.
+ `/aws/ecs/FluentBit-cluster.windows-app-task`- Ini adalah grup log yang sesuai dengan semua tugas yang diluncurkan untuk keluarga definisi `windows-app-task` tugas di dalam `FluentBit-cluster` cluster.

   `task-out.FIRST_TASK_ID.sample-container`- Aliran log ini berisi semua log yang dihasilkan oleh contoh pertama tugas dalam wadah tugas sample-container. 

  `task-out.SECOND_TASK_ID.sample-container`- Aliran log ini berisi semua log yang dihasilkan oleh instance kedua tugas dalam wadah tugas sample-container. 

 Aliran `task-out.TASK_ID.sample-container` log memiliki bidang yang mirip dengan berikut ini:

```
{
    "source": "stdout",
    "ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
    "container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
    "ecs_cluster": "FluentBit-cluster",
    "ecs_container_name": "sample-container",
    "ecs_task_definition_version": "1",
    "container_id": "61f5e6EXAMPLE",
    "log": "10",
    "ecs_task_definition_family": "windows-app-task"
}
```

**Untuk memverifikasi pengaturan Fluent Bit**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Pada panel navigasi, pilih **Grup log**. Pastikan Anda berada di Wilayah tempat Anda menerapkan Fluent Bit ke kontainer Anda.

   Dalam daftar grup log di Wilayah AWS, Anda akan melihat yang berikut:
   + `/ecs/fluent-bit-logs`
   + `/aws/ecs/FluentBit-cluster.windows-app-task`

   Jika Anda melihat grup log ini, pengaturan Fluent Bit diverifikasi.

## Langkah 9: Membersihkan
<a name="tutorial-deploy-fluentbit-on-windows-cleanup"></a>

Setelah Anda menyelesaikan tutorial ini, bersihkan sumber daya yang terkait dengannya untuk menghindari biaya yang tidak Anda gunakan. 

**Untuk membersihkan sumber daya tutorial**

1. Hentikan `windows-simple-task` tugas dan `ecs-fluent-bit` tugas. Untuk informasi selengkapnya, lihat [Menghentikan tugas Amazon ECS](standalone-task-stop.md).

1. Jalankan perintah berikut untuk menghapus grup `/ecs/fluent-bit-logs` log. Untuk informasi selengkapnya, tentang menghapus grup log lihat [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)di *AWS Command Line Interface Referensi*.

   ```
   aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
   aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
   ```

1. Jalankan perintah berikut untuk mengakhiri instance.

   ```
   aws ec2 terminate-instances --instance-ids instance-id
   ```

1. Jalankan perintah berikut untuk menghapus peran IAM. 

   ```
   aws iam delete-role --role-name ecsInstanceRole
   aws iam delete-role --role-name fluentTaskRole
   ```

1. Jalankan perintah berikut untuk menghapus cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster FluentBit-cluster
   ```

# Menggunakan gMSA untuk Linux wadah EC2 di Amazon ECS
<a name="linux-gmsa"></a>

Amazon ECS mendukung otentikasi Active Directory untuk container Linux di EC2 melalui jenis akun layanan khusus yang disebut *grup Managed Service Account* (). gMSA

LinuxAplikasi jaringan berbasis, seperti aplikasi .NET Core, dapat menggunakan Active Directory untuk memfasilitasi otentikasi dan manajemen otorisasi antara pengguna dan layanan. Anda dapat menggunakan fitur ini dengan merancang aplikasi yang terintegrasi dengan Active Directory dan berjalan di server yang bergabung dengan domain. Tetapi, karena Linux kontainer tidak dapat digabungkan dengan domain, Anda perlu mengonfigurasi Linux wadah untuk dijalankan. gMSA

LinuxContainer yang berjalan dengan gMSA mengandalkan `credentials-fetcher` daemon yang berjalan pada instans Amazon EC2 host container. Artinya, daemon mengambil gMSA kredensyal dari pengontrol domain Active Directory dan kemudian mentransfer kredensyal ini ke instance container. Untuk informasi selengkapnya tentang akun layanan, lihat [Membuat gMSAs kontainer Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) di situs web Microsoft Learn.

## Pertimbangan-pertimbangan
<a name="linux-gmsa-considerations"></a>

Pertimbangkan hal berikut sebelum Anda gunakan gMSA untuk Linux wadah:
+ Jika kontainer Anda berjalan di EC2, Anda dapat menggunakannya gMSA untuk Windows kontainer dan Linux kontainer. Untuk informasi tentang cara menggunakan gMSA untuk wadah Linux di Fargate, lihat. [Menggunakan gMSA untuk Linux wadah di Fargate](fargate-linux-gmsa.md)
+ Anda mungkin memerlukan Windows komputer yang bergabung dengan domain untuk menyelesaikan prasyarat. Misalnya, Anda mungkin memerlukan Windows komputer yang bergabung dengan domain untuk membuat Active Directory denganPowerShell. gMSA PowerShell Alat Direktur RSAT Aktif hanya tersedia untukWindows. Untuk informasi selengkapnya, lihat [Menginstal alat administrasi Direktori Aktif](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Anda memilih antara **domainless gMSA** dan **menggabungkan setiap instance ke satu** domain. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

  Kemudian, pilih penyimpanan data untuk CredSpec dan opsional, untuk kredensyal pengguna Active Directory untuk domainless. gMSA

  Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif ()CredSpec. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Anda menghasilkan CredSpec file dan kemudian menyimpannya di salah satu opsi CredSpec penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer. Untuk menggunakan metode domainless, bagian opsional dalam CredSpec file dapat menentukan kredensional di salah satu opsi *domainless user credentials*penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonECS/latest/developerguide/linux-gmsa.html)

## Prasyarat
<a name="linux-gmsa-prerequisites"></a>

Sebelum Anda menggunakan fitur gMSA untuk wadah Linux dengan Amazon ECS, pastikan untuk menyelesaikan yang berikut ini:
+ Anda menyiapkan domain Direktori Aktif dengan sumber daya yang ingin diakses oleh kontainer Anda. Amazon ECS mendukung pengaturan berikut:
  + Direktori Directory Service Aktif. Directory Service adalah Direktori Aktif AWS terkelola yang di-host di Amazon EC2. Untuk informasi selengkapnya, lihat [Memulai dengan Microsoft AD yang AWS Dikelola](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) di *Panduan AWS Directory Service Administrasi*.
  + Direktori Aktif lokal. Anda harus memastikan bahwa instans penampung Amazon ECS Linux dapat bergabung dengan domain. Untuk informasi selengkapnya, lihat [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html).
+ Anda memiliki gMSA akun yang ada di Direktori Aktif. Untuk informasi selengkapnya, lihat [Menggunakan gMSA untuk Linux wadah EC2 di Amazon ECS](#linux-gmsa).
+ Anda menginstal dan menjalankan `credentials-fetcher` daemon pada instance container Amazon ECS Linux. Anda juga menambahkan kumpulan kredensil awal ke `credentials-fetcher` daemon untuk mengautentikasi dengan Active Directory.
**catatan**  
`credentials-fetcher`Daemon hanya tersedia untuk Amazon Linux 2023 dan Fedora 37 dan yang lebih baru. Daemon tidak tersedia untuk Amazon Linux 2. Untuk informasi selengkapnya, lihat [aws/credentials-fetcher](https://github.com/aws/credentials-fetcher) di. GitHub
+ Anda mengatur kredensyal untuk `credentials-fetcher` daemon untuk mengautentikasi dengan Active Directory. Kredensialnya harus menjadi anggota grup keamanan Active Directory yang memiliki akses ke akun. gMSA Ada beberapa opsi di[Putuskan apakah Anda ingin menggabungkan instance ke domain, atau menggunakan gMSA domainless.](#linux-gmsa-initial-creds).
+ Anda menambahkan izin IAM yang diperlukan. Izin yang diperlukan bergantung pada metode yang Anda pilih untuk kredensyal awal dan untuk menyimpan spesifikasi kredensialnya:
  + Jika Anda menggunakan *domainless gMSA* untuk kredensyal awal, izin IAM untuk AWS Secrets Manager diperlukan pada peran eksekusi tugas.
  + Jika Anda menyimpan spesifikasi kredensyal di SSM Parameter Store, izin IAM untuk Amazon EC2 Systems Manager Parameter Store diperlukan pada peran eksekusi tugas.
  + Jika Anda menyimpan spesifikasi kredensyal di Amazon S3, izin IAM untuk Amazon Simple Storage Service diperlukan pada peran eksekusi tugas.

## Menyiapkan Linux Kontainer gMSA berkemampuan di Amazon ECS
<a name="linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Siapkan infrastruktur**  
Langkah-langkah berikut adalah pertimbangan dan pengaturan yang dilakukan sekali. Setelah menyelesaikan langkah-langkah ini, Anda dapat mengotomatiskan pembuatan instance kontainer untuk menggunakan kembali konfigurasi ini.

Putuskan bagaimana kredensyal awal disediakan dan konfigurasikan data pengguna EC2 dalam templat peluncuran EC2 yang dapat digunakan kembali untuk menginstal daemon. `credentials-fetcher`

1. <a name="linux-gmsa-initial-creds"></a>

**Putuskan apakah Anda ingin menggabungkan instance ke domain, atau menggunakan gMSA domainless.**
   + <a name="linux-gmsa-initial-join"></a>

**Bergabunglah dengan instans EC2 ke domain Active Directory**

     
     + <a name="linux-gmsa-initial-join-userdata"></a>

**Bergabunglah dengan instance berdasarkan data pengguna**

       Tambahkan langkah-langkah untuk bergabung dengan domain Active Directory ke data pengguna EC2 Anda dalam template peluncuran EC2. Beberapa grup Amazon EC2 Auto Scaling dapat menggunakan template peluncuran yang sama.

       Anda dapat menggunakan langkah-langkah ini [Bergabung dengan Active Directory atau FreeIPA domain](https://docs.fedoraproject.org/en-US/quick-docs/join-active-directory-freeipa/) di Fedora Docs.
   + <a name="linux-gmsa-initial-domainless"></a>

**Jadikan pengguna Active Directory untuk domainless gMSA**

     `credentials-fetcher`*Daemon memiliki fitur yang disebut domainless. gMSA* Fitur ini memerlukan domain, tetapi instans EC2 tidak perlu digabungkan ke domain. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama. Sebagai gantinya, Anda memberikan nama rahasia di AWS Secrets Manager dalam CredSpec file. Rahasianya harus berisi nama pengguna, kata sandi, dan domain untuk masuk.

     Fitur ini didukung dan dapat digunakan dengan wadah Linux dan Windows.

     Fitur ini mirip dengan *gMSA support for non-domain-joined container hosts*fitur. Untuk informasi selengkapnya tentang fitur Windows, lihat [gMSAarsitektur dan peningkatan](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) di situs web Microsoft Learn.

     1. Buat pengguna di domain Active Directory Anda. Pengguna di Active Directory harus memiliki izin untuk mengakses akun gMSA layanan yang Anda gunakan dalam tugas.

     1. Buat rahasia di AWS Secrets Manager, setelah Anda membuat pengguna di Active Directory. Untuk informasi selengkapnya, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

     1. Masukkan nama pengguna, kata sandi, dan domain ke pasangan nilai kunci JSON yang dipanggil`username`, `password` dan`domainName`, masing-masing.

        ```
        {"username":"username","password":"passw0rd", "domainName":"example.com"}
        ```

     1. Tambahkan konfigurasi ke CredSpec file untuk akun layanan. Tambahan `HostAccountConfig` berisi Amazon Resource Name (ARN) dari rahasia di Secrets Manager.

        Pada Windows, `PluginGUID` harus cocok dengan GUID dalam contoh cuplikan berikut. Di Linux, `PluginGUID` itu diabaikan. Ganti `MySecret` dengan contoh dengan Amazon Resource Name (ARN) rahasia Anda.

        ```
            "ActiveDirectoryConfig": {
                "HostAccountConfig": {
                    "PortableCcgVersion": "1",
                    "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
                    "PluginInput": {
                        "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
                    }
                }
        ```

     1. gMSAFitur *tanpa domain* memerlukan izin tambahan dalam peran eksekusi tugas. Ikuti langkahnya[(Opsional) rahasia tanpa domain gMSA](#linux-gmsa-domainless-secret).

1. <a name="linux-gmsa-install"></a>

**Konfigurasikan instance dan instal `credentials-fetcher` daemon**

   Anda dapat menginstal `credentials-fetcher` daemon dengan skrip data pengguna di Template Peluncuran EC2 Anda. Contoh berikut menunjukkan dua jenis data pengguna, `cloud-config` YAML atau bash script. Contoh-contoh ini untuk Amazon Linux 2023 (AL2023). Ganti `MyCluster` dengan nama cluster Amazon ECS yang Anda inginkan untuk bergabung dengan instans ini.
   + <a name="linux-gmsa-install-yaml"></a>

**`cloud-config` YAML**

     ```
     Content-Type: text/cloud-config
     package_reboot_if_required: true
     packages:
       # prerequisites
       - dotnet
       - realmd
       - oddjob
       - oddjob-mkhomedir
       - sssd
       - adcli
       - krb5-workstation
       - samba-common-tools
       # https://github.com/aws/credentials-fetcher gMSA credentials management for containers
       - credentials-fetcher
     write_files:
     # configure the ECS Agent to join your cluster.
     # replace MyCluster with the name of your cluster.
     - path: /etc/ecs/ecs.config
       owner: root:root
       permissions: '0644'
       content: |
         ECS_CLUSTER=MyCluster
         ECS_GMSA_SUPPORTED=true
     runcmd:
     # start the credentials-fetcher daemon and if it succeeded, make it start after every reboot
     - "systemctl start credentials-fetcher"
     - "systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher"
     ```
   + <a name="linux-gmsa-install-userdata"></a>

**bashnaskah**

     Jika Anda lebih nyaman dengan bash skrip dan memiliki beberapa variabel untuk ditulis`/etc/ecs/ecs.config`, gunakan `heredoc` format berikut. Format ini menulis segalanya di antara baris dimulai dengan **cat** dan `EOF` pada file konfigurasi.

     ```
     #!/usr/bin/env bash
     set -euxo pipefail
     
     # prerequisites
     timeout 30 dnf install -y dotnet realmd oddjob oddjob-mkhomedir sssd adcli krb5-workstation samba-common-tools
     # install https://github.com/aws/credentials-fetcher gMSA credentials management for containers
     timeout 30 dnf install -y credentials-fetcher
     
     # start credentials-fetcher
     systemctl start credentials-fetcher
     systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher
     
     cat <<'EOF' >> /etc/ecs/ecs.config
     ECS_CLUSTER=MyCluster
     ECS_GMSA_SUPPORTED=true
     EOF
     ```

   Ada variabel konfigurasi opsional untuk `credentials-fetcher` daemon yang dapat Anda atur. `/etc/ecs/ecs.config` Kami menyarankan Anda mengatur variabel dalam data pengguna di blok YAMM atau `heredoc` mirip dengan contoh sebelumnya. Melakukannya mencegah masalah dengan konfigurasi sebagian yang dapat terjadi dengan mengedit file beberapa kali. Untuk informasi selengkapnya tentang konfigurasi agen ECS, lihat [Amazon ECS Container Agent](https://github.com/aws/amazon-ecs-agent/blob/master/README.md#environment-variables) on. GitHub
   + Secara opsional, Anda dapat menggunakan variabel `CREDENTIALS_FETCHER_HOST` jika Anda mengubah konfigurasi `credentials-fetcher` daemon untuk memindahkan soket ke lokasi lain.

**Menyiapkan izin dan rahasia**  
Lakukan langkah-langkah berikut sekali untuk setiap aplikasi dan setiap definisi tugas. Kami menyarankan Anda menggunakan praktik terbaik untuk memberikan hak istimewa paling sedikit dan mempersempit izin yang digunakan dalam kebijakan. Dengan cara ini, setiap tugas hanya dapat membaca rahasia yang dibutuhkannya.

1. <a name="linux-gmsa-domainless-secret"></a>

**(Opsional) rahasia tanpa domain gMSA**

   Jika Anda menggunakan metode domainless di mana instance tidak bergabung dengan domain, ikuti langkah ini.

   Anda harus menambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas. Melakukan hal itu memberikan akses `credentials-fetcher` daemon ke rahasia Secrets Manager. Ganti `MySecret` contoh dengan Amazon Resource Name (ARN) rahasia Anda dalam daftar. `Resource`

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret-AbCdEf"
           }
       ]
   }
   ```

------
**catatan**  
Jika Anda menggunakan kunci KMS Anda sendiri untuk mengenkripsi rahasia Anda, Anda harus menambahkan izin yang diperlukan untuk peran ini dan menambahkan peran ini ke kebijakan kunci. AWS KMS 

1. 

**Putuskan apakah Anda menggunakan SSM Parameter Store atau S3 untuk menyimpan CredSpec**

   Amazon ECS mendukung cara-cara berikut untuk mereferensikan jalur file di `credentialSpecs` bidang definisi tugas.

   Jika Anda menggabungkan instance ke satu domain, gunakan awalan `credentialspec:` di awal ARN dalam string. Jika Anda menggunakan domainlessgMSA, maka gunakan. `credentialspecdomainless:`

   Untuk informasi selengkapnya tentang CredSpec, lihat [File spesifikasi kredensi](#linux-gmsa-credentialspec).
   + <a name="linux-gmsa-credspec-s3"></a>

**Bucket Amazon S3**

     Tambahkan spesifikasi kredenal ke bucket Amazon S3. Kemudian, rujuk Nama Sumber Daya Amazon (ARN) dari bucket Amazon S3 di bidang `credentialSpecs` definisi tugas.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Untuk memberikan akses tugas ke bucket S3, tambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas Amazon ECS.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Sid": "VisualEditor",
                 "Effect": "Allow",
                 "Action": [
                     "s3:Get*",
                     "s3:List*"
                 ],
                 "Resource": [
                     "arn:aws:s3:::amzn-s3-demo-bucket",
                     "arn:aws:s3:::amzn-s3-demo-bucket/{object}"
                 ]
             }
         ]
     }
     ```

------
   + <a name="linux-gmsa-credspec-ssm"></a>

**Parameter SSM Menyimpan parameter**

     Tambahkan spesifikasi kredenal ke parameter Penyimpanan Parameter SSM. Kemudian, rujuk Amazon Resource Name (ARN) dari parameter SSM Parameter Store di `credentialSpecs` bidang definisi tugas.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:ssm:aws-region:111122223333:parameter/parameter_name"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Untuk memberikan akses tugas Anda ke parameter Penyimpanan Parameter SSM, tambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas Amazon ECS.

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

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "ssm:GetParameters"
                 ],
                 "Resource": "arn:aws:ssm:us-east-1:123456789012:parameter/my-parameter"
             }
         ]
     }
     ```

------

## File spesifikasi kredensi
<a name="linux-gmsa-credentialspec"></a>

Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif () *CredSpec*. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Linux Anda menghasilkan CredSpec dan mereferensikannya di `credentialSpecs` bidang dalam definisi tugas Anda. CredSpecFile tidak mengandung rahasia apa pun.

Berikut ini adalah contoh CredSpec file.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="linux-gmsa-credentialspec-create"></a>
**MembuatCredSpec**  
Anda membuat CredSpec dengan menggunakan CredSpec PowerShell modul pada Windows komputer yang bergabung dengan domain. Ikuti langkah-langkah dalam [Membuat spesifikasi kredensyal di situs](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) web Microsoft Belajar.

# Menggunakan gMSA untuk Linux wadah di Fargate
<a name="fargate-linux-gmsa"></a>

Amazon ECS mendukung otentikasi Direktori Aktif untuk wadah Linux di Fargate melalui jenis akun layanan khusus yang disebut *grup Akun Layanan Terkelola* (). gMSA

LinuxAplikasi jaringan berbasis, seperti aplikasi .NET Core, dapat menggunakan Active Directory untuk memfasilitasi otentikasi dan manajemen otorisasi antara pengguna dan layanan. Anda dapat menggunakan fitur ini dengan merancang aplikasi yang terintegrasi dengan Active Directory dan berjalan di server yang bergabung dengan domain. Tetapi, karena Linux kontainer tidak dapat digabungkan dengan domain, Anda perlu mengonfigurasi Linux wadah untuk dijalankan. gMSA

## Pertimbangan-pertimbangan
<a name="fargate-linux-gmsa-considerations"></a>

Pertimbangkan hal berikut sebelum Anda gunakan gMSA untuk Linux wadah di Fargate:
+ Anda harus menjalankan Platform Versi 1.4 atau yang lebih baru.
+ Anda mungkin memerlukan Windows komputer yang bergabung dengan domain untuk menyelesaikan prasyarat. Misalnya, Anda mungkin memerlukan Windows komputer yang bergabung dengan domain untuk membuat Active Directory denganPowerShell. gMSA PowerShell Alat Direktur RSAT Aktif hanya tersedia untukWindows. Untuk informasi selengkapnya, lihat [Menginstal alat administrasi Direktori Aktif](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html).
+ Anda harus menggunakan **domainless gMSA**. 

  Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif ()CredSpec. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Anda membuat CredSpec file, dan kemudian menyimpannya di ember Amazon S3.
+ Sebuah tugas hanya dapat mendukung satu Direktori Aktif.

## Prasyarat
<a name="fargate-linux-gmsa-prerequisites"></a>

Sebelum Anda menggunakan fitur gMSA untuk wadah Linux dengan Amazon ECS, pastikan untuk menyelesaikan yang berikut ini:
+ Anda menyiapkan domain Direktori Aktif dengan sumber daya yang ingin diakses oleh kontainer Anda. Amazon ECS mendukung pengaturan berikut:
  + Direktori Directory Service Aktif. Directory Service adalah Direktori Aktif AWS terkelola yang di-host di Amazon EC2. Untuk informasi selengkapnya, lihat [Memulai dengan Microsoft AD yang AWS Dikelola](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) di *Panduan AWS Directory Service Administrasi*.
  + Direktori Aktif lokal. Anda harus memastikan bahwa instans penampung Amazon ECS Linux dapat bergabung dengan domain. Untuk informasi selengkapnya, lihat [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Anda memiliki gMSA akun yang ada di Direktori Aktif dan pengguna yang memiliki izin untuk mengakses akun gMSA layanan. Untuk informasi selengkapnya, lihat [Jadikan pengguna Active Directory untuk domainless gMSA](#fargate-linux-gmsa-initial-domainless).
+ Anda memiliki ember Amazon S3. Lihat informasi yang lebih lengkap di [Membuat bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) dalam *Panduan Pengguna Amazon S3*.

## Menyiapkan Linux Kontainer gMSA berkemampuan di Amazon ECS
<a name="fargate-linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Siapkan infrastruktur**  
Langkah-langkah berikut adalah pertimbangan dan pengaturan yang dilakukan sekali. 
+ <a name="fargate-linux-gmsa-initial-domainless"></a>

**Jadikan pengguna Active Directory untuk domainless gMSA**

  Saat Anda menggunakan domainlessgMSA, penampung tidak bergabung dengan domain. Aplikasi lain yang berjalan di wadah tidak dapat menggunakan kredensyal untuk mengakses domain. Tugas yang menggunakan domain berbeda dapat berjalan pada wadah yang sama. Anda memberikan nama rahasia AWS Secrets Manager dalam CredSpec file. Rahasianya harus berisi nama pengguna, kata sandi, dan domain untuk masuk.

  Fitur ini mirip dengan *gMSA support for non-domain-joined container hosts*fitur. Untuk informasi selengkapnya tentang fitur Windows, lihat [gMSAarsitektur dan peningkatan](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) di situs web Microsoft Learn.

  1. Konfigurasikan pengguna di domain Active Directory Anda. Pengguna di Direktori Aktif harus memiliki izin untuk mengakses akun gMSA layanan yang Anda gunakan dalam tugas.

  1. Anda memiliki VPC dan subnet yang dapat menyelesaikan nama domain Active Directory. Konfigurasikan VPC dengan opsi DHCP dengan nama domain yang menunjuk ke nama layanan Active Directory. Untuk informasi tentang cara mengonfigurasi opsi DHCP untuk VPC, [lihat Set opsi Bekerja dengan DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) di Panduan Pengguna *Amazon Virtual Private Cloud*.

  1. Buat rahasia di AWS Secrets Manager. 

  1. Buat file spesifikasi kredensi.

**Menyiapkan izin dan rahasia**  
Lakukan langkah-langkah berikut satu kali untuk setiap aplikasi dan setiap definisi tugas. Kami menyarankan Anda menggunakan praktik terbaik untuk memberikan hak istimewa paling sedikit dan mempersempit izin yang digunakan dalam kebijakan. Dengan cara ini, setiap tugas hanya dapat membaca rahasia yang dibutuhkannya.

1. Buat pengguna di domain Active Directory Anda. Pengguna di Active Directory harus memiliki izin untuk mengakses akun gMSA layanan yang Anda gunakan dalam tugas.

1. Setelah Anda membuat pengguna Active Directory, buat rahasia di AWS Secrets Manager. Untuk informasi selengkapnya, lihat [Membuat AWS Secrets Manager rahasia](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

1. Masukkan nama pengguna, kata sandi, dan domain ke pasangan nilai kunci JSON yang dipanggil`username`, `password` dan`domainName`, masing-masing.

   ```
   {"username":"username","password":"passw0rd", "domainName":"example.com"}
   ```

1. <a name="fargate-linux-gmsa-domainless-secret"></a>Anda harus menambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas. Melakukan hal itu memberikan akses `credentials-fetcher` daemon ke rahasia Secrets Manager. Ganti `MySecret` contoh dengan Amazon Resource Name (ARN) rahasia Anda dalam daftar. `Resource`

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
               "arn:aws:secretsmanager:us-east-1:111122223333:secret:MySecret"
               ]
           }
       ]
   }
   ```

------
**catatan**  
Jika Anda menggunakan kunci KMS Anda sendiri untuk mengenkripsi rahasia Anda, Anda harus menambahkan izin yang diperlukan untuk peran ini dan menambahkan peran ini ke kebijakan kunci. AWS KMS 

1. <a name="linux-gmsa-credspec-ssm"></a>Tambahkan spesifikasi kredenal ke bucket Amazon S3. Kemudian, rujuk Nama Sumber Daya Amazon (ARN) dari bucket Amazon S3 di bidang `credentialSpecs` definisi tugas.

   ```
   {
       "family": "",
       "executionRoleArn": "",
       "containerDefinitions": [
           {
               "name": "",
               ...
               "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
               ],
               ...
           }
       ],
       ...
   }
   ```

   Untuk memberikan akses tugas ke bucket S3, tambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas Amazon ECS.

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor",
               "Effect": "Allow",
               "Action": [
               "s3:GetObjectVersion",
               "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::{bucket_name}",
                   "arn:aws:s3:::{bucket_name}/{object}"
               ]
           }
       ]
   }
   ```

------

## File spesifikasi kredensi
<a name="fargate-linux-gmsa-credentialspec"></a>

Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif () *CredSpec*. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Linux Anda menghasilkan CredSpec dan mereferensikannya di `credentialSpecs` bidang dalam definisi tugas Anda. CredSpecFile tidak mengandung rahasia apa pun.

Berikut ini adalah contoh CredSpec file.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="fargate-linux-gmsa-credentialspec-create"></a>
**Membuat CredSpec dan mengunggahnya ke Amazon S3**  
Anda membuat CredSpec dengan menggunakan CredSpec PowerShell modul pada Windows komputer yang bergabung dengan domain. Ikuti langkah-langkah dalam [Membuat spesifikasi kredensyal di situs](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) web Microsoft Belajar.

Setelah Anda membuat file spesifikasi kredensi, unggah ke bucket Amazon S3. Salin CredSpec file ke komputer atau lingkungan tempat Anda menjalankan AWS CLI perintah.

Jalankan AWS CLI perintah berikut untuk mengunggah CredSpec ke Amazon S3. Ganti `amzn-s3-demo-bucket` dengan nama bucket Amazon S3 Anda. Anda dapat menyimpan file sebagai objek di bucket dan lokasi mana pun, tetapi Anda harus mengizinkan akses ke bucket dan lokasi tersebut dalam kebijakan yang Anda lampirkan ke peran eksekusi tugas.

Untuk PowerShell, gunakan perintah berikut:

```
$ Write-S3Object -BucketName "amzn-s3-demo-bucket" -Key "ecs-domainless-gmsa-credspec" -File "gmsa-cred-spec.json"
```

 AWS CLI Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. 

```
$ aws s3 cp gmsa-cred-spec.json \
s3://amzn-s3-demo-bucket/ecs-domainless-gmsa-credspec
```

# Menggunakan Amazon ECS Windows container dengan domainless gMSA menggunakan AWS CLI
<a name="tutorial-gmsa-windows"></a>

Tutorial berikut menunjukkan cara membuat tugas Amazon ECS yang menjalankan wadah Windows yang memiliki kredensyal untuk mengakses Active Directory dengan file. AWS CLI Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

**Topics**
+ [

## Prasyarat
](#tutorial-gmsa-windows-prerequisites)
+ [

## Langkah 1: Buat dan konfigurasikan gMSA akun di Layanan Domain Direktori Aktif (AD DS)
](#tutorial-gmsa-windows-step1)
+ [

## Langkah 2: Unggah Kredensial ke Secrets Manager
](#tutorial-gmsa-windows-step2)
+ [

## Langkah 3: Ubah CredSpec JSON Anda untuk menyertakan informasi tanpa domain gMSA
](#tutorial-gmsa-windows-step3)
+ [

## Langkah 4: Unggah CredSpec ke Amazon S3
](#tutorial-gmsa-windows-step4)
+ [

## Langkah 5: (Opsional) Buat cluster Amazon ECS
](#tutorial-gmsa-windows-step5)
+ [

## Langkah 6: Buat peran IAM untuk instance kontainer
](#tutorial-gmsa-windows-step6)
+ [

## Langkah 7: Buat peran eksekusi tugas khusus
](#tutorial-gmsa-windows-step7)
+ [

## Langkah 8: Buat peran tugas untuk Amazon ECS Exec
](#tutorial-gmsa-windows-step8)
+ [

## Langkah 9: Daftarkan definisi tugas yang menggunakan domainless gMSA
](#tutorial-gmsa-windows-step9)
+ [

## Langkah 10: Daftarkan instance wadah Windows ke cluster
](#tutorial-gmsa-windows-step10)
+ [

## Langkah 11: Verifikasi contoh kontainer
](#tutorial-gmsa-windows-step11)
+ [

## Langkah 12: Jalankan tugas Windows
](#tutorial-gmsa-windows-step12)
+ [

## Langkah 13: Verifikasi wadah memiliki gMSA kredensi
](#tutorial-gmsa-windows-step13)
+ [

## Langkah 14: Bersihkan
](#tutorial-gmsa-windows-step14)
+ [

## Debugging Amazon ECS tanpa domain gMSA untuk wadah Windows
](#tutorial-gmsa-windows-debugging)

## Prasyarat
<a name="tutorial-gmsa-windows-prerequisites"></a>

Jika mengikuti tutorial ini, berarti prasyarat berikut telah selesai:
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah selesai.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+  Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya tentang menginstal atau memutakhirkan AWS CLI, lihat [Menginstal. AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
**catatan**  
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).
+ Anda menyiapkan domain Direktori Aktif dengan sumber daya yang ingin diakses oleh kontainer Anda. Amazon ECS mendukung pengaturan berikut:
  + Direktori Directory Service Aktif. Directory Service adalah Direktori Aktif AWS terkelola yang di-host di Amazon EC2. Untuk informasi selengkapnya, lihat [Memulai dengan Microsoft AD yang AWS Dikelola](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) di *Panduan AWS Directory Service Administrasi*.
  + Direktori Aktif lokal. Anda harus memastikan bahwa instans penampung Amazon ECS Linux dapat bergabung dengan domain. Untuk informasi selengkapnya, lihat [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Anda memiliki VPC dan subnet yang dapat menyelesaikan nama domain Active Directory.
+ Anda memilih antara **domainless gMSA** dan **menggabungkan setiap instance ke satu** domain. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

  Kemudian, pilih penyimpanan data untuk CredSpec dan opsional, untuk kredensyal pengguna Active Directory untuk domainless. gMSA

  Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif ()CredSpec. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Anda menghasilkan CredSpec file dan kemudian menyimpannya di salah satu opsi CredSpec penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer. Untuk menggunakan metode domainless, bagian opsional dalam CredSpec file dapat menentukan kredensional di salah satu opsi *domainless user credentials*penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonECS/latest/developerguide/tutorial-gmsa-windows.html)
+ (Opsional) AWS CloudShell adalah alat yang memberi pelanggan baris perintah tanpa perlu membuat instance EC2 mereka sendiri. Untuk informasi lebih lanjut, lihat [Apa itu AWS CloudShell?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dalam *AWS CloudShell User Guide*.

## Langkah 1: Buat dan konfigurasikan gMSA akun di Layanan Domain Direktori Aktif (AD DS)
<a name="tutorial-gmsa-windows-step1"></a>

Buat dan konfigurasikan gMSA akun di domain Active Directory.

**catatan**  
Langkah ini membuat dua akun terpisah: Akun Layanan Terkelola Grup (GMSA) yang menyediakan identitas untuk kontainer Anda, dan akun pengguna biasa yang digunakan untuk otentikasi domain. Akun ini melayani tujuan yang berbeda dan harus memiliki nama yang berbeda.

1. 

**Menghasilkan kunci root Layanan Distribusi Kunci**
**catatan**  
Jika Anda menggunakan Directory Service, maka Anda dapat melewati langkah ini.

   Kunci root dan gMSA izin KDS dikonfigurasi dengan AWS Microsoft AD terkelola Anda.

   Jika Anda belum membuat Akun gMSA Layanan di domain Anda, Anda harus terlebih dahulu membuat kunci root Key Distribution Service (KDS). KDS bertanggung jawab untuk membuat, memutar, dan melepaskan gMSA kata sandi ke host resmi. Ketika `ccg.exe` kebutuhan untuk mengambil gMSA kredensil, itu menghubungi KDS untuk mengambil kata sandi saat ini.

   Untuk memeriksa apakah kunci root KDS telah dibuat, jalankan PowerShell cmdlet berikut dengan hak admin domain pada pengontrol domain menggunakan modul. `ActiveDirectory` PowerShell Untuk informasi selengkapnya tentang modul, lihat [ActiveDirectory Modul](https://learn.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) di situs web Microsoft Learn.

   ```
   PS C:\> Get-KdsRootKey
   ```

   Jika perintah mengembalikan ID kunci, Anda dapat melewati sisa langkah ini. Jika tidak, buat kunci root KDS dengan menjalankan perintah berikut:

   ```
   PS C:\> Add-KdsRootKey -EffectiveImmediately
   ```

   Meskipun argumen `EffectiveImmediately` untuk perintah menyiratkan kunci efektif segera, Anda harus menunggu 10 jam sebelum kunci root KDS direplikasi dan tersedia untuk digunakan pada semua pengontrol domain.

1. 

**Buat gMSA akun**

   Untuk membuat gMSA akun dan memungkinkan `ccg.exe` untuk mengambil gMSA kata sandi, jalankan PowerShell perintah berikut dari Windows Server atau klien dengan akses ke domain. Ganti `ExampleAccount` dengan nama yang Anda inginkan untuk gMSA akun Anda, dan ganti `example-domain` dengan nama domain Active Directory Anda (misalnya, jika domain Anda`contoso.com`, gunakan`contoso`).

   1. 

      ```
      PS C:\> Install-WindowsFeature RSAT-AD-PowerShell
      ```

   1. 

      ```
      PS C:\> New-ADGroup -Name "ExampleAccount Authorized Hosts" -SamAccountName "ExampleAccountHosts" -GroupScope DomainLocal
      ```

   1. 

      ```
      PS C:\> New-ADServiceAccount -Name "ExampleAccount" -DnsHostName "example-domain" -ServicePrincipalNames "host/ExampleAccount", "host/example-domain" -PrincipalsAllowedToRetrieveManagedPassword "ExampleAccountHosts"
      ```

   1. Buat pengguna dengan kata sandi permanen yang tidak kedaluwarsa. Kredensil ini disimpan AWS Secrets Manager dan digunakan oleh setiap tugas untuk bergabung dengan domain. Ini adalah akun pengguna terpisah dari akun GMSA yang dibuat di atas. Ganti `ExampleServiceUser` dengan nama yang Anda inginkan untuk akun pengguna layanan ini.

      ```
      PS C:\> New-ADUser -Name "ExampleServiceUser" -AccountPassword (ConvertTo-SecureString -AsPlainText "Test123" -Force) -Enabled 1 -PasswordNeverExpires 1
      ```

   1. 

      ```
      PS C:\> Add-ADGroupMember -Identity "ExampleAccountHosts" -Members "ExampleServiceUser"
      ```

   1. Instal PowerShell modul untuk membuat CredSpec objek di Active Directory dan output CredSpec JSON.

      ```
      PS C:\> Install-PackageProvider -Name NuGet -Force
      ```

      ```
      PS C:\> Install-Module CredentialSpec
      ```

   1. 

      ```
      PS C:\> New-CredentialSpec -AccountName ExampleAccount
      ```

1. Salin output JSON dari perintah sebelumnya ke dalam file bernama`gmsa-cred-spec.json`. Ini adalah CredSpec filenya. Ini digunakan pada Langkah 3,[Langkah 3: Ubah CredSpec JSON Anda untuk menyertakan informasi tanpa domain gMSA](#tutorial-gmsa-windows-step3).

## Langkah 2: Unggah Kredensial ke Secrets Manager
<a name="tutorial-gmsa-windows-step2"></a>

Salin kredensyal Active Directory ke dalam sistem penyimpanan kredensyal yang aman, sehingga setiap tugas mengambilnya. Ini adalah metode domainlessgMSA. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.
+ Jalankan AWS CLI perintah berikut dan ganti nama pengguna, kata sandi, dan nama domain agar sesuai dengan lingkungan Anda. Gunakan nama akun pengguna layanan (bukan nama akun GMSA) untuk nama pengguna. Simpan ARN rahasia untuk digunakan pada langkah berikutnya, [Langkah 3: Ubah CredSpec JSON Anda untuk menyertakan informasi tanpa domain gMSA](#tutorial-gmsa-windows-step3)

  Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

  ```
  $ aws secretsmanager create-secret \
  --name gmsa-plugin-input \
  --description "Amazon ECS - gMSA Portable Identity." \
  --secret-string "{\"username\":\"ExampleServiceUser\",\"password\":\"Test123\",\"domainName\":\"contoso.com\"}"
  ```

## Langkah 3: Ubah CredSpec JSON Anda untuk menyertakan informasi tanpa domain gMSA
<a name="tutorial-gmsa-windows-step3"></a>

Sebelum mengunggah CredSpec ke salah satu opsi penyimpanan, tambahkan informasi ke CredSpec dengan ARN rahasia di Secrets Manager dari langkah sebelumnya. Untuk informasi selengkapnya, lihat [Konfigurasi spesifikasi kredensyal tambahan untuk kasus penggunaan host non-domain-joined kontainer di situs](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) web Microsoft Learn.

1. Tambahkan informasi berikut ke CredSpec file di dalam file`ActiveDirectoryConfig`. Ganti ARN dengan rahasia di Secrets Manager dari langkah sebelumnya.

   Perhatikan bahwa `PluginGUID` nilai harus cocok dengan GUID dalam contoh cuplikan berikut dan diperlukan.

   ```
   "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Anda juga dapat menggunakan rahasia di SSM Parameter Store dengan menggunakan ARN dalam format ini:. `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`

1. Setelah Anda memodifikasi CredSpec file, itu akan terlihat seperti contoh berikut:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "ExampleAccount",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "example-domain",
       "DnsName": "example-domain",
       "NetBiosName": "example-domain"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         },
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

## Langkah 4: Unggah CredSpec ke Amazon S3
<a name="tutorial-gmsa-windows-step4"></a>



Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. Salin CredSpec file ke komputer atau lingkungan tempat Anda menjalankan AWS CLI perintah.

1. Jalankan AWS CLI perintah berikut untuk mengunggah CredSpec ke Amazon S3. Ganti `MyBucket` dengan nama bucket Amazon S3 Anda. Anda dapat menyimpan file sebagai objek di bucket dan lokasi mana pun, tetapi Anda harus mengizinkan akses ke bucket dan lokasi tersebut dalam kebijakan yang Anda lampirkan ke peran eksekusi tugas.

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws s3 cp gmsa-cred-spec.json \
   s3://MyBucket/ecs-domainless-gmsa-credspec
   ```

## Langkah 5: (Opsional) Buat cluster Amazon ECS
<a name="tutorial-gmsa-windows-step5"></a>

Secara default, akun Anda memiliki klaster Amazon ECS bernama`default`. Cluster ini digunakan secara default di AWS CLI, SDKs, dan CloudFormation. Anda dapat menggunakan klaster tambahan untuk mengelompokkan dan mengatur tugas dan infrastruktur, dan menetapkan default untuk beberapa konfigurasi.

Anda dapat membuat cluster dari Konsol Manajemen AWS, AWS CLI, SDKs, atau CloudFormation. Pengaturan dan konfigurasi di cluster tidak mempengaruhigMSA.

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

```
$ aws ecs create-cluster --cluster-name windows-domainless-gmsa-cluster
```

**penting**  
Jika Anda memilih untuk membuat cluster Anda sendiri, Anda harus menentukan `--cluster clusterName` untuk setiap perintah yang ingin Anda gunakan dengan cluster itu.

## Langkah 6: Buat peran IAM untuk instance kontainer
<a name="tutorial-gmsa-windows-step6"></a>

*Instance container* adalah komputer host untuk menjalankan container dalam tugas ECS, misalnya instans Amazon EC2. Setiap instans kontainer mendaftar ke cluster Amazon ECS. Sebelum meluncurkan instans Amazon EC2 dan mendaftarkannya ke klaster, Anda harus membuat peran IAM agar instans penampung dapat digunakan.

Untuk membuat peran instance container, lihat[Peran IAM instans kontainer Amazon ECS](instance_IAM_role.md). Default `ecsInstanceRole` memiliki izin yang cukup untuk menyelesaikan tutorial ini.

## Langkah 7: Buat peran eksekusi tugas khusus
<a name="tutorial-gmsa-windows-step7"></a>

Amazon ECS dapat menggunakan peran IAM yang berbeda untuk izin yang diperlukan untuk memulai setiap tugas, bukan peran instance container. Peran ini adalah *peran eksekusi tugas*. Sebaiknya buat peran eksekusi tugas hanya dengan izin yang diperlukan untuk ECS untuk menjalankan tugas, juga dikenal sebagai izin hak istimewa paling sedikit*.* *Untuk informasi lebih lanjut tentang prinsip hak istimewa terkecil, lihat [SEC03- BP02 Berikan akses hak istimewa paling sedikit](https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_permissions_least_privileges.html) di Kerangka Well-Architected AWS .*

1. Untuk membuat peran eksekusi tugas, lihat[Membuat peran eksekusi tugas](task_execution_IAM_role.md#create-task-execution-role). Izin default memungkinkan instance container untuk menarik gambar kontainer dari Amazon Elastic Container Registry `stdout` dan dan `stderr` dari aplikasi Anda untuk dicatat ke Amazon CloudWatch Logs.

   Karena peran membutuhkan izin khusus untuk tutorial ini, Anda dapat memberikan peran nama yang berbeda dari`ecsTaskExecutionRole`. Tutorial ini digunakan `ecsTaskExecutionRole` dalam langkah-langkah selanjutnya.

1. Tambahkan izin berikut dengan membuat kebijakan khusus, baik kebijakan sebaris yang hanya ada untuk peran ini, atau kebijakan yang dapat Anda gunakan kembali. Ganti ARN untuk pernyataan pertama dengan bucket dan lokasi Amazon S3, dan yang kedua `Resource` dengan ARN rahasia di Secrets Manager. `Resource`

   Jika Anda mengenkripsi rahasia di Secrets Manager dengan kunci khusus, Anda juga harus mengizinkan `kms:Decrypt` kunci tersebut.

   Jika Anda menggunakan SSM Parameter Store bukan Secrets Manager, Anda harus mengizinkan `ssm:GetParameter` parameter, bukan. `secretsmanager:GetSecretValue`

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::MyBucket/ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:gmsa-plugin-AbCdEf"
           }
       ]
   }
   ```

------

## Langkah 8: Buat peran tugas untuk Amazon ECS Exec
<a name="tutorial-gmsa-windows-step8"></a>

Tutorial ini menggunakan Amazon ECS Exec untuk memverifikasi fungsionalitas dengan menjalankan perintah di dalam tugas yang sedang berjalan. Untuk menggunakan ECS Exec, layanan atau tugas harus mengaktifkan ECS Exec dan peran tugas (tetapi bukan peran eksekusi tugas) harus memiliki izin. `ssmmessages` Untuk kebijakan IAM yang diperlukan, lihat[Izin ECS Exec](task-iam-roles.md#ecs-exec-required-iam-permissions).

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

Untuk membuat peran tugas menggunakan AWS CLI, ikuti langkah-langkah ini.

1. Buat file yang disebut `ecs-tasks-trust-policy.json` dengan konten berikut:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "ecs-tasks.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Buat peran IAM. Anda dapat mengganti nama `ecs-exec-demo-task-role` tetapi menyimpan nama untuk langkah-langkah berikut.

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws iam create-role --role-name ecs-exec-demo-task-role \
   --assume-role-policy-document file://ecs-tasks-trust-policy.json
   ```

   Anda dapat menghapus file tersebut`ecs-tasks-trust-policy.json`.

1. Buat file yang disebut `ecs-exec-demo-task-role-policy.json` dengan konten berikut:

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

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ssmmessages:CreateControlChannel",
                   "ssmmessages:CreateDataChannel",
                   "ssmmessages:OpenControlChannel",
                   "ssmmessages:OpenDataChannel"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Buat kebijakan IAM dan lampirkan ke peran dari langkah sebelumnya.

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws iam put-role-policy \
       --role-name ecs-exec-demo-task-role \
       --policy-name ecs-exec-demo-task-role-policy \
       --policy-document file://ecs-exec-demo-task-role-policy.json
   ```

   Anda dapat menghapus file tersebut`ecs-exec-demo-task-role-policy.json`.

## Langkah 9: Daftarkan definisi tugas yang menggunakan domainless gMSA
<a name="tutorial-gmsa-windows-step9"></a>



Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. Buat file yang disebut `windows-gmsa-domainless-task-def.json` dengan konten berikut:

   ```
   {
     "family": "windows-gmsa-domainless-task",
     "containerDefinitions": [
       {
         "name": "windows_sample_app",
         "image": "mcr.microsoft.com/windows/servercore/iis",
         "cpu": 1024,
         "memory": 1024,
         "essential": true,
         "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
         ],
         "entryPoint": [
           "powershell",
           "-Command"
         ],
         "command": [
           "New-Item -Path C:\\inetpub\\wwwroot\\index.html -ItemType file -Value '<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>' -Force ; C:\\ServiceMonitor.exe w3svc"
         ],
         "portMappings": [
           {
             "protocol": "tcp",
             "containerPort": 80,
             "hostPort": 8080
           }
         ]
       }
     ],
     "taskRoleArn": "arn:aws:iam::111122223333:role/ecs-exec-demo-task-role",
     "executionRoleArn": "arn:aws:iam::111122223333:role/ecsTaskExecutionRole"
   }
   ```

1. Daftarkan definisi tugas dengan menjalankan perintah berikut:

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws ecs register-task-definition \
   --cli-input-json file://windows-gmsa-domainless-task-def.json
   ```

## Langkah 10: Daftarkan instance wadah Windows ke cluster
<a name="tutorial-gmsa-windows-step10"></a>

Luncurkan instans Windows Amazon EC2 dan jalankan agen kontainer ECS untuk mendaftarkannya sebagai instance container di cluster. ECS menjalankan tugas pada instance kontainer yang terdaftar ke cluster tempat tugas dimulai.

1. Untuk meluncurkan instans Windows Amazon EC2 yang dikonfigurasi untuk Amazon ECS di, lihat. Konsol Manajemen AWS[Meluncurkan instans penampung Amazon ECS Windows](launch_window-container_instance.md) Berhenti di langkah untuk *data pengguna*.

1. UntukgMSA, data pengguna harus mengatur variabel lingkungan `ECS_GMSA_SUPPORTED` sebelum memulai agen kontainer ECS.

   Untuk ECS Exec, agen harus memulai dengan argumen. `-EnableTaskIAMRole`

   Untuk mengamankan peran IAM instance dengan mencegah tugas mencapai layanan web EC2 IMDS untuk mengambil kredensyal peran, tambahkan argumen. `-AwsvpcBlockIMDS` Ini hanya berlaku untuk tugas yang menggunakan mode `awsvpc` jaringan.

   ```
   <powershell>
   [Environment]::SetEnvironmentVariable("ECS_GMSA_SUPPORTED", $TRUE, "Machine")
   Import-Module ECSTools
   Initialize-ECSAgent -Cluster windows-domainless-gmsa-cluster -EnableTaskIAMRole -AwsvpcBlockIMDS
   </powershell>
   ```

1. Tinjau ringkasan konfigurasi instans di panel **Ringkasan**, dan ketika Anda siap, pilih **Luncurkan instans**.

## Langkah 11: Verifikasi contoh kontainer
<a name="tutorial-gmsa-windows-step11"></a>

Anda dapat memverifikasi bahwa ada instance kontainer di cluster menggunakan file Konsol Manajemen AWS. Namun, gMSA perlu fitur tambahan yang ditunjukkan sebagai *atribut*. Atribut ini tidak terlihat di Konsol Manajemen AWS, jadi tutorial ini menggunakan AWS CLI.

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. Buat daftar instance kontainer di cluster. Instance kontainer memiliki ID yang berbeda dari ID instance EC2.

   ```
   $ aws ecs list-container-instances
   ```

   Output:

   ```
   {
       "containerInstanceArns": [
           "arn:aws:ecs:aws-region:111122223333:container-instance/default/MyContainerInstanceID"
       ]
   }
   ```

   Misalnya, `526bd5d0ced448a788768334e79010fd` adalah ID instance kontainer yang valid.

1. Gunakan ID instance container dari langkah sebelumnya untuk mendapatkan detail untuk instance container. Ganti `MyContainerInstanceID` dengan ID.

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws ecs describe-container-instances \
        ----container-instances MyContainerInstanceID
   ```

   Perhatikan bahwa outputnya sangat panjang.

1. Verifikasi bahwa `attributes` daftar memiliki objek dengan kunci yang dipanggil `name` dan nilai`ecs.capability.gmsa-domainless`. Berikut ini adalah contoh objek.

   Output:

   ```
   {
       "name": "ecs.capability.gmsa-domainless"
   }
   ```

## Langkah 12: Jalankan tugas Windows
<a name="tutorial-gmsa-windows-step12"></a>

Jalankan tugas Amazon ECS. Jika hanya ada 1 instance kontainer di cluster, Anda dapat menggunakan`run-task`. Jika ada banyak instance kontainer yang berbeda, mungkin lebih mudah untuk menggunakan `start-task` dan menentukan ID instance container untuk menjalankan tugas, daripada menambahkan batasan penempatan ke definisi tugas untuk mengontrol jenis instance kontainer untuk menjalankan tugas ini.

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. 

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   aws ecs run-task --task-definition windows-gmsa-domainless-task \
       --enable-execute-command --cluster windows-domainless-gmsa-cluster
   ```

   Perhatikan ID tugas yang dikembalikan oleh perintah.

1. Jalankan perintah berikut untuk memverifikasi bahwa tugas telah dimulai. Perintah ini menunggu dan tidak mengembalikan shell prompt sampai tugas dimulai. Ganti `MyTaskID` dengan ID tugas dari langkah sebelumnya.

   ```
   $ aws ecs wait tasks-running --task MyTaskID
   ```

## Langkah 13: Verifikasi wadah memiliki gMSA kredensi
<a name="tutorial-gmsa-windows-step13"></a>

Verifikasi bahwa wadah dalam tugas memiliki Kerberos token. gMSA 

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. 

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws ecs execute-command \
   --task MyTaskID \
   --container windows_sample_app \
   --interactive \
   --command powershell.exe
   ```

   Outputnya akan menjadi PowerShell prompt.

1. Jalankan perintah berikut di PowerShell terminal di dalam wadah.

   ```
   PS C:\> klist get ExampleAccount$
   ```

   Dalam output, perhatikan `Principal` adalah yang Anda buat sebelumnya.

## Langkah 14: Bersihkan
<a name="tutorial-gmsa-windows-step14"></a>

Setelah selesai dengan tutorial ini, Anda harus membersihkan sumber daya yang terkait untuk menghindari timbulnya biaya untuk sumber daya yang tidak terpakai.

Langkah ini menggunakan AWS CLI. Anda dapat menjalankan perintah ini AWS CloudShell di shell default, yaitu`bash`.

1. Hentikan tugas. Ganti `MyTaskID` dengan ID tugas dari langkah 12,[Langkah 12: Jalankan tugas Windows](#tutorial-gmsa-windows-step12).

   ```
   $ aws ecs stop-task --task MyTaskID
   ```

1. Mengakhiri instans Amazon EC2. Setelah itu, instance container di cluster akan dihapus secara otomatis setelah satu jam.

   Anda dapat menemukan dan menghentikan instance dengan menggunakan konsol Amazon EC2. Atau, Anda dapat menjalankan perintah berikut. Untuk menjalankan perintah, temukan ID instans EC2 di output `aws ecs describe-container-instances` perintah dari langkah 1,[Langkah 11: Verifikasi contoh kontainer](#tutorial-gmsa-windows-step11). i-10a64379 adalah contoh ID instans EC2.

   ```
   $ aws ec2 terminate-instances --instance-ids MyInstanceID
   ```

1. Hapus CredSpec file di Amazon S3. Ganti `MyBucket` dengan nama bucket Amazon S3 Anda.

   ```
   $ aws s3api delete-object --bucket MyBucket --key ecs-domainless-gmsa-credspec/gmsa-cred-spec.json
   ```

1. Hapus rahasia dari Secrets Manager. Jika Anda menggunakan SSM Parameter Store sebagai gantinya, hapus parameternya.

   Perintah berikut menggunakan karakter kelanjutan garis miring terbalik yang digunakan oleh `sh` dan shell yang kompatibel. Perintah ini tidak kompatibel dengan PowerShell. Anda harus memodifikasi perintah untuk menggunakannya PowerShell.

   ```
   $ aws secretsmanager delete-secret --secret-id gmsa-plugin-input \
        --force-delete-without-recovery
   ```

1. Deregister dan hapus definisi tugas. Dengan membatalkan pendaftaran definisi tugas, Anda menandainya sebagai tidak aktif sehingga tidak dapat digunakan untuk memulai tugas baru. Kemudian, Anda dapat menghapus definisi tugas.

   1. Deregister definisi tugas dengan menentukan versinya. ECS secara otomatis membuat versi definisi tugas, yang diberi nomor mulai dari 1. Anda merujuk ke versi dalam format yang sama dengan label pada gambar kontainer, seperti`:1`.

      ```
      $ aws ecs deregister-task-definition --task-definition windows-gmsa-domainless-task:1
      ```

   1. Hapus definisi tugas.

      ```
      $ aws ecs delete-task-definitions --task-definition windows-gmsa-domainless-task:1
      ```

1. (Opsional) Hapus cluster ECS, jika Anda membuat cluster.

   ```
   $ aws ecs delete-cluster --cluster windows-domainless-gmsa-cluster
   ```

## Debugging Amazon ECS tanpa domain gMSA untuk wadah Windows
<a name="tutorial-gmsa-windows-debugging"></a>



Status tugas Amazon ECS  
ECS mencoba memulai tugas tepat sekali. Setiap tugas yang memiliki masalah dihentikan, dan disetel ke status`STOPPED`. Ada dua jenis masalah umum dengan tugas. Pertama, tugas yang tidak bisa dimulai. Kedua, tugas di mana aplikasi telah berhenti di dalam salah satu wadah. Di Konsol Manajemen AWS, lihat bidang **Alasan berhenti** dari tugas karena alasan mengapa tugas itu dihentikan. Dalam AWS CLI, jelaskan tugas dan lihat`stoppedReason`. Untuk langkah-langkah di Konsol Manajemen AWS dan AWS CLI, lihat[Melihat Amazon ECS menghentikan kesalahan tugas](stopped-task-errors.md).

Peristiwa-peristiwa Windows  
Peristiwa Windows untuk gMSA dalam wadah dicatat dalam file `Microsoft-Windows-Containers-CCG` log dan dapat ditemukan di Penampil Acara di bagian Aplikasi dan Layanan di`Logs\Microsoft\Windows\Containers-CCG\Admin`. Untuk tips debugging lainnya, lihat [Memecahkan masalah g MSAs untuk kontainer Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-troubleshooting#non-domain-joined-container-hosts-use-event-logs-to-identify-configuration-issues) di situs web Microsoft Learn.

Plugin agen gMSA ECS  
Logging untuk gMSA plugin untuk agen ECS pada instance kontainer Windows ada di direktori berikut,`C:/ProgramData/Amazon/gmsa-plugin/`. Lihat di log ini untuk melihat apakah kredensil pengguna tanpa domain diunduh dari lokasi penyimpanan, seperti Secrets Manager, dan format kredensialnya telah dibaca dengan benar.

# Pelajari cara menggunakan GMSAs untuk wadah Windows EC2 untuk Amazon ECS
<a name="windows-gmsa"></a>

Amazon ECS mendukung otentikasi Active Directory untuk wadah Windows melalui jenis akun layanan khusus yang disebut *grup Akun Layanan Terkelola* (GMSA).

Aplikasi jaringan berbasis Windows seperti aplikasi NET sering menggunakan Direktori Aktif untuk memfasilitasi autentikasi dan otorisasi manajemen antara pengguna dan layanan. Developer umumnya merancang aplikasi mereka untuk mengintegrasikan dengan Direktori Aktif dan berjalan pada server yang bergabung dengan domain untuk tujuan ini. Karena kontainer Windows tidak dapat bergabung dengan domain, Anda harus mengonfigurasi kontainer Windows untuk berjalan dengan gMSA.

Wadah Windows yang berjalan dengan GMSA bergantung pada instans Amazon EC2 hostnya untuk mengambil kredenal GMSA dari pengontrol domain Active Directory dan menyediakannya ke instance container. Untuk informasi selengkapnya, lihat [Membuat g MSAs untuk kontainer Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).

**catatan**  
Fitur ini tidak didukung pada wadah Windows di Fargate.

**Topics**
+ [

## Pertimbangan-pertimbangan
](#windows-gmsa-considerations)
+ [

## Prasyarat
](#windows-gmsa-prerequisites)
+ [

## Menyiapkan gMSA untuk Windows Container di Amazon ECS
](#windows-gmsa-setup)

## Pertimbangan-pertimbangan
<a name="windows-gmsa-considerations"></a>

Berikut ini harus dipertimbangkan saat menggunakan g MSAs untuk wadah Windows:
+ Saat menggunakan AMI Penuh Windows Server 2016 yang dioptimalkan Amazon ECS untuk instance container Anda, nama host container harus sama dengan nama akun GMSA yang ditentukan dalam file spesifikasi kredenal. Untuk menentukan hostname untuk kontainer, gunakan parameter ketentuan kontainer `hostname`. Untuk informasi selengkapnya, lihat [Pengaturan jaringan](task_definition_parameters.md#container_definition_network).
+ Anda memilih antara **domainless gMSA** dan **menggabungkan setiap instance ke satu** domain. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

  Kemudian, pilih penyimpanan data untuk CredSpec dan opsional, untuk kredensyal pengguna Active Directory untuk domainless. gMSA

  Amazon ECS menggunakan file spesifikasi kredensi Direktori Aktif ()CredSpec. File ini berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah. Anda menghasilkan CredSpec file dan kemudian menyimpannya di salah satu opsi CredSpec penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer. Untuk menggunakan metode domainless, bagian opsional dalam CredSpec file dapat menentukan kredensional di salah satu opsi *domainless user credentials*penyimpanan dalam tabel berikut, khusus untuk Sistem Operasi instance kontainer.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonECS/latest/developerguide/windows-gmsa.html)

## Prasyarat
<a name="windows-gmsa-prerequisites"></a>

Sebelum Anda menggunakan fitur gMSA untuk Windows container dengan Amazon ECS, pastikan untuk menyelesaikan yang berikut ini:
+ Anda menyiapkan domain Direktori Aktif dengan sumber daya yang ingin diakses oleh kontainer Anda. Amazon ECS mendukung pengaturan berikut:
  + Direktori Directory Service Aktif. Directory Service adalah Direktori Aktif AWS terkelola yang di-host di Amazon EC2. Untuk informasi selengkapnya, lihat [Memulai dengan Microsoft AD yang AWS Dikelola](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) di *Panduan AWS Directory Service Administrasi*.
  + Direktori Aktif lokal. Anda harus memastikan bahwa instans penampung Amazon ECS Linux dapat bergabung dengan domain. Untuk informasi selengkapnya, lihat [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Anda memiliki gMSA akun yang ada di Direktori Aktif. Untuk informasi selengkapnya, lihat [Membuat g MSAs untuk kontainer Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).
+ **Anda memilih untuk menggunakan *domainless gMSA* atau instans penampung Amazon ECS Windows yang menghosting tugas Amazon ECS harus *domain yang digabungkan* ke Direktori Aktif dan menjadi anggota grup keamanan Direktori Aktif yang memiliki akses ke akun GMSA.**

  Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.
+ Anda menambahkan izin IAM yang diperlukan. Izin yang diperlukan bergantung pada metode yang Anda pilih untuk kredensyal awal dan untuk menyimpan spesifikasi kredensialnya:
  + Jika Anda menggunakan *domainless gMSA* untuk kredensyal awal, izin IAM untuk diperlukan AWS Secrets Manager pada peran instans Amazon EC2.
  + Jika Anda menyimpan spesifikasi kredensyal di SSM Parameter Store, izin IAM untuk Amazon EC2 Systems Manager Parameter Store diperlukan pada peran eksekusi tugas.
  + Jika Anda menyimpan spesifikasi kredensyal di Amazon S3, izin IAM untuk Amazon Simple Storage Service diperlukan pada peran eksekusi tugas.

## Menyiapkan gMSA untuk Windows Container di Amazon ECS
<a name="windows-gmsa-setup"></a>

Untuk mengatur gMSA untuk Windows Containers di Amazon ECS, Anda dapat mengikuti tutorial lengkap yang mencakup konfigurasi prasyarat. [Menggunakan Amazon ECS Windows container dengan domainless gMSA menggunakan AWS CLI](tutorial-gmsa-windows.md)

Bagian berikut mencakup CredSpec konfigurasi secara rinci.

**Topics**
+ [

### Contoh CredSpec
](#windows-gmsa-example)
+ [

### Penyiapan tanpa domain gMSA
](#windows-gmsa-domainless)
+ [

### Referensi File Spek Kredensial dalam Definisi Tugas
](#windows-gmsa-credentialspec)

### Contoh CredSpec
<a name="windows-gmsa-example"></a>

Amazon ECS menggunakan file spesifikasi kredensyal yang berisi gMSA metadata yang digunakan untuk menyebarkan konteks gMSA akun ke wadah Windows. Anda dapat menghasilkan file spesifikasi kredensial dan referensi dalam bidang `credentialSpec` pada ketentuan tugas Anda. File spek kredensial tidak berisi rahasia apa pun.

Berikut ini contoh file spek kredensial:

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "contoso.com",
        "DnsName": "contoso.com",
        "NetBiosName": "contoso"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "contoso.com"
            }
        ]
    }
}
```

### Penyiapan tanpa domain gMSA
<a name="windows-gmsa-domainless"></a>

Kami merekomendasikan domainless gMSA daripada menggabungkan instance container ke satu domain. Dengan menggunakan domainlessgMSA, instance container tidak digabungkan ke domain, aplikasi lain pada instance tidak dapat menggunakan kredensil untuk mengakses domain, dan tugas yang menggabungkan domain yang berbeda dapat berjalan pada instance yang sama.

1. Sebelum mengunggah CredSpec ke salah satu opsi penyimpanan, tambahkan informasi ke ARN rahasia di Secrets Manager atau SSM Parameter Store. CredSpec Untuk informasi selengkapnya, lihat [Konfigurasi spesifikasi kredensyal tambahan untuk kasus penggunaan host non-domain-joined kontainer di situs](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) web Microsoft Learn.

**Format kredensi tanpa domain gMSA**  
Berikut ini adalah format JSON untuk gMSA kredensyal domainless untuk Active Directory Anda. Simpan kredensialnya di Secrets Manager atau SSM Parameter Store.

   ```
   {
       "username":"WebApp01",
       "password":"Test123!",
       "domainName":"contoso.com"
   }
   ```

1. Tambahkan informasi berikut ke CredSpec file di dalam file`ActiveDirectoryConfig`. Ganti ARN dengan rahasia di Secrets Manager atau SSM Parameter Store.

   Perhatikan bahwa `PluginGUID` nilai harus cocok dengan GUID dalam contoh cuplikan berikut dan diperlukan.

   ```
       "HostAccountConfig": {
           "PortableCcgVersion": "1",
           "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
           "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Anda juga dapat menggunakan rahasia di SSM Parameter Store dengan menggunakan ARN dalam format ini:. `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`

1. Setelah Anda memodifikasi CredSpec file, itu akan terlihat seperti contoh berikut:

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "WebApp01",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "contoso",
       "DnsName": "contoso",
       "NetBiosName": "contoso"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         },
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

### Referensi File Spek Kredensial dalam Definisi Tugas
<a name="windows-gmsa-credentialspec"></a>

Amazon ECS mendukung cara-cara berikut untuk mereferensikan jalur file di `credentialSpecs` bidang definisi tugas. Untuk masing-masing opsi ini, Anda dapat memberikan `credentialspec:` atau`domainlesscredentialspec:`, tergantung pada apakah Anda menggabungkan instance penampung ke satu domain, atau menggunakan domainlessgMSA, masing-masing.

#### Bucket Amazon S3
<a name="gmsa-credspec-s3"></a>

Tambahkan spesifikasi kredensyal ke bucket Amazon S3, lalu rujuk Nama Sumber Daya Amazon (ARN) bucket Amazon S3 di bidang definisi tugas. `credentialSpecs`

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
            ],
            ...
        }
    ],
    ...
}
```

Anda juga harus menambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas Amazon ECS untuk memberikan akses tugas Anda ke bucket Amazon S3.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::{bucket_name}",
                "arn:aws:s3:::{bucket_name}/{object}"
            ]
        }
    ]
}
```

------

#### Parameter SSM Menyimpan parameter
<a name="gmsa-credspec-ssm"></a>

Tambahkan spesifikasi kredenal ke parameter Penyimpanan Parameter SSM, lalu rujuk Nama Sumber Daya Amazon (ARN) parameter Penyimpanan Parameter SSM di bidang definisi tugas. `credentialSpecs`

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:ssm:region:111122223333:parameter/parameter_name"
            ],
            ...
        }
    ],
    ...
}
```

Anda juga harus menambahkan izin berikut sebagai kebijakan inline ke peran IAM eksekusi tugas Amazon ECS untuk memberikan akses tugas Anda ke parameter Penyimpanan Parameter SSM.

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssm:GetParameters"
            ],
            "Resource": "arn:aws:ssm:*:111122223333:parameter/example*"
        }
    ]
}
```

------

#### File Lokal
<a name="gmsa-credspec-file"></a>

Dengan detail spesifikasi kredensial dalam file lokal, referensi jalur file di bidang ketentuan tugas `credentialSpecs`. Jalur file yang direferensikan harus relatif terhadap `C:\ProgramData\Docker\CredentialSpecs` direktori dan menggunakan garis miring terbalik ('\$1') sebagai pemisah jalur file.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspec:file://CredentialSpecDir\CredentialSpecFile.json"
            ],
            ...
        }
    ],
    ...
}
```

# Menggunakan EC2 Image Builder untuk membangun Amazon ECS yang disesuaikan yang dioptimalkan AMIs
<a name="image-builder-tutorial"></a>

AWS merekomendasikan agar Anda menggunakan AMI yang dioptimalkan Amazon ECS karena AMI tersebut telah dikonfigurasi sebelumnya dengan persyaratan dan rekomendasi untuk menjalankan beban kerja penampung Anda. Mungkin ada saat-saat ketika Anda perlu menyesuaikan AMI Anda untuk menambahkan perangkat lunak tambahan. Anda dapat menggunakan EC2 Image Builder untuk pembuatan, pengelolaan, dan penyebaran gambar server Anda. Anda mempertahankan kepemilikan gambar yang disesuaikan yang dibuat di akun Anda. Anda dapat menggunakan pipeline EC2 Image Builder untuk mengotomatiskan pembaruan dan penambalan sistem untuk gambar Anda, atau menggunakan perintah yang berdiri sendiri untuk membuat gambar dengan sumber daya konfigurasi yang ditentukan.

Anda membuat resep untuk gambar Anda. Resepnya mencakup gambar induk, dan komponen tambahan apa pun. Anda juga membuat pipeline yang mendistribusikan AMI khusus Anda.

Anda membuat resep untuk gambar Anda. Resep image Builder Image adalah dokumen yang mendefinisikan image dasar dan komponen yang diterapkan pada image dasar untuk menghasilkan konfigurasi yang diinginkan untuk gambar AMI keluaran. Anda juga membuat pipeline yang mendistribusikan AMI khusus Anda. Untuk informasi selengkapnya, lihat [Cara kerja EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/how-image-builder-works.html) di Panduan Pengguna *EC2 Image* Builder.

Kami menyarankan Anda menggunakan salah satu AMI yang dioptimalkan Amazon ECS berikut sebagai “Gambar Induk” Anda di EC2 Image Builder:
+ Linux
  + Amazon ECS x86 AL2023 yang dioptimalkan
  + Amazon ECS yang dioptimalkan Amazon Linux 2023 (arm64) AMI
  + Amazon ECS yang dioptimalkan Amazon Linux 2 kernel 5 AMI
  + Amazon ECS yang dioptimalkan Amazon Linux 2 x86 AMI
+ Windows
  + Amazon ECS-dioptimalkan Windows 2022 Full x86
  + Amazon ECS yang dioptimalkan Windows 2022 Core x86
  + Amazon ECS yang dioptimalkan Windows 2019 Full x86
  + Amazon ECS yang dioptimalkan Windows 2019 Core x86
  + Amazon ECS yang dioptimalkan Windows 2016 Full x86

Kami juga menyarankan Anda memilih “Gunakan versi OS terbaru yang tersedia”. Pipeline akan menggunakan versi semantik untuk gambar induk, yang membantu mendeteksi pembaruan ketergantungan dalam pekerjaan yang dijadwalkan secara otomatis. Untuk informasi selengkapnya, lihat [Pembuatan versi semantik](https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html) di Panduan Pengguna *EC2 Image Builder*.

AWS secara teratur memperbarui gambar AMI Amazon ECS yang dioptimalkan dengan tambalan keamanan dan versi agen kontainer baru. Saat Anda menggunakan ID AMI sebagai gambar induk Anda dalam resep gambar Anda, Anda perlu secara teratur memeriksa pembaruan pada gambar induk. Jika ada pembaruan, Anda harus membuat versi baru resep Anda dengan AMI yang diperbarui. Ini memastikan bahwa gambar kustom Anda menggabungkan versi terbaru dari gambar induk. Untuk informasi tentang cara membuat alur kerja untuk memperbarui instans EC2 secara otomatis di klaster Amazon ECS dengan yang baru dibuat AMIs, lihat [Cara membuat pipeline pengerasan AMI dan mengotomatiskan pembaruan](https://aws.amazon.com/blogs/security/how-to-create-an-ami-hardening-pipeline-and-automate-updates-to-your-ecs-instance-fleet/) pada armada instans ECS Anda.

Anda juga dapat menentukan Amazon Resource Name (ARN) dari gambar induk yang diterbitkan melalui pipeline EC2 Image Builder terkelola. Amazon secara rutin menerbitkan gambar AMI Amazon ECS yang dioptimalkan melalui saluran pipa terkelola. Gambar-gambar ini dapat diakses publik. Anda harus memiliki izin yang benar untuk mengakses gambar. Saat Anda menggunakan ARN gambar alih-alih AMI dalam resep Image Builder, pipeline Anda secara otomatis menggunakan versi terbaru dari gambar induk setiap kali dijalankan. Pendekatan ini menghilangkan kebutuhan untuk membuat versi resep baru secara manual untuk setiap pembaruan. 

## Bersihkan AMI Amazon ECS yang dioptimalkan
<a name="cleanup-ecs-optimized-ami"></a>

Saat menggunakan AMI Amazon ECS yang dioptimalkan sebagai gambar induk, Anda harus membersihkan gambar untuk mencegah masalah sementara. AMI Amazon ECS yang dioptimalkan telah dikonfigurasi sebelumnya untuk agen Amazon ECS untuk memulai secara otomatis dan mendaftar sebagai instans penampung dengan Amazon ECS. Menggunakannya sebagai gambar dasar tanpa pembersihan yang tepat dapat menyebabkan masalah pada AMI kustom Anda.

Untuk membersihkan gambar untuk penggunaan di masa mendatang, buat komponen yang menjalankan perintah berikut untuk menghentikan paket ecs-init dan proses Docker:

```
sudo systemctl stop ecs
sudo systemctl stop docker
```

Hapus semua file log dari instance saat ini untuk mencegah melestarikannya saat menyimpan gambar. Gunakan contoh skrip dalam [praktik terbaik Keamanan untuk EC2 Image](https://docs.aws.amazon.com/imagebuilder/latest/userguide/security-best-practices.html) Builder untuk membersihkan berbagai file dari instance.

Untuk membersihkan data spesifik Amazon ECS, jalankan perintah berikut:

```
sudo rm -rf /var/log/ecs/*
sudo rm /var/lib/ecs/data/agent.db
```

Untuk informasi selengkapnya tentang membuat Amazon ECS kustom yang dioptimalkan AMIs, lihat [Bagaimana cara membuat AMI kustom dari AMI Amazon ECS](https://forums.aws.amazon.com/knowledge-center/ecs-create-custom-amis/) yang dioptimalkan? di pusat AWS pengetahuan.

## Menggunakan gambar ARN dengan infrastruktur sebagai kode (IAc)
<a name="infrastructure-as-code-arn"></a>

Anda dapat mengonfigurasi resep menggunakan konsol EC2 Image Builder, atau infrastruktur sebagai kode (misalnya CloudFormation,), atau AWS SDK. Saat Anda menentukan gambar induk dalam resep Anda, Anda dapat menentukan ID AMI EC2, ARN image Builder Image Builder, ID produk AWS Marketplace , atau gambar kontainer. AWS menerbitkan gambar AMI IDs dan Image Builder ARNs dari Amazon ECS AMIs yang dioptimalkan secara publik. Berikut ini adalah format ARN untuk gambar:

```
arn:${Partition}:imagebuilder:${Region}:${Account}:image/${ImageName}/${ImageVersion}
```

Ini `ImageVersion` memiliki format berikut. Ganti*major*, *minor* dan *patch* dengan nilai terbaru.

```
<major>.<minor>.<patch>
```

Anda dapat mengganti`major`, `minor` dan `patch` ke nilai tertentu atau Anda dapat menggunakan ARN tanpa versi dari sebuah gambar, sehingga pipeline Anda tetap up-to-date dengan versi terbaru dari gambar induk. ARN tanpa versi menggunakan format wildcard 'x.x.x' untuk mewakili versi gambar. Pendekatan ini memungkinkan layanan Image Builder untuk secara otomatis menyelesaikan ke versi terbaru dari gambar. Menggunakan ARN tanpa versi memastikan bahwa referensi Anda selalu mengarah ke gambar terbaru yang tersedia, merampingkan proses mempertahankan gambar terbaru dalam penerapan Anda. Saat Anda membuat resep dengan konsol, EC2 Image Builder secara otomatis mengidentifikasi ARN untuk gambar induk Anda. Saat Anda menggunakan IAc untuk membuat resep, Anda harus mengidentifikasi ARN dan memilih versi gambar yang diinginkan atau menggunakan arn tanpa versi untuk menunjukkan gambar terbaru yang tersedia. Kami menyarankan Anda membuat skrip otomatis untuk memfilter dan hanya menampilkan gambar yang sesuai dengan kriteria Anda. Skrip Python berikut menunjukkan cara mengambil daftar Amazon ECS yang dioptimalkan. AMIs 

Skrip menerima dua argumen opsional: `owner` dan`platform`, dengan nilai default “Amazon”, dan “Windows” masing-masing. Nilai yang valid untuk argumen pemilik adalah:`Self`,`Shared`,`Amazon`, dan`ThirdParty`. Nilai yang valid untuk argumen platform adalah `Windows` dan`Linux`. Misalnya, jika Anda menjalankan skrip dengan `owner` argumen yang disetel ke `Amazon` dan `platform` disetel ke`Linux`, skrip akan menghasilkan daftar gambar yang diterbitkan oleh Amazon termasuk gambar yang dioptimalkan Amazon ECS.

```
import boto3
import argparse

def list_images(owner, platform):
    # Create a Boto3 session
    session = boto3.Session()
    
    # Create an EC2 Image Builder client
    client = session.client('imagebuilder')

    # Define the initial request parameters
    request_params = {
        'owner': owner,
        'filters': [
            {
                'name': 'platform',
                'values': [platform]
            }
        ]
    }

    # Initialize the results list
    all_images = []

    # Get the initial response with the first page of results
    response = client.list_images(**request_params)

    # Extract images from the response
    all_images.extend(response['imageVersionList'])

    # While 'nextToken' is present, continue paginating
    while 'nextToken' in response and response['nextToken']:
        # Update the token for the next request
        request_params['nextToken'] = response['nextToken']

        # Get the next page of results
        response = client.list_images(**request_params)

        # Extract images from the response
        all_images.extend(response['imageVersionList'])

    return all_images

def main():
    # Initialize the parser
    parser = argparse.ArgumentParser(description="List AWS images based on owner and platform")
    
    # Add the parameters/arguments
    parser.add_argument("--owner", default="Amazon", help="The owner of the images. Default is 'Amazon'.")
    parser.add_argument("--platform", default="Windows", help="The platform type of the images. Default is 'Windows'.")

    # Parse the arguments
    args = parser.parse_args()

    # Retrieve all images based on the provided owner and platform
    images = list_images(args.owner, args.platform)

    # Print the details of the images
    for image in images:
        print(f"Name: {image['name']}, Version: {image['version']}, ARN: {image['arn']}")

if __name__ == "__main__":
    main()
```

## Menggunakan gambar ARN dengan CloudFormation
<a name="arn-with-cloudformation"></a>

Resep gambar Image Builder adalah cetak biru yang menentukan gambar induk dan komponen yang diperlukan untuk mencapai konfigurasi gambar keluaran yang diinginkan. Anda menggunakan `AWS::ImageBuilder::ImageRecipe` sumber daya. Atur `ParentImage` nilai ke gambar ARN. Gunakan ARN tanpa versi dari gambar yang Anda inginkan untuk memastikan pipeline Anda selalu menggunakan versi gambar terbaru. Misalnya, `arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x`. Definisi `AWS::ImageBuilder::ImageRecipe` sumber daya berikut menggunakan ARN image terkelola Amazon:

```
ECSRecipe:
    Type: AWS::ImageBuilder::ImageRecipe
    Properties:
      Name: MyRecipe
      Version: '1.0.0'
      Components:
        - ComponentArn: [<The component arns of the image recipe>]
      ParentImage: "arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x"
```

Untuk informasi selengkapnya tentang [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html)sumber daya, lihat di *Panduan AWS CloudFormation Pengguna*.

Anda dapat mengotomatiskan pembuatan gambar baru di pipeline Anda dengan menyetel `Schedule` properti `AWS::ImageBuilder::ImagePipeline` sumber daya. Jadwal mencakup kondisi awal dan ekspresi cron. Untuk informasi selengkapnya, lihat [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html) di *AWS CloudFormation Panduan Pengguna*.

 `AWS::ImageBuilder::ImagePipeline`Contoh berikut ini memiliki pipeline yang menjalankan build pada pukul 10:00 AM Coordinated Universal Time (UTC) setiap hari. Tetapkan `Schedule` nilai-nilai berikut:
+ Atur `PipelineExecutionStartCondition` ke `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Build dimulai hanya jika sumber daya dependen seperti image induk atau komponen, yang menggunakan wildcard 'x' dalam versi semantiknya, diperbarui. Ini memastikan build menggabungkan pembaruan terbaru dari sumber daya tersebut.
+ Setel ScheduleExpression ke ekspresi `(0 10 * * ? *)` cron.

```
ECSPipeline:
    Type: AWS::ImageBuilder::ImagePipeline
    Properties:
      Name: my-pipeline
      ImageRecipeArn: <arn of the recipe you created in previous step>
      InfrastructureConfigurationArn: <ARN of the infrastructure configuration associated with this image pipeline>
      Schedule:
        PipelineExecutionStartCondition: EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
        ScheduleExpression: 'cron(0 10 * * ? *)'
```

## Menggunakan gambar ARN dengan Terraform
<a name="arn-with-terraform"></a>

Pendekatan untuk menentukan gambar dan jadwal induk pipeline Anda di Terraform sejalan dengan yang ada di. AWS CloudFormation Anda menggunakan `aws_imagebuilder_image_recipe` sumber daya. Atur `parent_image` nilai ke gambar ARN. Gunakan ARN tanpa versi dari gambar yang Anda inginkan untuk memastikan pipeline Anda selalu menggunakan versi gambar terbaru. Untuk informasi lebih lanjut, lihat [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference)di dokumentasi Terraform. 

Di blok konfigurasi jadwal`aws_imagebuilder_image_pipeline resource`, atur nilai `schedule_expression` argumen ke ekspresi cron pilihan Anda untuk menentukan seberapa sering pipeline berjalan, dan atur `pipeline_execution_start_condition` ke`EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Untuk informasi lebih lanjut, lihat [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference)di dokumentasi Terraform. 

# Menggunakan AWS Deep Learning Containers di Amazon ECS
<a name="deep-learning-containers"></a>

AWS Deep Learning Containers menyediakan satu set image Docker untuk melatih dan menyajikan model di TensorFlow dan Apache MXNet (Inkubasi) di Amazon ECS. Deep Learning Containers memungkinkan lingkungan yang dioptimalkan dengan TensorFlow library NVIDIA CUDA (untuk instans GPU), dan Intel MKL (untuk instance CPU). Gambar kontainer untuk Deep Learning Containers tersedia di Amazon ECR untuk referensi dalam definisi tugas Amazon ECS. Anda dapat menggunakan Deep Learning Containers bersama dengan Amazon Elastic Inference untuk menurunkan biaya inferensi Anda.

*Untuk mulai menggunakan Deep Learning Containers tanpa Elastic Inference di Amazon ECS, lihat [penyiapan Amazon ECS](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/deep-learning-containers-ecs-setup.html) di Panduan Pengembang.AWS Deep Learning AMIs *

# Tutorial: Membuat Layanan Menggunakan Blue/Green Deployment
<a name="create-blue-green"></a>

Amazon ECS telah mengintegrasikan blue/green penerapan ke wizard Create Service di konsol Amazon ECS. Untuk informasi selengkapnya, lihat [Membuat penyebaran pembaruan bergulir Amazon ECS](create-service-console-v2.md).

Tutorial berikut menunjukkan cara membuat layanan Amazon ECS yang berisi tugas Fargate yang menggunakan jenis penyebaran blue/green dengan. AWS CLI

**catatan**  
Support untuk melakukan blue/green penerapan telah ditambahkan untuk CloudFormation. *Untuk informasi selengkapnya, lihat [Menjalankan penerapan biru/hijau Amazon ECS melalui CodeDeploy penggunaan CloudFormation di](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) Panduan Pengguna.AWS CloudFormation *

## Prasyarat
<a name="create-blue-green-prereqs"></a>

Tutorial ini mengasumsikan bahwa Anda telah menyelesaikan prasyarat berikut:
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya tentang menginstal atau memutakhirkan AWS CLI, lihat [Menginstal. AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html)
+ Langkah-langkah di [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) telah diselesaikan.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda memiliki VPC dan grup keamanan yang dibuat untuk digunakan. Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Peran Amazon ECS CodeDeploy IAM dibuat. Untuk informasi selengkapnya, lihat [Peran Amazon ECS CodeDeploy IAM](codedeploy_IAM_role.md).

## Langkah 1: Buat Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

Layanan Amazon ECS yang menggunakan jenis blue/green penyebaran memerlukan penggunaan Application Load Balancer atau Network Load Balancer. Tutorial ini menggunakan Application Load Balancer.

**Untuk membuat Application Load Balancer**

1. Gunakan [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html)perintah untuk membuat Application Load Balancer. Tentukan dua subnet yang bukan dari Availability Zone serta grup keamanan yang sama.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   Ouput tersebut mencakup Amazon Resource Name (ARN) dari penyeimbang beban, dengan format berikut:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Gunakan [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)perintah untuk membuat grup target. Grup target ini akan merutekan lalu lintas ke tugas asli yang ditetapkan dalam layanan Anda.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   Output termasuk ARN dari grup target, dengan format berikut:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Menggunakan perintah [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) untuk membuat listener penyeimbang beban dengan aturan default yang meneruskan permintaan ke grup target.

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   Output tersebut mencakup ARN listener, dengan format berikut:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Langkah 2: Buat Cluster Amazon ECS
<a name="create-blue-green-cluster"></a>

Gunakan perintah [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) untuk membuat sebuah klaster bernama `tutorial-bluegreen-cluster` untuk digunakan.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

Output tersebut mencakup klaster ARN, dengan format berikut:

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Langkah 3: Daftarkan Definisi Tugas
<a name="create-blue-green-taskdef"></a>

Gunakan [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)perintah untuk mendaftarkan definisi tugas yang kompatibel dengan Fargate. Hal ini membutuhkan penggunaan mode jaringan `awsvpc`. Berikut ini adalah contoh ketentuan tugas yang digunakan untuk tutorial ini.

Pertama, buat file bernama `fargate-task.json` dengan isi berikut. Pastikan bahwa Anda menggunakan ARN untuk peran eksekusi tugas Anda. Untuk informasi selengkapnya, lihat [Peran IAM pelaksanaan tugas Amazon ECS](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "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\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

Kemudian daftarkan ketentuan tugas menggunakan file `fargate-task.json` yang Anda buat.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Langkah 4: Buat Layanan Amazon ECS
<a name="create-blue-green-service"></a>

Gunakan perintah [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) untuk membuat layanan. 

Pertama, buat file bernama `service-bluegreen.json` dengan konten berikut.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

Kemudian buat layanan Anda menggunakan file `service-bluegreen.json` yang Anda buat.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

Output tersebut mencakup ARN layanan, dengan format berikut:

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Langkah 5: Buat Sumber AWS CodeDeploy Daya
<a name="create-blue-green-codedeploy"></a>

Gunakan langkah-langkah berikut untuk membuat CodeDeploy aplikasi Anda, grup target Application Load Balancer untuk grup CodeDeploy deployment, dan grup deployment. CodeDeploy 

**Untuk membuat CodeDeploy sumber daya**

1. Gunakan perintah [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) untuk membuat aplikasi. CodeDeploy Tentukan platform komputasi `ECS`.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   Output termasuk ID aplikasi, dengan format berikut:

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Gunakan [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)perintah untuk membuat grup target Application Load Balancer kedua, yang akan digunakan saat membuat grup CodeDeploy penyebaran Anda.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   Output termasuk ARN untuk grup target, dengan format berikut:

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Gunakan [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)perintah untuk membuat grup CodeDeploy penyebaran.

   Pertama, buat file bernama `tutorial-deployment-group.json` dengan konten berikut. Contoh ini menggunakan sumber daya yang Anda buat. Untuk`serviceRoleArn`, tentukan ARN peran Amazon ECS CodeDeploy IAM Anda. Untuk informasi selengkapnya, lihat [Peran Amazon ECS CodeDeploy IAM](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   Kemudian buat grup CodeDeploy penyebaran.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   Output termasuk ID grup deployment, dengan format berikut:

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Langkah 6: Buat dan Pantau CodeDeploy Deployment
<a name="create-blue-green-verify"></a>

Gunakan langkah-langkah berikut untuk membuat dan mengunggah file spesifikasi aplikasi (AppSpec file) dan CodeDeploy penerapan.

**Untuk membuat dan memantau CodeDeploy penyebaran**

1. Buat dan unggah AppSpec file menggunakan langkah-langkah berikut.

   1. Buat file bernama `appspec.yaml` dengan isi grup deployment CodeDeploy . Contoh ini menggunakan sumber daya yang Anda buat sebelumnya dalam tutorial.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Gunakan perintah [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) untuk membuat bucket Amazon S3 untuk AppSpec file tersebut.

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Gunakan perintah [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) untuk mengunggah AppSpec file ke bucket Amazon S3.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Buat CodeDeploy penyebaran menggunakan langkah-langkah berikut.

   1. Buat file bernama `create-deployment.json` dengan isi CodeDeploy penyebaran. Contoh ini menggunakan sumber daya yang Anda buat sebelumnya dalam tutorial.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Gunakan perintah [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) untuk membuat deployment.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      Output termasuk ID deployment, dengan format berikut:

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Gunakan [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html)perintah untuk mendapatkan rincian penyebaran, menentukan `deploymentId` dari output sebelumnya.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Lanjutkan untuk mengambil detail deployment sampai status `Succeeded`, seperti yang ditunjukkan dalam output berikut.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Langkah 7: Bersihkan
<a name="create-blue-green-cleanup"></a>

Bila Anda telah menyelesaikan tutorial ini, bersihkan sumber daya yang terkait dengannya untuk menghindari biaya untuk sumber daya yang tidak Anda gunakan.

**Membersihkan sumber daya tutorial**

1. Gunakan [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)perintah untuk menghapus grup CodeDeploy penyebaran.

   ```
   aws deploy delete-deployment-group \
        --application-name tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

1. Gunakan perintah [hapus-aplikasi](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) untuk menghapus aplikasi. CodeDeploy 

   ```
   aws deploy delete-application \
        --application-name tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Gunakan perintah [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) untuk menghapus layanan Amazon ECS. Menggunakan bendera `--force` mengizinkan Anda untuk menghapus layanan bahkan jika itu tidak menurunkan skala ke tugas nol.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Gunakan perintah [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) untuk menghapus cluster Amazon ECS.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Gunakan perintah [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) untuk menghapus AppSpec file dari bucket Amazon S3.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Gunakan perintah [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) untuk menghapus bucket Amazon S3.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Gunakan [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html)perintah untuk menghapus Application Load Balancer.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Gunakan [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html)perintah untuk menghapus dua kelompok target Application Load Balancer.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```