Deep Dive: performance-tuning met metingen – wat er op 16 oktober 2026 veranderde, en wat niet

Tuning zonder getallen is gokken. Eén tuningronde op drie servers: wat er gemeten werd, wat er veranderd werd, wat bewust met rust werd gelaten, hoe de metrics het daarna bevestigden – en één meetfout die tot de verkeerde wijziging had geleid.

Illustratie bij de Deep Dive-serie

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

Deep Dive in de serie rond de Ansible Tour. De tour legt de roles uit, de deep dives de techniek eronder: hoe het werkt, waarom het hier zo wordt gebruikt en wat er onderweg misging.

Op 16 oktober 2026 kregen de drie servers één tuningronde: de blog en twee Nextcloud-servers. Geen van hen was traag. De vraag was een andere: er was op alle drie vrij geheugen – waar zou het echt helpen, en waar zou het er alleen druk uitzien? Deze post loopt door de methode, elke wijziging met het getal erachter, de dingen die bewust met rust zijn gelaten, en wat de metingen vier dagen later zeggen. Aan het eind staat een update van 26 oktober: wat er sindsdien is veranderd – en een fout van mezelf.

Inhoud

🧭 De methode

  • Pieken over zeven dagen, geen momentopnamen. Een blik op top toont één moment. Prometheus bewaart 30 dagen aan samples, elke 15 seconden; max_over_time(…[7d]) geeft de slechtste minuut van de week, en die moeten limieten overleven.
  • Tellingen in plaats van aannames. Hoeveel PHP-bestanden er zijn, hoeveel tijdelijke tabellen per dag naar schijf gaan, hoeveel inotify-instanties in gebruik zijn – elk één enkel commando.
  • Eén reden per wijziging. Elke instelling hieronder heeft een meting ernaast. Instellingen zonder meting zijn niet aangeraakt.
  • Voor en na. Dezelfde queries opnieuw na de uitrol, plus containermetrics die laten zien of een limiet nu te krap is.

De resources, en wat je eruit afleest

ResourceMetricValkuil
CPUgebruik per container tegenover zijn limiet; CFS-throttlingEen container kan gethrottled worden terwijl de host niets doet – de limiet is de bottleneck, niet de machine.
Geheugenworking set tegenover de limiet“Used” bevat de page cache; vrij RAM is niet verspild, Linux gebruikt het voor bestanden.
WorkergeheugenPSS in plaats van RSSRSS telt gedeeld geheugen (OPcache) in elk proces mee en overdrijft hier met een factor vijf.
WachtrijenFPM listen queue, max_children bereiktNul wachtrij betekent genoeg workers – meer zou alleen geheugen kosten.
Kernellimieteninotify-instanties en -watches, file descriptorsZe falen met vreemde fouten (“too many open files”) lang voordat iets er vol uitziet.

De les: een limiet moet de slechtste minuut van de week overleven, niet het moment waarop je toevallig kijkt.

🛡️ Waarom de moeite als niets traag is

  • Limieten zijn goedkoop te verhogen voordat ze bijten en duur om achteraf te diagnosticeren, als het symptoom een syncclient is die één keer per week blijft hangen.
  • Defaults zijn de gok van iemand anders. Twee ervan bleken voor Nextcloud een factor vier fout.
  • Weten wat je niet moet veranderen is de helft van het resultaat: grotere buffers op de verkeerde plek verschuiven de bottleneck alleen of verbergen hem.

🔧 Wat er veranderd is

GebiedGemetenVeranderd naarWaar
PHP-FPM-workers (Nextcloud)piek 17 van 20 en 10 van 12 tegelijk bezet30 en 20 workers; containerlimieten 6 en 5 GiBhostvariabelen
OPcache (Nextcloud)15.500 en 17.800 PHP-bestanden; limiet 10.000 = 16.229 slots256 MB, 20.000 bestanden (32.531 slots)PHP-configmap
APCu (Nextcloud)PHP-default 32 MB, één segment voor alle workers128 MBPHP-configmap
Tijdelijke bestanden van MariaDB2.000–3.500 tijdelijke tabellen per dag op schijf/tmp als tmpfs (host: 4 GB, blogpod: 512 MiB)MariaDB-unit / pod
Collabora“office failed to load” bij een koude start10 en 6 voorgestarte documentprocessenhostvariabelen
Hangende PHP-requestshelemaal geen wall-clock-limietrequest_terminate_timeout 300 s blog / 3.600 s NextcloudFPM-pool
Kernel: inotifydefault 128 instanties per gebruiker; root gebruikte er al 638.192 instanties, 524.288 watchescommon_sysctl
Kernel: write-backdirty pages weggeschreven bij 10 / 30 % van het RAM5 / 10 %common_sysctl

