# Amazon EKS 和 Kubernetes 的性能日志事件中的相关字段
<a name="Container-Insights-reference-performance-entries-EKS"></a>

对于 Amazon EKS 和 Kubernetes，容器化的 CloudWatch 代理将数据作为性能日志事件发出。这使 CloudWatch 能够摄取和存储高基数数据。CloudWatch 使用性能日志事件中的数据在集群、节点和 pod 级别创建聚合的 CloudWatch 指标，而不会丢失详细信息。

下表列出了这些性能日志事件中与 Container Insights 指标数据收集相关的字段。您可以使用 CloudWatch Logs Insights 查询其中的任何字段以收集数据或调查问题。有关更多信息，请参阅[使用 CloudWatch Logs Insights 分析日志数据](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html)。


| Type | 日志字段 | 来源 | 公式或备注 | 
| --- | --- | --- | --- | 
|  Pod |  `pod_cpu_utilization`  |  计算  |  公式：`pod_cpu_usage_total / node_cpu_limit`  | 
|  Pod |  `pod_cpu_usage_total` `pod_cpu_usage_total` 以千分之一核心为单位报道。  |  cadvisor  |   | 
|  Pod |  `pod_cpu_limit`  |  计算  |  公式：`sum(container_cpu_limit)` `sum(container_cpu_limit)` 包括已经完成的容器组（pod）。 如果 pod 中的任何容器未定义 CPU 限制，则该字段不会显示在日志事件中。这包括 [init 容器](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources)。  | 
|  Pod |  `pod_cpu_request`  |  计算  |  公式：`sum(container_cpu_request)` 不保证设置 `container_cpu_request`。仅在总和中包括设置的字段。  | 
|  Pod |  `pod_cpu_utilization_over_pod_limit`  |  计算  |  公式：`pod_cpu_usage_total / pod_cpu_limit`  | 
|  Pod |  `pod_cpu_reserved_capacity`  |  计算  |  公式：`pod_cpu_request / node_cpu_limit`  | 
|  Pod |  `pod_memory_utilization`  |  计算  |  公式：`pod_memory_working_set / node_memory_limit` 它是 pod 内存使用量相比节点内存限制的百分比。  | 
|  Pod |  `pod_memory_working_set`  |  cadvisor  |   | 
|  Pod |  `pod_memory_limit`  |  计算  |  公式：`sum(container_memory_limit)` 如果 pod 中的任何容器没有定义内存限制，则该字段不会显示在日志事件中。这包括 [init 容器](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources)。  | 
|  Pod |  `pod_memory_request`  |  计算  |  公式：`sum(container_memory_request)` 不保证设置 `container_memory_request`。仅在总和中包括设置的字段。  | 
|  Pod |  `pod_memory_utilization_over_pod_limit`  |  计算  |  公式：`pod_memory_working_set / pod_memory_limit` 如果 pod 中的任何容器没有定义内存限制，则该字段不会显示在日志事件中。这包括 [init 容器](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#resources)。  | 
|  Pod |  `pod_memory_reserved_capacity`  |  计算  |  公式：`pod_memory_request / node_memory_limit`  | 
|  Pod |  `pod_network_tx_bytes`  |  计算  |  公式：`sum(pod_interface_network_tx_bytes)` 该数据适用于每个 pod 的所有网络接口。CloudWatch 代理计算总数并添加指标提取规则。  | 
|  Pod |  `pod_network_rx_bytes`  |  计算  |  公式：`sum(pod_interface_network_rx_bytes)`  | 
|  Pod |  `pod_network_total_bytes`  |  计算  |  公式：`pod_network_rx_bytes + pod_network_tx_bytes`  | 
|  PodNet |  `pod_interface_network_rx_bytes`  |  cadvisor  | 该数据是 pod 网络接口每秒接收的网络字节数。  | 
|  PodNet |  `pod_interface_network_tx_bytes`  |  cadvisor  | 该数据是 pod 网络接口每秒发送的网络字节数。 | 
|  容器 |  `container_cpu_usage_total`  |  cadvisor  |   | 
|  容器 |  `container_cpu_limit`  |  cadvisor  |  不保证设置该字段。如果未设置，则不会发出该指标。 | 
|  容器 |  `container_cpu_request`  |  cadvisor  |  不保证设置该字段。如果未设置，则不会发出该指标。 | 
|  容器 |  `container_memory_working_set`  |  cadvisor  |   | 
|  容器 |  `container_memory_limit`  |  容器组（pod）  |  不保证设置该字段。如果未设置，则不会发出该指标。 | 
|  容器 |  `container_memory_request`  |  容器组（pod）  |  不保证设置该字段。如果未设置，则不会发出该指标。 | 
|  节点 |  `node_cpu_utilization`  |  计算  |  公式：`node_cpu_usage_total / node_cpu_limit`  | 
|  节点 |  `node_cpu_usage_total`  |  cadvisor  |   | 
|  节点 |  `node_cpu_limit`  |  /proc  |   | 
|  节点 |  `node_cpu_request`  |  计算  | 公式：`sum(pod_cpu_request)` 对于 cronjobs，`node_cpu_request` 还包括来自已完成的容器组（pod）的请求。这可能会导致 `node_cpu_reserved_capacity` 的值很高。  | 
|  节点 |  `node_cpu_reserved_capacity`  |  计算  | 公式：`node_cpu_request / node_cpu_limit`  | 
|  节点 |  `node_memory_utilization`  |  计算  | 公式：`node_memory_working_set / node_memory_limit`  | 
|  节点 |  `node_memory_working_set`  |  cadvisor  |   | 
|  节点 |  `node_memory_limit`  |  /proc  |   | 
|  节点 |  `node_memory_request`  |  计算  |  公式：`sum(pod_memory_request)`  | 
|  节点 |  `node_memory_reserved_capacity`  |  计算  | 公式：`node_memory_request / node_memory_limit`  | 
|  节点 |  `node_network_rx_bytes`  |  计算  | 公式：`sum(node_interface_network_rx_bytes)`  | 
|  节点 |  `node_network_tx_bytes`  |  计算  | 公式：`sum(node_interface_network_tx_bytes)`  | 
|  节点 |  `node_network_total_bytes`  |  计算  | 公式：`node_network_rx_bytes + node_network_tx_bytes`  | 
|  节点 |  `node_number_of_running_pods`  |  Pod 列表  |   | 
|  节点 |  `node_number_of_running_containers`  |  Pod 列表  |   | 
|  NodeNet |  `node_interface_network_rx_bytes`  |  cadvisor  |  该数据是工作线程节点网络接口每秒接收的网络字节数。  | 
|  NodeNet |  `node_interface_network_tx_bytes`  |  cadvisor  |  该数据是工作线程节点网络接口每秒发送的网络字节数。  | 
|  NodeFS |  `node_filesystem_capacity`  |  cadvisor  |   | 
|  NodeFS |  `node_filesystem_usage`  |  cadvisor  |   | 
|  NodeFS |  `node_filesystem_utilization`  |  计算  |  公式：`node_filesystem_usage / node_filesystem_capacity` 该数据适用于每个设备名称。  | 
|  集群 |  `cluster_failed_node_count`  |  API 服务器  |   | 
|  集群 |  `cluster_node_count`  |  API 服务器  |   | 
|  服务 |  `service_number_of_running_pods`  |  API 服务器  |   | 
|  `Namespace` |  `namespace_number_of_running_pods`  |  API 服务器  |   | 

## 指标计算示例
<a name="Container-Insights-calculation-examples"></a>

本节包含的示例说明了如何计算上表中的某些值。

假设您具有一个处于以下状态的集群。

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

下表说明了如何使用该数据计算 pod CPU 指标。


| 指标 | 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)`  |  不适用，因为没有定义 `Container2` 的 CPU 限制  |  0.4 / 1 = 40%  |  1 / 2 = 50%  | 
|  `pod_cpu_reserved_capacity` |  `sum(container_cpu_request) / node_cpu_limit`  |  (1 \$1 0) / 4 = 25%  |  0.5 / 4 = 12.5%  |  2 / 8 = 25%  | 

下表说明了如何使用该数据计算节点 CPU 指标。


| 指标 | 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%  |