View a markdown version of this page

Nozioni di base su AWS App Mesh e Amazon ECS - AWS App Mesh
ScenarioPrerequisitiFase 1: creare una mesh e un servizio virtualeFase 2: creare un nodo virtualeFase 3: creare un router virtuale e una routeFase 4: Revisione e creazioneFase 5: creare risorse aggiuntiveFase 6: aggiornare i serviziArgomenti avanzati

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à.

Nozioni di base su AWS App Mesh e 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 potrai più accedere alla AWS App Mesh console o alle risorse. AWS App Mesh Per ulteriori informazioni, consulta questo post del blog Migrazione da AWS App Mesh ad Amazon ECS Service Connect.

Questo argomento ti aiuta a utilizzarlo AWS App Mesh con un servizio effettivo in esecuzione su Amazon ECS. Questo tutorial illustra le funzionalità di base di diversi tipi di risorse App Mesh.

Scenario

Per illustrare come usare App Mesh, supponiamo di avere un'applicazione con le seguenti caratteristiche:

  • È costituito da due servizi denominati serviceA eserviceB.

  • Entrambi i servizi sono registrati in uno spazio dei nomi denominato apps.local.

  • ServiceAcomunica con serviceB oltre HTTP/2 la 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 aserviceBv2, puoi verificare che sia privo di bug prima di inviare il 100 percento del traffico daserviceA.

  • 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 che tutto il traffico è stato inviato aserviceBv2, vuoi interrompereserviceB.

  • Per soddisfare i requisiti precedenti, non è necessario modificare il codice dell'applicazione o la registrazione di servizi esistenti per i servizi effettivi.

Per soddisfare i tuoi requisiti, decidi di creare una rete 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 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 del blog Migrazione da AWS App Mesh ad Amazon ECS Service Connect.

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. Un servizio virtuale è un'astrazione di un servizio effettivo. Per ulteriori informazioni, consulta Servizi virtuali.

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 o aggiornare il. AWS CLI Seleziona la scheda relativa allo strumento che desideri utilizzare.

Console di gestione AWS

  1. Apri la procedura guidata di prima esecuzione della console App Mesh all'indirizzo. https://console.aws.amazon.com/appmesh/get-started

  2. Per Mesh name (Nome mesh), immettere apps.

  3. Per Virtual service name (Nome servizio virtuale), immettere serviceb.apps.local.

  4. Scegliere Next (Avanti) per continuare.

AWS CLI

  1. Creare una mesh con il comando create-mesh.

    aws appmesh create-mesh --mesh-name apps

  2. Creare un servizio virtuale con il comando create-virtual-service.

    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.

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 ascolterà il traffico utilizzando il HTTP/2 protocollo 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.

  2. Per Modalità di rilevamento del servizio, scegli DNS e immetti serviceb.apps.local per Nome host DNS.

  3. In Configurazione del listener, scegli http2 per Protocollo e immetti 80 per Porta.

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

  2. Creare il nodo virtuale con il comando create-virtual-node 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, consulta Router virtuali e Percorsi.

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 HTTP/2 protocollo sulla porta 80. Sono supportati anche altri protocolli.

  • Una route denominata serviceB. Instrada il 100% del suo traffico verso il nodo serviceB virtuale. Il peso viene effettuato 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.

  2. In Configurazione del listener, scegli http2 per Protocollo e specifica 80 per Porta.

  3. Per Route name (Nome route), immettere serviceB.

  4. Per Tipo di route, scegli http2.

  5. Per il nome del nodo virtuale in Configurazione Target, seleziona serviceB e inserisci 100 Peso.

  6. In Configurazione Match, scegli un metodo.

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

    2. Creare il router virtuale con il comando create-virtual-router utilizzando il file JSON come input.

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

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

    2. Creare la route con il comando create-route 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 .

aws appmesh describe-mesh --mesh-name apps

Esaminare le impostazioni del servizio virtuale creato con il comando describe-virtual-service .

aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local

Esaminare le impostazioni del nodo virtuale creato con il comando describe-virtual-node .

aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB

