Facturering per seconde uitgelegd: waarom een sandbox van 20 seconden $0.00055 kost

„Per seconde gefactureerd” is zo'n zin die compleet klinkt maar het niet is. Erachter zitten meerdere beslissingen die bepalen wat je betaalt: wat er gemeten wordt, wanneer de klok start en stopt, of er een minimum is, hoe fracties van een cent worden behandeld en wanneer het geld echt van je tegoed gaat.

Dit artikel legt onze antwoorden vast, met de rekensommen, voor code-sandboxes. Het doel: dat je een rekening op de cent kunt voorspellen voordat je iets start, en het punt herkent waarop facturering per seconde het verkeerde model is voor jouw werklast.

De eenheid: gereserveerde vCPU en RAM

De prijs van een sandbox is de prijs van de resources die het tarief reserveert:

• $0.040 per vCPU-uur
• $0.013 per GiB RAM per uur

Het tarief small (0.5 vCPU, 1 GB) kost dus 0.5 × 0.040 + 1 × 0.013 = $0.033 per uur, ongeveer $0.0000092 per seconde. Het grootste, max (8 vCPU, 16 GB), kost $0.528 per uur.

We meten reservering, geen verbruik. Een sandbox die op het volgende commando wacht, kost per seconde evenveel als een die een project compileert. Echte CPU meten zou op papier eerlijker lijken, maar maakt de prijs onmogelijk vooraf te kennen, en de capaciteit wordt hoe dan ook voor je vastgehouden. Uitgaand verkeer wordt niet gefactureerd.

De klok: van aanmaken tot verwijderen

Een kortstondige sandbox wordt gefactureerd vanaf het moment van aanmaken tot het verwijderen. Daaronder valt ook de tijd dat hij inactief is voordat de inactiviteits-time-out hem verwijdert, standaard 300 seconden.

Daar komen de meeste verrassingen vandaan. Een script van twee minuten, in een sandbox die niemand verwijdert, wordt voor zeven minuten gefactureerd: twee werk en vijf wachten op de time-out. De oplossing is saai: verwijder de sandbox als je klaar bent (het with-blok van de SDK doet dat voor je) of verlaag de inactiviteits-time-out.

Het minimum: 60 seconden per sandbox

Elke kortstondige sandbox wordt voor minstens 60 seconden van zijn levensduur gefactureerd. Een microVM starten, schijf en netwerk koppelen en alles weer afbreken kost hetzelfde, of de code erin nu één seconde draait of vijftig.

Het minimum wordt één keer toegepast, als de sandbox eindigt, en alleen als zijn totale levensduur korter was dan 60 seconden. Er komt geen extra minimum per uur of per commando bij.

Opbouw en afschrijving: microdollars en hele centen

Dit is het deel dat „per seconde” meestal niet vertelt. De sandbox-host registreert het gebruik in uurblokken, één per sandbox. Eens per minuut haalt de factureringstaak de afgesloten blokken op, prijst ze en schrijft het tegoed af.

Prijzen gebeurt in miljoensten van een dollar. Afschrijven in hele centen. Wat onder een cent overblijft, blijft op je account staan en komt bij de volgende afschrijving; er wordt niet naar boven afgerond, niet per sandbox en niet per uur.

Op kleine schaal maakt dat uit. Honderd sandboxes van 20 seconden bouwen 100 × $0.00055 = $0.055 op. Er wordt vijf cent afgeschreven en een halve cent wacht op de volgende batch. Als elke sandbox op een cent werd afgerond, kostte hetzelfde werk een dollar.

Nog twee eigenschappen zijn goed om te weten:

• Elk blok wordt precies één keer afgeschreven. Het gebruiksrecord en de afschrijving worden in één databasetransactie geschreven, met sandbox en uur als sleutel. Een herhaalde run of verloren bevestiging kan niet dubbel afschrijven.
• Storingen vertragen afschrijvingen, ze raken ze niet kwijt en verdubbelen ze niet. Kan de facturering de sandbox-host niet bereiken, dan wordt niets bevestigd, wachten de blokken en worden ze afgeschreven zodra de verbinding terug is.

Gevolg: het dashboard kan tot een uur achterlopen op het live cijfer. Voor het live cijfer geeft GET /sandboxes/{id}/usage billed_usd en een estimated_total_usd voor de sandbox tot nu toe.

Persistente sandboxes: per begonnen uur, met een plafond

Persistente sandboxes houden hun schijf tussen sessies, tot 30 dagen. Ze worden per begonnen uur gefactureerd: 61 minuten zijn twee uur. In ruil daarvoor kost een kalendermaand (UTC) nooit meer dan 730 uur min 25%.

Voor het tarief standard is dat plafond $36.14 per maand in plaats van $48.18. Zolang een persistente sandbox gepauzeerd is, wordt hij helemaal niet gefactureerd.

Als het tegoed op is

Het tegoed gaat nooit onder nul. Nieuwe sandboxes worden geweigerd met 402 insufficient_balance. Kortstondige sandboxes die al draaien, eindigen bij hun inactiviteits-time-out of TTL. Persistente worden na 24 uur zonder opwaardering gepauzeerd en gaan vanzelf verder zodra je tegoed toevoegt. Gepauzeerde snapshots worden 14 dagen bewaard. Daarna wordt de sandbox verwijderd en antwoordt zijn id met 410 sandbox_deleted.

Als een AI-agent sandboxes voor je aanmaakt, stel dan een dag- en maandlimiet in. Wordt die bereikt, dan komt 429 budget_exceeded terug met het tijdstip waarop hij reset, iets waarop een programma kan reageren.

Waar facturering per seconde verliest

Facturering per seconde is uitstekend voor werk dat in seconden en minuten wordt gemeten. Hoe langer het werk duurt, hoe slechter het wordt.

Het kantelpunt ligt ongeveer waar een werklast meer dan een paar uur per dag draait. Daarna betaal je voor flexibiliteit die je niet gebruikt, en een server die je per maand huurt is per uur een stuk goedkoper. De eerlijke manier om naar facturering per seconde te kijken is als de prijs om geen capaciteit te hoeven plannen, niet als korting.

Een snelle schatting

Uurprijs van het tarief × seconden dat de sandbox zal bestaan ÷ 3600, met 60 seconden als ondergrens. Tel de inactiviteits-time-out erbij als je hem niet zelf verwijdert. Rond voor persistente sandboxes elke sessie naar boven af op hele uren en stop bij het maandplafond.

Alle regels, quota en de budget-API staan in limieten en facturering van sandboxes; de aanroepen hierboven in de SDK-referentie. Vraag je je af wat je eigenlijk per seconde huurt, dan legt Firecracker-microVM's uitgelegd dat uit, en wat AI-agents echt van infrastructuur nodig hebben laat zien waarom het factureringsmodel zo belangrijk wordt zodra software, en niet mensen, de machines aanmaakt.