Deep Dive: tuning delle prestazioni con le misure – cosa è cambiato il 16 ottobre 2026, e cosa no
Tuning senza numeri è tirare a indovinare. Un giro di tuning su tre server: cosa è stato misurato, cosa è stato cambiato, cosa è stato lasciato com'era di proposito, come le metriche successive lo hanno confermato – e un errore di misura che avrebbe portato alla modifica sbagliata.

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
Deep Dive della serie attorno all’Ansible Tour. Il tour spiega i ruoli, i deep dive la tecnologia sottostante: come funziona, perché qui viene usata in questo modo e cosa è andato storto lungo la strada.
Il 16 ottobre 2026 i tre server hanno ricevuto un giro di tuning: il blog e due server Nextcloud. Nessuno era lento. La domanda era un’altra: su tutti e tre c’era memoria libera – dove avrebbe aiutato davvero, e dove avrebbe solo dato l’impressione di lavorare? Questo post ripercorre il metodo, ogni modifica con il numero che c’è dietro, le cose lasciate stare di proposito, e cosa dicono le misure quattro giorni dopo. Alla fine c’è un aggiornamento del 26 ottobre: cosa è cambiato da allora – e un errore mio.
Indice
🧭 Il metodo
- Picchi su sette giorni, non istantanee. Un’occhiata a
topmostra un momento. Prometheus conserva 30 giorni di campioni ogni 15 secondi;max_over_time(…[7d])dà il minuto peggiore della settimana, ed è quello che i limiti devono reggere. - Conteggi invece di supposizioni. Quanti file PHP esistono, quante tabelle temporanee finiscono su disco al giorno, quante istanze inotify sono in uso – ognuno un singolo comando.
- Un motivo per ogni modifica. Ogni impostazione qui sotto ha una misura accanto. Le impostazioni che non ne avevano non sono state toccate.
- Prima e dopo. Le stesse query di nuovo dopo il rollout, più le metriche dei container che mostrano se un limite ora è troppo stretto.
Le risorse, e cosa leggerne
| Risorsa | Metrica | Trappola |
|---|---|---|
| CPU | uso per container rispetto al suo limite; throttling CFS | Un container può essere strozzato mentre l’host è inattivo – il collo di bottiglia è il limite, non la macchina. |
| Memoria | working set rispetto al limite | “Usata” include la page cache; la RAM libera non è sprecata, Linux la usa per i file. |
| Memoria dei worker | PSS invece di RSS | RSS conta la memoria condivisa (OPcache) in ogni processo e qui sovrastima di un fattore cinque. |
| Code | listen queue di FPM, max_children raggiunto | Coda a zero significa worker sufficienti – di più costerebbero solo memoria. |
| Limiti del kernel | istanze e watch inotify, file descriptor | Falliscono con errori strani (“too many open files”) molto prima che qualcosa sembri pieno. |
In sintesi: un limite deve reggere il minuto peggiore della settimana, non il momento in cui ti capita di guardare.
🛡️ Perché preoccuparsene se niente è lento
- Alzare i limiti costa poco prima che mordano e diagnosticarli dopo costa caro, quando il sintomo è un client di sincronizzazione che si blocca una volta alla settimana.
- I default sono la supposizione di qualcun altro. Due di essi si sono rivelati sbagliati per Nextcloud di un fattore quattro.
- Sapere cosa non cambiare è metà del risultato: buffer più grandi nel posto sbagliato spostano soltanto il collo di bottiglia o lo nascondono.
🔧 Cosa è stato cambiato
| Area | Misurato | Cambiato in | Dove |
|---|---|---|---|
| Worker PHP-FPM (Nextcloud) | picco di 17 su 20 e 10 su 12 occupati contemporaneamente | 30 e 20 worker; limiti dei container 6 e 5 GiB | variabili degli host |
| OPcache (Nextcloud) | 15.500 e 17.800 file PHP; limite 10.000 = 16.229 slot | 256 MB, 20.000 file (32.531 slot) | config map di PHP |
| APCu (Nextcloud) | default PHP 32 MB, un segmento per tutti i worker | 128 MB | config map di PHP |
| File temporanei di MariaDB | 2.000–3.500 tabelle temporanee al giorno su disco | /tmp come tmpfs (host: 4 GB, pod del blog: 512 MiB) | unit di MariaDB / pod |
| Collabora | “office failed to load” a freddo | 10 e 6 processi documento pre-avviati | variabili degli host |
| Richieste PHP appese | nessun limite di tempo reale | request_terminate_timeout 300 s blog / 3.600 s Nextcloud | pool FPM |
| Kernel: inotify | default 128 istanze per utente; root ne usava già 63 | 8.192 istanze, 524.288 watch | common_sysctl |
| Kernel: write-back | dirty page scritte al 10 / 30 % della RAM | 5 / 10 % | common_sysctl |
Perché queste e non altre
- Worker: 17 su 20 è l'85 % al picco – il prossimo pomeriggio intenso avrebbe fatto la coda. I limiti dei container hanno seguito i pool, non il contrario: PSS per worker moltiplicato per
max_children, più OPcache e APCu, con margine. - OPcache: sul server Nextcloud più piccolo 1.500 file non entravano mai e venivano compilati a ogni richiesta. Lo decide il numero di file, non una sensazione.
- Le tabelle temporanee con colonne TEXT non possono mai usare il motore in memoria, quindi regolare
tmp_table_sizenon avrebbe cambiato nulla. Spostare in RAM la directory in cui vengono scritte sì. Una trappola lungo la strada: combinato conPrivateTmp=yes, la directory privata su disco di systemd vince e il tmpfs viene ignorato in silenzio – scoperto testando consystemd-run, non leggendo. E nel pod del blog un volume in memoria conta nel limite di memoria del container, che quindi è passato da 768 MiB a 1.280 MiB. - inotify: K3s, containerd e ogni pod con un file watcher prendono istanze come root. 63 su 128 oggi va bene, e dopo i prossimi pod diventa un errore misterioso.
- Write-back al 10 % invece che al 30 % di 23 GB significa al massimo 2,3 GB di dati non scritti invece di 7 GB – blocchi più brevi quando il kernel alla fine deve scrivere, e meno dati persi in un crash brusco.
tuned e sysctl: chi vince
AlmaLinux fa girare tuned con il profilo virtual-guest, che imposta da sé vm.dirty_ratio = 30. Il nostro 10 è ciò che riporta il kernel, perché tuned riapplica /etc/sysctl.d/ dopo il proprio profilo (reapply_sysctl = 1, il default). Senza questo, il profilo annullerebbe in silenzio l’impostazione a ogni avvio. Controllare il valore attivo con sysctl -n dopo un riavvio è l’unica prova affidabile.
In sintesi: ogni modifica ha bisogno di un numero che la giustifichi. Dove non ce n’era, l’impostazione è rimasta com’era.
🧊 Cosa è stato lasciato stare di proposito
| Area | Misurato | Perché no |
|---|---|---|
| Buffer pool di InnoDB | hit rate > 99,8 %, pool più grandi dei dati (2 GB per 344 MB) | Più memoria non può migliorare una cache che contiene già tutto. |
| Redis | 1–1,5 MB usati | Niente da guadagnare. |
| PHP-FPM del blog | picco di 6 worker su 12, coda al massimo 1 | Il pool era abbastanza grande. |
| OPcache del blog | ~4.600 file PHP, limite 10.000 | Ci sta. |
| Connessioni MariaDB | picco di 15 su 50 | Spazio in abbondanza. |
Nemmeno la memoria libera che nulla usa è persa: Linux la riempie con la cache dei file, che è esattamente ciò che vuole un file server.
In sintesi: più memoria per una cache che contiene già tutto non migliora nulla. Sapere cosa non cambiare è metà del lavoro.
📊 Quattro giorni dopo
| Blog | Nextcloud A | Nextcloud B | |
|---|---|---|---|
| Picco di worker PHP attivi (7 giorni) | 8 su 12 | 13 su 30 | 9 su 20 |
max_children raggiunto | 0 | 0 | 0 |
| Picco di memoria del container / limite | 538 MiB / 1 GiB | 763 MiB / 6 GiB | 277 MiB / 5 GiB |
| Periodi CPU strozzati | 2,1 % | 2,2 % | 0,2 % |
| Richieste PHP lente (> 5 s) | 0 | 0 | 0 |
| Query lente al database (> 1 s) | 0 | 0 | 0 |
| Memoria disponibile sull’host | 5,0 su 7,5 GB | 19 su 23 GB | 8,5 su 11,4 GB |
Nessun pool si è avvicinato al suo limite, nessun container al suo limite di memoria, il throttling resta su valori bassi a una cifra, e gli host hanno ancora libera la maggior parte della memoria. Le modifiche sono costate poco e hanno tolto tre soffitti reali – worker, slot del bytecode, un limite di tempo reale – prima che qualcuno ci sbattesse contro.
L’errore di misura
Mentre raccoglievo i numeri qui sopra, la prima query per il container PHP del blog ha restituito un picco di 940 MiB su un limite di 1 GiB – il che avrebbe richiesto subito un limite più alto. La query sommava tutte le serie del container: durante un rollout il pod vecchio e quello nuovo esistono contemporaneamente, e subito dopo il riavvio di un container cAdvisor riporta brevemente il cgroup vecchio e quello nuovo. Il picco di un singolo pod era 538 MiB. Sommare per pod, o prendere il massimo per pod, è la lettura corretta; una semplice sum per nome del container somma cose che non sono mai esistite nello stesso momento in un processo.
🔄 Aggiornamento, 26 ottobre 2026
Dieci giorni dopo sono seguite altre quattro modifiche, ognuna di nuovo con una misura dietro:
- Container PHP del blog: 1 → 1,5 GiB. Non perché mancasse memoria. All’inizio ho diviso la memoria del container per il numero di worker in esecuzione, ho ottenuto 90–130 MB per worker e ho concluso che 1 GiB era troppo poco per un pool pieno di 12. Era l’errore di misura di sopra in un’altra forma: la memoria del container include il segmento OPcache condiviso e la page cache. Misurato con il PSS un worker ha bisogno di 20–26 MB, un pool pieno di circa 0,5 GB. Il limite più alto è rimasto comunque, perché un singolo upload con elaborazione dell’immagine può usare fino a
memory_limit = 512M. - Collabora sul server Nextcloud più grande: 4 → 6 core. Durante la generazione delle anteprime il picco era 3,94 core – proprio al limite. Il server ha otto core.
- Due preavvisi per PHP-FPM: una mail quando più dell'80 % dei worker è occupato per cinque minuti, e una appena viene raggiunto
max_children. - Il blog gira con PHP 8.5, come i due server Nextcloud.
🆘 Promemoria: sintomo → comando
La versione breve di questo articolo per il momento in cui qualcosa non va. Da eseguire sull’host come root; <…> sono segnaposto.
| Sintomo | Comando |
|---|---|
| A un pod manca memoria? | max_over_time(max by (pod) (container_memory_working_set_bytes{container="<c>"})[7d:1m]) |
| A un pod manca CPU (throttling)? | sum(increase(container_cpu_cfs_throttled_periods_total{container="<c>"}[7d]))/ sum(increase(container_cpu_cfs_periods_total{container="<c>"}[7d])) |
| Ci sono abbastanza worker PHP? | max_over_time(sum(phpfpm_active_processes)[7d:1m])max_over_time(max(phpfpm_listen_queue)[7d:1m]) |
| Qualcosa è stato ucciso per mancanza di memoria? | journalctl -k | grep -i "out of memory"Loki: {job="journal", transport="kernel"} |= "oom" |
| Cosa resta all’host? | free -h; uptime; df -h /k3s kubectl top pods -A |
| Dove guardare per primo | # Grafana: dashboard "Container-Ressourcen" (limits, throttling, OOM kills) |
🎯 Le lezioni
- Decide il picco su una settimana, non il momento.
- Ogni impostazione riceve la misura su cui si basa.
- La memoria per processo si misura con il PSS. RSS e “memoria del container divisa per i processi” contano più volte la memoria condivisa.
- Aggrega le metriche dei container per pod, non per nome del container: durante un rollout esistono due pod.
- Se un’impostazione del kernel è attiva lo mostra
sysctl -ndopo un riavvio – non il file di configurazione.
⚖️ Alternative – e perché misurare prima
| Approccio | Punto di forza | Debolezza |
|---|---|---|
| Tuning da checklist | Veloce, non servono strumenti | Cambia ciò di cui aveva bisogno l’autore della lista, non ciò di cui ha bisogno questo server. |
| Macchina più grande | Aiuta sempre un po' | Nasconde il soffitto invece di spostarlo; costa ogni mese. |
| Strumenti APM commerciali | Trace fino alla singola funzione | Costi, un agente in ogni container, ed eccessivo per questi carichi. |
| Misurare, poi cambiare una cosa | Ogni modifica ha un motivo e un controllo | Servono metriche già presenti – ed è per questo che sono venute prima. |
Il risultato più prezioso della giornata non è stata un’impostazione ma una lista: otto modifiche, ognuna con un numero, e cinque cose lasciate stare, anch’esse ognuna con un numero. Il prossimo giro di tuning partirà da lì, e se un valore si rivelerà sbagliato, sarà chiaro su cosa si basava.
