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 ECS
**Importante**
Avviso di fine del supporto: il 30 settembre 2026, AWS interromperà il supporto per. AWS App Mesh Dopo il 30 settembre 2026, non sarà più possibile 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 ECS. 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
**Importante**
Avviso di fine del supporto: il 30 settembre 2026, AWS verrà interrotto il supporto per. AWS App Mesh Dopo il 30 settembre 2026, non sarà più possibile 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)
+ Una comprensione esistente dei concetti di App Mesh. Per ulteriori informazioni, consulta [Che cos'è AWS App Mesh?](what-is-app-mesh.md).
+ Una comprensione esistente dei ECSs concetti di Amazon. Per ulteriori informazioni, consulta [What is Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) nella Amazon Elastic Container Service Developer Guide.
+ 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. Le procedure descritte in questo argomento presuppongono che i servizi esistenti abbiano un nome `serviceA` `serviceBv2` e che tutti i servizi siano individuabili tramite uno spazio dei nomi denominato. `serviceB` `apps.local`
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. Per ulteriori informazioni sulla scoperta dei servizi su Amazon ECS, consulta [Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). Per creare un servizio Amazon ECS con service discovery, consulta [Tutorial: Creazione di un servizio utilizzando Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html). Se non disponi già di servizi in esecuzione, puoi [creare un servizio Amazon ECS con service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html).
## 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 è installata la versione 1.18.116 o successiva o la versione 2.0.38 o successiva, è necessario [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 scoprire 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. Verranno creati nodi virtuali 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 attività Amazon ECS a leggere la configurazione di uno o più nodi virtuali. Per ulteriori informazioni su come autorizzare il proxy, consulta [Autorizzazione del proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
+ Aggiorna ciascuna delle definizioni di attività Amazon ECS esistenti per utilizzare il proxy Envoy.
**Credenziali**
Il contenitore Envoy richiede AWS Identity and Access Management le credenziali per la firma delle richieste inviate al servizio App Mesh. [Per le attività Amazon ECS distribuite con il tipo di avvio Amazon EC2, le credenziali possono provenire dal ruolo dell'[istanza o da un ruolo IAM dell'](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html)attività.](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) Le attività di Amazon ECS distribuite con Fargate su contenitori Linux non hanno accesso al server di metadati Amazon EC2 che fornisce le credenziali del profilo IAM dell'istanza. Per fornire le credenziali, è necessario assegnare un ruolo di attività IAM a qualsiasi attività distribuita con il tipo di container Fargate su Linux.
*Se un'attività viene distribuita con il tipo di avvio di Amazon EC2 e l'accesso è bloccato al server di metadati Amazon EC2, come descritto nell'annotazione Importante [in IAM Role for](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) Tasks, all'attività deve essere associato anche un ruolo IAM dell'attività.* [Al ruolo assegnato all'istanza o all'attività deve essere associata una policy IAM, come descritto in Autorizzazione proxy.](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html)
**Per aggiornare la definizione dell'attività utilizzando il AWS CLI**
Utilizzi il AWS CLI comando [https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)Amazon ECS. La definizione di attività di esempio riportata di seguito mostra come configurare App Mesh per il servizio.
**Nota**
La configurazione di App Mesh for Amazon ECS tramite la console non è disponibile.
### Definizione dell'attività (json)
**Configurazione del proxy**
Per configurare il servizio Amazon ECS per l'utilizzo di App Mesh, la definizione delle attività del servizio deve contenere la seguente sezione di configurazione del proxy. Imposta la configurazione del proxy `type` su `APPMESH` e il nome `containerName` su `envoy`. Imposta di conseguenza i valori di proprietà indicati di seguito.
`IgnoredUID`
Il proxy Envoy non instrada il traffico dai processi che utilizzano questo ID utente. Per questa opzione puoi scegliere qualsiasi ID utente, ma l'ID deve essere lo stesso indicato come `user` ID per il container Envoy nella definizione dell'attività. Questa corrispondenza consente a Envoy di ignorare il proprio traffico senza utilizzare il proxy. I nostri esempi utilizzano `1337` per scopi storici.
`ProxyIngressPort`
Questa è la porta in entrata per il contenitore proxy Envoy. Imposta questo valore su `15000`.
`ProxyEgressPort`
Questa è la porta in uscita per il contenitore proxy Envoy. Imposta questo valore su `15001`.
`AppPorts`
Specificate le porte in entrata su cui i contenitori delle applicazioni sono in ascolto. In questo esempio, il container dell'applicazione resta in ascolto sulla porta `9080`. La porta specificata deve corrispondere alla porta configurata nel listener del nodo virtuale.
`EgressIgnoredIPs`
Envoy non invia traffico proxy a questi indirizzi IP. Imposta questo valore su`169.254.170.2,169.254.169.254`, che ignora il server di metadati Amazon EC2 e l'endpoint di metadati delle attività Amazon ECS. L'endpoint di metadati fornisce ruoli IAM per le credenziali delle attività. È possibile aggiungere ulteriori indirizzi.
`EgressIgnoredPorts`
Puoi aggiungere un elenco di porte separate da virgole. Envoy non invia traffico proxy a queste porte. Anche se non elenchi delle porte, la porta 22 viene ignorata.
Il numero massimo di porte in uscita che possono essere ignorate è 15.
```
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
}
```
**Dipendenza tra Envoy e container dell'applicazione**
Prima di potersi avviare, i container delle applicazioni nelle definizioni dell'attività devono attendere il bootstrap e l'avvio del proxy Envoy. Per fare in modo che ciò accada, impostate una `dependsOn` sezione in ogni definizione del contenitore dell'applicazione per attendere che il contenitore Envoy riporti come. `HEALTHY` Il codice seguente mostra un esempio di definizione del container dell'applicazione con questa dipendenza. Tutte le proprietà nell'esempio seguente sono obbligatorie. Anche alcuni valori delle proprietà sono obbligatori, ma altri lo sono. *replaceable*
```
{
"name": "appName",
"image": "appImage",
"portMappings": [{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}],
"essential": true,
"dependsOn": [{
"containerName": "envoy",
"condition": "HEALTHY"
}]
}
```
**Definizione del container Envoy**
Le definizioni delle attività Amazon ECS devono contenere un'immagine del contenitore App Mesh Envoy.
Tutte le regioni [supportate](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) possono essere sostituite *Region-code* con qualsiasi regione diversa da`me-south-1`,,`ap-east-1`, `ap-southeast-3``eu-south-1`, `il-central-1` e. `af-south-1`
Standard
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
Conforme a FIPS
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
`me-south-1`
Standard
```
772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-east-1`
Standard
```
856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-southeast-3`
Standard
```
909464085924.dkr.ecr.ap-southeast-3.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`eu-south-1`
Standard
```
422531588944.dkr.ecr.eu-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`il-central-1`
Standard
```
564877687649.dkr.ecr.il-central-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`af-south-1`
Standard
```
924023996002.dkr.ecr.af-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`Public repository`
Standard
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod
```
Conforme a FIPS
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
**Importante**
Solo la versione v1.9.0.0-prod o successiva è supportata per l'uso con App Mesh.
È necessario utilizzare l'immagine del contenitore App Mesh Envoy finché il team del progetto Envoy non unisce le modifiche che supportano App Mesh. [Per ulteriori dettagli, consulta il problema relativo alla roadmap. GitHub ](https://github.com/aws/aws-app-mesh-roadmap/issues/10)
Tutte le proprietà nell'esempio seguente sono obbligatorie. Anche alcuni valori delle proprietà sono obbligatori, ma altri lo sono*replaceable*.
**Nota**
La definizione del container Envoy deve essere contrassegnata come `essential`.
Si consiglia di allocare unità `512` CPU e almeno `64` MiB di memoria nel contenitore Envoy. Su Fargate il valore minimo che potrai impostare è `1024` MiB di memoria.
Il nome del nodo virtuale per il servizio Amazon ECS deve essere impostato sul valore della `APPMESH_RESOURCE_ARN` proprietà. Questa proprietà richiede una versione `1.15.0` o successiva dell'immagine Envoy. Per ulteriori informazioni, consulta [Immagine dell'inviato](envoy.md).
Il valore dell'impostazione `user` deve corrispondere al valore `IgnoredUID` della configurazione del proxy di definizione dell'attività. In questo esempio viene utilizzato `1337`.
Il controllo dello stato mostrato qui attende che il contenitore Envoy si avvii correttamente prima di segnalare ad Amazon ECS che il contenitore Envoy è integro e pronto per l'avvio dei contenitori dell'applicazione.
Per impostazione predefinita, App Mesh utilizza il nome della risorsa specificata in `APPMESH_RESOURCE_ARN` quando Envoy si riferisce a se stesso nei parametri e nelle tracce. È possibile ignorare questo comportamento impostando la variabile di ambiente `APPMESH_RESOURCE_CLUSTER` con il proprio nome. Questa proprietà richiede una versione `1.15.0` o successiva dell'immagine Envoy. Per ulteriori informazioni, consulta [Immagine dell'inviato](envoy.md).
Il seguente codice mostra un esempio di definizione del container Envoy.
```
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [{
"name": "APPMESH_RESOURCE_ARN",
"value": "arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
}],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
```
**Esempi di definizioni di attività**
L'esempio seguente di definizioni di attività di Amazon ECS mostra come unire gli esempi precedenti in una definizione di attività per. `taskB` Vengono forniti esempi per la creazione di attività per entrambi i tipi di avvio di Amazon ECS con o senza utilizzo AWS X-Ray. Modifica i *replaceable* valori, se necessario, per creare definizioni di attività per le attività denominate `taskBv2` e incluse `taskA` nello scenario. Sostituisci con il nome della tua mesh e del tuo nodo virtuale il valore `APPMESH_RESOURCE_ARN` e poi il valore `AppPorts` con un elenco di porte su cui la tua applicazione resta in ascolto. Per impostazione predefinita, App Mesh utilizza il nome della risorsa specificata in `APPMESH_RESOURCE_ARN` quando Envoy si riferisce a se stesso nei parametri e nelle tracce. È possibile ignorare questo comportamento impostando la variabile di ambiente `APPMESH_RESOURCE_CLUSTER` con il proprio nome. Tutte le proprietà degli esempi seguenti sono obbligatorie. Anche alcuni valori delle proprietà sono obbligatori, ma altri lo sono*replaceable*.
Se stai eseguendo un'attività Amazon ECS come descritto nella sezione Credenziali, devi aggiungere un [ruolo IAM di attività](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) esistente, agli esempi.
**Importante**
Fargate deve utilizzare un valore di porta maggiore di 1024.
**Example Definizione delle attività in JSON per Amazon ECS - Fargate su contenitori Linux**
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "0.5 vCPU",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example Definizione delle attività in JSON per Amazon ECS con - AWS X-Ray Fargate su contenitori Linux**
X-Ray consente di raccogliere dati sulle richieste servite da un'applicazione e fornisce strumenti che è possibile utilizzare per visualizzare il flusso di traffico. L'utilizzo del driver X-Ray per Envoy consente a Envoy di riportare le informazioni di tracciamento a X-Ray. [È possibile abilitare il tracciamento X-Ray utilizzando la configurazione Envoy.](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html) In base alla configurazione, Envoy invia i dati di tracciamento al demone X-Ray che funziona come contenitore [sidecar](https://docs.aws.amazon.com/xray/latest/devguide/xray-daemon-ecs.html) e il daemon inoltra le tracce al servizio X-Ray. Una volta pubblicate le tracce su X-Ray, è possibile utilizzare la console X-Ray per visualizzare il grafico delle chiamate di assistenza e richiedere i dettagli di tracciamento. Il seguente codice JSON rappresenta una definizione di attività per abilitare l'integrazione con X-Ray.
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "512",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
},
{
"name" : "xray-daemon",
"image" : "amazon/aws-xray-daemon",
"user" : "1337",
"essential" : true,
"cpu" : "32",
"memoryReservation" : "256",
"portMappings" : [
{
"containerPort" : 2000,
"protocol" : "udp"
}
]
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example Definizione delle attività in JSON per Amazon ECS - tipo di avvio EC2**
```
{
"family": "taskB",
"memory": "256",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
**Example Definizione delle attività in JSON per Amazon ECS con AWS X-Ray - tipo di avvio EC2**
```
{
"family": "taskB",
"memory": "256",
"cpu" : "1024",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
},
{
"name": "xray-daemon",
"image": "amazon/aws-xray-daemon",
"user": "1337",
"essential": true,
"cpu": 32,
"memoryReservation": 256,
"portMappings": [
{
"containerPort": 2000,
"protocol": "udp"
}
]
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
## Argomenti avanzati
### Implementazioni Canary utilizzando App Mesh
Le implementazioni e le versioni di Canary ti aiutano a spostare il traffico tra una vecchia versione di un'applicazione e una nuova versione distribuita. Monitora inoltre lo stato della nuova versione distribuita. In caso di problemi con la nuova versione, Canary Deployment può riportare automaticamente il traffico alla versione precedente. Le implementazioni di Canary ti danno la possibilità di spostare il traffico tra le versioni dell'applicazione con un maggiore controllo.
Per ulteriori informazioni su come implementare distribuzioni Canary per Amazon ECS utilizzando App Mesh, consulta [Creare una pipeline con distribuzioni Canary](https://aws.amazon.com/blogs/containers/create-a-pipeline-with-canary-deployments-for-amazon-ecs-using-aws-app-mesh/) per Amazon ECS utilizzando App Mesh
**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).