Kubernetes autoscaling

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.

AutoscalerSchaaltOp basis vanTypisch gebruik bij Magento en Laravel
Horizontal Pod Autoscaler (HPA)Aantal replicasCPU, geheugen of custom metricsPHP-FPM/nginx-pods, Octane-workers, Varnish
KEDAAantal replicas, ook naar nul; of JobsExterne bronnen: Redis-lijsten, RabbitMQ, MySQL-query, Prometheus, cronMagento-consumers, Laravel queue-workers en Horizon, geplande voorschaling
Vertical Pod Autoscaler (VPA)CPU- en geheugenrequests per podHistorisch verbruikAdvies voor requests in Off-modus; automatisch voor workloads zonder HPA
Cluster-autoscalerAantal nodes in vooraf gedefinieerde node groupsPods die niet geplaatst kunnen wordenWerkt bij vrijwel elke managed Kubernetes-aanbieder
KarpenterNodes, direct op het juiste type en formaatPods die niet geplaatst kunnen worden, plus consolidatieAWS 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
Liever bellen? 0591-239 299
Beschikbaar deze week

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.

WorkloadKEDA-scalerSignaalInstelling die we vaak kiezen
Laravel queue-workers op Redis of Valkeyredis (lists)Lengte van de lijst queues:default of een eigen queuelistLength per worker afgestemd op jobduur, minReplicaCount 1 voor kritieke queues
Laravel Horizonredis of prometheusQueue-lengte of wachttijd per supervisorHorizon-balancing binnen de pod, KEDA voor het aantal pods
Magento-consumers op RabbitMQrabbitmqBerichten per queue, bijvoorbeeld voor async orderverwerkingPer consumer een eigen ScaledObject, max afgestemd op databasebelasting
Magento-consumers op de MySQL-queuemysqlAantal berichten met status nieuw in queue_message_statusLage pollingfrequentie om de database niet extra te belasten
Imports en exportsScaledJob met redis, rabbitmq of prometheusEr staat werk klaarEén Job per batch, schaal naar nul als er niets is
Voorschalen voor campagnescronTijdvenster, bijvoorbeeld rond een mailing of Black FridayHoger 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

Onze aanpak van Kubernetes autoscaling

Eerst meten, dan schalen. Het vaste team dat je platform bouwt, test het ook onder belasting.

  1. 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. 2

    Requests, limits en FPM afstemmen

    Requests op gemeten verbruik, geheugenlimit passend bij pm.max_children, CPU-limits alleen waar nodig.

  3. 3

    Pod-autoscaling inrichten

    HPA voor webpods met een onderbouwd behavior-blok, KEDA-ScaledObjects voor queues en cron, ScaledJobs voor batchwerk.

  4. 4

    Node-autoscaling en buffer

    Karpenter of cluster-autoscaler, PodDisruptionBudgets en placeholder-capaciteit zodat nieuwe pods niet op een node hoeven te wachten.

  5. 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.

Hyvä Silver PartnerHypernode Silver Partner

Veelgestelde vragen

Kubernetes autoscaling is het automatisch aanpassen van capaciteit aan de vraag. De Horizontal Pod Autoscaler past het aantal pods aan, de Vertical Pod Autoscaler de CPU en het geheugen per pod, en de cluster-autoscaler of Karpenter het aantal nodes. KEDA voegt schalen op externe signalen toe, zoals queue-lengte.

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.