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

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