Waarom deze en geen andere

  • Workers: 17 van 20 is 85 % op de piek – de volgende drukke middag zou in de wachtrij zijn beland. De containerlimieten volgden de pools, niet andersom: PSS per worker maal max_children, plus OPcache en APCu, met ruimte over.
  • OPcache: op de kleinere Nextcloud-server pasten 1.500 bestanden nooit en werden ze bij elk request gecompileerd. Het aantal bestanden beslist dit, niet een gevoel.
  • Tijdelijke tabellen met TEXT-kolommen kunnen nooit de memory engine gebruiken, dus tmp_table_size tunen zou niets hebben veranderd. De directory waar ze naartoe geschreven worden in RAM zetten wel. Eén valkuil onderweg: in combinatie met PrivateTmp=yes wint de private directory van systemd op schijf en wordt de tmpfs stilletjes genegeerd – gevonden door te testen met systemd-run, niet door te lezen. En in de blogpod telt een volume in het geheugen mee voor de geheugenlimiet van de container, die daarom van 768 MiB naar 1.280 MiB ging.
  • inotify: K3s, containerd en elke pod met een file watcher nemen instanties als root. 63 van 128 is vandaag prima en een raadselachtige fout na de volgende paar pods.
  • Write-back bij 10 % in plaats van 30 % van 23 GB betekent hooguit 2,3 GB niet-weggeschreven data in plaats van 7 GB – kortere haperingen als de kernel eindelijk moet schrijven, en minder dataverlies bij een harde crash.

tuned en sysctl: wie wint

AlmaLinux draait tuned met het profiel virtual-guest, dat zelf vm.dirty_ratio = 30 zet. Onze 10 is wat de kernel meldt, omdat tuned /etc/sysctl.d/ na zijn eigen profiel opnieuw toepast (reapply_sysctl = 1, de default). Zonder dat zou het profiel de instelling bij elke boot stilletjes ongedaan maken. De live waarde controleren met sysctl -n na een reboot is het enige betrouwbare bewijs.

De les: elke wijziging heeft een getal nodig dat haar rechtvaardigt. Waar er geen was, bleef de instelling zoals ze was.

🧊 Wat bewust met rust is gelaten

GebiedGemetenWaarom niet
InnoDB buffer poolhitrate > 99,8 %, pools groter dan de data (2 GB voor 344 MB)Meer geheugen kan een cache die al alles bevat niet beter maken.
Redis1–1,5 MB gebruiktNiets te winnen.
PHP-FPM van de blogpiek 6 van 12 workers, wachtrij hooguit 1De pool was groot genoeg.
OPcache van de blog~4.600 PHP-bestanden, limiet 10.000Past.
MariaDB-verbindingenpiek 15 van 50Ruim genoeg.

Vrij geheugen dat niets gebruikt is ook niet verloren: Linux vult het met bestandscache, en dat is precies wat een bestandsserver wil.

De les: meer geheugen voor een cache die al alles bevat, verbetert niets. Weten wat je niet moet veranderen is het halve werk.

📊 Vier dagen later

BlogNextcloud ANextcloud B
Piek actieve PHP-workers (7 dagen)8 van 1213 van 309 van 20
max_children bereikt000
Geheugenpiek container / limiet538 MiB / 1 GiB763 MiB / 6 GiB277 MiB / 5 GiB
Gethrottlede CPU-periodes2,1 %2,2 %0,2 %
Trage PHP-requests (> 5 s)000
Trage databasequeries (> 1 s)000
Beschikbaar geheugen op de host5,0 van 7,5 GB19 van 23 GB8,5 van 11,4 GB

Geen pool kwam in de buurt van zijn limiet, geen container in de buurt van zijn geheugenlimiet, de throttling blijft in de lage enkele cijfers en de hosts hebben nog steeds het grootste deel van hun geheugen vrij. De wijzigingen kostten weinig en haalden drie echte plafonds weg – workers, bytecode-slots, een wall-clock-limiet – voordat iemand ertegenaan liep.

De meetfout

