Skenario Prasyarat Langkah 1: Buat mesh dan layanan virtual Langkah 2: Buat simpul virtual Langkah 3: Buat router virtual dan rute Langkah 4: Tinjau dan buat Langkah 5: Buat sumber daya tambahan Langkah 6: Perbarui layanan

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.

Topik ini membantu Anda menggunakan AWS App Mesh layanan aktual yang berjalan di AmazonEC2. 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 danserviceB.
Kedua layanan terdaftar ke namespace bernama. apps.local
ServiceAberkomunikasi dengan serviceB lebih 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 keserviceBv2, Anda dapat memvalidasi bahwa itu bebas bug sebelum Anda mengirim 100 persen lalu lintas dariserviceA.
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 keserviceBv2, Anda ingin berhentiserviceB.
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 denganDNS, AWS Cloud Map, atau keduanya. Untuk menggunakan panduan memulai ini, kami sarankan Anda memiliki tiga layanan yang sudah ada yang terdaftarDNS. 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 EC2 instans Amazon dan menyebarkan aplikasi ke sana. Untuk informasi selengkapnya, lihat Tutorial: Memulai instans Amazon EC2 Linux di Panduan EC2 Pengguna Amazon. Langkah-langkah yang tersisa mengasumsikan bahwa layanan yang sebenarnya diberi nama serviceAserviceB,, 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. Layanan virtual adalah abstraksi dari layanan yang sebenarnya. Untuk informasi selengkapnya, lihat Layanan virtual.

Buat sumber daya berikut:

Sebuah mesh bernamaapps, karena semua layanan dalam skenario terdaftar ke apps.local namespace.
Layanan virtual bernamaserviceb.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 AWS Management Console 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 Pilih tab untuk alat yang ingin Anda gunakan.

Langkah 2: Buat simpul virtual

Node virtual bertindak sebagai pointer logis ke layanan yang sebenarnya. Untuk informasi selengkapnya, lihat Node virtual.

Buat node virtual bernamaserviceB, karena salah satu node virtual mewakili layanan yang sebenarnya bernamaserviceB. Layanan aktual yang diwakili oleh node virtual dapat ditemukan melalui DNS dengan nama host. 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.

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, silakan lihat Router virtual dan Rute.

Buat sumber daya berikut:

Router virtual bernamaserviceB, 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 bernamaserviceB. 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.

AWS Management Console

Untuk nama router Virtual, masukkanserviceB.
Di bawah konfigurasi Listener, pilih http2 untuk Protokol dan tentukan 80 untuk Port.
Untuk nama Rute, masukkanserviceB.
Untuk jenis Rute, pilih http2.
Untuk nama simpul Virtual di bawah konfigurasi Target, pilih serviceB dan masukkan 100 untuk Berat.
Di bawah konfigurasi Match, pilih Metode.
Untuk melanjutkan, pilih Berikutnya.

AWS CLI

Buat router virtual.

Buat file bernama create-virtual-router.json dengan konten berikut:


{
    "meshName": "apps",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 80,
                    "protocol": "http2"
                }
            }
        ]
    },
    "virtualRouterName": "serviceB"
}