Esaminare le impostazioni del router virtuale creato con il comando describe-virtual-router .

aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB

Esaminare le impostazioni del percorso creato con il comando describe-route .

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 sulla HTTP/2 porta 80. Per il nodo serviceA virtuale, configura un backend diserviceb.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 denominatoservicea.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 aserviceBv2, 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).

  2. Selezionare la mesh apps creata in una fase precedente.

  3. Nel riquadro di navigazione a sinistra selezionare Virtual nodes (Nodi virtuali).

  4. Scegliere Create virtual node (Crea nodo virtuale).

  5. Per Nome del nodo virtuale immetti serviceBv2, per Modalità di rilevamento del servizio scegli DNS e per Nome host DNS immetti servicebv2.apps.local.

  6. Per Configurazione del listener seleziona http2 per Protocollo e immetti 80 per Porta.

  7. Scegliere Create virtual node (Crea nodo virtuale).

  8. 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.

  9. Per Inserisci un nome del servizio virtuale in Nuovo back-end immetti serviceb.apps.local.

  10. In Configurazione del listener scegli http2 per Protocollo, immetti 80 per Porta e quindi scegli Crea un nodo virtuale.

  11. Nel riquadro di navigazione a sinistra selezionare Virtual routers (Router virtuali) quindi selezionare il router virtuale serviceB dall'elenco.

  12. In Route, seleziona la route denominata ServiceB creata in una fase precedente e scegli Modifica.

  13. In Destinazioni, Nome del nodo virtuale, cambia il valore di Peso per serviceB su 75.

  14. Scegli Aggiungi obiettivo, scegli serviceBv2 dall'elenco a discesa e imposta il valore di Peso su. 25

  15. Selezionare Salva.

  16. Nel riquadro di navigazione a sinistra seleziona Servizi virtuali, quindi scegli Crea un servizio virtuale.

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

    2. Creare il nodo virtuale.

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

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

    2. Creare il nodo virtuale.

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

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

    2. Aggiornare il servizio virtuale con il comando update-virtual-service.

      aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json

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

    2. Aggiornare la route con il comando update-route.

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

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

    2. 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.

  • 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à di Amazon ECS distribuite con il tipo di avvio Amazon EC2, le credenziali possono provenire dal ruolo di istanza o da un ruolo IAM dell'attività. https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html Le attività 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, devi associare un ruolo di attività IAM a qualsiasi attività distribuita con il tipo di container Fargate on Linux.

Se un'attività viene distribuita con il tipo di avvio Amazon EC2 e l'accesso è bloccato al server di metadati Amazon EC2, come descritto nell'annotazione Importante in IAM Role for 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 AWS CLI

Si utilizza il AWS CLI comando register-task-definition Amazon ECS. La definizione di attività di esempio riportata di seguito mostra come configurare App Mesh per il tuo servizio.

Nota

La configurazione di App Mesh per Amazon ECS tramite la console non è disponibile.

Configurazione del proxy

Per configurare il servizio Amazon ECS per l'utilizzo di App Mesh, la definizione delle attività del servizio deve avere 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 container proxy Envoy. Imposta questo valore su 15000.

ProxyEgressPort

Questa è la porta in uscita per il container proxy Envoy. Imposta questo valore su 15001.

AppPorts

Specifica le porte in entrata su cui sono in ascolto i contenitori delle tue applicazioni. 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 su169.254.170.2,169.254.169.254, che ignora il server di metadati Amazon EC2 e l'endpoint dei metadati delle attività Amazon ECS. L'endpoint dei metadati fornisce i 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.

Nota

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 assicurarvi che ciò accada, impostate una dependsOn sezione in ogni definizione di contenitore di applicazioni in cui attendere che il contenitore Envoy indichi 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 possono essere sostituite Region-code con qualsiasi regione diversa dame-south-1,ap-east-1, ap-southeast-3eu-south-1, il-central-1 e. af-south-1

Standard

840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod

FIPS-compliant

840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod-fips
me-south-1

Standard

772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
ap-east-1

Standard

856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
ap-southeast-3

Standard

