Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai dengan AWS App Mesh dan Amazon ECS
**penting**
Pemberitahuan akhir dukungan: Pada 30 September 2026, AWS akan menghentikan dukungan untuk. AWS App Mesh Setelah 30 September 2026, Anda tidak akan lagi dapat mengakses AWS App Mesh konsol atau AWS App Mesh sumber daya. Untuk informasi lebih lanjut, kunjungi posting blog ini [Migrasi dari AWS App Mesh ke Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Topik ini membantu Anda menggunakan AWS App Mesh layanan aktual yang berjalan di Amazon ECS. Tutorial ini mencakup fitur dasar dari beberapa jenis sumber daya App Mesh.
## Skenario
Untuk mengilustrasikan cara menggunakan App Mesh, asumsikan bahwa Anda memiliki aplikasi dengan karakteristik sebagai berikut:
+ Terdiri dari dua layanan bernama `serviceA` dan`serviceB`.
+ Kedua layanan terdaftar ke namespace bernama. `apps.local`
+ `ServiceA`berkomunikasi dengan `serviceB` lebih dari HTTP/2, port 80.
+ Anda telah menerapkan versi 2 `serviceB` dan mendaftarkannya dengan nama `serviceBv2` di `apps.local` namespace.
Anda memiliki persyaratan berikut:
+ Anda ingin mengirim 75 persen lalu lintas dari `serviceA` ke `serviceB` dan 25 persen lalu lintas ke yang `serviceBv2` pertama. Dengan hanya mengirim 25 persen ke`serviceBv2`, Anda dapat memvalidasi bahwa itu bebas bug sebelum Anda mengirim 100 persen lalu lintas dari`serviceA`.
+ Anda ingin dapat dengan mudah menyesuaikan bobot lalu lintas sehingga 100 persen lalu lintas masuk `serviceBv2` setelah terbukti dapat diandalkan. Setelah semua lalu lintas dikirim ke`serviceBv2`, Anda ingin berhenti`serviceB`.
+ Anda tidak ingin harus mengubah kode aplikasi atau pendaftaran penemuan layanan yang ada untuk layanan Anda yang sebenarnya untuk memenuhi persyaratan sebelumnya.
Untuk memenuhi kebutuhan Anda, Anda memutuskan untuk membuat mesh layanan App Mesh dengan layanan virtual, node virtual, router virtual, dan rute. Setelah menerapkan mesh Anda, Anda memperbarui layanan Anda untuk menggunakan proxy Envoy. Setelah diperbarui, layanan Anda berkomunikasi satu sama lain melalui proxy Utusan daripada langsung satu sama lain.
## Prasyarat
**penting**
Pemberitahuan akhir dukungan: Pada 30 September 2026, AWS akan menghentikan dukungan untuk. AWS App Mesh Setelah 30 September 2026, Anda tidak akan lagi dapat mengakses AWS App Mesh konsol atau AWS App Mesh sumber daya. Untuk informasi lebih lanjut, kunjungi posting blog ini [Migrasi dari AWS App Mesh ke Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
+ Pemahaman yang ada tentang konsep App Mesh. Untuk informasi selengkapnya, lihat [Apa itu AWS App Mesh?](what-is-app-mesh.md).
+ Pemahaman yang ada tentang ECSs konsep Amazon. Untuk informasi selengkapnya, lihat [Apa itu Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) di Panduan Pengembang Layanan Kontainer Elastis Amazon.
+ App Mesh mendukung layanan Linux yang terdaftar dengan DNS, AWS Cloud Map, atau keduanya. Untuk menggunakan panduan memulai ini, kami sarankan Anda memiliki tiga layanan yang sudah ada yang terdaftar di DNS. Prosedur dalam topik ini mengasumsikan bahwa layanan yang ada diberi nama`serviceA`,`serviceB`, `serviceBv2` dan bahwa semua layanan dapat ditemukan melalui namespace bernama. `apps.local`
Anda dapat membuat mesh layanan dan sumber dayanya bahkan jika layanan tidak ada, tetapi Anda tidak dapat menggunakan mesh sampai Anda telah menerapkan layanan yang sebenarnya. Untuk informasi selengkapnya tentang penemuan layanan di Amazon ECS, lihat [Penemuan Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). Untuk membuat layanan Amazon ECS dengan penemuan layanan, lihat [Tutorial: Membuat Layanan Menggunakan Penemuan Layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html). Jika Anda belum menjalankan layanan, Anda dapat [membuat layanan Amazon ECS dengan penemuan layanan](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html).
## Langkah 1: Buat mesh dan layanan virtual
Mesh layanan adalah batas logis untuk lalu lintas jaringan antara layanan yang berada di dalamnya. Untuk informasi selengkapnya, lihat [Jala Layanan](meshes.md). Layanan virtual adalah abstraksi dari layanan yang sebenarnya. Untuk informasi selengkapnya, lihat [Layanan virtual](virtual_services.md).
Buat sumber daya berikut:
+ Sebuah mesh bernama`apps`, karena semua layanan dalam skenario terdaftar ke `apps.local` namespace.
+ Layanan virtual bernama`serviceb.apps.local`, karena layanan virtual mewakili layanan yang dapat ditemukan dengan nama itu, dan Anda tidak ingin mengubah kode Anda untuk merujuk nama lain. Layanan virtual bernama `servicea.apps.local` ditambahkan pada langkah selanjutnya.
Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI versi 1.18.116 atau lebih tinggi atau 2.0.38 atau lebih tinggi untuk menyelesaikan langkah-langkah berikut. Jika menggunakan AWS CLI, gunakan `aws --version` perintah untuk memeriksa AWS CLI versi yang Anda instal. [Jika Anda tidak memiliki versi 1.18.116 atau lebih tinggi atau 2.0.38 atau lebih tinggi diinstal, maka Anda harus menginstal atau memperbarui. AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html) Pilih tab untuk alat yang ingin Anda gunakan.
------
#### [ Konsol Manajemen AWS ]
1. Buka wizard yang dijalankan pertama kali konsol App Mesh saat memulai [https://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Untuk **nama Mesh**, masukkan**apps**.
1. Untuk **nama layanan Virtual**, masukkan**serviceb.apps.local**.
1. Untuk melanjutkan, pilih **Berikutnya**.
------
#### [ AWS CLI ]
1. Buat mesh dengan `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)` perintah.
```
aws appmesh create-mesh --mesh-name apps
```
1. Buat layanan virtual dengan `[create-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-service.html)` perintah.
```
aws appmesh create-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local --spec {}
```
------
## Langkah 2: Buat simpul virtual
Node virtual bertindak sebagai pointer logis ke layanan yang sebenarnya. Untuk informasi selengkapnya, lihat [Node virtual](virtual_nodes.md).
Buat node virtual bernama`serviceB`, karena salah satu node virtual mewakili layanan yang sebenarnya bernama`serviceB`. Layanan aktual yang diwakili oleh node virtual dapat ditemukan melalui `DNS` dengan nama host dari. `serviceb.apps.local` Sebagai alternatif, Anda dapat menemukan layanan aktual menggunakan. AWS Cloud Map Node virtual akan mendengarkan lalu lintas menggunakan protokol HTTP/2 pada port 80. Protokol lain juga didukung, seperti halnya pemeriksaan kesehatan. Anda akan membuat node virtual untuk `serviceA` dan `serviceBv2` di langkah selanjutnya.
------
#### [ Konsol Manajemen AWS ]
1. Untuk **nama simpul Virtual**, masukkan**serviceB**.
1. Untuk **metode Penemuan layanan**, pilih **DNS** dan masukkan **serviceb.apps.local** untuk nama host **DNS**.
1. **Di bawah **konfigurasi Listener**, pilih **http2** untuk **Protokol** dan masukkan **80** untuk Port.**
1. Untuk melanjutkan, pilih **Berikutnya**.
------
#### [ AWS CLI ]
1. Buat file bernama `create-virtual-node-serviceb.json` dengan konten berikut:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Buat node virtual dengan [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)perintah menggunakan file JSON sebagai input.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Langkah 3: Buat router virtual dan rute
Router virtual merutekan lalu lintas untuk satu atau lebih layanan virtual di dalam mesh Anda. Untuk informasi selengkapnya, lihat [Router virtual](virtual_routers.md) dan [Rute](routes.md).
Buat sumber daya berikut:
+ Router virtual bernama`serviceB`, karena layanan `serviceB.apps.local` virtual tidak memulai komunikasi keluar dengan layanan lain. Ingatlah bahwa layanan virtual yang Anda buat sebelumnya adalah abstraksi dari `serviceb.apps.local` layanan Anda yang sebenarnya. Layanan virtual mengirimkan lalu lintas ke router virtual. Router virtual mendengarkan lalu lintas menggunakan protokol HTTP/2 pada port 80. Protokol lain juga didukung.
+ Sebuah rute bernama`serviceB`. Ini merutekan 100 persen lalu lintasnya ke node `serviceB` virtual. Bobotnya ada di langkah selanjutnya setelah Anda menambahkan simpul `serviceBv2` virtual. Meskipun tidak tercakup dalam panduan ini, Anda dapat menambahkan kriteria filter tambahan untuk rute dan menambahkan kebijakan coba lagi untuk menyebabkan proxy Envoy melakukan beberapa upaya untuk mengirim lalu lintas ke node virtual ketika mengalami masalah komunikasi.
------
#### [ Konsol Manajemen AWS ]
1. Untuk **nama router Virtual,** masukkan**serviceB**.
1. **Di bawah **konfigurasi Listener**, pilih **http2** untuk **Protokol** dan tentukan **80** untuk Port.**
1. Untuk **nama Rute**, masukkan**serviceB**.
1. Untuk **jenis Rute**, pilih **http2**.
1. Untuk **nama simpul Virtual** di bawah **konfigurasi Target**, pilih `serviceB` dan masukkan **100** untuk **Berat**.
1. Di bawah **konfigurasi Match**, pilih **Metode**.
1. Untuk melanjutkan, pilih **Berikutnya**.
------
#### [ AWS CLI ]
1. Buat router virtual.
1. Buat file bernama `create-virtual-router.json` dengan konten berikut:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Buat router virtual dengan [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)perintah menggunakan file JSON sebagai input.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Buat rute.
1. Buat file bernama `create-route.json` dengan konten berikut:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Buat rute dengan perintah [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) menggunakan file JSON sebagai input.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Langkah 4: Tinjau dan buat
Tinjau pengaturan terhadap instruksi sebelumnya.
------
#### [ Konsol Manajemen AWS ]
Pilih **Edit** jika Anda perlu membuat perubahan di bagian mana pun. Setelah Anda puas dengan pengaturan, pilih **Buat mesh**.
Layar **Status** menunjukkan kepada Anda semua sumber daya mesh yang dibuat. Anda dapat melihat sumber daya yang dibuat di konsol dengan memilih **View mesh**.
------
#### [ AWS CLI ]
Tinjau pengaturan mesh yang Anda buat dengan [perintah describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Tinjau pengaturan layanan virtual yang Anda buat dengan [describe-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-service.html)perintah.
```
aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local
```
Tinjau pengaturan node virtual yang Anda buat dengan [describe-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-node.html)perintah.
```
aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB
```
Tinjau pengaturan router virtual yang Anda buat dengan [describe-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-router.html)perintah.
```
aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB
```
Tinjau pengaturan rute yang Anda buat dengan [perintah deskripsi-rute](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-route.html).
```
aws appmesh describe-route --mesh-name apps \
--virtual-router-name serviceB --route-name serviceB
```
------
## Langkah 5: Buat sumber daya tambahan
Untuk menyelesaikan skenario, Anda perlu:
+ Buat satu node virtual bernama `serviceBv2` dan yang lain bernama`serviceA`. Kedua node virtual mendengarkan permintaan melalui HTTP/2 port 80. Untuk node `serviceA` virtual, konfigurasikan backend dari. `serviceb.apps.local` Semua lalu lintas keluar dari node `serviceA` virtual dikirim ke layanan virtual bernama`serviceb.apps.local`. Meskipun tidak tercakup dalam panduan ini, Anda juga dapat menentukan jalur file untuk menulis log akses untuk node virtual.
+ Buat satu layanan virtual tambahan bernama`servicea.apps.local`, yang mengirimkan semua lalu lintas langsung ke node `serviceA` virtual.
+ Perbarui `serviceB` rute yang Anda buat pada langkah sebelumnya untuk mengirim 75 persen lalu lintasnya ke node `serviceB` virtual dan 25 persen lalu lintasnya ke node `serviceBv2` virtual. Seiring waktu, Anda dapat terus memodifikasi bobot hingga `serviceBv2` menerima 100 persen dari lalu lintas. Setelah semua lalu lintas dikirim`serviceBv2`, Anda dapat mematikan dan menghentikan node `serviceB` virtual dan layanan aktual. Saat Anda mengubah bobot, kode Anda tidak memerlukan modifikasi apa pun, karena nama layanan `serviceb.apps.local` virtual dan aktual tidak berubah. Ingatlah bahwa layanan `serviceb.apps.local` virtual mengirimkan lalu lintas ke router virtual, yang merutekan lalu lintas ke node virtual. Nama penemuan layanan untuk node virtual dapat diubah kapan saja.
------
#### [ Konsol Manajemen AWS ]
1. Di panel navigasi kiri, pilih **Meshes**.
1. Pilih `apps` mesh yang Anda buat pada langkah sebelumnya.
1. Di panel navigasi kiri, pilih **Virtual nodes**.
1. Pilih **Buat simpul virtual**.
1. Untuk **nama simpul Virtual**, masukkan**serviceBv2**, untuk **metode penemuan Layanan**, pilih **DNS**, dan untuk **nama host DNS**, masukkan. **servicebv2.apps.local**
1. **Untuk **konfigurasi Listener**, pilih **http2** untuk **Protokol** dan masukkan **80** untuk Port.**
1. Pilih **Buat simpul virtual**.
1. Pilih **Buat simpul virtual** lagi. Masukkan **serviceA** untuk **nama simpul Virtual**. Untuk **metode Penemuan layanan**, pilih **DNS**, dan untuk **nama host DNS**, masukkan. **servicea.apps.local**
1. Untuk **Masukkan nama layanan virtual** di bawah **Backend baru**, masukkan. **serviceb.apps.local**
1. Di bawah **konfigurasi Listener**, pilih **http2** untuk **Protokol**, masukkan **80** untuk **Port**, dan kemudian pilih **Buat** simpul virtual.
1. Di panel navigasi kiri, pilih **Router virtual** dan kemudian pilih router `serviceB` virtual dari daftar.
1. **Di bawah Rute, pilih rute bernama `ServiceB` yang Anda buat pada langkah sebelumnya, dan pilih **Edit**.**
1. Di bawah **Target**, **nama node Virtual**, ubah nilai **Weight** `serviceB` untuk menjadi**75**.
1. Pilih **Tambah target**, pilih `serviceBv2` dari daftar dropdown, dan atur nilai **Weight** ke. **25**
1. Pilih **Simpan**.
1. Di panel navigasi kiri, pilih **Layanan virtual** dan kemudian pilih **Buat layanan virtual**.
1. Masukkan **servicea.apps.local** **nama layanan Virtual**, pilih **Virtual node** for **Provider**, pilih `serviceA` untuk **Virtual node**, dan kemudian pilih **Create Virtual Service.**
------
#### [ AWS CLI ]
1. Buat node `serviceBv2` virtual.
1. Buat file bernama `create-virtual-node-servicebv2.json` dengan konten berikut:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Buat node virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Buat node `serviceA` virtual.
1. Buat file bernama `create-virtual-node-servicea.json` dengan konten berikut:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Buat node virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Perbarui layanan `serviceb.apps.local` virtual yang Anda buat pada langkah sebelumnya untuk mengirim lalu lintas ke router `serviceB` virtual. Ketika layanan virtual awalnya dibuat, itu tidak mengirim lalu lintas ke mana pun, karena router `serviceB` virtual belum dibuat.
1. Buat file bernama `update-virtual-service.json` dengan konten berikut:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Perbarui layanan virtual dengan [update-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-virtual-service.html)perintah.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```
1. Perbarui `serviceB` rute yang Anda buat di langkah sebelumnya.
1. Buat file bernama `update-route.json` dengan konten berikut:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Perbarui rute dengan perintah [update-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-route.html).
```
aws appmesh update-route --cli-input-json file://update-route.json
```
1. Buat layanan `serviceA` virtual.
1. Buat file bernama `create-virtual-servicea.json` dengan konten berikut:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Buat layanan virtual.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Ringkasan mesh**
Sebelum Anda membuat mesh layanan, Anda memiliki tiga layanan aktual bernama`servicea.apps.local`,`serviceb.apps.local`, dan`servicebv2.apps.local`. Selain layanan yang sebenarnya, Anda sekarang memiliki mesh layanan yang berisi sumber daya berikut yang mewakili layanan sebenarnya:
+ Dua layanan virtual. Proxy mengirimkan semua lalu lintas dari layanan `servicea.apps.local` virtual ke layanan `serviceb.apps.local` virtual melalui router virtual.
+ Tiga node virtual bernama`serviceA`,`serviceB`, dan`serviceBv2`. Proxy Envoy menggunakan informasi penemuan layanan yang dikonfigurasi untuk node virtual untuk mencari alamat IP dari layanan yang sebenarnya.
+ Satu router virtual dengan satu rute yang menginstruksikan proxy Utusan untuk merutekan 75 persen lalu lintas masuk ke node `serviceB` virtual dan 25 persen lalu lintas ke node virtual. `serviceBv2`
## Langkah 6: Perbarui layanan
Setelah membuat mesh Anda, Anda harus menyelesaikan tugas-tugas berikut:
+ Otorisasi proxy Envoy yang Anda terapkan dengan setiap tugas Amazon ECS untuk membaca konfigurasi satu atau beberapa node virtual. Untuk informasi selengkapnya tentang cara mengotorisasi proxy, lihat [Otorisasi proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
+ Perbarui setiap definisi tugas Amazon ECS yang ada untuk menggunakan proxy Envoy.
**Kredensial**
Container Envoy memerlukan AWS Identity and Access Management kredensil untuk menandatangani permintaan yang dikirim ke layanan App Mesh. [Untuk tugas Amazon ECS yang diterapkan dengan jenis peluncuran Amazon EC2, kredensialnya dapat berasal dari peran [instans atau dari peran IAM](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html) tugas.](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) Tugas Amazon ECS yang diterapkan dengan Fargate di wadah Linux tidak memiliki akses ke server metadata Amazon EC2 yang menyediakan kredenal profil IAM instans. Untuk menyediakan kredensialnya, Anda harus melampirkan peran tugas IAM ke tugas apa pun yang digunakan dengan Fargate pada jenis container Linux.
*Jika tugas diterapkan dengan jenis peluncuran Amazon EC2 dan akses diblokir ke server metadata Amazon EC2, seperti yang dijelaskan dalam anotasi Penting dalam Peran IAM [untuk Tugas, maka peran IAM](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) tugas juga harus dilampirkan ke tugas.* Peran yang Anda tetapkan ke instans atau tugas harus memiliki kebijakan IAM yang dilampirkan padanya seperti yang dijelaskan dalam otorisasi [Proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
**Untuk memperbarui definisi tugas Anda menggunakan AWS CLI**
Anda menggunakan AWS CLI perintah [https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)Amazon ECS. Contoh definisi tugas di bawah ini menunjukkan cara mengonfigurasi App Mesh untuk layanan Anda.
**catatan**
Mengonfigurasi App Mesh untuk Amazon ECS melalui konsol tidak tersedia.
### Definisi tugas json
**Konfigurasi proxy**
Untuk mengonfigurasi layanan Amazon ECS agar menggunakan App Mesh, definisi tugas layanan Anda harus memiliki bagian konfigurasi proxy berikut. Atur konfigurasi proxy `type` ke `APPMESH` dan `containerName` ke`envoy`. Tetapkan nilai properti berikut sesuai.
`IgnoredUID`
Proxy Envoy tidak merutekan lalu lintas dari proses yang menggunakan ID pengguna ini. Anda dapat memilih ID pengguna apa pun yang Anda inginkan untuk nilai properti ini, tetapi ID ini harus sama dengan `user` ID untuk wadah Utusan dalam definisi tugas Anda. Pencocokan ini memungkinkan Utusan untuk mengabaikan lalu lintasnya sendiri tanpa menggunakan proxy. Contoh kami digunakan `1337` untuk tujuan sejarah.
`ProxyIngressPort`
Ini adalah port masuk untuk wadah proxy Envoy. Tetapkan nilai ini ke`15000`.
`ProxyEgressPort`
Ini adalah port keluar untuk wadah proxy Envoy. Tetapkan nilai ini ke`15001`.
`AppPorts`
Tentukan port masuk yang didengarkan oleh wadah aplikasi Anda. Dalam contoh ini, wadah aplikasi mendengarkan pada port`9080`. Port yang Anda tentukan harus cocok dengan port yang dikonfigurasi pada pendengar simpul virtual.
`EgressIgnoredIPs`
Utusan tidak mem-proxy lalu lintas ke alamat IP ini. Tetapkan nilai ini ke`169.254.170.2,169.254.169.254`, yang mengabaikan server metadata Amazon EC2 dan titik akhir metadata tugas Amazon ECS. Titik akhir metadata menyediakan peran IAM untuk kredensil tugas. Anda dapat menambahkan alamat tambahan.
`EgressIgnoredPorts`
Anda dapat menambahkan daftar port yang dipisahkan koma. Utusan tidak mem-proxy lalu lintas ke port ini. Bahkan jika Anda tidak mencantumkan port, port 22 diabaikan.
Jumlah maksimum port keluar yang dapat diabaikan adalah 15.
```
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
}
```
**Ketergantungan Utusan wadah aplikasi**
Wadah aplikasi dalam definisi tugas Anda harus menunggu proxy Utusan untuk bootstrap dan mulai sebelum mereka dapat memulai. Untuk memastikan ini terjadi, Anda menetapkan `dependsOn` bagian di setiap definisi wadah aplikasi untuk menunggu kontainer Utusan melaporkan sebagai. `HEALTHY` Kode berikut menunjukkan contoh definisi wadah aplikasi dengan ketergantungan ini. Semua properti dalam contoh berikut diperlukan. Beberapa nilai properti juga diperlukan, tetapi beberapa di antaranya*replaceable*.
```
{
"name": "appName",
"image": "appImage",
"portMappings": [{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}],
"essential": true,
"dependsOn": [{
"containerName": "envoy",
"condition": "HEALTHY"
}]
}
```
**Definisi wadah utusan**
Definisi tugas Amazon ECS Anda harus berisi gambar wadah App Mesh Envoy.
Semua Wilayah yang [didukung](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) dapat diganti *Region-code* dengan Wilayah apa pun selain`me-south-1`,`ap-east-1`,`ap-southeast-3`,,`eu-south-1`,`il-central-1`, dan`af-south-1`.
Standar
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
Sesuai FIPS
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
`me-south-1`
Standar
```
772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-east-1`
Standar
```
856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-southeast-3`
Standar
```
909464085924.dkr.ecr.ap-southeast-3.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`eu-south-1`
Standar
```
422531588944.dkr.ecr.eu-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`il-central-1`
Standar
```
564877687649.dkr.ecr.il-central-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`af-south-1`
Standar
```
924023996002.dkr.ecr.af-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`Public repository`
Standar
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod
```
Sesuai FIPS
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
**penting**
Hanya versi v1.9.0.0-prod atau yang lebih baru yang didukung untuk digunakan dengan App Mesh.
Anda harus menggunakan image container App Mesh Envoy hingga tim project Envoy menggabungkan perubahan yang mendukung App Mesh. Untuk detail tambahan, lihat [masalah GitHub peta jalan](https://github.com/aws/aws-app-mesh-roadmap/issues/10).
Semua properti dalam contoh berikut diperlukan. Beberapa nilai properti juga diperlukan, tetapi beberapa di antaranya*replaceable*.
**catatan**
Definisi wadah Utusan harus ditandai sebagai. `essential`
Kami merekomendasikan mengalokasikan unit `512` CPU dan setidaknya `64` MiB memori ke wadah Envoy. Di Fargate, yang terendah yang dapat Anda atur adalah memori `1024` MiB.
Nama node virtual untuk layanan Amazon ECS harus disetel ke nilai `APPMESH_RESOURCE_ARN` properti. Properti ini memerlukan versi `1.15.0` atau yang lebih baru dari gambar Utusan. Untuk informasi selengkapnya, lihat [Gambar utusan](envoy.md).
Nilai untuk `user` pengaturan harus sesuai dengan `IgnoredUID` nilai dari konfigurasi proxy definisi tugas. Dalam contoh ini, kami menggunakan `1337`.
Pemeriksaan kesehatan yang ditunjukkan di sini menunggu wadah Utusan untuk melakukan bootstrap dengan benar sebelum melaporkan ke Amazon ECS bahwa wadah Utusan sehat dan siap untuk wadah aplikasi dimulai.
Secara default, App Mesh menggunakan nama sumber daya yang Anda tentukan `APPMESH_RESOURCE_ARN` saat Envoy merujuk dirinya sendiri dalam metrik dan jejak. Anda dapat menimpa perilaku ini dengan mengatur variabel lingkungan `APPMESH_RESOURCE_CLUSTER` dengan nama Anda sendiri. Properti ini memerlukan versi `1.15.0` atau yang lebih baru dari gambar Utusan. Untuk informasi selengkapnya, lihat [Gambar utusan](envoy.md).
Kode berikut menunjukkan contoh definisi kontainer Utusan.
```
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [{
"name": "APPMESH_RESOURCE_ARN",
"value": "arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
}],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
```
**Contoh ketentuan tugas**
Contoh berikut definisi tugas Amazon ECS menunjukkan cara menggabungkan contoh dari atas ke definisi tugas untuk. `taskB` Contoh disediakan untuk membuat tugas untuk kedua jenis peluncuran Amazon ECS dengan atau tanpa menggunakan AWS X-Ray. Ubah *replaceable* nilai, yang sesuai, untuk membuat definisi tugas untuk tugas bernama `taskBv2` dan `taskA` dari skenario. Gantikan nama mesh dan nama node virtual Anda dengan `APPMESH_RESOURCE_ARN` nilai dan daftar port yang didengarkan aplikasi Anda untuk `AppPorts` nilai konfigurasi proxy. Secara default, App Mesh menggunakan nama sumber daya yang Anda tentukan `APPMESH_RESOURCE_ARN` saat Envoy merujuk dirinya sendiri dalam metrik dan jejak. Anda dapat menimpa perilaku ini dengan mengatur variabel lingkungan `APPMESH_RESOURCE_CLUSTER` dengan nama Anda sendiri. Semua properti dalam contoh berikut diperlukan. Beberapa nilai properti juga diperlukan, tetapi beberapa di antaranya*replaceable*.
Jika Anda menjalankan tugas Amazon ECS seperti yang dijelaskan di bagian Kredensial, Anda perlu menambahkan [peran IAM tugas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) yang ada, ke contoh.
**penting**
Fargate harus menggunakan nilai port yang lebih besar dari 1024.
**Example Definisi tugas JSON untuk Amazon ECS - Fargate pada wadah Linux**
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "0.5 vCPU",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example Definisi tugas JSON untuk Amazon ECS dengan - AWS X-Ray Fargate pada wadah Linux**
X-Ray memungkinkan Anda mengumpulkan data tentang permintaan yang dilayani aplikasi dan menyediakan alat yang dapat Anda gunakan untuk memvisualisasikan arus lalu lintas. Menggunakan driver X-Ray untuk Utusan memungkinkan Utusan untuk melaporkan informasi penelusuran ke X-Ray. Anda dapat mengaktifkan penelusuran X-Ray menggunakan konfigurasi [Envoy](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html). Berdasarkan konfigurasi, Envoy mengirimkan data penelusuran ke daemon X-Ray yang berjalan sebagai wadah [sespan](https://docs.aws.amazon.com/xray/latest/devguide/xray-daemon-ecs.html) dan daemon meneruskan jejak ke layanan X-Ray. Setelah jejak dipublikasikan ke X-Ray, Anda dapat menggunakan konsol X-Ray untuk memvisualisasikan grafik panggilan layanan dan meminta detail jejak. JSON berikut merupakan definisi tugas untuk mengaktifkan integrasi X-Ray.
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "512",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
},
{
"name" : "xray-daemon",
"image" : "amazon/aws-xray-daemon",
"user" : "1337",
"essential" : true,
"cpu" : "32",
"memoryReservation" : "256",
"portMappings" : [
{
"containerPort" : 2000,
"protocol" : "udp"
}
]
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example Definisi tugas JSON untuk Amazon ECS - Jenis peluncuran EC2**
```
{
"family": "taskB",
"memory": "256",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
**Example Definisi tugas JSON untuk Amazon ECS dengan AWS X-Ray - tipe peluncuran EC2**
```
{
"family": "taskB",
"memory": "256",
"cpu" : "1024",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
},
{
"name": "xray-daemon",
"image": "amazon/aws-xray-daemon",
"user": "1337",
"essential": true,
"cpu": 32,
"memoryReservation": 256,
"portMappings": [
{
"containerPort": 2000,
"protocol": "udp"
}
]
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
## Topik lanjutan
### Penerapan Canary menggunakan App Mesh
Penerapan dan rilis Canary membantu Anda mengalihkan lalu lintas antara versi lama aplikasi dan versi yang baru digunakan. Ini juga memantau kesehatan versi yang baru digunakan. Jika ada masalah dengan versi baru, penyebaran kenari dapat secara otomatis mengalihkan lalu lintas kembali ke versi lama. Penerapan Canary memberi Anda kemampuan untuk mengalihkan lalu lintas antar versi aplikasi dengan kontrol lebih besar.
Untuk informasi selengkapnya tentang cara menerapkan penerapan canary untuk Amazon ECS menggunakan App Mesh, lihat [Membuat pipeline dengan penerapan canary untuk Amazon ECS menggunakan App Mesh](https://aws.amazon.com/blogs/containers/create-a-pipeline-with-canary-deployments-for-amazon-ecs-using-aws-app-mesh/)
**catatan**
Untuk contoh dan penelusuran lainnya untuk App Mesh, lihat repositori contoh [App Mesh](https://github.com/aws/aws-app-mesh-examples).