Kubernetes – Consumo de memória elevado em aplicações que escrevem em disco

Operações de entrada e saída no disco são custosas, a maioria dos sistemas Operacionais Implementam estrategias de caching na escrita e leitura de Dados no sistema de arquivos. no casso kernel linuxele utiliza algumas estrategias, como por exemplo o page cachecujo objetivo Principal é armazenar os Dados lidos pelo sistema de arquivos em cachepara que a próxima operação de leitura esse dado esteja disponível em memória.

Ao analisar as metricas coletadas pelo Prometheus De Uma application go Rodando um um POD do KubernetesIdentificamos um consumo de memória muito Superior ao esperado, dado que a applicação não fazia nada além de escrever Dados Aleatórios em poucos arquivos. Através de uma série de analyzees e pesquisas conseguimos relacionar o comportamento de analyzes page caching I think there is a problem.

application

Applications related to project objects not in the repository: GoDisk Writer. Ela é simples, e sua única função é escrever um buffer em arquivo, repetidas vezes até um certolimite:

func writeLoop(path string, maxFileSize int, count int) error {
    buffer := make([]byte, 10*1024)
    for i := 0; i < len(buffer); i++ {
        buffer[i] = byte(i)
    }

    currentFile := 0

    for {
        file, err := openFile(path, currentFile)
        if err != nil {
            return err
        }

        var fileSize uint64 = 0

        for {
            written, err := file.Write(buffer)
            if err != nil {
                panic(err)
            }
            fileSize += uint64(written)
            if fileSize >= uint64(maxFileSize) {
                currentFile++
                if currentFile >= (count) {
                    return nil
                }
                break
            }
        }
    }
}

O trecho que código acima esta utilizando o pacote operating system. O sistema operacional realiza a chamada SYS_CALL write.

Kubectl Top

Or, an application repository for defined documents. pod.yamlUse Rodar o effectively pod Atrave do Commando kubectl apply -f pod.yaml.

Monitor repeated use. podUse of special forces watch kubectl top pod:

NAME          CPU(cores)   MEMORY(bytes)
disk-writer   1m           408Mi

Após o termino da escrita em disco, a coluna MEMORY estabilizou na casa dos 400Mi. Este compportamento é inesperado, pois além do consumo alto de memória durante or processamento, ele continuea acima do esperado com aaplicação em reposo.

De onde vem a informação do do commando kubectl top pod? Esse foi o Questionamento que levantei após me deparar com esse comportamento.

There is no answer pipeline de metric Do Kubernetes.

Metrics API

• cAdvisor: Demon set para coletar, agregar e expor métricas de contêineres incluído no Kubelet.

• cuvellette: Agente para gerenciar recursos de contêineres. Recurring metrics are used to use endpoints. /metrics/resource E /stats The API is kubelet.

• Node-level resource metrics:API fornecida pelo kubelet para descobrir and recuperar estatísticas resumidas por node disponíveis através do end /metrics/resource.

• metrics server: Additional components are clusters que coleta e agrega métricas de recursos obtidas de cada. kubelet. Fornece is used in metric system. HPA, VPA Epelo Commando kubectl top.

• API de Metericas: API do Kubernetes que suporta o acesso a CPU e memória usados ​​para escalonamento automático.

oh commando kubectl top Access to metric system CPU e memoria através da API de Metericasque inicia uma cadeia de comunicação entre componentes chegando até o container runtime.

work set

work set é is metric byte que indica a yangidade de memoria consumida por um pod. This is an article about Aponta que esse métrica é uma estimativa calculada pelo sistema operacional.

Trezzo Retirado Da official document: “Um um the door is ideal too, oh working set é is used to press free memory using the quantity of memory. No, o cálculo varia de acordo com o sistema Operacional do Host e geralmente faz uso intensivo de heurísticas para produzir uma estimativa.”

cAdvisor

o cAdvisor The é o component is performed as a proxy. container runtimee ele é o Reply por coletar o work setatualmente ele está navigation v1.3.