Buat router virtual dengan create-virtual-routerperintah menggunakan JSON file sebagai input.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```

Buat rute.

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"
}

Buat rute dengan perintah create-route menggunakan JSON file sebagai input.
```
aws appmesh create-route --cli-input-json file://create-route.json
```

Langkah 4: Tinjau dan buat

Tinjau pengaturan terhadap instruksi sebelumnya.

Langkah 5: Buat sumber daya tambahan

Untuk menyelesaikan skenario, Anda perlu:

Buat satu node virtual bernama serviceBv2 dan yang lain bernamaserviceA. Kedua node virtual mendengarkan permintaan di atas 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 bernamaserviceb.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 bernamaservicea.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 dikirimserviceBv2, 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.

AWS Management Console

Di panel navigasi kiri, pilih Meshes.
Pilih apps mesh yang Anda buat pada langkah sebelumnya.
Di panel navigasi kiri, pilih Virtual nodes.
Pilih Buat simpul virtual.
Untuk nama simpul Virtual, masukkanserviceBv2, untuk metode Penemuan layanan, pilih DNS, dan untuk DNSnama host, masukkanservicebv2.apps.local.
Untuk konfigurasi Listener, pilih http2 untuk Protokol dan masukkan 80 untuk Port.
Pilih Buat simpul virtual.
Pilih Buat simpul virtual lagi. Masukkan serviceA untuk nama simpul Virtual. Untuk metode Penemuan layanan, pilih DNS, dan untuk DNSnama host, masukkanservicea.apps.local.
Untuk Masukkan nama layanan virtual di bawah Backend baru, masukkan. serviceb.apps.local
Di bawah konfigurasi Listener, pilih http2 untuk Protokol, masukkan 80 untuk Port, lalu pilih Buat simpul virtual.
Di panel navigasi kiri, pilih Router virtual dan kemudian pilih router serviceB virtual dari daftar.
Di bawah Rute, pilih rute bernama ServiceB yang Anda buat pada langkah sebelumnya, dan pilih Edit.
Di bawah Target, nama node Virtual, ubah nilai Weight serviceB untuk menjadi75.
Pilih Tambah target, pilih serviceBv2 dari daftar dropdown, dan atur nilai Weight ke. 25
Pilih Simpan.
Di panel navigasi kiri, pilih Layanan virtual dan kemudian pilih Buat layanan virtual.
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

Buat simpul serviceBv2 virtual.

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"
}

Buat simpul virtual.


aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json

Buat simpul serviceA virtual.

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"
}

Buat simpul virtual.


aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json

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"
}
```
2. Perbarui layanan virtual dengan update-virtual-serviceperintah.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```

Perbarui serviceB rute yang Anda buat di langkah sebelumnya.

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"
}

Perbarui rute dengan perintah update-route.


aws appmesh update-route --cli-input-json file://update-route.json

Buat layanan serviceA virtual.

Buat file bernama create-virtual-servicea.json dengan konten berikut:


{
   "meshName" : "apps",
   "spec" : {
      "provider" : {
         "virtualNode" : {
            "virtualNodeName" : "serviceA"
         }
      }
   },
   "virtualServiceName" : "servicea.apps.local"
}

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 bernamaservicea.apps.local,serviceb.apps.local, danservicebv2.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 bernamaserviceA,serviceB, danserviceBv2. 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, lihatOtorisasi Proxy Utusan.
Untuk memperbarui layanan Anda yang ada, selesaikan langkah-langkah berikut.

Untuk mengonfigurasi EC2 instans Amazon sebagai anggota node virtual

Buat IAM peran.

Buat file bernama ec2-trust-relationship.json dengan isi berikut ini.


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

Buat IAM peran dengan perintah berikut.


aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json

Lampirkan IAM kebijakan 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. appsadalah nama mesh yang Anda buat Langkah 1: Buat mesh dan layanan virtual dan serviceB merupakan nama node virtual yang Anda buatLangkah 2: Buat simpul virtual. Ganti 111122223333 dengan ID akun Anda dan us-west-2 dengan Wilayah tempat Anda membuat mesh Anda.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "appmesh:StreamAggregatedResources",
            "Resource": [
                "arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
            ]
        }
    ]
}
```
2. Buat kebijakan dengan perintah berikut.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
3. 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
```
4. 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
```
Luncurkan EC2 instans Amazon dengan IAM peran yang Anda buat.
Connect ke instans Anda melaluiSSH.
Instal Docker dan AWS CLI pada instance Anda sesuai dengan dokumentasi sistem operasi Anda.

Otentikasi ke repositori Envoy ECR Amazon di Wilayah tempat Anda ingin klien Docker Anda menarik gambarnya.

Semua Wilayah kecualime-south-1,ap-east-1,ap-southeast-3,eu-south-1,il-central-1, danaf-south-1. Anda dapat mengganti us-west-2 dengan Wilayah yang didukung kecualime-south-1,ap-east-1,ap-southeast-3,eu-south-1,il-central-1, danaf-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

Jalankan salah satu perintah berikut untuk memulai container App Mesh Envoy pada instance Anda, bergantung pada Region mana Anda ingin menarik gambarnya. Bagian apps and serviceB nilai 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 EC2 instans Amazon 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 kecualime-south-1,ap-east-1,ap-southeast-3,eu-south-1,il-central-1, danaf-south-1. Anda dapat mengganti Region-code dengan setiap Wilayah yang didukung kecualime-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 dan2147483647.
```
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.29.6.1-prod
```
- me-south-1Wilayah. Anda dapat mengganti 1337 dengan nilai apa pun antara 0 dan2147483647.
```
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.29.6.1-prod
```
- ap-east-1Wilayah. Anda dapat mengganti 1337 dengan nilai apa pun antara 0 dan2147483647.
```
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.29.6.1-prod
```
catatan
APPMESH_RESOURCE_ARNProperti memerlukan versi 1.15.0 atau yang lebih baru dari gambar Utusan. Untuk informasi selengkapnya, lihat Gambar utusan.

penting
Hanya versi v1.9.0.0-prod atau yang lebih baru yang didukung untuk digunakan dengan App Mesh.

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 nilainyaAPPMESH_IGNORE_UID, tetapi nilainya harus sama dengan nilai yang Anda tentukan pada langkah sebelumnya; misalnya1337. 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

Tampilkan lebih banyak

Tampilkan lebih sedikit

Untuk mengonfigurasi iptables aturan untuk merutekan lalu lintas aplikasi ke proxy Envoy, jalankan skrip yang Anda buat di langkah sebelumnya.
```
sudo ./envoy-networking.sh
```
Mulai kode aplikasi node virtual Anda.

catatan

Untuk contoh dan penelusuran lainnya untuk App Mesh, lihat repositori contoh App Mesh.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

App Mesh dan Kubernetes

Contoh App Mesh