In deze post bespreek ik het nieuwe Flex-plan: hoe het werkt, welke voordelen het biedt, en waar de beperkingen liggen. We gaan in op de technische details, unieke functionaliteiten en wat dit betekent voor ontwikkelaars die streven naar schaalbare en efficiënte serverless architecturen.
Bij Cloud Republic meten we al enkele jaren de responsprestaties van Azure Functions op https://serverlessbenchmark.cloudrepublic.nl/. Onlangs hebben we hier ook de prestaties van Functions Flex toegevoegd. Het valt mij op dat Flex Consumption-plannen sneller zijn dan de klassieke Consumptionplannen. Een uitzondering zijn de C# Functions op Windows, hier zien we vergelijkbare performance.
Functions Flex vereenvoudigt het configuratieproces in vergelijking met klassieke functies. Bij klassieke functies, zoals bij onze serverless benchmark, zijn alle mogelijke optimalisaties toegepast; inclusief enkele verborgen configuratie-instellingen (“magic flags”) in de omgevingsvariabelen. Ondanks dat dit goed gedocumenteerd is, is het niet de standaard of intuïtief instelbaar. Bij Flex Functions zijn dergelijke aanpassingen niet nodig, wat de gebruikservaring verbetert.
Het belangrijkste voordeel van Functions Flex is de verbeterde schaalbaarheid. Om dit te begrijpen, moeten we kijken naar hoe klassieke Azure Functions schaalt. In de klassieke consumptieplannen is opschalen gebaseerd op een interne regel-engine. Dit is in feite een opgevoerde versie van de schaalregels die worden gebruikt voor App Services. Het nadeel hiervan is dat schalen stapsgewijs gebeurt, steeds één instantie tegelijk. Deze beperking wordt duidelijk bij het fan-out patroon in Durable Functions. Wanneer je in één keer honderden processen opschaalt, zal niet alles gelijktijdig worden uitgevoerd.
Met Functions Flex heeft Microsoft een compleet nieuwe aanpak ontwikkeld. Dit wordt mogelijk gemaakt door een nieuwe backend, genaamd Project Legion. Project Legion is een container orchestrator die al enige tijd bestaat, zo vormt het bijvoorbeeld de basis voor Azure Container Apps.
Voor Azure Functions introduceert het een functionaliteit genaamd “Pool Groups”. Pool Groups zorgen ervoor dat Functions Flex een pool van actieve function hosts kan onderhouden. Zodra een Function App moet opschalen, wordt deze in een reeds actieve host geladen. Hierdoor worden cold-start tijden gereduceerd tot enkel het laden van de applicatiecode, het absolute minimum. Dankzij Project Legion biedt Functions Flex vergelijkbare, of zelfs betere cold-start prestaties dan klassieke consumptieplannen – maar dan zonder dat er speciale configuraties nodig zijn.
Bovendien maakt deze functionaliteit het voor Flex Functions mogelijk om te schalen zonder nieuwe machines te alloceren. In plaats daarvan bepaalt de runtime hoeveel parallelle executies een enkele app aankan, berekent de benodigde capaciteit en schaalt naar de benodigde hoeveelheid op.
Deze aanpak brengt echter uitdagingen met zich mee wanneer een Function App gemengde triggers heeft. Bijvoorbeeld, een app die zowel HTTP-triggers als Service Bus-triggers gebruikt. In dit scenario kunnen de triggers elkaar beïnvloeden omdat beide typen gebruikmaken van gedeelde resources. Als één trigger een piekbelasting veroorzaakt, kan dit de prestaties van de andere trigger negatief beïnvloeden. Dit maakt het bepalen van de benodigde hoeveelheid instances complexer en introduceert extra uitdagingen bij het schalen van de applicatie.
Om dit probleem op te lossen, wordt iedere functie binnen een Function App onafhankelijk van elkaar geschaald, met uitzondering van HTTP-triggered functies. HTTP-triggers binnen dezelfde app worden als groep geschaald. Dit betekent wel dat de oude truc, waarbij een timer-trigger werd gebruikt om een functie “warm” te houden, nu definitief niet meer werkt.
Naast het verbeterde opschaalmechanisme, biedt Functions Flex Consumption ook een aantal nieuwe mogelijkheden die voorheen niet beschikbaar waren.
Met Flex is het nu mogelijk om Virtual Networks (VNETs) te configureren. Voorheen was deze functionaliteit alleen beschikbaar in Premium Functions. Hiermee kunnen ontwikkelaars hun applicaties beter beveiligen en integreren met andere resources binnen een netwerk.
Net als bij Premium Functions kun je met Flex Consumption een of meerdere instanties altijd actief houden. Dit elimineert cold-starts volledig, wat essentieel kan zijn voor applicaties met strikte prestatie-eisen.
Flex Consumption ondersteunt nu ook Availability Zones. Dit betekent dat je Function App operationeel blijft, zelfs als een deel van een datacenter uitvalt, bijvoorbeeld door een probleem met de koeling. Hoewel zeldzaam, biedt dit een extra hoge betrouwbaarheid die in sommige scenario’s cruciaal kan zijn.
Een van de meest interessante nieuwe mogelijkheden is het instellen van de hoeveelheid RAM. Wat hierbij belangrijk is, is dat CPU en beschikbare bandbreedte automatisch worden opgeschaald met de geselecteerde hoeveelheid RAM. Heb je grote, complexe berekeningen? Dan kun je kiezen voor instances met 4GB RAM. Gebruik je Python (en daarmee geen parallelle executies)? Dan is 500MB wellicht meer dan genoeg, wat de kosten kan verlagen.
Deze instelling bepaalt ook de schaalbaarheid. De soft-cap ligt niet op het aantal instanties, maar op de totale hoeveelheid resources die wordt gebruikt. Een instance met 500MB RAM kan bijvoorbeeld acht keer zoveel instanties draaien als een met 4GB RAM, waardoor je meer flexibiliteit hebt in hoe je applicatie schaalt.
Wat mij direct opviel bij het gebruik van Flex Consumption is hoeveel beter de ARM (Azure Resource Manager) api is. Flex consumption vertrouwt niet meer op omgevings-variabelen voor zijn configuratie. Waar in het verleden altijd minimaal onderstaande gezet moesten zijn:
AzureWebJobsStorage, FUNCTIONS_WORKER_RUNTIME, FUNCTIONS_EXTENSION_VERSION en WEBSITE_CONTENTAZUREFILECONNECTIONSTRING Hoeft bij functions flex alleen nog maar de “AzureWebJobsStorage” gezet te zijn. Daarnaast bestaat het “windowsFxVersion”/”linuxFxVersion” niet meer.
Al deze configuratie heeft een nieuw segment genaamd “functionAppConfig”. De functionAppConfig ziet er als volgend uit:
functionAppConfig: {
deployment: {
storage: {
type: "blobContainer",
value: "${blobContainerEndpoint}",
authentication: {
type: "SystemAssignedIdentity"
}
}
},
scaleAndConcurrency: {
maximumInstanceCount: 40,
instanceMemoryMB: 2048
},
runtime: {
name: "dotnet-isolated",
version: "8.0"
}
}
De oplettende lezer is mogelijk al 2 dingen opgevallen (misschien zelfs wel meer, who am I to judge). Als eerste is het nu mogelijk om managed idenities te gebruiken voor het storage account waarop de functionApp binary komt te staan. Daarnaast hoef je niet meer te specificeren welke function runtime versie je gebruikt (de ~4). Deze wordt afgeleid uit de runtime en de runtime versie (language versie). Als ontwikkelaar is dit een significant simpelere API.
Natuurlijk komt er met een nieuwe technologie ook een nieuwe set aan limitaties. Sommige zullen te overzien zijn, sommige zijn misschien wel dealbreakers.
Dit is er een limitatie waarvan ik verwacht dat die in de loop van tijd wordt opgelost. Momenteel is Flex Consumption in een handjevol regio’s beschikbaar, maar hier komen er steeds meer bij. Op het moment van schrijven zijn het:
Gelukkig best goed geografisch verdeeld, maar een heel stuk minder dan de 92 regio’s momenteel beschikbaar.
In het verleden ben ik tegen bugs in specifieke versies van Azure Functions aangelopen. Bij zowel Consumption als Premium plannen kan je handmatig een vorige versie selecteren door een specifieke versie onder het veld “FUNCTIONS_EXTENSION_VERSION” in te stellen. Doordat Flex een pool draait met al bestaande hosts kan dit niet meer, en ik verwacht ook niet dat dit ooit terug komt.
Flex Consumption functies ondersteunen geen slots. Het is dus niet meer mogelijk met Flex Consumption om je code naar een niet productie slot uit te rollen en dan naar productie te swappen.
Dit kan erg workflow verstorend werken, maar hoeft geen ramp te zijn. Zeker als een FunctionApp meer doet dan alleen http-triggers levert dit erg creatieve scenario’s op. Wat gebeurt er bijvoorbeeld als een servicebus trigger op een staging slot nog draait? Ik durf het wel te zeggen: een hoop hoofdpijn voor de software ontwikkelaar.
Flex consumption is een grote stap voorwaarts voor Azure Functions. VNET-support is een zeer welkome feature, en uitschalen werkt echt veel beter. Wel zijn er relatief kleine limitaties die echt wat van een ontwikkelteam vragen. Maar als een team daarmee akkoord gaat, is het zeker de moeite waard.