It’s not fun setMemoryStats Keep your documents cadvisor/blob/master/container/libcontainer/handler.goOr realized through the following calculation:

    inactiveFileKeyName := "total_inactive_file"
    if cgroups.IsCgroup2UnifiedMode() {
        inactiveFileKeyName = "inactive_file"
    }

    workingSet := ret.Memory.Usage
    if v, ok := s.MemoryStats.Stats[inactiveFileKeyName]; ok {
        ret.Memory.TotalInactiveFile = v
        if workingSet < v {
            workingSet = 0
        } else {
            workingSet -= v
        }
    }
    ret.Memory.WorkingSet = workingSet

Este trecho é importante, pois aqui é onde o cAdvisor Like estatísticas, captura. cgroupelectronic calculation o working_set. Repair sub-topics for statistics. inactive_file.

Group C

Group C Well, do it recursively. kernel do Linux Allows the organization of groups of systems to allow formal hierarchies of group processes and iterative control. com cgroupsThere may be restrictions on repeated use.

• CPU: Defines the process speed utilizing the processing speed group.
• Memória: Limits the amount of memory for a user’s process group.
• I/O de Disco: Control the internal workload and status of group groups to realize the arrangement of equipment. Rede: Check the rejection response for the process group.

Test Podemos based on memory evaluation cgroup do pod que usamos como exemplo, através do passo a passo abaixo.

connector number pod: kubectl exec disk-writer -it -- bash.

Navegar até o diretório das estatísticas do cgroup: cd /sys/fs/cgroup.

Listar todos os arquivos relacionados à memória: ls | grep -e memory.stat -e memory.current.

memory.current
memory.stat

Oh bravery memory.current It represents the total quantity of memory in the United States. pelo cgroup, enquato memory.stat To learn more, please distribute and check your memory carefully.

Confirmation or Document Verification memory.current que é a Quantidade total de memória alocado pelo cgroup: cat memory.current.

13124435968 # aproximadamente 12512 MB

Este valor é muito maior que os 408Mi Ke O Commando kubectl top pod As a result.

Verification o inactive_file No storage memory.stat: cat memory.stat | grep inactive_file

inactive_file 12692201472 # aproximadamente 12108 MB

No problem anterior, verificamos que o cAdvisor realize subtração do inactive_filePara calculation o working_setse fizermos o mesmo, o result series: 12512MB−12108MB=404MB.

o pod que utilizamos como exemplo consumes approx. 408Mivalor muito acima do esperado para uma aplicação que um baixo nível de alocação de memória.

go to the storage memory.statum calculo de distribuição percentage das maiores estatisticas em relação ao realization memory.currentThe results are as follows: slab_reclaimable: 421,722,560 bytes (94.2%).

Slab salvage possible

Detailed analysis information is realized about memory consumption for applications and no operations for disco. Kubernetes exposes a description of a specific system. kernel Linux. Oh, stay focused. Page CacheParações de leitura e escrita em disco pode resultar em um alto consumo de memória para otimizar, mesmo após a conclusão das Operações de escrita. Esse compportamento é refletido na metrica working_setque exclui a memória inativa, resultando em discrepâncias entre o consumo real eo Reportado pelo comando kubectl top.

O estudo Demonstro que uma parcela significativa da memória alocada estava relacionada a objetos Slab salvage possibleque são estruturas de dados Cache is a fellow kernel for allocasang kernel for memory. Esses Dados, embora ainda armazenados em cache, podem ser liberados quando o sistema estiver sob pressão de memória, o que explica a diferença entre o consumo de memória observado diretamente no cgroup Report on metrics in Kubernetes.

Portanto, o comportamento de alto consumo de memória em aplicações que escrevem em disco pode ser atribuído a essa estrategia de caching do system operacional. It is an important factor that plays a critical role in iteratively monitoring the adequacy of production environments on Kubernetes and kernel Linux, without necessarily representing design issues.