---
title: Docker Container Mem
slug: docker-container-mem
description: Learn about the different memory metrics for Docker containers, including anonymous and file cache memory, page cache, memory limits, page faults, page in/out, resident set size, huge pages, and usage percentages. This comprehensive document provides valu
docTags: 
createdAt: 2021-04-06T16:59:20.000Z
---

| **Chave**                                          | **Tipo** | **Descrição**                                                                                                                                                                                                                                                                                         |
| -------------------------------------------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| docker\_container\_mem.`active_anon`               | byte     | Cache anônimo e de troca na lista ativa de menos usados ​​recentemente (LRU), incluindo tmpfs( shmem), em bytes                                                                                                                                                                                       |
| docker\_container\_mem.`active_file`               | byte     | memória com backup de arquivo na lista LRU ativa, em bytes                                                                                                                                                                                                                                            |
| docker\_container\_mem.`cache`                     | byte     | cache de página, incluindo tmpfs( shmem), em bytes                                                                                                                                                                                                                                                    |
| docker\_container\_mem.`container_id`              | string   | Container ID                                                                                                                                                                                                                                                                                          |
| docker\_container\_mem.`hierarchical_memory_limit` | byte     | Limite de memória para a hierarquia que contém o memorycgroup, em bytes                                                                                                                                                                                                                               |
| docker\_container\_mem.`inactive_anon`             | byte     | Cache anônimo e de troca na lista LRU inativa, incluindo tmpfs( shmem), em bytes                                                                                                                                                                                                                      |
| docker\_container\_mem.`inactive_file`             | byte     | Memória com backup de arquivo na lista LRU inativa, em bytes                                                                                                                                                                                                                                          |
| docker\_container\_mem.`max_usage`                 | byte     | Uso máximo de memória registrado                                                                                                                                                                                                                                                                      |
| docker\_container\_mem.`pgfault`                   | counter  | Número de falhas de página, em que o kernel deve alocar e inicializar a memória física para uso no espaço de endereço virtual de um processo.                                                                                                                                                         |
| docker\_container\_mem.`pgmajfault`                | counter  | Número de falhas de página principais, em que o kernel precisa liberar ativamente a memória física antes da alocação e inicialização.                                                                                                                                                                 |
| docker\_container\_mem.`pgpgin`                    | counter  | Número de páginas paginadas de memória.                                                                                                                                                                                                                                                               |
| docker\_container\_mem.`pgpgout`                   | counter  | Número de páginas paginadas da memória.                                                                                                                                                                                                                                                               |
| docker\_container\_mem.`rss`                       | byte     | Tamanho em bytes do cache anônimo e de troca (não inclui tmpfs). <br /><br />O tamanho real do conjunto residente é dado pela soma de rss e mapped\_file.                                                                                                                                             |
| docker\_container\_mem.`rss_huge`                  | byte     | Número de bytes de enormes páginas anônimas transparentes.                                                                                                                                                                                                                                            |
| docker\_container\_mem.`total_active_anon`         | counter  | Soma de todos os filhos `active_anon`                                                                                                                                                                                                                                                                 |
| docker\_container\_mem.`total_active_file`         | counter  | Soma de todos os filhos `active_file`                                                                                                                                                                                                                                                                 |
| docker\_container\_mem.`total_cache`               | counter  | Soma do `cache` de todos os filhos                                                                                                                                                                                                                                                                    |
| docker\_container\_mem.`total_inactive_anon`       | counter  | Soma de todos os filhos `inactive_file`                                                                                                                                                                                                                                                               |
| docker\_container\_mem.`total_inactive_file`       | counter  | Soma de todos os filhos `inactive_file`                                                                                                                                                                                                                                                               |
| docker\_container\_mem.`total_mapped_file`         | counter  | Soma do `cache` de todos os filhos                                                                                                                                                                                                                                                                    |
| docker\_container\_mem.`total_pgfault`             | counter  | Indica o número de vezes que um processo do cgroup acionou uma "falha de página". <br /><br />Uma falha de página ocorre quando um processo acessa uma parte de seu espaço de memória virtual que é inexistente ou protegido                                                                          |
| docker\_container\_mem.`total_pgmajfault`          | counter  | Indique o número de vezes que um processo do cgroup disparou uma "falha grave". <br /><br />Falhas "maiores" acontecem quando o kernel realmente precisa ler os dados do disco.                                                                                                                       |
| docker\_container\_mem.`total_pgpgin`              | counter  | Soma de todos os filhos `pgpgin`                                                                                                                                                                                                                                                                      |
| docker\_container\_mem.`total_pgpgout`             | counter  | Soma de todos os filhos `pgpgout`                                                                                                                                                                                                                                                                     |
| docker\_container\_mem.`total_rss`                 | counter  | Quantidade de memória que não corresponde a nada no disco: pilhas, pilhas e mapas de memória anônimos                                                                                                                                                                                                 |
| docker\_container\_mem.`total_rss_huge`            | counter  | Soma de todos os filhos `pgpgout`                                                                                                                                                                                                                                                                     |
| docker\_container\_mem.`total_unevictable`         | byte     | Quantidade de memória que não pode ser recuperada; geralmente, ele levará em conta a memória que foi "bloqueada" com mlock. <br /><br />É frequentemente usado por estruturas de criptografia para garantir que as chaves secretas e outros materiais confidenciais nunca sejam trocados para o disco |
| docker\_container\_mem.`total_writeback`           | byte     | Indica a quantidade de memória que foi gravada de volta neste contêiner.                                                                                                                                                                                                                              |
| docker\_container\_mem.`unevictable`               | byte     | Indica a quantidade de memória que não pode ser recuperada por este contêiner.                                                                                                                                                                                                                        |
| docker\_container\_mem.`usage`                     | byte     | Uso de memória em bytes                                                                                                                                                                                                                                                                               |
| docker\_container\_mem.`usage_percent`             | byte     | Uso de memória como uma porcentagem da memória total disponível                                                                                                                                                                                                                                       |
| docker\_container\_mem.`writeback`                 | byte     | Indica a quantidade de memória que foi gravada de volta neste contêiner.                                                                                                                                                                                                                              |

