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 EC2
**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 EC2. 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
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. 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.
Jika Anda belum menjalankan layanan, Anda dapat meluncurkan instans Amazon EC2 dan menyebarkan aplikasi ke dalamnya. Untuk informasi selengkapnya, lihat [Tutorial: Memulai instans Amazon EC2 Linux di Panduan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-lamp-amazon-linux-2.html) Pengguna Amazon EC2. Langkah-langkah yang tersisa mengasumsikan bahwa layanan yang sebenarnya diberi nama `serviceA``serviceB`,, `serviceBv2` dan bahwa semua layanan dapat ditemukan melalui namespace bernama. `apps.local`
## 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 AWS CLI versi 1.18.116 Konsol Manajemen AWS 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 mendengarkan lalu lintas menggunakan protokol HTTP/2 pada port 80. Protokol lain juga didukung, seperti halnya pemeriksaan kesehatan. Anda 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 simpul 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 gunakan dengan setiap layanan untuk membaca konfigurasi satu atau lebih node virtual. Untuk informasi selengkapnya tentang cara mengotorisasi proxy, lihat[Otorisasi Proxy Utusan](proxy-authorization.md).
+ Untuk memperbarui layanan Anda yang ada, selesaikan langkah-langkah berikut.
**Untuk mengonfigurasi instans Amazon EC2 sebagai anggota node virtual**
1. Buat peran IAM.
1. Buat file bernama `ec2-trust-relationship.json` dengan isi berikut ini.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Buat peran IAM dengan perintah berikut.
```
aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json
```
1. Lampirkan kebijakan IAM ke peran yang memungkinkannya membaca dari Amazon ECR dan hanya konfigurasi node virtual App Mesh tertentu.
1. Buat file bernama `virtual-node-policy.json` dengan konten berikut. `apps`adalah nama mesh yang Anda buat [Langkah 1: Buat mesh dan layanan virtual](#create-mesh-and-virtual-service) dan `serviceB` merupakan nama node virtual yang Anda buat[Langkah 2: Buat simpul virtual](#create-virtual-node). Ganti *111122223333* dengan ID akun Anda dan *us-west-2* dengan Wilayah tempat Anda membuat mesh.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
]
}
]
}
```
------
1. Buat kebijakan dengan perintah berikut.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
1. Lampirkan kebijakan yang Anda buat di langkah sebelumnya ke peran sehingga peran dapat membaca konfigurasi hanya untuk node `serviceB` virtual dari App Mesh.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::111122223333:policy/virtual-node-policy --role-name mesh-virtual-node-service-b
```
1. Lampirkan kebijakan `AmazonEC2ContainerRegistryReadOnly` terkelola ke peran sehingga dapat menarik image container Envoy dari Amazon ECR.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly --role-name mesh-virtual-node-service-b
```
1. [Luncurkan instans Amazon EC2 dengan peran IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) yang Anda buat.
1. Connect ke instans Anda melalui SSH.
1. Instal Docker dan AWS CLI pada instance Anda sesuai dengan dokumentasi sistem operasi Anda.
1. Otentikasi ke repositori Envoy Amazon ECR di Wilayah tempat Anda ingin klien Docker Anda menarik gambarnya.
+ Semua Wilayah kecuali`me-south-1`,`ap-east-1`,`ap-southeast-3`,`eu-south-1`,`il-central-1`, dan`af-south-1`. Anda dapat mengganti *us-west-2* dengan [Wilayah yang didukung](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) kecuali`me-south-1`,,`ap-east-1`,`ap-southeast-3`,`eu-south-1`,`il-central-1`, dan`af-south-1`.
```
$aws ecr get-login-password \
--region us-west-2 \
| docker login \
--username AWS \
--password-stdin 840364872350.dkr.ecr.us-west-2.amazonaws.com
```
+ Wilayah `me-south-1`
```
$aws ecr get-login-password \
--region me-south-1 \
| docker login \
--username AWS \
--password-stdin 772975370895.dkr.ecr.me-south-1.amazonaws.com
```
+ Wilayah `ap-east-1`
```
$aws ecr get-login-password \
--region ap-east-1 \
| docker login \
--username AWS \
--password-stdin 856666278305.dkr.ecr.ap-east-1.amazonaws.com
```
1. Jalankan salah satu perintah berikut untuk memulai container App Mesh Envoy pada instance Anda, bergantung pada Region mana Anda ingin menarik gambarnya. *serviceB*Nilai-nilai *apps* dan adalah mesh dan nama node virtual yang didefinisikan dalam skenario. Informasi ini memberi tahu proxy konfigurasi node virtual mana yang akan dibaca dari App Mesh. Untuk menyelesaikan skenario, Anda juga perlu menyelesaikan langkah-langkah ini untuk instans Amazon EC2 yang meng-host layanan yang diwakili oleh node `serviceBv2` dan `serviceA` virtual. Untuk aplikasi Anda sendiri, ganti nilai-nilai ini dengan milik Anda sendiri.
+ Semua Wilayah kecuali`me-south-1`,`ap-east-1`,`ap-southeast-3`,`eu-south-1`,`il-central-1`, dan`af-south-1`. Anda dapat mengganti *Region-code* dengan [Wilayah apa pun yang didukung](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) kecuali`me-south-1`,`ap-east-1`,`ap-southeast-3`,`eu-south-1`,,`il-central-1`, dan `af-south-1` Wilayah. Anda dapat mengganti `1337` dengan nilai apa pun antara `0` dan`2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ `me-south-1`Wilayah. Anda dapat mengganti `1337` dengan nilai apa pun antara `0` dan`2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ `ap-east-1`Wilayah. Anda dapat mengganti `1337` dengan nilai apa pun antara `0` dan`2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
**catatan**
`APPMESH_RESOURCE_ARN`Properti memerlukan versi `1.15.0` atau yang lebih baru dari gambar Utusan. Untuk informasi selengkapnya, lihat [Gambar utusan](envoy.md).
**penting**
Hanya versi v1.9.0.0-prod atau yang lebih baru yang didukung untuk digunakan dengan App Mesh.
1. Pilih `Show more` di bawah ini. Buat file bernama `envoy-networking.sh` pada instance Anda dengan konten berikut. Ganti *8000* dengan port yang digunakan kode aplikasi Anda untuk lalu lintas masuk. Anda dapat mengubah nilainya`APPMESH_IGNORE_UID`, tetapi nilainya harus sama dengan nilai yang Anda tentukan pada langkah sebelumnya; misalnya`1337`. Anda dapat menambahkan alamat tambahan `APPMESH_EGRESS_IGNORED_IP` jika perlu. Jangan memodifikasi baris lainnya.
```
#!/bin/bash -e
#
# Start of configurable options
#
#APPMESH_START_ENABLED="0"
APPMESH_IGNORE_UID="1337"
APPMESH_APP_PORTS="8000"
APPMESH_ENVOY_EGRESS_PORT="15001"
APPMESH_ENVOY_INGRESS_PORT="15000"
APPMESH_EGRESS_IGNORED_IP="169.254.169.254,169.254.170.2"
# Enable routing on the application start.
[ -z "$APPMESH_START_ENABLED" ] && APPMESH_START_ENABLED="0"
# Enable IPv6.
[ -z "$APPMESH_ENABLE_IPV6" ] && APPMESH_ENABLE_IPV6="0"
# Egress traffic from the processess owned by the following UID/GID will be ignored.
if [ -z "$APPMESH_IGNORE_UID" ] && [ -z "$APPMESH_IGNORE_GID" ]; then
echo "Variables APPMESH_IGNORE_UID and/or APPMESH_IGNORE_GID must be set."
echo "Envoy must run under those IDs to be able to properly route it's egress traffic."
exit 1
fi
# Port numbers Application and Envoy are listening on.
if [ -z "$APPMESH_ENVOY_EGRESS_PORT" ]; then
echo "APPMESH_ENVOY_EGRESS_PORT must be defined to forward traffic from the application to the proxy."
exit 1
fi
# If an app port was specified, then we also need to enforce the proxies ingress port so we know where to forward traffic.
if [ ! -z "$APPMESH_APP_PORTS" ] && [ -z "$APPMESH_ENVOY_INGRESS_PORT" ]; then
echo "APPMESH_ENVOY_INGRESS_PORT must be defined to forward traffic from the APPMESH_APP_PORTS to the proxy."
exit 1
fi
# Comma separated list of ports for which egress traffic will be ignored, we always refuse to route SSH traffic.
if [ -z "$APPMESH_EGRESS_IGNORED_PORTS" ]; then
APPMESH_EGRESS_IGNORED_PORTS="22"
else
APPMESH_EGRESS_IGNORED_PORTS="$APPMESH_EGRESS_IGNORED_PORTS,22"
fi
#
# End of configurable options
#
function initialize() {
echo "=== Initializing ==="
if [ ! -z "$APPMESH_APP_PORTS" ]; then
iptables -t nat -N APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_INGRESS
fi
fi
iptables -t nat -N APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_EGRESS
fi
}
function enable_egress_routing() {
# Stuff to ignore
[ ! -z "$APPMESH_IGNORE_UID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Stuff to ignore ipv6
[ ! -z "$APPMESH_IGNORE_UID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
fi
# The list can contain both IPv4 and IPv6 addresses. We will loop over this list
# to add every IPv4 address into `iptables` and every IPv6 address into `ip6tables`.
[ ! -z "$APPMESH_EGRESS_IGNORED_IP" ] && \
for IP_ADDR in $(echo "$APPMESH_EGRESS_IGNORED_IP" | tr "," "\n"); do
if [[ $IP_ADDR =~ .*:.* ]]
then
[ "$APPMESH_ENABLE_IPV6" == "1" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
else
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
fi
done
# Redirect everything that is not ignored
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic
iptables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Redirect everything that is not ignored ipv6
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic ipv6
ip6tables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
fi
}
function enable_ingress_redirect_routing() {
# Route everything arriving at the application port to Envoy
iptables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local
iptables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Route everything arriving at the application port to Envoy ipv6
ip6tables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local ipv6
ip6tables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
fi
}
function enable_routing() {
echo "=== Enabling routing ==="
enable_egress_routing
if [ ! -z "$APPMESH_APP_PORTS" ]; then
enable_ingress_redirect_routing
fi
}
function disable_routing() {
echo "=== Disabling routing ==="
iptables -t nat -F APPMESH_INGRESS
iptables -t nat -F APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -F APPMESH_INGRESS
ip6tables -t nat -F APPMESH_EGRESS
fi
}
function dump_status() {
echo "=== iptables FORWARD table ==="
iptables -L -v -n
echo "=== iptables NAT table ==="
iptables -t nat -L -v -n
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
echo "=== ip6tables FORWARD table ==="
ip6tables -L -v -n
echo "=== ip6tables NAT table ==="
ip6tables -t nat -L -v -n
fi
}
function clean_up() {
disable_routing
ruleNum=$(iptables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
iptables -t nat -D PREROUTING $ruleNum
ruleNum=$(iptables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
iptables -t nat -D OUTPUT $ruleNum
iptables -t nat -X APPMESH_INGRESS
iptables -t nat -X APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ruleNum=$(ip6tables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
ip6tables -t nat -D PREROUTING $ruleNum
ruleNum=$(ip6tables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
ip6tables -t nat -D OUTPUT $ruleNum
ip6tables -t nat -X APPMESH_INGRESS
ip6tables -t nat -X APPMESH_EGRESS
fi
}
function main_loop() {
echo "=== Entering main loop ==="
while read -p '> ' cmd; do
case "$cmd" in
"quit")
clean_up
break
;;
"status")
dump_status
;;
"enable")
enable_routing
;;
"disable")
disable_routing
;;
*)
echo "Available commands: quit, status, enable, disable"
;;
esac
done
}
function print_config() {
echo "=== Input configuration ==="
env | grep APPMESH_ || true
}
print_config
initialize
if [ "$APPMESH_START_ENABLED" == "1" ]; then
enable_routing
fi
main_loop
```
1. Untuk mengonfigurasi `iptables` aturan untuk merutekan lalu lintas aplikasi ke proxy Envoy, jalankan skrip yang Anda buat di langkah sebelumnya.
```
sudo ./envoy-networking.sh
```
1. Mulai kode aplikasi node virtual Anda.
**catatan**
Untuk contoh dan penelusuran lainnya untuk App Mesh, lihat repositori contoh [App Mesh](https://github.com/aws/aws-app-mesh-examples).