Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Guida introduttiva AWS App Mesh ad Amazon EC2
**Importante**
Avviso di fine del supporto: il 30 settembre 2026, AWS interromperà il supporto per. AWS App Mesh Dopo il 30 settembre 2026, non potrai più accedere alla AWS App Mesh console o alle risorse. AWS App Mesh Per ulteriori informazioni, consulta questo post di blog [Migrazione AWS App Mesh da Amazon ECS Service Connect.](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect)
Questo argomento ti aiuta a AWS App Mesh utilizzarlo con un servizio effettivo in esecuzione su Amazon EC2. Questo tutorial copre le funzionalità di base di diversi tipi di risorse App Mesh.
## Scenario
Per illustrare come utilizzare App Mesh, supponiamo di avere un'applicazione con le seguenti caratteristiche:
+ È costituito da due servizi denominati `serviceA` e`serviceB`.
+ Entrambi i servizi sono registrati in uno spazio dei nomi denominato `apps.local`.
+ `ServiceA` comunica con `serviceB` su HTTP/2, porta 80.
+ Hai già distribuito la versione 2 di `serviceB` e l'hai registrata con il nome `serviceBv2` nello spazio dei nomi `apps.local`.
I requisiti sono i seguenti:
+ Vuoi inviare il 75 percento del traffico da `serviceA` a `serviceB` e il 25 percento del traffico a `serviceBv2` First. Inviando solo il 25 percento a`serviceBv2`, puoi verificare che sia privo di bug prima di inviare il 100% del traffico da`serviceA`.
+ Vuoi essere in grado di regolare facilmente la ponderazione del traffico in modo che il 100% del traffico vada a `serviceBv2` una volta dimostrato essere affidabile. Una volta inviato tutto il traffico a`serviceBv2`, vuoi `serviceB` interromperlo.
+ Per soddisfare i requisiti precedenti non è necessario modificare il codice dell'applicazione esistente o la registrazione di Service Discovery per usufruire dei servizi effettivi.
Per soddisfare le tue esigenze, decidi di creare una mesh di servizi App Mesh con servizi virtuali, nodi virtuali, un router virtuale e un percorso. Dopo aver implementato la mesh, aggiorni i servizi per utilizzare il proxy Envoy. Una volta aggiornati, i servizi comunicano tra loro tramite il proxy Envoy anziché direttamente tra loro.
## Prerequisiti
App Mesh supporta i servizi Linux registrati con DNS o entrambi. AWS Cloud Map Per utilizzare questa guida introduttiva, è consigliabile avere tre servizi esistenti registrati con DNS. Puoi creare una mesh dei servizi e le relative risorse anche se i servizi non esistono, ma non puoi utilizzare la mesh fino a quando non hai distribuito i servizi effettivi.
Se non disponi già di servizi in esecuzione, puoi avviare istanze Amazon EC2 e distribuirvi applicazioni. Per ulteriori informazioni, consulta [Tutorial: Guida introduttiva alle istanze Amazon EC2 Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-lamp-amazon-linux-2.html) nella Amazon EC2 User Guide. Le fasi rimanenti presuppongono che i servizi effettivi siano denominati `serviceA`, `serviceB` e `serviceBv2` e che tutti i servizi siano individuabili tramite uno spazio dei nomi denominato `apps.local`.
## Fase 1: creare una mesh e un servizio virtuale
Una mesh dei servizi è un limite logico per il traffico di rete tra i servizi che si trovano al suo interno. Per ulteriori informazioni, consulta [Reti di servizio](meshes.md). Un servizio virtuale è un'astrazione di un servizio effettivo. Per ulteriori informazioni, consulta [Servizi virtuali](virtual_services.md).
Crea le seguenti risorse:
+ Una mesh denominata `apps`, perché tutti i servizi nello scenario sono registrati nello spazio dei nomi `apps.local`.
+ Un servizio virtuale denominato `serviceb.apps.local` perché il servizio virtuale rappresenta un servizio individuabile tramite questo nome e non vuoi modificare il codice per fare riferimento a un altro nome. Un servizio virtuale denominato `servicea.apps.local` viene aggiunto in una fase successiva.
Puoi utilizzare la AWS CLI versione 1.18.116 Console di gestione AWS o successiva o 2.0.38 o successiva per completare i seguenti passaggi. Se si utilizza il AWS CLI, utilizzare il `aws --version` comando per verificare la versione installata. AWS CLI Se non hai installato la versione 1.18.116 o successiva o 2.0.38 o successiva, devi [installare](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html) o aggiornare la. AWS CLI Seleziona la scheda relativa allo strumento che desideri utilizzare.
------
#### [ Console di gestione AWS ]
1. [Apri la procedura guidata per la prima esecuzione della console App Mesh all'iniziohttps://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Per **Mesh name (Nome mesh)**, immettere **apps**.
1. Per **Virtual service name (Nome servizio virtuale)**, immettere **serviceb.apps.local**.
1. Scegliere **Next (Avanti)** per continuare.
------
#### [ AWS CLI ]
1. Creare una mesh con il comando `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`.
```
aws appmesh create-mesh --mesh-name apps
```
1. Creare un servizio virtuale con il comando `[create-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-service.html)`.
```
aws appmesh create-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local --spec {}
```
------
## Fase 2: creare un nodo virtuale
Un nodo virtuale funziona come un puntatore logico a un servizio effettivo. Per ulteriori informazioni, consulta [Nodi virtuali](virtual_nodes.md).
Crea un nodo virtuale denominato `serviceB` perché uno dei nodi virtuali rappresenta il servizio effettivo denominato `serviceB`. Il servizio effettivo rappresentato dal nodo virtuale è individuabile tramite `DNS` con il nome host `serviceb.apps.local`. In alternativa, puoi individuare i servizi effettivi utilizzando AWS Cloud Map. Il nodo virtuale ascolta il traffico utilizzando il protocollo HTTP/2 sulla porta 80. Sono supportati anche altri protocolli, così come i controlli di stato. I nodi virtuali vengono creati per `serviceA` e `serviceBv2` in una fase successiva.
------
#### [ Console di gestione AWS ]
1. Per **Virtual node name (Nome nodo virtuale)**, immettere **serviceB**.
1. Per **Modalità di rilevamento del servizio**, scegli **DNS** e immetti **serviceb.apps.local** per **Nome host DNS**.
1. In **Configurazione del listener**, scegli **http2** per **Protocollo** e immetti **80** per **Porta**.
1. Scegliere **Next (Avanti)** per continuare.
------
#### [ AWS CLI ]
1. Crea un file denominato `create-virtual-node-serviceb.json` con i seguenti contenuti:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Crea il nodo virtuale con il [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)comando utilizzando il file JSON come input.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Fase 3: creare un router virtuale e una route
I router virtuali gestiscono il traffico per uno o più servizi virtuali all'interno della mesh. Per ulteriori informazioni, consultare [Router virtuali](virtual_routers.md) e [Percorsi](routes.md).
Crea le seguenti risorse:
+ Un router virtuale denominato `serviceB` perché il servizio virtuale `serviceB.apps.local` non avvia la comunicazione in uscita con altri servizi. Tieni presente che il servizio virtuale creato in precedenza è un'astrazione del servizio `serviceb.apps.local` effettivo. Il servizio virtuale invia il traffico al router virtuale. Il router virtuale ascolta il traffico utilizzando il protocollo HTTP/2 sulla porta 80. Sono supportati anche altri protocolli.
+ Una route denominata `serviceB`. Indirizza il 100% del traffico verso il `serviceB` nodo virtuale. Il peso viene calcolato in una fase successiva dopo l'aggiunta del nodo `serviceBv2` virtuale. Sebbene non sia trattato in questa guida, è possibile impostare criteri di filtro aggiuntivi per la route e aggiungere una policy per i nuovi tentativi per far sì che il proxy Envoy effettui più tentativi di invio del traffico a un nodo virtuale quando si verifica un problema di comunicazione.
------
#### [ Console di gestione AWS ]
1. Per **Virtual router name (Nome router virtuale)**, immettere **serviceB**.
1. In **Configurazione del listener**, scegli **http2** per **Protocollo** e specifica **80** per **Porta**.
1. Per **Route name (Nome route)**, immettere **serviceB**.
1. Per **Tipo di route**, scegli **http2**.
1. Per **il nome del nodo virtuale** nella **configurazione Target**, seleziona `serviceB` e inserisci **100** **Weight**.
1. In **Match configuration**, scegli un **metodo**.
1. Scegliere **Next (Avanti)** per continuare.
------
#### [ AWS CLI ]
1. Creare un router virtuale.
1. Crea un file denominato `create-virtual-router.json` con i seguenti contenuti:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Crea il router virtuale con il [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)comando utilizzando il file JSON come input.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Creare una route.
1. Crea un file denominato `create-route.json` con i seguenti contenuti:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Creare la route con il comando [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) utilizzando il file JSON come input.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Fase 4: Revisione e creazione
Rivedi le impostazioni in relazione alle istruzioni precedenti.
------
#### [ Console di gestione AWS ]
Scegli **Modifica** per apportare modifiche in qualsiasi sezione. Una volta soddisfatte le impostazioni, scegli **Crea una mesh**.
La schermata **Stato** mostra tutte le risorse mesh create. Puoi visualizzare le risorse create nella console selezionando **Visualizza mesh**.
------
#### [ AWS CLI ]
Esaminare le impostazioni della mesh creata con il comando [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html) .
```
aws appmesh describe-mesh --mesh-name apps
```
Rivedi le impostazioni del servizio virtuale che hai creato con il [describe-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-service.html)comando.
```
aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local
```
Rivedi le impostazioni del nodo virtuale che hai creato con il [describe-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-node.html)comando.
```
aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB
```
Rivedi le impostazioni del router virtuale che hai creato con il [describe-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-router.html)comando.
```
aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB
```
Esaminare le impostazioni del percorso creato con il comando [describe-route](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
```
------
## Fase 5: creare risorse aggiuntive
Per completare lo scenario è necessario:
+ Creare un nodo virtuale denominato `serviceBv2` e un altro denominato `serviceA`. Entrambi i nodi virtuali ascoltano le richieste su HTTP/2, porta 80. Per il nodo `serviceA` virtuale, configura un backend di`serviceb.apps.local`. Tutto il traffico in uscita dal nodo `serviceA` virtuale viene inviato al servizio virtuale denominato. `serviceb.apps.local` Sebbene non sia trattato in questa guida, è anche possibile specificare un percorso file in cui scrivere i log degli accessi per un nodo virtuale.
+ Crea un servizio virtuale aggiuntivo denominato`servicea.apps.local`, che invia tutto il traffico direttamente al nodo `serviceA` virtuale.
+ Aggiornare la route `serviceB` creata in una fase precedente per inviare il 75% del traffico al nodo virtuale `serviceB` e il 25% del traffico al nodo virtuale `serviceBv2`. È possibile continuare a modificare i pesi finché `serviceBv2` riceva il 100% del traffico. Una volta inviato tutto il traffico a`serviceBv2`, puoi chiudere e interrompere il nodo `serviceB` virtuale e il servizio effettivo. Quando si cambiano i pesi, il codice non richiede alcuna modifica perché i nomi dei servizi virtuali ed effettivi `serviceb.apps.local` non cambiano. Tenere presente che il servizio virtuale `serviceb.apps.local` invia il traffico al router virtuale che instrada il traffico ai nodi virtuali. I nomi di individuazione dei servizi per i nodi virtuali possono essere modificati in qualsiasi momento.
------
#### [ Console di gestione AWS ]
1. Nel riquadro di navigazione a sinistra, selezionare **Meshes (Mesh)**.
1. Selezionare la mesh `apps` creata in una fase precedente.
1. Nel riquadro di navigazione a sinistra selezionare **Virtual nodes (Nodi virtuali)**.
1. Scegliere **Create virtual node (Crea nodo virtuale)**.
1. Per **Nome del nodo virtuale** immetti **serviceBv2**, per **Modalità di rilevamento del servizio** scegli **DNS** e per **Nome host DNS** immetti **servicebv2.apps.local**.
1. Per **Configurazione del listener** seleziona **http2** per **Protocollo** e immetti **80** per **Porta**.
1. Scegliere **Create virtual node (Crea nodo virtuale)**.
1. Scegli **Crea un nodo virtuale**. Immetti **serviceA** per **Nome del nodo virtuale**. Per **Modalità di rilevamento del servizio** scegli **DNS** e per **Nome host DNS** immetti **servicea.apps.local**.
1. Per **Inserisci un nome del servizio virtuale** in **Nuovo back-end** immetti **serviceb.apps.local**.
1. In **Configurazione del listener** scegli **http2** per **Protocollo**, immetti **80** per **Porta** e quindi scegli **Crea un nodo virtuale**.
1. Nel riquadro di navigazione a sinistra selezionare** Virtual routers (Router virtuali)** quindi selezionare il router virtuale `serviceB` dall'elenco.
1. In **Route**, seleziona la route denominata `ServiceB` creata in una fase precedente e scegli **Modifica**.
1. In **Destinazioni**, **Nome del nodo virtuale**, cambia il valore di **Peso** per `serviceB` su **75**.
1. Scegli **Aggiungi obiettivo**, scegli `serviceBv2` dall'elenco a discesa e imposta il valore di **Weight** su. **25**
1. Scegli **Save** (Salva).
1. Nel riquadro di navigazione a sinistra seleziona **Servizi virtuali**, quindi scegli **Crea un servizio virtuale**.
1. Immetti **servicea.apps.local** per **Nome del servizio virtuale**, seleziona **Nodo virtuale** per **Provider**, seleziona `serviceA` per **Nodo virtuale** e quindi scegli **Crea un servizio virtuale.**
------
#### [ AWS CLI ]
1. Creare il nodo virtuale `serviceBv2`.
1. Crea un file denominato `create-virtual-node-servicebv2.json` con i seguenti contenuti:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Creare il nodo virtuale.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Creare il nodo virtuale `serviceA`.
1. Crea un file denominato `create-virtual-node-servicea.json` con i seguenti contenuti:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Creare il nodo virtuale.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Aggiornare il servizio virtuale `serviceb.apps.local` creato in una fase precedente per inviare il traffico al router virtuale `serviceB`. Quando il servizio virtuale è stato originariamente creato non inviava traffico poiché il router virtuale `serviceB` non era ancora stato creato.
1. Crea un file denominato `update-virtual-service.json` con i seguenti contenuti:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Aggiorna il servizio virtuale con il [update-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-virtual-service.html)comando.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```
1. Aggiornare la route `serviceB` creata in una fase precedente.
1. Crea un file denominato `update-route.json` con i seguenti contenuti:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Aggiornare la route con il comando [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. Creare il servizio virtuale `serviceA`.
1. Crea un file denominato `create-virtual-servicea.json` con i seguenti contenuti:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Creare il servizio virtuale.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Riepilogo della mesh**
Prima di creare la mesh dei servizi, erano presenti tre servizi effettivi denominati `servicea.apps.local`, `serviceb.apps.local` e `servicebv2.apps.local`. Oltre ai servizi effettivi, ora hai una mesh dei servizi che contiene le seguenti risorse che rappresentano i servizi effettivi:
+ Due servizi virtuali. Il proxy invia tutto il traffico dal servizio virtuale `servicea.apps.local` al servizio virtuale `serviceb.apps.local` tramite un router virtuale.
+ Tre nodi virtuali denominati `serviceA`, `serviceB` e `serviceBv2`. Il proxy Envoy utilizza le informazioni di individuazione dei servizi configurate per i nodi virtuali per cercare gli indirizzi IP dei servizi effettivi.
+ Un router virtuale con una route che indica al proxy Envoy di indirizzare il 75% del traffico in ingresso al nodo virtuale `serviceB` e il 25% del traffico al nodo virtuale `serviceBv2`.
## Fase 6: aggiornare i servizi
Dopo aver creato la mesh, è necessario completare le seguenti attività:
+ Autorizza il proxy Envoy che distribuisci con ogni servizio a leggere la configurazione di uno o più nodi virtuali. Per ulteriori informazioni su come autorizzare il proxy, vedere. [Autorizzazione Envoy Proxy](proxy-authorization.md)
+ Per aggiornare il servizio esistente, completa i passaggi seguenti.
**Per configurare un'istanza Amazon EC2 come membro di un nodo virtuale**
1. Crea un ruolo IAM.
1. Crea un file denominato `ec2-trust-relationship.json` con i seguenti contenuti.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Crea un ruolo IAM con il seguente comando.
```
aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json
```
1. Allega le policy IAM al ruolo che gli consentono di leggere da Amazon ECR e solo la configurazione di uno specifico nodo virtuale App Mesh.
1. Crea un file denominato `virtual-node-policy.json` con il seguente contenuto. `apps` è il nome della mesh creata in [Fase 1: creare una mesh e un servizio virtuale](#create-mesh-and-virtual-service) e `serviceB` è il nome del nodo virtuale creato in [Fase 2: creare un nodo virtuale](#create-virtual-node). Sostituiscilo *111122223333* con l'ID del tuo account e *us-west-2* con la regione in cui hai creato la 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. Creare la policy con il seguente comando.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
1. Allega la policy che hai creato nel passaggio precedente al ruolo in modo che il ruolo possa leggere la configurazione solo per il nodo `serviceB` virtuale da 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. Allega la policy `AmazonEC2ContainerRegistryReadOnly` gestita al ruolo in modo che possa estrarre l'immagine del contenitore Envoy da Amazon ECR.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly --role-name mesh-virtual-node-service-b
```
1. [Avvia un'istanza Amazon EC2 con il ruolo IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) che hai creato.
1. Eseguire la connessione all'istanza tramite SSH.
1. Installa Docker and the AWS CLI sulla tua istanza in base alla documentazione del sistema operativo.
1. Effettua l'autenticazione nel repository Amazon ECR di Envoy nella regione da cui desideri che il client Docker estragga l'immagine.
+ Tutte le regioni tranne`me-south-1`,,,, e`ap-east-1`. `ap-southeast-3` `eu-south-1` `il-central-1` `af-south-1` È possibile *us-west-2* sostituirla con qualsiasi [regione supportata](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) ad eccezione di `me-south-1` `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`,, e`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
```
+ Regione `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
```
+ Regione `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. Esegui uno dei seguenti comandi per avviare il contenitore App Mesh Envoy sulla tua istanza, a seconda della regione da cui desideri estrarre l'immagine. I *serviceB* valori *apps* e sono i nomi della mesh e dei nodi virtuali definiti nello scenario. Queste informazioni indicano al proxy quale configurazione del nodo virtuale leggere da App Mesh. Per completare lo scenario, è inoltre necessario completare questi passaggi per le istanze Amazon EC2 che ospitano i servizi rappresentati dai nodi virtuali`serviceBv2`. `serviceA` Per la propria applicazione, sostituire questi valori con quelli appropriati.
+ Tutte le regioni tranne`me-south-1`,`ap-east-1`,`ap-southeast-3`, `eu-south-1``il-central-1`, e. `af-south-1` È possibile *Region-code* sostituirla con qualsiasi [regione supportata](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) ad eccezione di `me-south-1``ap-east-1`,`ap-southeast-3`,`eu-south-1`,`il-central-1`, e `af-south-1` Regioni. Puoi sostituire `1337` con qualsiasi valore compreso tra `0` e `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
```
+ Regione `me-south-1`. Puoi sostituire `1337` con qualsiasi valore compreso tra `0` e `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
```
+ Regione `ap-east-1`. Puoi sostituire `1337` con qualsiasi valore compreso tra `0` e `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
```
**Nota**
La `APPMESH_RESOURCE_ARN` proprietà richiede una versione `1.15.0` o successiva dell'immagine Envoy. Per ulteriori informazioni, consulta [Immagine dell'inviato](envoy.md).
**Importante**
Solo la versione v1.9.0.0-prod o successiva è supportata per l'uso con App Mesh.
1. Seleziona `Show more` di seguito. Crea un file denominato `envoy-networking.sh` nell'istanza con i seguenti contenuti. *8000*Sostituiscila con la porta utilizzata dal codice dell'applicazione per il traffico in entrata. Puoi modificare il valore per `APPMESH_IGNORE_UID`, ma il valore deve essere uguale a quello specificato nel passaggio precedente, ad esempio `1337`. Se necessario puoi aggiungere altri indirizzi in `APPMESH_EGRESS_IGNORED_IP`. Non modificare altre righe.
```
#!/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. Per configurare le regole `iptables` per instradare il traffico dell'applicazione al proxy Envoy, esegui lo script creato nel passaggio precedente.
```
sudo ./envoy-networking.sh
```
1. Avviare il codice dell'applicazione del nodo virtuale.
**Nota**
Per altri esempi e procedure dettagliate per App Mesh, consulta l'archivio degli esempi di [App Mesh](https://github.com/aws/aws-app-mesh-examples).