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à. # Monitoraggio dell'applicazione utilizzando le metriche di Envoy **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) Envoy classifica le sue metriche nelle seguenti categorie principali: + **Downstream**: metriche relative alle connessioni e alle richieste che arrivano al proxy. + **Upstream**: metriche relative alle connessioni in uscita e alle richieste effettuate dal proxy. + **Server**: metriche che descrivono lo stato interno di Envoy. Queste includono metriche come l'uptime o la memoria allocata. In App Mesh, il proxy intercetta il traffico a monte e a valle. Ad esempio, le richieste ricevute dai tuoi clienti e le richieste effettuate dal tuo contenitore di servizi sono classificate come traffico a valle da Envoy. Per distinguere tra questi diversi tipi di traffico upstream e downstream, App Mesh classifica ulteriormente le metriche di Envoy in base alla direzione del traffico relativa al servizio: + **Ingress**: metriche e risorse relative alle connessioni e alle richieste che affluiscono al contenitore di servizi. + **Uscita**: metriche e risorse relative alle connessioni e alle richieste che provengono dal tuo container di servizi e, in ultima analisi, escono dal tuo task Amazon ECS o dal pod Kubernetes. L'immagine seguente mostra la comunicazione tra il proxy e i contenitori di servizi. ![\[Diagram showing proxy and service containers within an Amazon ECS task or Kubernetes Pod with ingress and egress flow.\]](http://docs.aws.amazon.com/it_it/app-mesh/latest/userguide/images/task-proxy-container.png) **Convenzioni di denominazione delle risorse** È utile capire come Envoy visualizza la tua mesh e come le sue risorse vengono mappate alle risorse che definisci in App Mesh. Queste sono le risorse Envoy principali configurate da App Mesh: + **Listener: gli** indirizzi e le porte su cui il proxy ascolta le connessioni downstream. Nell'immagine precedente, App Mesh crea un listener in ingresso per il traffico in entrata nell'attività Amazon ECS o nel pod Kubernetes e un listener in uscita per il traffico in uscita dal container di servizi. + **Cluster**: un gruppo denominato di endpoint upstream a cui il proxy si connette e indirizza il traffico. In App Mesh, il contenitore di servizi è rappresentato come un cluster, così come tutti gli altri nodi virtuali a cui il servizio può connettersi. + **Percorsi**: corrispondono ai percorsi definiti nella mesh. Contengono le condizioni in base alle quali il proxy soddisfa una richiesta e il cluster di destinazione a cui viene inviata la richiesta. + **Endpoint e assegnazioni di carico del cluster: gli** indirizzi IP dei cluster upstream. Quando viene utilizzato AWS Cloud Map come meccanismo di rilevamento dei servizi per i nodi virtuali, App Mesh invia le istanze di servizio rilevate come risorse endpoint al proxy. + **Segreti**: questi includono, a titolo esemplificativo, le chiavi di crittografia e i certificati TLS. Quando viene utilizzato AWS Certificate Manager come fonte per certificati client e server, App Mesh invia certificati pubblici e privati al proxy come risorse segrete. App Mesh utilizza uno schema coerente per denominare le risorse Envoy che puoi utilizzare per ricollegarti alla tua mesh. Comprendere lo schema di denominazione per listener e cluster è importante per comprendere le metriche di Envoy in App Mesh. **Nomi degli ascoltatori** I nomi degli ascoltatori vengono utilizzati nel seguente formato: ``` lds___ ``` In genere vedrai i seguenti listener configurati in Envoy: + `lds_ingress_0.0.0.0_15000` + `lds_egress_0.0.0.0_15001` Utilizzando un plug-in Kubernetes CNI o le regole delle tabelle IP, il traffico nell'attività Amazon ECS o nel pod Kubernetes viene indirizzato alle porte e. `15000` `15001` App Mesh configura Envoy con questi due listener per accettare il traffico in ingresso (in entrata) e in uscita (in uscita). Se non hai un listener configurato sul tuo nodo virtuale, non dovresti vedere un listener in ingresso. **Nomi dei cluster** La maggior parte dei cluster utilizza il seguente formato: ``` cds_____ ``` I nodi virtuali con cui comunicano i tuoi servizi hanno ciascuno il proprio cluster. Come accennato in precedenza, App Mesh crea un cluster per il servizio in esecuzione accanto a Envoy in modo che il proxy possa inviargli traffico in ingresso. Ad esempio, se hai un nodo virtuale denominato `my-virtual-node` che ascolta il traffico http sulla porta `8080` e quel nodo virtuale si trova in una mesh denominata`my-mesh`, App Mesh crea un cluster denominato`cds_ingress_my-mesh_my-virtual-node_http_8080`. Questo cluster funge da destinazione per il traffico verso il contenitore `my-virtual-node` di servizi. App Mesh può anche creare i seguenti tipi di cluster speciali aggiuntivi. Questi altri cluster non corrispondono necessariamente a risorse definite esplicitamente nella mesh. + Cluster utilizzati per raggiungere altri servizi. AWS Questo tipo consente alla mesh di raggiungere la maggior parte dei AWS servizi per impostazione predefinita:`cds_egress__amazonaws`. + Cluster utilizzato per eseguire il routing per i gateway virtuali. Questo può generalmente essere tranquillamente ignorato:. + Per ascoltatori singoli: `cds_ingress___self_redirect__` + Per più ascoltatori: `cds_ingress___self_redirect___` + Il cluster è l'endpoint che puoi definire, come TLS, quando recuperi segreti utilizzando il Secret Discovery Service di Envoy:. `static_cluster_sds_unix_socket` ## Esempi di metriche applicative Per illustrare le metriche disponibili in Envoy, la seguente applicazione di esempio ha tre nodi virtuali. I servizi virtuali, i router virtuali e i percorsi della mesh possono essere ignorati poiché non si riflettono nelle metriche di Envoy. In questo esempio, tutti i servizi ascoltano il traffico http sulla porta 8080. ![\[Diagram showing Envoy proxies in product-details, cart, and website services of an online store mesh.\]](http://docs.aws.amazon.com/it_it/app-mesh/latest/userguide/images/envoy-metric-example1.png) Ti consigliamo di aggiungere la variabile di ambiente `ENABLE_ENVOY_STATS_TAGS=1` ai contenitori proxy Envoy in esecuzione nella tua mesh. Ciò aggiunge le seguenti dimensioni metriche a tutte le metriche emesse dal proxy: + `appmesh.mesh` + `appmesh.virtual_node` + `appmesh.virtual_gateway` Questi tag sono impostati sul nome di mesh, nodo virtuale o gateway virtuale per consentire il filtraggio delle metriche utilizzando i nomi delle risorse nella mesh. **Nomi delle risorse** Il proxy del nodo virtuale del sito Web dispone delle seguenti risorse: + Due listener per il traffico in entrata e in uscita: + `lds_ingress_0.0.0.0_15000` + `lds_egress_0.0.0.0_15001` + Due cluster in uscita, che rappresentano i due backend dei nodi virtuali: + `cds_egress_online-store_product-details_http_8080` + `cds_egress_online-store_cart_http_8080` + Un cluster di ingresso per il contenitore di servizi del sito Web: + `cds_ingress_online-store_website_http_8080` **Esempio di metriche per gli ascoltatori** + `listener.0.0.0.0_15000.downstream_cx_active`—Numero di connessioni di rete in ingresso attive a Envoy. + `listener.0.0.0.0_15001.downstream_cx_active`—Numero di connessioni di rete in uscita attive verso Envoy. Le connessioni effettuate dall'applicazione a servizi esterni sono incluse in questo conteggio. + `listener.0.0.0.0_15000.downstream_cx_total`—Numero totale di connessioni di rete in ingresso a Envoy. + `listener.0.0.0.0_15001.downstream_cx_total`—Numero totale di connessioni di rete in uscita verso Envoy. [Per il set completo di metriche dei listener, consulta Statistics nella documentazione di Envoy.](https://www.envoyproxy.io/docs/envoy/latest/configuration/listeners/stats) **Esempio di metriche del cluster** + `cluster_manager.active_clusters`—Il numero totale di cluster a cui Envoy ha stabilito almeno una connessione. + `cluster_manager.warming_clusters`—Il numero totale di cluster a cui Envoy deve ancora connettersi. Le seguenti metriche del cluster utilizzano il formato di. `cluster..` Questi nomi di metriche sono univoci per l'esempio dell'applicazione e vengono emessi dal contenitore Envoy del sito Web: + `cluster.cds_egress_online-store_product-details_http_8080.upstream_cx_total`—Numero totale di connessioni tra il sito Web e i dettagli del prodotto. + `cluster.cds_egress_online-store_product-details_http_8080.upstream_cx_connect_fail`—Numero totale di connessioni non riuscite tra il sito Web e i dettagli del prodotto. + `cluster.cds_egress_online-store_product-details_http_8080.health_check.failure`—Numero totale di controlli sanitari non riusciti tra il sito Web e i dettagli del prodotto. + `cluster.cds_egress_online-store_product-details_http_8080.upstream_rq_total`—Numero totale di richieste effettuate tra il sito Web e i dettagli del prodotto. + `cluster.cds_egress_online-store_product-details_http_8080.upstream_rq_time`—Tempo impiegato dalle richieste effettuate tra il sito Web e i dettagli del prodotto. + `cluster.cds_egress_online-store_product-details_http_8080.upstream_rq_2xx`—Numero di risposte HTTP 2xx ricevute dal sito Web da product-details. Per il set completo di metriche HTTP, consulta [Statistics](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/stats) nella documentazione di Envoy. **Metriche del server di gestione** Envoy emette anche metriche relative alla sua connessione al piano di controllo App Mesh, che funge da server di gestione di Envoy. Ti consigliamo di monitorare alcune di queste metriche per avvisarti quando i tuoi proxy vengono desincronizzati dal piano di controllo per lunghi periodi di tempo. La perdita di connettività al piano di controllo o gli aggiornamenti non riusciti impediscono ai proxy di ricevere nuove configurazioni da App Mesh, incluse le modifiche alla mesh effettuate tramite App Mesh. APIs + `control_plane.connected_state`—Questa metrica è impostata su 1 quando il proxy è connesso ad App Mesh, altrimenti è 0. + `*.update_rejected`—Numero totale di aggiornamenti di configurazione rifiutati da Envoy. Di solito sono dovuti a una configurazione errata dell'utente. Ad esempio, se configuri App Mesh per leggere un certificato TLS da un file che non può essere letto da Envoy, l'aggiornamento contenente il percorso di quel certificato viene rifiutato. + Per Listener updated rejected, le statistiche saranno. `listener_manager.lds.update_rejected` + Per Cluster updated refected, le statistiche saranno`cluster_manager.cds.update_rejected`. + `*.update_success`—Numero di aggiornamenti di configurazione eseguiti con successo da App Mesh al tuo proxy. Questi includono il payload di configurazione iniziale inviato all'avvio di un nuovo contenitore Envoy. + In caso di successo dell'aggiornamento di Listener, le statistiche saranno. `listener_manager.lds.update_success` + Se Cluster Updated ha successo, le statistiche saranno`cluster_manager.cds.update_success`. Per il set di metriche del server di gestione, consulta [Management Server nella documentazione](https://www.envoyproxy.io/docs/envoy/latest/configuration/overview/mgmt_server) di Envoy. # Esportazione delle metriche **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) Envoy emette molte statistiche sia sul proprio funzionamento che su varie dimensioni sul traffico in entrata e in uscita. [Per ulteriori informazioni sulle statistiche di Envoy, consulta Statistiche nella documentazione di Envoy.](https://www.envoyproxy.io/docs/envoy/latest/intro/arch_overview/observability/statistics) Queste metriche sono disponibili tramite l'`/stats`endpoint sulla porta di amministrazione del proxy, che in genere è. `9901` Il `stat` prefisso sarà diverso a seconda che si utilizzino ascoltatori singoli o multipli. Di seguito sono riportati alcuni esempi per illustrare le differenze. **avvertimento** Se aggiorni il tuo singolo listener alla funzionalità a listener multipli, potresti subire una modifica sostanziale a causa del prefisso stat aggiornato illustrato nella tabella seguente. Ti consigliamo di utilizzare l'immagine Envoy o una versione successiva. `1.22.2.1-prod` Ciò consente di visualizzare nomi di metriche simili nell'endpoint Prometheus. | Single Listener (SL) /Statistiche esistenti con prefisso listener «ingress» | Listener multipli (ML) /Nuove statistiche con «ingress». . «prefisso dell'ascoltatore | | --- | --- | | `http.*ingress*.rds.rds_ingress_http_5555.version_text` | `http.*ingress.http.5555*.rds.rds_ingress_http_5555.version_text` `http.*ingress.http.6666*.rds.rds_ingress_http_6666.version_text` | | `listener.0.0.0.0_15000.http.*ingress*.downstream_rq_2xx` | `listener.0.0.0.0_15000.http.*ingress.http.5555*.downstream_rq_2xx` `listener.0.0.0.0_15000.http.*ingress.http.6666*.downstream_rq_2xx` | | `http.*ingress*.downstream_cx_length_ms` | `http.*ingress.http.5555*.downstream_cx_length_ms` `http.*ingress.http.6666*.downstream_cx_length_ms` | Per ulteriori informazioni sull'endpoint stats, consulta [Statistics endpoint nella documentazione di Envoy](https://www.envoyproxy.io/docs/envoy/latest/operations/admin#get--stats). Per ulteriori informazioni sull'interfaccia di amministrazione, vedere. [Abilita l'interfaccia di amministrazione del proxy Envoy](troubleshooting-best-practices.md#ts-bp-enable-proxy-admin-interface) ## Prometheus per App Mesh con Amazon EKS **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) Prometheus è un toolkit di monitoraggio e avvisi open source. Una delle sue funzionalità consiste nello specificare un formato per l'emissione di metriche che può essere utilizzato da altri sistemi. Per ulteriori informazioni su Prometheus, vedere [Panoramica](https://prometheus.io/docs/introduction/overview/) nella documentazione di Prometheus. Envoy può emettere le sue metriche tramite il suo endpoint stats passando il parametro. `/stats?format=prometheus` Per i clienti che utilizzano Envoy image build v1.22.2.1-prod, ci sono due dimensioni aggiuntive per indicare le statistiche specifiche del listener di ingresso: + `appmesh.listener_protocol` + `appmesh.listener_port` Di seguito è riportato un confronto tra le statistiche esistenti di Prometheus e le nuove statistiche. + Statistiche esistenti con prefisso listener «ingress» ``` envoy_http_downstream_rq_xx{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_node="foodteller-vn",envoy_response_code_class="2",envoy_http_conn_manager_prefix="ingress"} 931433 ``` + Nuove statistiche con «ingress». . "\$1 Appmesh Envoy Image v1.22.2.1-prod o versione successiva ``` envoy_http_downstream_rq_xx{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_node="foodteller-vn",envoy_response_code_class="2",appmesh_listener_protocol="http",appmesh_listener_port="5555",envoy_http_conn_manager_prefix="ingress"} 20 ``` + Nuove statistiche con «ingress». . «\$1 Envoy Imagebuild personalizzato ``` envoy_http_http_5555_downstream_rq_xx{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_node="foodteller-vn",envoy_response_code_class="2",envoy_http_conn_manager_prefix="ingress"} 15983 ``` Per più ascoltatori, il cluster `cds_ingress___self_redirect___` speciale sarà specifico per ogni ascoltatore. + Statistiche esistenti con prefisso del listener «ingress» ``` envoy_cluster_assignment_stale{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_gateway="tellergateway-vg",Mesh="multiple-listeners-mesh",VirtualGateway="tellergateway-vg",envoy_cluster_name="cds_ingress_multiple-listeners-mesh_tellergateway-vg_self_redirect_http_15001"} 0 ``` + Nuove statistiche con «ingress». . » ``` envoy_cluster_assignment_stale{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_gateway="tellergateway-vg",envoy_cluster_name="cds_ingress_multiple-listeners-mesh_tellergateway-vg_self_redirect_1111_http_15001"} 0 envoy_cluster_assignment_stale{appmesh_mesh="multiple-listeners-mesh",appmesh_virtual_gateway="tellergateway-vg",envoy_cluster_name="cds_ingress_multiple-listeners-mesh_tellergateway-vg_self_redirect_2222_http_15001"} 0 ``` ### Installazione di Prometheus 1. Aggiungi il repository EKS a Helm: ``` helm repo add eks https://aws.github.io/eks-charts ``` 1. Installa App Mesh Prometheus ``` helm upgrade -i appmesh-prometheus eks/appmesh-prometheus \ --namespace appmesh-system ``` ### L'esempio di Prometheus Di seguito è riportato un esempio di creazione di una memoria persistente `PersistentVolumeClaim` per Prometheus. ``` helm upgrade -i appmesh-prometheus eks/appmesh-prometheus \ --namespace appmesh-system \ --set retention=12h \ --set persistentVolumeClaim.claimName=prometheus ``` ### Procedura dettagliata per l'utilizzo di Prometheus + [App Mesh con EKS: osservabilità: Prometheus](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/eks/o11y-prometheus.md) ### Per ulteriori informazioni su Prometheus e Prometheus con Amazon EKS + [Documentazione Prometheus](https://prometheus.io/docs/introduction/overview/) + **EKS -** [Metriche del piano di controllo con](https://docs.aws.amazon.com/eks/latest/userguide/prometheus.html) Prometheus ## CloudWatch per 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) **Emissione delle statistiche di Envoy da CloudWatch Amazon EKS** Puoi installare l' CloudWatch agente nel tuo cluster e configurarlo per raccogliere un sottoinsieme di metriche dai tuoi proxy. Se non disponi già di un cluster Amazon EKS, puoi crearne uno seguendo la procedura descritta in [Walkthrough: App Mesh with Amazon EKS on](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/eks). GitHub Puoi installare un'applicazione di esempio sul cluster seguendo la stessa procedura dettagliata. Per impostare le autorizzazioni IAM appropriate per il cluster e installare l'agente, segui la procedura descritta in [Installare l' CloudWatch agente con Prometheus](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights-Prometheus-Setup.html) Metrics Collection. L'installazione predefinita contiene una configurazione scrape di Prometheus che richiama un utile sottoinsieme di statistiche di Envoy. Per ulteriori informazioni, consulta [Prometheus Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights-Prometheus-metrics.html#ContainerInsights-Prometheus-metrics-appmesh) for App Mesh. Per creare una CloudWatch dashboard personalizzata di App Mesh configurata per visualizzare le metriche raccolte dall'agente, segui i passaggi del tutorial [Visualizzazione delle metriche di Prometheus](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights-Prometheus-viewmetrics.html). I grafici inizieranno a popolarsi con le metriche corrispondenti man mano che il traffico entra nell'applicazione App Mesh. ### Metriche di filtraggio per CloudWatch L'[estensione delle metriche](https://docs.aws.amazon.com/app-mesh/latest/userguide/metrics.html#metrics-extension) App Mesh fornisce un sottoinsieme di metriche utili che forniscono informazioni sui comportamenti delle risorse che definisci nella mesh. Poiché l' CloudWatchagente supporta lo scraping delle metriche di Prometheus, puoi fornire una configurazione scrape per selezionare le metriche che desideri estrarre da Envoy e a cui inviare. CloudWatch [Puoi trovare un esempio di metriche di scraping utilizzando Prometheus nella nostra procedura dettagliata di Metrics Extension.](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-metrics-extension-ecs) ### CloudWatch Esempio Puoi trovare una configurazione di esempio CloudWatch nel nostro [repository AWS Samples](https://github.com/aws-samples/aws-app-mesh-cloudwatch-agent). ### Procedure dettagliate per l'utilizzo CloudWatch + [Aggiungi funzionalità di monitoraggio e registrazione](https://www.appmeshworkshop.com/monitoring/) nel nostro [workshop App Mesh](https://www.appmeshworkshop.com/introduction/). + [App Mesh con EKS: osservabilità: CloudWatch](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/eks/o11y-cloudwatch.md) + [Utilizzo dell'estensione metrica di App Mesh su ECS](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-metrics-extension-ecs) ## Estensione delle metriche per 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) Envoy genera centinaia di parametri suddivisi in diverse dimensioni. Le metriche non sono semplici nel modo in cui si riferiscono ad App Mesh. Nel caso dei servizi virtuali, non esiste alcun meccanismo per sapere con certezza quale servizio virtuale sta comunicando con un determinato nodo virtuale o gateway virtuale. L'estensione delle metriche App Mesh migliora i proxy Envoy in esecuzione nella mesh. Questo miglioramento consente ai proxy di emettere metriche aggiuntive che tengono conto delle risorse definite. Questo piccolo sottoinsieme di metriche aggiuntive ti aiuterà a comprendere meglio il comportamento di quelle risorse che hai definito in App Mesh. Per abilitare l'estensione delle metriche App Mesh, imposta la variabile di ambiente `APPMESH_METRIC_EXTENSION_VERSION` su`1`. ``` APPMESH_METRIC_EXTENSION_VERSION=1 ``` Per ulteriori informazioni sulle variabili di configurazione di Envoy, consulta. [Variabili di configurazione di Envoy](envoy-config.md) ### Metriche relative al traffico in entrata + `ActiveConnectionCount` + `envoy.appmesh.ActiveConnectionCount`— Numero di connessioni TCP attive. + *Dimensioni*: Mesh, VirtualNode VirtualGateway + **`NewConnectionCount`** + `envoy.appmesh.NewConnectionCount`— Numero totale di connessioni TCP. + *Dimensioni*: Mesh, VirtualNode VirtualGateway + **`ProcessedBytes`** + `envoy.appmesh.ProcessedBytes`— Byte TCP totali inviati e ricevuti dai client downstream. + *Dimensioni: Mesh*, VirtualNode VirtualGateway + **`RequestCount`** + `envoy.appmesh.RequestCount`— Il numero di richieste HTTP elaborate. + *Dimensioni*: mesh VirtualNode, VirtualGateway + **`GrpcRequestCount`** + `envoy.appmesh.GrpcRequestCount`— Il numero di richieste GPRC elaborate. + *Dimensioni*: mesh, VirtualNode VirtualGateway ### Metriche relative al traffico in uscita Vedrai dimensioni diverse nelle tue metriche in uscita a seconda che provengano da un nodo virtuale o da un gateway virtuale. + `TargetProcessedBytes` + `envoy.appmesh.TargetProcessedBytes`— Byte TCP totali inviati e ricevuti dai target a monte di Envoy. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`HTTPCode_Target_2XX_Count`** + `envoy.appmesh.HTTPCode_Target_2XX_Count`— Il numero di richieste HTTP a una destinazione a monte di Envoy che hanno prodotto una risposta HTTP 2xx. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`HTTPCode_Target_3XX_Count`** + `envoy.appmesh.HTTPCode_Target_3XX_Count`— Il numero di richieste HTTP a una destinazione a monte di Envoy che hanno prodotto una risposta HTTP 3xx. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`HTTPCode_Target_4XX_Count`** + `envoy.appmesh.HTTPCode_Target_4XX_Count`— Il numero di richieste HTTP a una destinazione a monte di Envoy che hanno prodotto una risposta HTTP 4xx. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`HTTPCode_Target_5XX_Count`** + `envoy.appmesh.HTTPCode_Target_5XX_Count`— Il numero di richieste HTTP a una destinazione a monte di Envoy che hanno prodotto una risposta HTTP 5xx. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`RequestCountPerTarget`** + `envoy.appmesh.RequestCountPerTarget`— Il numero di richieste inviate a un target a monte di Envoy. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode + **`TargetResponseTime`** + `envoy.appmesh.TargetResponseTime`— Il tempo trascorso dal momento in cui viene effettuata una richiesta a un target a monte di Envoy a quando viene ricevuta la risposta completa. + *Dimensioni:* + Dimensioni dei nodi virtuali: Mesh VirtualNode, TargetVirtualService, TargetVirtualNode + Dimensioni del gateway virtuale: Mesh VirtualGateway, TargetVirtualService, TargetVirtualNode ## Datadog per 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) Datadog è un'applicazione di monitoraggio e sicurezza per il monitoraggio end-to-end, le metriche e la registrazione delle applicazioni cloud. Datadog rende l'infrastruttura, le applicazioni e le applicazioni di terze parti completamente osservabili. ### Installazione di Datadog + [EKS - Per configurare Datadog con EKS, segui questi passaggi dai documenti Datadog.](https://docs.datadoghq.com/integrations/amazon_app_mesh/?tab=eks) + [ECS EC2 - Per configurare Datadog con ECS EC2, segui questi passaggi dai documenti Datadog.](https://docs.datadoghq.com/integrations/amazon_app_mesh/?tab=ecsec2) ### Per saperne di più su Datadog + [Documentazione Datadog](https://docs.datadoghq.com/)