
Kubernetes autoscaling: meeschalen met je verkeer, niet met je hoop
Autoscaling is de reden dat veel teams naar Kubernetes kijken. Het is ook de plek waar de meeste teleurstelling zit. Pods schalen niet als de requests verkeerd staan, nodes komen te laat, en de database schaalt helemaal niet mee. Wij richten Kubernetes autoscaling in op de echte knelpunten van Magento en Laravel: webverkeer, queues, cron en de piekmomenten die je al maanden ziet aankomen.
- HPA voor webverkeer, KEDA voor queues en cron
- Karpenter of cluster-autoscaler voor nodes die op tijd klaarstaan
- Requests en limits onderbouwd met metingen
Wat is Kubernetes autoscaling, en welke lagen zijn er?
Kubernetes autoscaling is het automatisch aanpassen van capaciteit aan de vraag. Dat gebeurt op twee niveaus. Op podniveau bepaalt de Horizontal Pod Autoscaler (HPA) hoeveel replicas er draaien, en de Vertical Pod Autoscaler (VPA) hoeveel CPU en geheugen elke pod krijgt. Op nodeniveau zorgen de cluster-autoscaler of Karpenter dat er genoeg servers zijn om die pods te plaatsen.
Daartussen zit KEDA. KEDA laat de HPA schalen op signalen buiten de pod: de lengte van een Redis-lijst, berichten in RabbitMQ, een Prometheus-query of een tijdschema. Voor webshops is dat vaak belangrijker dan CPU. Een orderqueue die volloopt, laat de CPU van je webpods ongemoeid.
De eerlijke versie: autoscaling lost alleen capaciteitsproblemen op in lagen die horizontaal kunnen schalen. PHP-FPM-pods, queue-workers en Varnish wel. Een enkele MySQL-primary niet. Op deze pagina laten we zien hoe we elke laag inrichten, wat je vooraf moet meten en waar de grenzen liggen.
Welke autoscaler voor welk werk
De meeste platformen gebruiken er drie tegelijk: HPA of KEDA voor pods, en één node-autoscaler.
| Autoscaler | Schaalt | Op basis van | Typisch gebruik bij Magento en Laravel |
|---|---|---|---|
| Horizontal Pod Autoscaler (HPA) | Aantal replicas | CPU, geheugen of custom metrics | PHP-FPM/nginx-pods, Octane-workers, Varnish |
| KEDA | Aantal replicas, ook naar nul; of Jobs | Externe bronnen: Redis-lijsten, RabbitMQ, MySQL-query, Prometheus, cron | Magento-consumers, Laravel queue-workers en Horizon, geplande voorschaling |
| Vertical Pod Autoscaler (VPA) | CPU- en geheugenrequests per pod | Historisch verbruik | Advies voor requests in Off-modus; automatisch voor workloads zonder HPA |
| Cluster-autoscaler | Aantal nodes in vooraf gedefinieerde node groups | Pods die niet geplaatst kunnen worden | Werkt bij vrijwel elke managed Kubernetes-aanbieder |
| Karpenter | Nodes, direct op het juiste type en formaat | Pods die niet geplaatst kunnen worden, plus consolidatie | AWS EKS; op AKS als node auto-provisioning |
Plan een vrijblijvend gesprek over je project
Een half uur via video met de mensen die het werk ook echt doen. Kies hieronder een moment dat jou past.
- Direct met het vaste team, geen tussenlagen
- Concrete feedback op je huidige situatie of plannen
- Eerlijk advies, ook als het antwoord "niet doen" is
- Indicatie van kosten en tijdlijn
Plan een gratis Tech Check
Vrijblijvend jouw uitdagingen bespreken
Of bel direct: 0591-239 299
Requests en limits: het fundament onder elke autoscaler
De HPA rekent in procenten van de request, niet van de node. Staat de CPU-request van een PHP-FPM-pod op 100m terwijl hij onder normale belasting 600m gebruikt, dan staat de HPA permanent op maximaal. Staat de request op 2 cores terwijl hij er 0,3 gebruikt, dan schaalt hij nooit, en betaal je voor lucht. Autoscaling begint dus met meten.
We draaien de VPA eerst in Off-modus, of lezen het verbruik uit Prometheus, over minimaal een week met normaal verkeer. Daarop zetten we de requests. Voor geheugen kiezen we bij PHP een limit gelijk aan de request. PHP-FPM-geheugen groeit met het aantal actieve workers, en een node die geheugen overboekt, gaat pods killen op het slechtste moment.
Bij CPU zijn we terughoudend met limits. Een CPU-limit leidt tot throttling: de container krijgt zijn quotum niet en wacht, ook als de node vrije capaciteit heeft. Bij PHP zie je dat als willekeurig trage requests. We meten throttling per container en zetten een CPU-limit alleen waar je een luidruchtige buur moet afschermen.
De andere helft zit in de container. pm.max_children in PHP-FPM bepaalt hoeveel requests één pod tegelijk aankan. Die waarde moet passen bij de geheugenlimit: max_children maal het geheugen per worker, plus de basis. Te hoog en de pod gaat OOM. Te laag en de pod weigert werk terwijl de CPU laag staat, en dan schaalt een CPU-HPA ook niet. Dan schalen we op PHP-FPM-bezetting via een custom metric.
HPA voor webverkeer: Magento- en Laravel-pods
De HPA gebruikt de API autoscaling/v2. Je geeft een minimum en maximum aantal replicas en een of meer metrics. Voor de webpods van Magento kiezen we meestal CPU als basis, aangevuld met de bezetting van PHP-FPM uit Prometheus via KEDA of een metrics-adapter. Een voorbeeld: minReplicas 3, maxReplicas 20, doel 65 procent CPU van de request.
Het behavior-blok is belangrijker dan het doelpercentage. Opschalen mag snel: bijvoorbeeld het aantal pods verdubbelen per minuut. Afschalen moet traag. De standaard stabilisatieperiode voor afschalen is vijf minuten; bij een webshop met golvend campagneverkeer zetten we die vaak langer, zodat pods niet verdwijnen tussen twee mailingrondes.
Opschalen is pas nuttig als nieuwe pods snel klaar zijn. Bij Magento betekent dat: static content en DI-compilatie in het image, niet bij het opstarten. Een pod die eerst setup:di:compile draait, is minuten bezig. Met alles in het image en een readiness-probe op een lichte health-check staat een nieuwe pod in seconden in de load balancer. Image-grootte en pull-tijd tellen ook mee; daarvoor houden we images klein en gebruiken we nodes met een image-cache waar dat kan.
Varnish schaalt anders. Elke extra Varnish-pod begint met een lege cache en verdeelt de hits. We schalen Varnish daarom beperkt en bewust, en zetten de capaciteit vooral bij de PHP-laag erachter. Meer over de volledige opbouw op onze pagina over Magento op Kubernetes.
KEDA voor queues, cron en achtergrondwerk
KEDA is een CNCF graduated project. Het maakt onder water een HPA aan, maar dan gevoed door de bron die er echt toe doet.
Een ScaledObject voor Laravel ziet er in de kern zo uit: scaleTargetRef wijst naar de Deployment met queue-workers, minReplicaCount 1, maxReplicaCount 15, en een trigger van type redis met listName queues:orders en listLength 20. Bij 200 wachtende jobs wil KEDA dan tien workers. Het maximum kiezen we niet op gevoel, maar op wat de database en externe API's aankunnen. Twintig workers die tegelijk het ERP aanroepen, kunnen dat ERP platleggen.
Workers moeten netjes kunnen stoppen. Bij afschalen krijgt een pod een SIGTERM. Laravel-workers en Horizon handelen dat af door de huidige job af te maken. We zetten terminationGracePeriodSeconds ruimer dan je langste normale job, en bij Magento-consumers een max-messages-waarde zodat processen regelmatig vers starten. Lange imports zetten we liever in een ScaledJob dan in een worker die halverwege wordt afgeschaald.
| Workload | KEDA-scaler | Signaal | Instelling die we vaak kiezen |
|---|---|---|---|
| Laravel queue-workers op Redis of Valkey | redis (lists) | Lengte van de lijst queues:default of een eigen queue | listLength per worker afgestemd op jobduur, minReplicaCount 1 voor kritieke queues |
| Laravel Horizon | redis of prometheus | Queue-lengte of wachttijd per supervisor | Horizon-balancing binnen de pod, KEDA voor het aantal pods |
| Magento-consumers op RabbitMQ | rabbitmq | Berichten per queue, bijvoorbeeld voor async orderverwerking | Per consumer een eigen ScaledObject, max afgestemd op databasebelasting |
| Magento-consumers op de MySQL-queue | mysql | Aantal berichten met status nieuw in queue_message_status | Lage pollingfrequentie om de database niet extra te belasten |
| Imports en exports | ScaledJob met redis, rabbitmq of prometheus | Er staat werk klaar | Eén Job per batch, schaal naar nul als er niets is |
| Voorschalen voor campagnes | cron | Tijdvenster, bijvoorbeeld rond een mailing of Black Friday | Hoger minimum in het venster, gecombineerd met de gewone metric |
VPA en in-place resize: wanneer verticaal schalen helpt
De VPA past requests aan op basis van verbruik. Lang betekende dat: pod verwijderen en opnieuw starten met nieuwe waarden. Sinds Kubernetes 1.35 is in-place pod resize stabiel, waarmee CPU en geheugen van een draaiende pod kunnen wijzigen, vaak zonder herstart. De VPA-modus InPlaceOrRecreate die daarvan gebruikmaakt, is volgens de Kubernetes-documentatie nog beta.
Gebruik HPA en VPA niet op dezelfde metric voor dezelfde workload. Als de HPA op CPU schaalt en de VPA tegelijk de CPU-request verhoogt, werken ze elkaar tegen. Wij gebruiken de VPA vooral in Off-modus als adviseur voor de requests, en automatisch voor workloads die niet horizontaal schalen, zoals een enkele cron-runner of een interne tool.
Voor PHP is verticaal schalen beperkt nuttig. Meer geheugen voor een PHP-FPM-pod helpt alleen als je ook pm.max_children aanpast, en dat vraagt een herstart van FPM. Bij Octane-workers met lang levende processen ligt dat anders. Daar meten we eerst voordat we iets automatiseren.
Nodes: cluster-autoscaler of Karpenter
Pods schalen is zinloos als er geen node is om ze op te zetten. De cluster-autoscaler kijkt naar pods in Pending en voegt een node toe uit een vooraf gedefinieerde node group. Dat werkt bij vrijwel elke managed Kubernetes-aanbieder, van EKS, GKE en AKS tot Europese aanbieders zoals Scaleway en OVHcloud. Je kiest zelf de nodetypes per groep.
Karpenter kiest het nodetype zelf, op basis van wat de wachtende pods nodig hebben, en consolideert actief: halflege nodes worden leeggemaakt en vervangen door kleinere of minder nodes. Karpenter is ontstaan bij AWS en is daar het meest volwassen. Azure biedt node auto-provisioning in AKS, gebouwd op Karpenter. Bij andere aanbieders blijft de cluster-autoscaler meestal de keuze.
Een nieuwe node kost tijd: machine starten, aan het cluster koppelen, images ophalen. Reken op minuten, niet seconden. Daarom houden we buffer aan. Dat kan met een paar placeholder-pods met lage prioriteit die direct plaatsmaken voor echte pods, waarna de autoscaler op de achtergrond een nieuwe node bijzet. Consolidatie temperen we met PodDisruptionBudgets, zodat Karpenter of de cluster-autoscaler nooit alle webpods tegelijk verplaatst.
Kostenkant: autoscaling verlaagt vooral de rekening als je basislast laag en je pieken kort zijn. Bij een vlakke belasting levert het weinig op. Spot- of preemptible nodes kunnen goedkoper zijn voor queue-workers die tegen een onderbreking kunnen, maar niet voor je database of je enige Varnish-pod. Ons artikel over Kubernetes-kosten zet de posten op een rij.
Black Friday en andere pieken: schalen dat je vooraf test
Weken vooraf
- Loadtest op een productiekopie met een realistisch scenario: zoeken, product, winkelwagen, checkout
- Meten waar het eerst breekt: PHP-FPM, database, OpenSearch, Valkey of een externe API
- maxReplicas en node-limieten afstemmen op wat de database aankan
- Quota bij je cloudaanbieder controleren, zodat je niet tegen een CPU-limiet aanloopt
Dagen vooraf
- Minimum aantal replicas verhogen met een KEDA cron-trigger of tijdelijke values
- Nodes vooraf bijzetten in plaats van te wachten op de autoscaler
- Cache warmen: belangrijke categorie- en productpagina's door Varnish laten ophalen
- Deploy-freeze afspreken en noodprocedure doornemen
Tijdens de piek
- Dashboards met checkout-latency, orders en queue-achterstand open
- Zware imports en reindexen pauzeren of buiten de piek plannen
- Alerts naar iemand die het platform kent, niet naar een algemene inbox
- Afschalen vertraagd, zodat een tweede golf niet op een krimpend cluster valt
Erna
- Minimum terugzetten en nodes laten consolideren
- Vergelijken: waar zat de grens, wat schaalde wel en wat niet
- Requests en limits bijstellen op het gemeten verbruik
- Bevindingen vastleggen voor de volgende campagne
Wat niet meeschaalt, en wat je daaraan doet
De database
Eén primary schaalt niet horizontaal. Leesreplica's, query-optimalisatie en een managed database buiten het cluster met genoeg ruimte zijn de echte maatregelen.
Lees verder →OpenSearch
Meer zoeknodes helpt alleen met de juiste shards en replica's. We dimensioneren het cluster vooraf op je catalogus en piekverkeer.
Lees verder →Externe API's
ERP, PIM en betaalproviders hebben eigen limieten. We begrenzen workers met maxReplicaCount en rate limiting in de jobs.
Lees verder →Je monitoring
Meer pods betekent meer metrics en logs. Zonder ruimte in Prometheus en Loki zie je tijdens de piek juist minder.
Lees verder →Onze aanpak van Kubernetes autoscaling
Eerst meten, dan schalen. Het vaste team dat je platform bouwt, test het ook onder belasting.
- 1
Verbruik meten
Een week of langer CPU, geheugen, PHP-FPM-bezetting en queue-lengte vastleggen, met VPA in Off-modus als tweede bron.
- 2
Requests, limits en FPM afstemmen
Requests op gemeten verbruik, geheugenlimit passend bij pm.max_children, CPU-limits alleen waar nodig.
- 3
Pod-autoscaling inrichten
HPA voor webpods met een onderbouwd behavior-blok, KEDA-ScaledObjects voor queues en cron, ScaledJobs voor batchwerk.
- 4
Node-autoscaling en buffer
Karpenter of cluster-autoscaler, PodDisruptionBudgets en placeholder-capaciteit zodat nieuwe pods niet op een node hoeven te wachten.
- 5
Loadtest en bijsturen
Realistische belasting op een kopie van productie. We noteren waar het breekt en passen grenzen en minima aan.
Wat je opgeleverd krijgt
- Meting van verbruik per workload, met onderbouwde requests en limits
- HPA-configuratie per webcomponent, inclusief behavior voor op- en afschalen
- KEDA-ScaledObjects en ScaledJobs voor queues, consumers en batchwerk
- Node-autoscaling met Karpenter of cluster-autoscaler, inclusief PodDisruptionBudgets
- Draaiboek voor piekmomenten met voorschaling via KEDA cron-trigger
- Loadtestrapport: waar de grens ligt en welke laag als eerste vastloopt
- Dashboards met replicas, nodes, queue-lengte en throttling
- Alles als Helm values of Kustomize-overlays in je GitOps-repository
Waarom Coding.nl voor Kubernetes autoscaling
We schalen de applicatie, niet alleen de pods
We kennen PHP-FPM, Magento-consumers en Laravel-queues van binnenuit. Daardoor schalen we op het signaal dat je omzet raakt.
Eerlijk over de grenzen
Als je database de bottleneck is, zeggen we dat. Meer pods zijn dan alleen meer kosten.
Geen tussenlagen
De mensen die je cluster inrichten, staan ook klaar tijdens de piek. Geen overdracht aan een ander team.
Ook als Kubernetes niet nodig is
Is je verkeer vlak en voorspelbaar, dan is goede managed hosting vaak goedkoper. Dat rekenen we je voor.

Verder lezen
- ›Laravel-queues automatisch schalen met KEDA
- ›Wat kost Kubernetes voor een webshop? De kostenposten
- ›Black Friday voorbereidingen — loadtest en scaling checklist
- ›Laravel op hoge belasting — Black Friday overleven
- ›Laravel op Kubernetes: Horizon, queues en scheduler inrichten
- ›Magento 2 op Kubernetes: de architectuur per component
- ›Laravel Queues voor e-commerce: orderverwerking op schaal
- ›Magento 2 cron jobs — waarom je shop 's nachts vastloopt
- ›Kubernetes of managed hosting voor je webshop?
Veelgestelde vragen
Weten of je platform de volgende piek aankan?
Plan een gesprek. We bekijken je verkeerspatroon, je requests en je queues, en vertellen eerlijk waar de grens nu ligt en of autoscaling daar iets aan verandert.