909464085924.dkr.ecr.ap-southeast-3.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
eu-south-1

Standard

422531588944.dkr.ecr.eu-south-1.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
il-central-1

Standard

564877687649.dkr.ecr.il-central-1.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
af-south-1

Standard

924023996002.dkr.ecr.af-south-1.amazonaws.com/aws-appmesh-envoy:v1.39.1.0-prod
Public repository

Standard

public.ecr.aws/appmesh/aws-appmesh-envoy:v1.39.1.0-prod

FIPS-compliant

public.ecr.aws/appmesh/aws-appmesh-envoy:v1.39.1.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 fino a quando il team di progetto Envoy non unirà le modifiche che supportano App Mesh. Per ulteriori dettagli, consulta il problema relativo alla tabella di marcia. GitHub

Tutte le proprietà nell'esempio seguente sono obbligatorie. Alcuni valori delle proprietà sono inoltre obbligatori, ma altri lo sonoreplaceable.

Nota

  • La definizione del container Envoy deve essere contrassegnata come essential.

  • Si consiglia di allocare unità 512 CPU e almeno 64 MiB di memoria al contenitore Envoy. Su Fargate il valore minimo che potrai impostare è il MiB di memoria. 1024

  • Il nome del nodo virtuale per il servizio Amazon ECS deve essere impostato sul valore della proprietà. APPMESH_RESOURCE_ARN Questa proprietà richiede una versione 1.15.0 o successiva dell'immagine Envoy. Per ulteriori informazioni, consulta Invia immagine.

  • 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 applicativi.

  • 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 Invia immagine.

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.39.1.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à

Il seguente esempio di definizione delle 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 taskA provenienti dallo 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. Alcuni valori delle proprietà sono inoltre obbligatori, ma altri lo sonoreplaceable.

Se stai eseguendo un'attività Amazon ECS come descritto nella sezione Credentials, devi aggiungere un ruolo IAM dell'attività esistente, agli esempi.

Importante

Fargate deve utilizzare un valore di porta superiore a 1024.

Esempio Definizione delle attività JSON per Amazon ECS - Contenitori Fargate su 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.39.1.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"
}
Esempio Definizione di attività JSON per Amazon ECS con AWS X-Ray - Fargate su contenitori Linux

X-Ray consente di raccogliere dati sulle richieste soddisfatte da un'applicazione e fornisce strumenti che è possibile utilizzare per visualizzare il flusso di traffico. L'utilizzo del X-Ray driver per Envoy consente a Envoy di segnalare le informazioni di tracciamento a. X-Ray È possibile abilitare il X-Ray tracciamento utilizzando la configurazione di Envoy. https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html In base alla configurazione, Envoy invia i dati di tracciamento al X-Ray daemon in esecuzione come contenitore sidecar e il daemon inoltra le tracce al servizio. X-Ray Una volta pubblicate le tracce su X-Ray, puoi utilizzare la X-Ray console per visualizzare il grafico delle chiamate al servizio e richiedere i dettagli delle tracce. Il JSON seguente rappresenta una definizione dell'attività per abilitare l'integrazione 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.39.1.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"
}
Esempio Definizione dell'attività 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.39.1.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"
}
Esempio Definizione di attività 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.39.1.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 tramite App Mesh

Le implementazioni e le versioni di Canary consentono di trasferire il traffico tra una vecchia versione di un'applicazione e una nuova versione distribuita. Inoltre, monitora lo stato della nuova versione distribuita. In caso di problemi con la nuova versione, la distribuzione di Canary può riportare automaticamente il traffico alla vecchia versione. Le implementazioni Canary offrono la possibilità di trasferire il traffico tra le versioni delle applicazioni con maggiore controllo.

Per ulteriori informazioni su come implementare le distribuzioni Canary per Amazon ECS utilizzando App Mesh, consulta Creare una pipeline con distribuzioni canarie per Amazon ECS utilizzando App Mesh

Nota

Per altri esempi e procedure dettagliate per App Mesh, consulta il repository degli esempi di App Mesh. https://github.com/aws/aws-app-mesh-examples