Bij het verzamelen van de getallen hierboven gaf de eerste query voor de PHP-container van de blog een piek van 940 MiB tegenover een limiet van 1 GiB – wat meteen om een hogere limiet zou hebben gevraagd. De query telde alle series van de container op: tijdens een rollout bestaan de oude en de nieuwe pod tegelijk, en vlak na een containerherstart meldt cAdvisor kort de oude en de nieuwe cgroup. De piek van één pod was 538 MiB. Optellen per pod, of het maximum per pod nemen, is de juiste lezing; een gewone sum op containernaam telt dingen op die nooit op hetzelfde moment in één proces bestonden.

🔄 Update, 26 oktober 2026

Tien dagen later volgden nog vier wijzigingen, elk weer met een meting erachter:

  • PHP-container van de blog: 1 → 1,5 GiB. Niet omdat het geheugen krap was. Eerst deelde ik het geheugen van de container door het aantal draaiende workers, kwam uit op 90–130 MB per worker en concludeerde dat 1 GiB te weinig was voor een volle pool van 12. Dat was de meetfout hierboven in een andere vorm: het geheugen van de container bevat het gedeelde OPcache-segment en de page cache. Gemeten met PSS heeft een worker 20–26 MB nodig, een volle pool ongeveer 0,5 GB. De hogere limiet bleef toch, omdat één upload met beeldverwerking tot memory_limit = 512M kan gebruiken.
  • Collabora op de grotere Nextcloud-server: 4 → 6 cores. Tijdens het genereren van previews was de piek 3,94 cores – precies op de limiet. De server heeft acht cores.
  • Twee vroege waarschuwingen voor PHP-FPM: een mail als meer dan 80 % van de workers vijf minuten bezet is, en een zodra max_children wordt bereikt.
  • De blog draait PHP 8.5, net als de twee Nextcloud-servers.

🆘 Spiekbriefje: symptoom → commando

De korte versie van dit artikel voor het moment dat er iets mis is. Uitvoeren op de host als root; <…> zijn placeholders.

SymptoomCommando
Heeft een pod te weinig geheugen?max_over_time(max by (pod) (container_memory_working_set_bytes{container="<c>"})[7d:1m])
Heeft een pod te weinig CPU (throttled)?sum(increase(container_cpu_cfs_throttled_periods_total{container="<c>"}[7d]))
/ sum(increase(container_cpu_cfs_periods_total{container="<c>"}[7d]))
Zijn er genoeg PHP-workers?max_over_time(sum(phpfpm_active_processes)[7d:1m])
max_over_time(max(phpfpm_listen_queue)[7d:1m])
Is er iets gekild wegens geheugentekort?journalctl -k | grep -i "out of memory"
Loki: {job="journal", transport="kernel"} |= "oom"
Wat heeft de host nog over?free -h; uptime; df -h /
k3s kubectl top pods -A
Waar je eerst kijkt# Grafana: dashboard "Container-Ressourcen" (limits, throttling, OOM kills)

🎯 De lessen

  • De piek over een week beslist, niet het moment.
  • Elke instelling krijgt de meting waarop ze gebaseerd is.
  • Geheugen per proces meet je met PSS. RSS en “containergeheugen gedeeld door processen” tellen gedeeld geheugen meerdere keren.
  • Aggregeer containermetrics per pod, niet op containernaam: tijdens een rollout bestaan er twee pods.
  • Of een kernelinstelling actief is, laat sysctl -n na een reboot zien – niet het configuratiebestand.

⚖️ Alternatieven – en waarom eerst meten

AanpakSterk puntZwak punt
Tuning volgens checklistSnel, geen tooling nodigVerandert wat de auteur van de lijst nodig had, niet wat deze server nodig heeft.
Grotere machineHelpt altijd een beetjeVerbergt het plafond in plaats van het te verschuiven; kost elke maand.
Commerciële APM-toolsTraces tot op één functieKosten, een agent in elke container, en overkill voor deze workloads.
Meten, dan één ding veranderenElke wijziging heeft een reden en een controleHeeft metrics nodig die er al zijn – daarom kwamen die eerst.

Het waardevolste resultaat van de dag was geen instelling maar een lijst: acht wijzigingen, elk met een getal, en vijf dingen die met rust zijn gelaten, elk ook met een getal. De volgende tuningronde begint daarbij, en als een waarde fout blijkt, is duidelijk waarop ze gebaseerd was.

Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details