Campos relevantes nos eventos de log de performance para Amazon EKS e Kubernetes

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.

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` O `pod_cpu_usage_total` é informado em milinúcleos.	cadvisor
Pod	`pod_cpu_limit`	Calculado	Fórmula: `sum(container_cpu_limit)` `sum(container_cpu_limit)` inclui pods já concluídos. 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.
Pod	`pod_cpu_request`	Calculado	Fórmula: `sum(container_cpu_request)` Não é garantido que `container_cpu_request` 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` É 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)` 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.
Pod	`pod_memory_request`	Calculado	Fórmula: `sum(container_memory_request)` Não é garantido que `container_memory_request` 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` 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.
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)` 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)` 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 operador.
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 operador.
NodeFS	`node_filesystem_capacity`	cadvisor
NodeFS	`node_filesystem_usage`	cadvisor
NodeFS	`node_filesystem_utilization`	Calculado	Fórmula: `node_filesystem_usage / node_filesystem_capacity` 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

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%

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Eventos de log de performance para o Amazon EKS e o Kubernetes

Monitoramento de métricas do Container Insights Prometheus