Deep Dive: tuning de performance com medições – o que mudou em 16 de outubro de 2026 e o que não mudou
Tuning sem números é chute. Uma rodada de tuning em três servidores: o que foi medido, o que foi mudado, o que foi deixado de lado de propósito, como as métricas depois confirmaram – e um erro de medição que teria levado à mudança errada.

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski
Deep Dive da série em torno do Ansible Tour. O tour explica as roles; os deep dives, a tecnologia por baixo: como ela funciona, por que é usada desse jeito aqui e o que deu errado pelo caminho.
Em 16 de outubro de 2026 os três servidores passaram por uma rodada de tuning: o blog e dois servidores Nextcloud. Nenhum deles estava lento. A pergunta era outra: havia memória livre nos três – onde ela realmente ajudaria, e onde só pareceria ocupada? Este post percorre o método, cada mudança com o número por trás dela, as coisas deixadas de lado de propósito e o que as medições dizem quatro dias depois. No fim há uma atualização de 26 de outubro: o que mudou desde então – e um erro meu.
Índice
🧭 O método
- Picos em sete dias, não snapshots. Uma olhada no
topmostra um momento. O Prometheus guarda 30 dias de amostras a cada 15 segundos;max_over_time(…[7d])dá o pior minuto da semana, que é o que os limites precisam aguentar. - Contagens em vez de suposições. Quantos arquivos PHP existem, quantas tabelas temporárias vão para o disco por dia, quantas instâncias de inotify estão em uso – cada uma, um único comando.
- Um motivo por mudança. Cada configuração abaixo tem uma medição ao lado. Configurações que não tinham nenhuma não foram tocadas.
- Antes e depois. As mesmas queries de novo depois do rollout, mais métricas de container que mostram se um limite agora ficou apertado demais.
Os recursos e o que ler deles
| Recurso | Métrica | Armadilha |
|---|---|---|
| CPU | uso por container contra o seu limite; throttling do CFS | Um container pode ser estrangulado enquanto o host está ocioso – o gargalo é o limite, não a máquina. |
| Memória | working set contra o limite | “Used” inclui o page cache; RAM livre não é desperdício, o Linux a usa para arquivos. |
| Memória dos workers | PSS em vez de RSS | O RSS conta a memória compartilhada (OPcache) em cada processo e aqui exagera por um fator de cinco. |
| Filas | listen queue do FPM, max_children atingido | Fila zero significa workers suficientes – mais só custaria memória. |
| Limites do kernel | instâncias e watches de inotify, file descriptors | Eles falham com erros estranhos (“too many open files”) muito antes de algo parecer cheio. |
A lição: um limite precisa aguentar o pior minuto da semana, não o momento em que você por acaso olha.
🛡️ Por que se dar ao trabalho se nada está lento
- Limites são baratos de aumentar antes de morderem e caros de diagnosticar depois, quando o sintoma é um cliente de sync que trava uma vez por semana.
- Padrões são o chute de outra pessoa. Dois deles se revelaram errados para o Nextcloud por um fator de quatro.
- Saber o que não mudar é metade do resultado: buffers maiores no lugar errado só movem o gargalo ou o escondem.
🔧 O que foi mudado
| Área | Medido | Mudado para | Onde |
|---|---|---|---|
| Workers do PHP-FPM (Nextcloud) | pico de 17 de 20 e 10 de 12 ocupados ao mesmo tempo | 30 e 20 workers; limites de container de 6 e 5 GiB | variáveis de host |
| OPcache (Nextcloud) | 15.500 e 17.800 arquivos PHP; limite 10.000 = 16.229 slots | 256 MB, 20.000 arquivos (32.531 slots) | config map do PHP |
| APCu (Nextcloud) | padrão do PHP de 32 MB, um segmento para todos os workers | 128 MB | config map do PHP |
| Arquivos temporários do MariaDB | 2.000–3.500 tabelas temporárias por dia no disco | /tmp como tmpfs (host: 4 GB, pod do blog: 512 MiB) | unit do MariaDB / pod |
| Collabora | “office failed to load” em um cold start | 10 e 6 processos de documento pré-iniciados | variáveis de host |
| Requisições PHP travadas | nenhum limite de tempo real | request_terminate_timeout 300 s blog / 3.600 s Nextcloud | pool do FPM |
| Kernel: inotify | padrão de 128 instâncias por usuário; o root já usava 63 | 8.192 instâncias, 524.288 watches | common_sysctl |
| Kernel: write-back | dirty pages gravadas a 10 / 30 % da RAM | 5 / 10 % | common_sysctl |
Por que esses e não outros
- Workers: 17 de 20 são 85 % no pico – a próxima tarde movimentada teria formado fila. Os limites de container seguiram os pools, não o contrário: PSS por worker vezes
max_children, mais OPcache e APCu, com folga. - OPcache: no servidor Nextcloud menor, 1.500 arquivos nunca cabiam e eram compilados a cada requisição. Quem decide isso é o número de arquivos, não um palpite.
- Tabelas temporárias com colunas TEXT nunca podem usar o memory engine, então ajustar
tmp_table_sizenão teria mudado nada. Mover para a RAM o diretório onde elas são escritas muda. Uma armadilha no caminho: combinado comPrivateTmp=yes, o diretório privado do systemd no disco vence e o tmpfs é ignorado em silêncio – descoberto testando comsystemd-run, não lendo. E no pod do blog um volume em memória conta contra o limite de memória do container, que por isso passou de 768 MiB para 1.280 MiB. - inotify: K3s, containerd e todo pod com um file watcher pegam instâncias como root. 63 de 128 está ok hoje e vira um erro misterioso depois dos próximos pods.
- Write-back a 10 % em vez de 30 % de 23 GB significa no máximo 2,3 GB de dados não gravados em vez de 7 GB – travadas mais curtas quando o kernel finalmente precisa gravar, e menos dados perdidos em um crash brusco.
tuned e sysctl: quem vence
O AlmaLinux roda o tuned com o perfil virtual-guest, que define vm.dirty_ratio = 30 por conta própria. O nosso 10 é o que o kernel informa, porque o tuned reaplica /etc/sysctl.d/ depois do seu próprio perfil (reapply_sysctl = 1, o padrão). Sem isso, o perfil desfaria a configuração em silêncio a cada boot. Conferir o valor ativo com sysctl -n depois de um reboot é a única prova confiável.
A lição: toda mudança precisa de um número que a justifique. Onde não havia nenhum, a configuração ficou como estava.
🧊 O que foi deixado de lado de propósito
| Área | Medido | Por que não |
|---|---|---|
| Buffer pool do InnoDB | taxa de acerto > 99,8 %, pools maiores que os dados (2 GB para 344 MB) | Mais memória não melhora um cache que já guarda tudo. |
| Redis | 1–1,5 MB usados | Nada a ganhar. |
| PHP-FPM do blog | pico de 6 de 12 workers, fila no máximo 1 | O pool era grande o bastante. |
| OPcache do blog | ~4.600 arquivos PHP, limite 10.000 | Cabe. |
| Conexões do MariaDB | pico de 15 de 50 | Espaço de sobra. |
Memória livre que nada usa também não está perdida: o Linux a enche com cache de arquivos, que é exatamente o que um servidor de arquivos quer.
A lição: mais memória para um cache que já guarda tudo não melhora nada. Saber o que não mudar é metade do trabalho.
📊 Quatro dias depois
| Blog | Nextcloud A | Nextcloud B | |
|---|---|---|---|
| Pico de workers PHP ativos (7 dias) | 8 de 12 | 13 de 30 | 9 de 20 |
max_children atingido | 0 | 0 | 0 |
| Pico de memória do container / limite | 538 MiB / 1 GiB | 763 MiB / 6 GiB | 277 MiB / 5 GiB |
| Períodos de CPU estrangulados | 2,1 % | 2,2 % | 0,2 % |
| Requisições PHP lentas (> 5 s) | 0 | 0 | 0 |
| Queries lentas no banco (> 1 s) | 0 | 0 | 0 |
| Memória disponível no host | 5,0 de 7,5 GB | 19 de 23 GB | 8,5 de 11,4 GB |
Nenhum pool chegou perto do limite, nenhum container perto do limite de memória, o throttling fica em um dígito baixo e os hosts ainda têm a maior parte da memória livre. As mudanças custaram pouco e removeram três tetos reais – workers, slots de bytecode, um limite de tempo real – antes que alguém batesse neles.
O erro de medição
Ao coletar os números acima, a primeira query para o container PHP do blog retornou um pico de 940 MiB contra um limite de 1 GiB – o que teria pedido um limite maior na hora. A query somava todas as séries do container: durante um rollout o pod antigo e o novo existem ao mesmo tempo, e logo após um restart de container o cAdvisor informa brevemente o cgroup antigo e o novo. O pico de um único pod era 538 MiB. Somar por pod, ou pegar o máximo por pod, é a leitura correta; um sum simples pelo nome do container soma coisas que nunca existiram ao mesmo tempo em um processo.
🔄 Atualização, 26 de outubro de 2026
Dez dias depois vieram mais quatro mudanças, cada uma de novo com uma medição por trás:
- Container PHP do blog: 1 → 1,5 GiB. Não porque faltava memória. Primeiro eu dividi a memória do container pelo número de workers em execução, cheguei a 90–130 MB por worker e concluí que 1 GiB era pouco para um pool cheio de 12. Era o erro de medição acima em outra forma: a memória do container inclui o segmento compartilhado do OPcache e o page cache. Medido por PSS, um worker precisa de 20–26 MB, um pool cheio de cerca de 0,5 GB. O limite maior ficou mesmo assim, porque um único upload com processamento de imagem pode usar até
memory_limit = 512M. - Collabora no servidor Nextcloud maior: 4 → 6 cores. Durante a geração de previews o pico foi de 3,94 cores – bem no limite. O servidor tem oito cores.
- Dois avisos antecipados para o PHP-FPM: um e-mail quando mais de 80 % dos workers ficam ocupados por cinco minutos, e um assim que
max_childrené atingido. - O blog roda PHP 8.5, como os dois servidores Nextcloud.
🆘 Cola: sintoma → comando
A versão curta deste artigo para o momento em que algo está errado. Execute no host como root; <…> são placeholders.
| Sintoma | Comando |
|---|---|
| Falta memória a um pod? | max_over_time(max by (pod) (container_memory_working_set_bytes{container="<c>"})[7d:1m]) |
| Falta CPU a um pod (throttled)? | sum(increase(container_cpu_cfs_throttled_periods_total{container="<c>"}[7d]))/ sum(increase(container_cpu_cfs_periods_total{container="<c>"}[7d])) |
| Há workers PHP suficientes? | max_over_time(sum(phpfpm_active_processes)[7d:1m])max_over_time(max(phpfpm_listen_queue)[7d:1m]) |
| Algo foi morto por falta de memória? | journalctl -k | grep -i "out of memory"Loki: {job="journal", transport="kernel"} |= "oom" |
| O que sobra no host? | free -h; uptime; df -h /k3s kubectl top pods -A |
| Onde olhar primeiro | # Grafana: dashboard "Container-Ressourcen" (limits, throttling, OOM kills) |
🎯 As lições
- Quem decide é o pico ao longo de uma semana, não o momento.
- Cada configuração recebe a medição em que se baseia.
- Memória por processo se mede com PSS. RSS e “memória do container dividida pelos processos” contam a memória compartilhada várias vezes.
- Agregue métricas de container por pod, não pelo nome do container: durante um rollout existem dois pods.
- Se uma configuração do kernel está em vigor, quem mostra é o
sysctl -ndepois de um reboot – não o arquivo de configuração.
⚖️ Alternativas – e por que medir primeiro
| Abordagem | Ponto forte | Ponto fraco |
|---|---|---|
| Tuning por checklist | Rápido, sem ferramentas | Muda o que o autor da lista precisava, não o que este servidor precisa. |
| Máquina maior | Sempre ajuda um pouco | Esconde o teto em vez de movê-lo; custa todo mês. |
| Ferramentas APM comerciais | Traces até uma única função | Custo, um agente em cada container e exagero para essas cargas. |
| Medir, depois mudar uma coisa | Toda mudança tem um motivo e uma verificação | Precisa de métricas que já existam – por isso elas vieram primeiro. |
O resultado mais valioso do dia não foi uma configuração, e sim uma lista: oito mudanças, cada uma com um número, e cinco coisas deixadas de lado, cada uma também com um número. A próxima rodada de tuning vai partir dela, e se um valor se revelar errado, vai estar claro em que ele se baseou.
