# Campos relevantes nos eventos de log de performance para Amazon EKS e Kubernetes
<a name="Container-Insights-reference-performance-entries-EKS"></a>

Para Amazon EKS e Kubernetes, o atendente do CloudWatch armazenado em contêineres emite dados como eventos de log de performance. Isso permite ao CloudWatch ingerir e armazenar dados de alta cardinalidade. O CloudWatch usa os dados nos eventos de log de performance para criar métricas agregadas do CloudWatch no nível do cluster, do nó e do pod, sem a necessidade de perder detalhes refinados.

A tabela a seguir lista os campos nesses eventos de log de performance que são relevantes à coleção de dados de métrica do Container Insights. Você pode usar o CloudWatch Logs Insights para consultar qualquer um desses campos para coletar dados ou investigar problemas. Para obter mais informações, consulte [Analisar dados de log com o CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html).


| Tipo | Campo de log | Origem | Fórmula ou observações | 
| --- | --- | --- | --- | 
| Pod | `pod_cpu_utilization` | Calculado | Fórmula: `pod_cpu_usage_total / node_cpu_limit` | 
| Pod | `pod_cpu_usage_total`<br />`pod_cpu_usage_total`O é informado em milinúcleos. | cadvisor |   | 
| Pod | `pod_cpu_limit` | Calculado | Fórmula: `sum(container_cpu_limit)` <br />`sum(container_cpu_limit)` inclui pods já concluídos.<br />Se qualquer contêiner no pod não tiver um limite de CPU definido, esse campo não aparecerá no evento de log. Isso inclui [ contêineres de inicialização](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_cpu_request` | Calculado | Fórmula: `sum(container_cpu_request)`<br />`container_cpu_request`Não é garantido que esteja definido. Somente os que estão definidos são incluídos na soma. | 
| Pod | `pod_cpu_utilization_over_pod_limit` | Calculado | Fórmula: `pod_cpu_usage_total / pod_cpu_limit` | 
| Pod | `pod_cpu_reserved_capacity` | Calculado | Fórmula: `pod_cpu_request / node_cpu_limit` | 
| Pod | `pod_memory_utilization` | Calculado | Fórmula: `pod_memory_working_set / node_memory_limit`<br />É a porcentagem de uso de memória do pod sobre a limitação de memória do nó. | 
| Pod | `pod_memory_working_set` | cadvisor |   | 
| Pod | `pod_memory_limit` | Calculado | Fórmula: `sum(container_memory_limit)`<br />Se qualquer contêiner no pod não tiver um limite de memória definido, esse campo não aparecerá no evento de log. Isso inclui [ contêineres de inicialização](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_memory_request` | Calculado | Fórmula: `sum(container_memory_request)`<br />`container_memory_request`Não é garantido que esteja definido. Somente os que estão definidos são incluídos na soma. | 
| Pod | `pod_memory_utilization_over_pod_limit` | Calculado | Fórmula: `pod_memory_working_set / pod_memory_limit`<br />Se qualquer contêiner no pod não tiver um limite de memória definido, esse campo não aparecerá no evento de log. Isso inclui [ contêineres de inicialização](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources). | 
| Pod | `pod_memory_reserved_capacity` | Calculado | Fórmula: `pod_memory_request / node_memory_limit` | 
| Pod | `pod_network_tx_bytes` | Calculado | Fórmula: `sum(pod_interface_network_tx_bytes)`<br />Esses dados estão disponíveis para todas as interfaces de rede por pod. O atendente do CloudWatch calcula o total e adiciona regras de extração de métrica. | 
| Pod | `pod_network_rx_bytes` | Calculado | Fórmula: `sum(pod_interface_network_rx_bytes)` | 
| Pod | `pod_network_total_bytes` | Calculado | Fórmula: `pod_network_rx_bytes + pod_network_tx_bytes` | 
| PodNet | `pod_interface_network_rx_bytes` | cadvisor | Esses dados são bytes de rx de rede por segundo de uma interface de rede de pod. | 
| PodNet | `pod_interface_network_tx_bytes` | cadvisor | Esses dados são bytes de tx de rede por segundo de uma interface de rede de pod. | 
| Contêiner | `container_cpu_usage_total` | cadvisor |   | 
| Contêiner | `container_cpu_limit` | cadvisor | Não há garantia de estar definido. Não é emitido se não está definido. | 
| Contêiner | `container_cpu_request` | cadvisor | Não há garantia de estar definido. Não é emitido se não está definido. | 
| Contêiner | `container_memory_working_set` | cadvisor |   | 
| Contêiner | `container_memory_limit` | pod | Não há garantia de estar definido. Não é emitido se não está definido. | 
| Contêiner | `container_memory_request` | pod | Não há garantia de estar definido. Não é emitido se não está definido. | 
| Nó | `node_cpu_utilization` | Calculado | Fórmula: `node_cpu_usage_total / node_cpu_limit` | 
| Nó | `node_cpu_usage_total` | cadvisor |   | 
| Nó | `node_cpu_limit` | /proc |   | 
| Nó | `node_cpu_request` | Calculado | Fórmula: `sum(pod_cpu_request)`<br />Para cronjobs, `node_cpu_request` também inclui solicitações de pods concluídos. Isso pode levar a um alto valor para `node_cpu_reserved_capacity`. | 
| Nó | `node_cpu_reserved_capacity` | Calculado | Fórmula: `node_cpu_request / node_cpu_limit` | 
| Nó | `node_memory_utilization` | Calculado | Fórmula: `node_memory_working_set / node_memory_limit` | 
| Nó | `node_memory_working_set` | cadvisor |   | 
| Nó | `node_memory_limit` | /proc |   | 
| Nó | `node_memory_request` | Calculado | Fórmula: `sum(pod_memory_request)` | 
| Nó | `node_memory_reserved_capacity` | Calculado | Fórmula: `node_memory_request / node_memory_limit` | 
| Nó | `node_network_rx_bytes` | Calculado | Fórmula: `sum(node_interface_network_rx_bytes)` | 
| Nó | `node_network_tx_bytes` | Calculado | Fórmula: `sum(node_interface_network_tx_bytes)` | 
| Nó | `node_network_total_bytes` | Calculado | Fórmula: `node_network_rx_bytes + node_network_tx_bytes` | 
| Nó | `node_number_of_running_pods` | Lista de pods |   | 
| Nó | `node_number_of_running_containers` | Lista de pods |   | 
| NodeNet | `node_interface_network_rx_bytes` | cadvisor | Esses dados são bytes de tx de rede por segundo de uma interface de rede do nó de processamento. | 
| NodeNet | `node_interface_network_tx_bytes` | cadvisor | Esses dados são bytes de tx de rede por segundo de uma interface de rede do nó de processamento. | 
| NodeFS | `node_filesystem_capacity` | cadvisor |   | 
| NodeFS | `node_filesystem_usage` | cadvisor |   | 
| NodeFS | `node_filesystem_utilization` | Calculado | Fórmula: `node_filesystem_usage / node_filesystem_capacity`<br />Esses dados estão disponíveis por nome do dispositivo. | 
| Cluster | `cluster_failed_node_count` | Servidor da API |   | 
| Cluster | `cluster_node_count` | Servidor da API |   | 
| Serviço | `service_number_of_running_pods` | Servidor da API |   | 
| `Namespace` | `namespace_number_of_running_pods` | Servidor da API |   | 

## Exemplos de cálculo de métricas
<a name="Container-Insights-calculation-examples"></a>

Esta seção inclui exemplos que mostram como alguns dos valores na tabela anterior são calculados.

Suponha que você tenha um cluster no estado a seguir.

```
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
```

A tabela a seguir mostra como as métricas de CPU do pod são calculadas usando esses dados.


| Métrica | Fórmula | 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/D, pois o limite de CPU para `Container2` não está definido | 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% | 

A tabela a seguir mostra como as métricas de CPU do nó são calculadas usando esses dados.


| Métrica | Fórmula | 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% |