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

# Campi rilevanti negli eventi di log delle prestazioni per Amazon EKS e Kubernetes
<a name="Container-Insights-reference-performance-entries-EKS"></a>

Per Amazon EKS e Kubernetes, l' CloudWatch agente containerizzato emette dati come eventi di registro delle prestazioni. Ciò consente di importare e CloudWatch archiviare dati ad alta cardinalità. CloudWatch utilizza i dati negli eventi del registro delle prestazioni per creare CloudWatch metriche aggregate a livello di cluster, nodo e pod senza la necessità di perdere dettagli granulari.

La tabella seguente elenca i campi di tali eventi di log delle prestazioni rilevanti per la raccolta dei dati di parametri di Container Insights. È possibile utilizzare CloudWatch Logs Insights per eseguire query su uno di questi campi per raccogliere dati o esaminare problemi. Per ulteriori informazioni, consulta [Analizza i dati di registro con CloudWatch Logs Insights.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html)


| Tipo | Campo di log | Origine | Formula o note | 
| --- | --- | --- | --- | 
| Pod | `pod_cpu_utilization` | Calcolato | Formula: `pod_cpu_usage_total / node_cpu_limit` | 
| Pod | `pod_cpu_usage_total`<br />`pod_cpu_usage_total` è riportato in millicore. | cadvisor |   | 
| Pod | `pod_cpu_limit` | Calcolato | Formula: `sum(container_cpu_limit)` <br />`sum(container_cpu_limit)` include pod già completati.<br />Se uno qualsiasi dei contenitori nel pod non dispone di un limite di CPU definito, questo campo non viene visualizzato nel log di eventi. Ciò include i [container init](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_cpu_request` | Calcolato | Formula: `sum(container_cpu_request)`<br />`container_cpu_request` non è garantito per essere impostato. Solo quelli che sono impostati sono inclusi nella somma. | 
| Pod | `pod_cpu_utilization_over_pod_limit` | Calcolato | Formula: `pod_cpu_usage_total / pod_cpu_limit` | 
| Pod | `pod_cpu_reserved_capacity` | Calcolato | Formula: `pod_cpu_request / node_cpu_limit` | 
| Pod | `pod_memory_utilization` | Calcolato | Formula: `pod_memory_working_set / node_memory_limit`<br />È la percentuale di utilizzo della memoria pod rispetto alla limitazione di memoria del nodo. | 
| Pod | `pod_memory_working_set` | cadvisor |   | 
| Pod | `pod_memory_limit` | Calcolato | Formula: `sum(container_memory_limit)`<br />Se uno qualsiasi dei contenitori nel pod non dispone di un limite di memoria definito, questo campo non viene visualizzato nel log di eventi. Ciò include i [container init](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_memory_request` | Calcolato | Formula: `sum(container_memory_request)`<br />`container_memory_request` non è garantito per essere impostato. Solo quelli che sono impostati sono inclusi nella somma. | 
| Pod | `pod_memory_utilization_over_pod_limit` | Calcolato | Formula: `pod_memory_working_set / pod_memory_limit`<br />Se uno qualsiasi dei contenitori nel pod non dispone di un limite di memoria definito, questo campo non viene visualizzato nel log di eventi. Ciò include i [container init](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_memory_reserved_capacity` | Calcolato | Formula: `pod_memory_request / node_memory_limit` | 
| Pod | `pod_network_tx_bytes` | Calcolato | Formula: `sum(pod_interface_network_tx_bytes)`<br />Questi dati sono disponibili per tutte le interfacce di rete per pod. L'agente di CloudWatch calcola il totale e aggiunge le regole di estrazione di parametri. | 
| Pod | `pod_network_rx_bytes` | Calcolato | Formula: `sum(pod_interface_network_rx_bytes)` | 
| Pod | `pod_network_total_bytes` | Calcolato | Formula: `pod_network_rx_bytes + pod_network_tx_bytes` | 
| PodNet | `pod_interface_network_rx_bytes` | cadvisor | Questi dati sono byte RX di rete al secondo di un'interfaccia di rete pod. | 
| PodNet | `pod_interface_network_tx_bytes` | cadvisor | Questi dati sono byte TX di rete al secondo di un'interfaccia di rete pod. | 
| Contenitore | `container_cpu_usage_total` | cadvisor |   | 
| Contenitore | `container_cpu_limit` | cadvisor | Non garantito come impostato. Non è emesso se non è impostato. | 
| Contenitore | `container_cpu_request` | cadvisor | Non garantito come impostato. Non è emesso se non è impostato. | 
| Contenitore | `container_memory_working_set` | cadvisor |   | 
| Contenitore | `container_memory_limit` | pod | Non garantito come impostato. Non è emesso se non è impostato. | 
| Contenitore | `container_memory_request` | pod | Non garantito come impostato. Non è emesso se non è impostato. | 
| Nodo | `node_cpu_utilization` | Calcolato | Formula: `node_cpu_usage_total / node_cpu_limit` | 
| Nodo | `node_cpu_usage_total` | cadvisor |   | 
| Nodo | `node_cpu_limit` | /proc |   | 
| Nodo | `node_cpu_request` | Calcolato | Formula: `sum(pod_cpu_request)`<br />Per cronjobs, `node_cpu_request` include anche le richieste provenienti dai pod completati. Ciò può portare a un valore elevato per `node_cpu_reserved_capacity`. | 
| Nodo | `node_cpu_reserved_capacity` | Calcolato | Formula: `node_cpu_request / node_cpu_limit` | 
| Nodo | `node_memory_utilization` | Calcolato | Formula: `node_memory_working_set / node_memory_limit` | 
| Nodo | `node_memory_working_set` | cadvisor |   | 
| Nodo | `node_memory_limit` | /proc |   | 
| Nodo | `node_memory_request` | Calcolato | Formula: `sum(pod_memory_request)` | 
| Nodo | `node_memory_reserved_capacity` | Calcolato | Formula: `node_memory_request / node_memory_limit` | 
| Nodo | `node_network_rx_bytes` | Calcolato | Formula: `sum(node_interface_network_rx_bytes)` | 
| Nodo | `node_network_tx_bytes` | Calcolato | Formula: `sum(node_interface_network_tx_bytes)` | 
| Nodo | `node_network_total_bytes` | Calcolato | Formula: `node_network_rx_bytes + node_network_tx_bytes` | 
| Nodo | `node_number_of_running_pods` | Elenco pod |   | 
| Nodo | `node_number_of_running_containers` | Elenco pod |   | 
| NodeNet | `node_interface_network_rx_bytes` | cadvisor | Questi dati sono byte RX di rete al secondo di un'interfaccia di rete nodo di lavoro. | 
| NodeNet | `node_interface_network_tx_bytes` | cadvisor | Questi dati sono byte TX di rete al secondo di un'interfaccia di rete nodo di lavoro. | 
| NodeFS | `node_filesystem_capacity` | cadvisor |   | 
| NodeFS | `node_filesystem_usage` | cadvisor |   | 
| NodeFS | `node_filesystem_utilization` | Calcolato | Formula: `node_filesystem_usage / node_filesystem_capacity`<br />Questi dati sono disponibili per nome dispositivo. | 
| Cluster | `cluster_failed_node_count` | Server API |   | 
| Cluster | `cluster_node_count` | Server API |   | 
| Servizio | `service_number_of_running_pods` | Server API |   | 
| `Namespace` | `namespace_number_of_running_pods` | Server API |   | 

## Esempi di calcolo dei parametri
<a name="Container-Insights-calculation-examples"></a>

Questa sezione include esempi che mostrano il modo in cui alcuni dei valori riportati nella tabella precedente sono calcolati.

Supponiamo che si disponga di un cluster nel seguente stato.

```
Node1
   node_cpu_limit = 4
   node_cpu_usage_total = 3
   
   Pod1
     pod_cpu_usage_total = 2
     
     Container1
        container_cpu_limit = 1
        container_cpu_request = 1
        container_cpu_usage_total = 0.8
        
     Container2
        container_cpu_limit = null
        container_cpu_request = null
        container_cpu_usage_total = 1.2
        
   Pod2
     pod_cpu_usage_total = 0.4
     
     Container3
        container_cpu_limit = 1
        container_cpu_request = 0.5
        container_cpu_usage_total = 0.4
        
Node2
   node_cpu_limit = 8
   node_cpu_usage_total = 1.5
   
   Pod3
     pod_cpu_usage_total = 1
     
     Container4
        container_cpu_limit = 2
        container_cpu_request = 2
        container_cpu_usage_total = 1
```

La tabella riportata di seguito mostra il modo in cui vengono calcolati i parametri della CPU del pod utilizzando questi dati.


| Metrica | Formula | Pod1 | Pod2 | Pod3 | 
| --- | --- | --- | --- | --- | 
| `pod_cpu_utilization` | `pod_cpu_usage_total / node_cpu_limit` | 2 / 4 = 50% | 0,4 / 4 = 10% | 1 / 8 = 12,5% | 
| `pod_cpu_utilization_over_pod_limit` | `pod_cpu_usage_total / sum(container_cpu_limit)` | N/A perché il limite di CPU per `Container2` non è definito | 0,4 / 1 = 40% | 1 / 2 = 50% | 
| `pod_cpu_reserved_capacity` | `sum(container_cpu_request) / node_cpu_limit` | (1 \+ 0) / 4 = 25% | 0,5 / 4 = 12,5% | 2 / 8 = 25% | 

La tabella riportata di seguito mostra il modo in cui vengono calcolati i parametri della CPU del nodo utilizzando questi dati.


| Metrica | Formula | Node1 | Node2 | 
| --- | --- | --- | --- | 
| `node_cpu_utilization` | `node_cpu_usage_total / node_cpu_limit` | 3 / 4 = 75% | 1,5 / 8 = 18,75% | 
| `node_cpu_reserved_capacity` | `sum(pod_cpu_request) / node_cpu_limit` | 1,5 / 4 = 37,5% | 2 / 8 = 25% |