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 a App Mesh
**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 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)
Puoi utilizzare App Mesh con applicazioni distribuite su Amazon ECS, Kubernetes (che distribuisci sulle tue istanze Amazon EC2 o eseguite su Amazon EKS) e Amazon EC2. Per iniziare a usare App Mesh, seleziona uno dei servizi su cui sono distribuite le applicazioni che desideri utilizzare con App Mesh. Puoi sempre consentire alle applicazioni degli altri servizi di funzionare anche con App Mesh dopo aver completato una delle guide introduttive.
**Topics**
+ [Guida introduttiva AWS App Mesh ad Amazon ECS](getting-started-ecs.md)
+ [Guida introduttiva a AWS App Mesh Kubernetes](getting-started-kubernetes.md)
+ [Guida introduttiva AWS App Mesh ad Amazon EC2](getting-started-ec2.md)
+ [Esempi di App Mesh](examples.md)
# 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).
# Guida introduttiva a AWS App Mesh Kubernetes
**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)
Quando esegui l'integrazione AWS App Mesh con Kubernetes utilizzando il controller App Mesh per Kubernetes, gestisci le risorse App Mesh, come mesh, servizi virtuali, nodi virtuali, router virtuali e percorsi tramite Kubernetes. Inoltre, aggiungi automaticamente le immagini del contenitore del sidecar App Mesh alle specifiche del pod Kubernetes. Questo tutorial ti guida attraverso l'installazione del controller App Mesh per Kubernetes per abilitare questa integrazione.
Il controller è accompagnato dalla distribuzione delle seguenti definizioni di risorse personalizzate Kubernetes: `meshes`, `virtual services`, `virtual nodes` e `virtual routers`. Il controller controlla la creazione, la modifica e l'eliminazione delle risorse personalizzate e apporta modifiche alle risorse App Mesh[Reti di servizio](meshes.md),[Servizi virtuali](virtual_services.md),[Nodi virtuali](virtual_nodes.md), [Gateway virtuali](virtual_gateways.md)[Percorsi gateway](gateway-routes.md), [Router virtuali](virtual_routers.md) (incluse[Percorsi](routes.md)) corrispondenti tramite l'API App Mesh. Per saperne di più o contribuire al controller, consulta il [GitHubprogetto](https://github.com/aws/aws-app-mesh-controller-for-k8s).
Il controller installa anche un webhook che inserisce i seguenti container nei pod Kubernetes etichettandoli con il nome che specifichi.
+ **Proxy App Mesh Envoy**: Envoy utilizza la configurazione definita nel piano di controllo App Mesh per determinare dove inviare il traffico dell'applicazione.
+ **App Mesh proxy route manager**: aggiorna `iptables` le regole nello spazio dei nomi di rete di un pod che instradano il traffico in entrata e in uscita tramite Envoy. Questo container viene eseguito come container init Kubernetes all'interno del pod.
## Prerequisiti
+ Una comprensione esistente dei concetti di App Mesh. Per ulteriori informazioni, consulta [Che cos'è AWS App Mesh?](what-is-app-mesh.md).
+ Un’adeguata conoscenza dei concetti di Kubernetes Per ulteriori informazioni, consulta [Cos'è Kubernetes nella documentazione di Kubernetes](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/).
+ Un cluster Kubernetes esistente. Se non disponi di un cluster esistente, consulta la sezione Guida [introduttiva ad Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) nella *Guida per l'utente di Amazon EKS*. Se stai eseguendo il tuo cluster Kubernetes su Amazon EC2, assicurati che Docker sia autenticato nel repository Amazon ECR in cui si trova l'immagine Envoy. Per ulteriori informazioni, consulta [Envoy image](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html), [Registry authentication](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) in Amazon Elastic Container Registry User Guide e [Pull an Image from a Private Registry](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) nella documentazione di Kubernetes.
+ 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.
+ È installata la AWS CLI versione 1.18.116 o successiva o 2.0.38 o successiva. [Per installare o aggiornare il AWS CLI, vedere Installazione di. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
+ Un client `kubectl` configurato per comunicare con il cluster Kubernetes. Se utilizzi Amazon Elastic Kubernetes Service, puoi utilizzare le istruzioni per `[kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)` l'installazione e la configurazione di un file. `[kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html)`
+ Helm versione 3.0 o successiva installato. Se non hai installato Helm, consulta [Using Helm with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/helm.html) nella Guida per *l'utente di Amazon EKS*.
+ Al momento Amazon EKS supporta `IPv6_ONLY` solo `IPv4_ONLY` e solo le preferenze IP, poiché Amazon EKS attualmente supporta solo pod in grado di servire solo `IPv4` traffico o solo `IPv6` traffico.
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: installazione deii componenti di integrazione
Installa i componenti di integrazione una sola volta in ogni cluster che ospita i pod che desideri utilizzare con App Mesh.
**Per installare i componenti di integrazione**
1. Le fasi rimanenti di questa procedura richiedono un cluster senza una versione non definitiva del controller installata. Se hai installato una versione non definitiva o non sei sicuro di averla installata, puoi scaricare ed eseguire uno script che verifica se nel tuo cluster è installata una versione non definitiva.
```
curl -o pre_upgrade_check.sh https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/upgrade/pre_upgrade_check.sh
sh ./pre_upgrade_check.sh
```
Se lo script restituisce `Your cluster is ready for upgrade. Please proceed to the installation instructions`, puoi procedere alla fase successiva. Se viene restituito un messaggio diverso, è necessario completare la procedura di aggiornamento prima di continuare. [Per ulteriori informazioni sull'aggiornamento di una versione non definitiva, consulta Upgrade on.](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#upgrade) GitHub
1. Aggiungi il repository `eks-charts` a Helm.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Installa le definizioni di risorse personalizzate (CRD) di App Mesh Kubernetes.
```
kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"
```
1. Crea uno spazio dei nomi Kubernetes per il controller.
```
kubectl create ns appmesh-system
```
1. Imposta le seguenti variabili per utilizzarle nelle prossime fasi. Sostituisci `cluster-name` e `Region-code` con i valori per il cluster esistente.
```
export CLUSTER_NAME=cluster-name
export AWS_REGION=Region-code
```
1. (Facoltativo) Se vuoi eseguire il controller su Fargate devi creare un profilo Fargate. Se non lo hai `eksctl` installato, consulta [Installazione o aggiornamento `eksctl` nella Guida per l'](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il profilo utilizzando la console, consulta [Creazione di un profilo Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) nella Guida per *l'utente di Amazon EKS*.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name appmesh-system --namespace appmesh-system
```
1. Crea un provider di identità OpenID Connect (OIDC) per il cluster. Se non lo hai `eksctl` installato, puoi installarlo seguendo le istruzioni in [Installazione o aggiornamento nella Guida per l'`eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il provider utilizzando la console, consulta la sezione [Abilitazione dei ruoli IAM per gli account di servizio sul tuo cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) nella *Amazon EKS User Guide*.
```
eksctl utils associate-iam-oidc-provider \
--region=$AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
```
1. Crea un ruolo IAM, associa le politiche [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor) AWS gestite ad esso e associalo all'account del servizio `appmesh-controller` Kubernetes. [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor) Il ruolo consente al controller di aggiungere, rimuovere e modificare risorse App Mesh.
**Nota**
Il comando crea un ruolo AWS IAM con un nome generato automaticamente. Non puoi specificare il nome del ruolo IAM creato.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace appmesh-system \
--name appmesh-controller \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess,arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--override-existing-serviceaccounts \
--approve
```
Se preferisci creare l'account di servizio utilizzando Console di gestione AWS o AWS CLI, consulta [Creazione di un ruolo e di una politica IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) nella *Guida per l'utente di Amazon EKS*. Se utilizzi Console di gestione AWS o AWS CLI per creare l'account, devi anche mappare il ruolo a un account di servizio Kubernetes. Per ulteriori informazioni, consulta [Specificare un ruolo IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) nella *Amazon EKS User Guide*.
1.
**Implementa il controller App Mesh. Per un elenco di tutte le opzioni di configurazione, vedi [Configuration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) on GitHub.**
1. Per distribuire il controller App Mesh per un cluster privato, devi prima abilitare App Mesh e gli endpoint Amazon VPC di rilevamento dei servizi nella sottorete privata collegata. È inoltre necessario impostare il. `accountId`
```
--set accountId=$AWS_ACCOUNT_ID
```
Per abilitare il tracciamento a raggi X in un cluster privato, abilita gli endpoint Amazon VPC X-Ray e Amazon ECR. Il controller lo utilizza `public.ecr.aws/xray/aws-xray-daemon:latest` per impostazione predefinita, quindi trasferisci questa immagine in locale e [inseriscila nel tuo repository ECR personale](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
**Nota**
[Gli endpoint Amazon VPC](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) attualmente non supportano gli archivi pubblici Amazon ECR.
L'esempio seguente mostra l'implementazione del controller con configurazioni per X-Ray.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller \
--set accountId=$AWS_ACCOUNT_ID \
--set log.level=debug \
--set tracing.enabled=true \
--set tracing.provider=x-ray \
--set xray.image.repository=your-account-id.dkr.ecr.your-region.amazonaws.com/your-repository \
--set xray.image.tag=your-xray-daemon-image-tag
```
Verifica se il demone X-Ray viene iniettato correttamente durante l'associazione della distribuzione dell'applicazione con il nodo o il gateway virtuale.
Per ulteriori informazioni, consulta [Private Clusters](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) nella *Amazon EKS User Guide*.
1. Implementa il controller App Mesh per altri cluster. Per un elenco di tutte le opzioni di configurazione, vedi [Configuration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) on. GitHub
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller
```
**Nota**
Se la tua famiglia di cluster Amazon EKS lo è`IPv6`, imposta il nome del cluster durante la distribuzione del controller App Mesh aggiungendo la seguente opzione al comando `--set clusterName=$CLUSTER_NAME` precedente.
**Importante**
Se il cluster si trova in `me-south-1``ap-east-1`,`ap-southeast-3`, `eu-south-1``il-central-1`, o `af-south-1` Regioni, è necessario aggiungere la seguente opzione al comando precedente:
Sostituisci *account-id* e *Region-code* con uno dei set di valori appropriati.
```
--set image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/amazon/appmesh-controller
```
772975370895.dkr. ecr.me-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
856666278305.dkr. ecr.ap-east-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
422531588944.dkr. ecr.eu-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
564877687649.dkr. ecr.il-central-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
924023996002.dkr. ecr.af-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
[L'immagine precedente è disponibile URIs nel registro delle modifiche.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub La versione AWS degli account su cui sono presenti le immagini è cambiata`v1.5.0`. Le versioni precedenti delle immagini sono ospitate su AWS account presenti nei registri di immagini dei container Amazon Elastic Kubernetes [Service](https://docs.aws.amazon.com/eks/latest/userguide/add-ons-images.html) di Amazon.
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr.ecr.me-south-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
856666278305.dkr.ecr.ap-east-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
909464085924.dkr.ecr.ap-southeast-3.amazonaws. com/amazon/appmesh- controller: v1.13.1
422531588944.dkr.ecr.eu-south-1.amazonaws. com/amazon/appmesh- controllore: v1.13.1
564877687649.dkr.ecr.il-central-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
924023996002.dkr.ecr.af-south-1.amazonaws. com/amazon/appmesh- controller: v1.13.1
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr. ecr.me-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
856666278305.dkr. ecr.ap-east-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
422531588944.dkr. ecr.eu-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
564877687649.dkr. ecr.il-central-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
924023996002.dkr. ecr.af-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
**Importante**
Solo la versione v1.9.0.0-prod o successiva è supportata per l'uso con App Mesh.
1. Verifica che la versione del controller sia `v1.4.0` o successiva. [È possibile rivedere il registro delle modifiche.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub
```
kubectl get deployment appmesh-controller \
-n appmesh-system \
-o json | jq -r ".spec.template.spec.containers[].image" | cut -f2 -d ':'
```
**Nota**
Se si visualizza il log per il container in esecuzione, è possibile che venga visualizzata una riga che include il testo seguente, che può essere tranquillamente ignorato.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```
## Fase 2: Implementazione delle risorse App Mesh
Quando distribuisci un'applicazione in Kubernetes, crei anche le risorse personalizzate Kubernetes in modo che il controller possa creare le risorse App Mesh corrispondenti. La procedura seguente consente di distribuire le risorse App Mesh con alcune delle relative funzionalità. Puoi trovare esempi di manifest per la distribuzione di altre funzionalità di risorse App Mesh nelle `v1beta2` sottocartelle di molte delle cartelle di funzionalità elencate nelle procedure dettagliate di [App Mesh](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs) su. GitHub
**Importante**
Dopo che il controller ha creato una risorsa App Mesh, ti consigliamo di apportare modifiche o eliminare la risorsa App Mesh solo utilizzando il controller. Se apporti modifiche o elimini la risorsa utilizzando App Mesh, il controller non cambierà o ricreerà la risorsa App Mesh modificata o eliminata per dieci ore, per impostazione predefinita. Puoi configurare un periodo inferiore. Per ulteriori informazioni, consulta [Configurazione](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) su. GitHub
**Per distribuire risorse App Mesh**
1. Crea uno spazio dei nomi Kubernetes in cui distribuire le risorse App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `namespace.yaml`.
```
apiVersion: v1
kind: Namespace
metadata:
name: my-apps
labels:
mesh: my-mesh
appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
1. Crea il namespace.
```
kubectl apply -f namespace.yaml
```
1. Crea una mesh di servizi App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `mesh.yaml`. Il file viene utilizzato per creare una risorsa mesh denominata`my-mesh`. Una mesh dei servizi è un limite logico per il traffico di rete tra i servizi che si trovano al suo interno.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
name: my-mesh
spec:
namespaceSelector:
matchLabels:
mesh: my-mesh
```
1. Crea la mesh.
```
kubectl apply -f mesh.yaml
```
1. Visualizza i dettagli della risorsa mesh Kubernetes creata.
```
kubectl describe mesh my-mesh
```
Output
```
Name: my-mesh
Namespace:
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"Mesh","metadata":{"annotations":{},"name":"my-mesh"},"spec":{"namespaceSelector":{"matchLa...
API Version: appmesh.k8s.aws/v1beta2
Kind: Mesh
Metadata:
Creation Timestamp: 2020-06-17T14:51:37Z
Finalizers:
finalizers.appmesh.k8s.aws/mesh-members
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 6295
Self Link: /apis/appmesh.k8s.aws/v1beta2/meshes/my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-mesh
Namespace Selector:
Match Labels:
Mesh: my-mesh
Status:
Conditions:
Last Transition Time: 2020-06-17T14:51:37Z
Status: True
Type: MeshActive
Mesh ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh
Observed Generation: 1
Events:
```
1. Visualizza i dettagli sulla mesh del servizio App Mesh creata dal controller.
```
aws appmesh describe-mesh --mesh-name my-mesh
```
Output
```
{
"mesh": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh",
"createdAt": "2020-06-17T09:51:37.920000-05:00",
"lastUpdatedAt": "2020-06-17T09:51:37.920000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
1. Crea un nodo virtuale App Mesh. Un nodo virtuale funge da puntatore logico a una distribuzione Kubernetes.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-node.yaml`. Il file viene utilizzato per creare un nodo virtuale App Mesh denominato `my-service-a` nel *`my-apps`* namespace. Il nodo virtuale rappresenta un servizio Kubernetes creato in una fase successiva. Il valore di `hostname` è il nome host DNS completo del servizio effettivo rappresentato da questo nodo virtuale.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualNode
metadata:
name: my-service-a
namespace: my-apps
spec:
podSelector:
matchLabels:
app: my-app-1
listeners:
- portMapping:
port: 80
protocol: http
serviceDiscovery:
dns:
hostname: my-service-a.my-apps.svc.cluster.local
```
I nodi virtuali hanno funzionalità, come la end-to-end crittografia e i controlli di integrità, che non sono trattate in questo tutorial. Per ulteriori informazioni, consulta [Nodi virtuali](virtual_nodes.md). Per visualizzare tutte le impostazioni disponibili per un nodo virtuale che puoi impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
1. Distribuisci il nodo virtuale.
```
kubectl apply -f virtual-node.yaml
```
1. Visualizza i dettagli della risorsa nodo virtuale Kubernetes creata.
```
kubectl describe virtualnode my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualNode","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"},"s...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualNode
Metadata:
Creation Timestamp: 2020-06-17T14:57:29Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 2
Resource Version: 22545
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualnodes/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Pod Selector:
Match Labels:
App: nginx
Service Discovery:
Dns:
Hostname: my-service-a.my-apps.svc.cluster.local
Status:
Conditions:
Last Transition Time: 2020-06-17T14:57:29Z
Status: True
Type: VirtualNodeActive
Observed Generation: 2
Virtual Node ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
Events:
```
1. Visualizza i dettagli del nodo virtuale creato dal controller in App Mesh.
**Nota**
Anche se il nome del nodo virtuale creato in Kubernetes è `my-service-a`, il nome del nodo virtuale creato in App Mesh è `my-service-a_my-apps`. Il controller aggiunge il nome dello spazio dei nomi Kubernetes al nome del nodo virtuale App Mesh quando crea la risorsa App Mesh. Il nome dello spazio dei nomi viene aggiunto perché in Kubernetes è possibile creare nodi virtuali con lo stesso nome in diversi namespace, ma in App Mesh un nome di nodo virtuale deve essere univoco all'interno di una mesh.
```
aws appmesh describe-virtual-node --mesh-name my-mesh --virtual-node-name my-service-a_my-apps
```
Output
```
{
"virtualNode": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps",
"createdAt": "2020-06-17T09:57:29.840000-05:00",
"lastUpdatedAt": "2020-06-17T09:57:29.840000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "my-service-a.my-apps.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "my-service-a_my-apps"
}
}
```
1. Crea un router virtuale App Mesh. I router virtuali gestiscono il traffico per uno o più servizi virtuali all'interno della mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-router.yaml`. Il file viene utilizzato per creare un router virtuale per indirizzare il traffico verso il nodo virtuale denominato `my-service-a` creato nel passaggio precedente. Il controller crea il router virtuale App Mesh e le risorse di routing. Puoi specificare molte più funzionalità per i percorsi e utilizzare protocolli diversi da `http`. Per ulteriori informazioni, consultare [Router virtuali](virtual_routers.md) e [Percorsi](routes.md). Nota che il nome del nodo virtuale a cui si fa riferimento è il nome del nodo virtuale Kubernetes, non il nome del nodo virtuale App Mesh creato in App Mesh dal controller.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
namespace: my-apps
name: my-service-a-virtual-router
spec:
listeners:
- portMapping:
port: 80
protocol: http
routes:
- name: my-service-a-route
httpRoute:
match:
prefix: /
action:
weightedTargets:
- virtualNodeRef:
name: my-service-a
weight: 1
```
(Facoltativo) Per visualizzare tutte le impostazioni disponibili per un router virtuale che puoi configurare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Per visualizzare tutte le impostazioni disponibili per un percorso che è possibile impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
1. Distribuisci il router virtuale.
```
kubectl apply -f virtual-router.yaml
```
1. Visualizza la risorsa router virtuale Kubernetes creata.
```
kubectl describe virtualrouter my-service-a-virtual-router -n my-apps
```
Output abbreviato
```
Name: my-service-a-virtual-router
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualRouter","metadata":{"annotations":{},"name":"my-service-a-virtual-router","namespac...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualRouter
...
Spec:
Aws Name: my-service-a-virtual-router_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Routes:
Http Route:
Action:
Weighted Targets:
Virtual Node Ref:
Name: my-service-a
Weight: 1
Match:
Prefix: /
Name: my-service-a-route
Status:
Conditions:
Last Transition Time: 2020-06-17T15:14:01Z
Status: True
Type: VirtualRouterActive
Observed Generation: 1
Route AR Ns:
My - Service - A - Route: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route
Virtual Router ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps
Events:
```
1. Visualizza la risorsa router virtuale creata dal controller in App Mesh. Hai specificato `my-service-a-virtual-router_my-apps` for`name`, perché quando il controller ha creato il router virtuale in App Mesh, ha aggiunto il nome dello spazio dei nomi Kubernetes al nome del router virtuale.
```
aws appmesh describe-virtual-router --virtual-router-name my-service-a-virtual-router_my-apps --mesh-name my-mesh
```
Output
```
{
"virtualRouter": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps",
"createdAt": "2020-06-17T10:14:01.547000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.547000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Visualizza la risorsa di percorso creata dal controller in App Mesh. La risorsa route non è stata creata in Kubernetes perché fa parte della configurazione del router virtuale in Kubernetes. Le informazioni sul percorso sono state mostrate nei dettagli della risorsa Kubernetes nella sottofase `c`. Il controller non ha aggiunto il nome dello spazio dei nomi Kubernetes al nome della route App Mesh quando ha creato la route in App Mesh perché i nomi delle route sono unici per un router virtuale.
```
aws appmesh describe-route \
--route-name my-service-a-route \
--virtual-router-name my-service-a-virtual-router_my-apps \
--mesh-name my-mesh
```
Output
```
{
"route": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route",
"createdAt": "2020-06-17T10:14:01.577000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.577000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"routeName": "my-service-a-route",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "my-service-a_my-apps",
"weight": 1
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Crea un servizio virtuale App Mesh. Un servizio virtuale è un'astrazione di un servizio reale fornita direttamente o indirettamente da un nodo virtuale mediante un router virtuale. I servizi dipendenti chiamano il servizio virtuale con il suo nome. Sebbene il nome non sia importante per App Mesh, consigliamo di denominare il servizio virtuale con il nome di dominio completo del servizio effettivo rappresentato dal servizio virtuale. Assegnando un nome al servizio virtuale in questo modo, non hai la necessità di modificare il codice dell'applicazione per fare riferimento a un nome diverso. Le richieste vengono instradate al nodo virtuale o al router virtuale specificato come provider per il servizio virtuale.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `virtual-service.yaml`. Il file viene utilizzato per creare un servizio virtuale che utilizza un provider di router virtuale per indirizzare il traffico verso il nodo virtuale denominato `my-service-a` creato in un passaggio precedente. Il valore per `awsName` in `spec` è il nome di dominio completo (FQDN) del servizio Kubernetes effettivo riassunto in questo servizio virtuale. Il servizio Kubernetes viene creato in [Fase 3: creazione o aggiornamento dei servizi](#create-update-services). Per ulteriori informazioni, consulta [Servizi virtuali](virtual_services.md).
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualService
metadata:
name: my-service-a
namespace: my-apps
spec:
awsName: my-service-a.my-apps.svc.cluster.local
provider:
virtualRouter:
virtualRouterRef:
name: my-service-a-virtual-router
```
Per visualizzare tutte le impostazioni disponibili per un servizio virtuale che puoi impostare nelle specifiche precedenti, esegui il comando seguente.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
1. Creare il servizio virtuale.
```
kubectl apply -f virtual-service.yaml
```
1. Visualizzare i dettagli della risorsa servizio virtuale Kubernetes creata.
```
kubectl describe virtualservice my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualService","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"}...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualService
Metadata:
Creation Timestamp: 2020-06-17T15:48:40Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 13598
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualservices/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a.my-apps.svc.cluster.local
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Provider:
Virtual Router:
Virtual Router Ref:
Name: my-service-a-virtual-router
Status:
Conditions:
Last Transition Time: 2020-06-17T15:48:40Z
Status: True
Type: VirtualServiceActive
Observed Generation: 1
Virtual Service ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local
Events:
```
1. Visualizza i dettagli della risorsa del servizio virtuale creata dal controller in App Mesh. Il controller Kubernetes non ha aggiunto il nome dello spazio dei nomi Kubernetes al nome del servizio virtuale App Mesh quando ha creato il servizio virtuale in App Mesh perché il nome del servizio virtuale è un FQDN univoco.
```
aws appmesh describe-virtual-service --virtual-service-name my-service-a.my-apps.svc.cluster.local --mesh-name my-mesh
```
Output
```
{
"virtualService": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local",
"createdAt": "2020-06-17T10:48:40.182000-05:00",
"lastUpdatedAt": "2020-06-17T10:48:40.182000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "my-service-a.my-apps.svc.cluster.local"
}
}
```
Sebbene non sia trattato in questo tutorial, il controller può anche implementare App Mesh [Gateway virtuali](virtual_gateways.md) e[Percorsi gateway](gateway-routes.md). Per una procedura dettagliata sulla distribuzione di queste risorse con il controller, consulta [Configuring Inbound Gateway](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-ingress-gateway) o un [manifesto di esempio](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template) che include le risorse su. GitHub
## Fase 3: creazione o aggiornamento dei servizi
A tutti i pod che desideri utilizzare con App Mesh devono essere aggiunti i contenitori collaterali App Mesh. L'iniettore aggiunge automaticamente i container sidecar a qualsiasi pod distribuito con l'etichetta che specifichi.
1. Abilitare l'autorizzazione proxy. Ti consigliamo di abilitare ogni distribuzione Kubernetes per lo streaming solo della configurazione per il proprio nodo virtuale App Mesh.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `proxy-auth.json`. Assicurati di sostituirlo *alternate-colored values* con il tuo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-east-1:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps"
]
}
]
}
```
------
1. Crea la policy.
```
aws iam create-policy --policy-name my-policy --policy-document file://proxy-auth.json
```
1. Crea un ruolo IAM, allega la policy creata nel passaggio precedente, crea un account di servizio Kubernetes e associa la policy all'account di servizio Kubernetes. Il ruolo consente al controller di aggiungere, rimuovere e modificare risorse App Mesh.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace my-apps \
--name my-service-a \
--attach-policy-arn arn:aws:iam::111122223333:policy/my-policy \
--override-existing-serviceaccounts \
--approve
```
Se preferisci creare l'account di servizio utilizzando Console di gestione AWS o AWS CLI, consulta [Creazione di un ruolo e di una policy IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) nella *Guida per l'utente di Amazon EKS*. Se utilizzi Console di gestione AWS o AWS CLI per creare l'account, devi anche mappare il ruolo a un account di servizio Kubernetes. Per ulteriori informazioni, consulta [Specificare un ruolo IAM per il tuo account di servizio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) nella *Amazon EKS User Guide*.
1. (Facoltativo) Se vuoi eseguire la distribuzione nei pod Fargate devi creare un profilo Fargate. Se non lo hai `eksctl` installato, puoi installarlo seguendo le istruzioni in [Installazione o aggiornamento nella Guida per l'`eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl)*utente di Amazon EKS*. Se preferisci creare il profilo utilizzando la console, consulta [Creazione di un profilo Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) nella Guida per *l'utente di Amazon EKS*.
```
eksctl create fargateprofile --cluster my-cluster --region Region-code --name my-service-a --namespace my-apps
```
1. Creare un servizio e una distribuzione Kubernetes. Se disponi di una distribuzione esistente che desideri utilizzare con App Mesh, devi implementare un nodo virtuale, come hai fatto nella fase secondaria `3` di. [Fase 2: Implementazione delle risorse App Mesh](#configure-app-mesh) Aggiorna la distribuzione per assicurarti che la relativa etichetta corrisponda all'etichetta che hai impostato sul nodo virtuale, in modo che i contenitori sidecar vengano aggiunti automaticamente ai pod e i pod vengano ridistribuiti.
1. Salva nel tuo computer i seguenti contenuti in un file denominato `example-service.yaml`. Se cambi il nome dello spazio dei nomi e usi i pod Fargate, il nome dello spazio dei nomi deve corrispondere al nome dello spazio dei nomi definito nel profilo Fargate.
```
apiVersion: v1
kind: Service
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
selector:
app: my-app-1
ports:
- protocol: TCP
port: 80
targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
replicas: 3
selector:
matchLabels:
app: my-app-1
template:
metadata:
labels:
app: my-app-1
spec:
serviceAccountName: my-service-a
containers:
- name: nginx
image: nginx:1.19.0
ports:
- containerPort: 80
```
**Importante**
Il valore per il `app` `matchLabels` `selector` nella specifica deve corrispondere al valore che hai specificato quando hai creato il nodo virtuale nella sottofase `3` di [Fase 2: Implementazione delle risorse App Mesh](#configure-app-mesh). In caso contrario i container sidecar non verranno inseriti nel container. Nell'esempio precedente, il valore dell'etichetta è `my-app-1`. Se distribuisci un gateway virtuale, anziché un nodo virtuale, il `Deployment` manifest deve includere solo il contenitore Envoy. Per ulteriori informazioni sull'immagine da utilizzare, consulta. [Immagine dell'inviato](envoy.md) Per un esempio di manifesto, vedi l'[esempio di implementazione su](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template#L585). GitHub
1. Distribuire il servizio.
```
kubectl apply -f example-service.yaml
```
1. Visualizzare il servizio e la distribuzione.
```
kubectl -n my-apps get pods
```
Output
```
NAME READY STATUS RESTARTS AGE
my-service-a-54776556f6-2cxd9 2/2 Running 0 10s
my-service-a-54776556f6-w26kf 2/2 Running 0 18s
my-service-a-54776556f6-zw5kt 2/2 Running 0 26s
```
1. Visualizzare i dettagli di uno dei pod che è stato distribuito.
```
kubectl -n my-apps describe pod my-service-a-54776556f6-2cxd9
```
Output abbreviato
```
Name: my-service-a-54776556f6-2cxd9
Namespace: my-app-1
Priority: 0
Node: ip-192-168-44-157.us-west-2.compute.internal/192.168.44.157
Start Time: Wed, 17 Jun 2020 11:08:59 -0500
Labels: app=nginx
pod-template-hash=54776556f6
Annotations: kubernetes.io/psp: eks.privileged
Status: Running
IP: 192.168.57.134
IPs:
IP: 192.168.57.134
Controlled By: ReplicaSet/my-service-a-54776556f6
Init Containers:
proxyinit:
Container ID: docker://e0c4810d584c21ae0cb6e40f6119d2508f029094d0e01c9411c6cf2a32d77a59
Image: 111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2
Image ID: docker-pullable://111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager
Port:
Host Port:
State: Terminated
Reason: Completed
Exit Code: 0
Started: Fri, 26 Jun 2020 08:36:22 -0500
Finished: Fri, 26 Jun 2020 08:36:22 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_START_ENABLED: 1
APPMESH_IGNORE_UID: 1337
APPMESH_ENVOY_INGRESS_PORT: 15000
APPMESH_ENVOY_EGRESS_PORT: 15001
APPMESH_APP_PORTS: 80
APPMESH_EGRESS_IGNORED_IP: 169.254.169.254
APPMESH_EGRESS_IGNORED_PORTS: 22
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Containers:
nginx:
Container ID: docker://be6359dc6ecd3f18a1c87df7b57c2093e1f9db17d5b3a77f22585ce3bcab137a
Image: nginx:1.19.0
Image ID: docker-pullable://nginx
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:28 -0500
Ready: True
Restart Count: 0
Environment:
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
envoy:
Container ID: docker://905b55cbf33ef3b3debc51cb448401d24e2e7c2dbfc6a9754a2c49dd55a216b6
Image: 840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod
Image ID: docker-pullable://840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy
Port: 9901/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:36 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_RESOURCE_ARN: arn:aws:iam::111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
APPMESH_PREVIEW: 0
ENVOY_LOG_LEVEL: info
AWS_REGION: us-west-2
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Pulling 30s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Pulled 23s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Created 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container proxyinit
Normal Started 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container proxyinit
Normal Pulling 20s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "nginx:1.19.0"
Normal Pulled 16s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "nginx:1.19.0"
Normal Created 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container nginx
Normal Started 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container nginx
Normal Pulling 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Pulled 8s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Created 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container envoy
Normal Started 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container envoy
```
Nell'output precedente, puoi vedere che i container `proxyinit` e `envoy` sono stati aggiunti al pod dal container. Se hai distribuito il servizio di esempio su Fargate, `envoy` il contenitore è stato aggiunto al pod dal controller, ma `proxyinit` il contenitore no.
1. (Facoltativo) Installa componenti aggiuntivi come Prometheus, Grafana, Jaeger e Datadog. AWS X-Ray Per ulteriori informazioni, consulta [i componenti aggiuntivi di App Mesh](https://github.com/aws/eks-charts#app-mesh-add-ons) GitHub e la sezione [Osservabilità](https://docs.aws.amazon.com/app-mesh/latest/userguide/observability.html) della App Mesh User Guide.
**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).
## Fase 4: pulizia
Rimuovere tutte le risorse di esempio create in questo tutorial. Il controller rimuove anche le risorse che sono state create nella mesh del servizio `my-mesh` App Mesh.
```
kubectl delete namespace my-apps
```
Se hai creato un profilo Fargate per il servizio di esempio, rimuovilo.
```
eksctl delete fargateprofile --name my-service-a --cluster my-cluster --region Region-code
```
Elimina la mesh.
```
kubectl delete mesh my-mesh
```
(Facoltativo) È possibile rimuovere i componenti di integrazione Kubernetes.
```
helm delete appmesh-controller -n appmesh-system
```
(Facoltativo) Se hai distribuito i componenti di integrazione Kubernetes su Fargate, elimina il profilo Fargate.
```
eksctl delete fargateprofile --name appmesh-system --cluster my-cluster --region Region-code
```
# 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).
# Esempi di App Mesh
**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 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)
Puoi trovare end-to-end procedure dettagliate mostrate AWS App Mesh in azione ed esempi di codice per l'integrazione con vari AWS servizi nel seguente repository:
[Esempi di App Mesh](https://github.com/aws/aws-app-mesh-examples)