Modalità sospensione: scalare a zero
Un'applicazione che nessuno usa dovrebbe costare quasi nulla ed essere di nuovo pronta alla richiesta successiva. La modalità sospensione fa questo: un'applicazione inattiva viene prima congelata, poi fermata, e la richiesta successiva la risveglia. È disattivata per impostazione predefinita e si sceglie applicazione per applicazione.
Tre stati
Attiva
L'applicazione funziona normalmente e serve le richieste.
Congelata
Il processo è messo in pausa dal congelatore dei cgroup di Linux. La sua memoria resta residente e le connessioni TCP restano aperte; risvegliarla significa scongelarla.
Fermata
L'unità systemd è fermata: memoria, rete privata e identificatore utente vengono restituiti. L'istanza resta voluta e posizionata nel cluster (mantiene la porta dell'host); risvegliarla riavvia l'unità, quindi l'applicazione riparte da zero.
Come si comporta
- Si attiva applicazione per applicazione, con l'impostazione sleep, disattivata per impostazione predefinita. Un'applicazione senza di essa non viene mai toccata: nessuna scrittura Raft, nessun monitoraggio dell'attività.
- Mentre un'applicazione si risveglia, l'ingress trattiene la richiesta e la inoltra una sola volta. Se il risveglio dura più di wakeTimeoutMs (5000 ms per impostazione predefinita), il client riceve un 503 con Retry-After e l'avvio prosegue, così la richiesta successiva riesce.
- Due timer di inattività: freezeAfterSeconds (60 s per impostazione predefinita) e stopAfterSeconds (900 s per impostazione predefinita). Il ritardo effettivo di congelamento non è mai inferiore al doppio del periodo di segnalazione dell'attività (5 s per impostazione predefinita).
- Con più orchestratori Higgs, un'applicazione dorme solo se ogni ingress la vede inattiva: il cluster conserva l'attività più recente segnalata da ciascuno, e solo il leader Raft decide, con una scrittura per transizione e mai una per richiesta.
- Una richiesta risveglia una sola replica, di preferenza una congelata. Le altre si risvegliano solo se il carico lo richiede, secondo la politica sleep.wake: richieste in corso per replica, un risveglio lento con richieste in attesa, o una frequenza di richieste. Si usano prima gli altri nodi.
- I webhook di Photon e le chiamate da servizio a servizio (la variabile GLUONIFY_SERVICE_<APP>_URL) passano dall'ingress interno e risvegliano anch'essi l'applicazione. Le sonde di salute (/q/...) non la risvegliano mai.
- Un'applicazione fermata si osserva solo tramite Strange: log, ultimi valori di cpu e memoria, stato e da quando. Non c'è nulla in esecuzione da interrogare. Calorimeter la mostra come addormentata, non come non funzionante: nessun falso allarme di disponibilità.
- Non per le applicazioni con compiti in background (attività pianificate, consumatori di code, WebSocket in uscita): un'applicazione congelata o fermata non fa nulla. Il runtime containerd non sa congelare: l'istanza resta attiva e il fallimento viene segnalato.
I numeri
Una sola macchina: un Apple M4 Max, con la VM Linux di Docker Desktop (kernel 7.0.14, arm64, container privilegiato). Applicazione: gluonify-probe, un'applicazione Quarkus nativa minimale senza database. Passata di riferimento (la più recente): 10 risvegli per caso attraverso l'ingress, una connessione nuova per richiesta, applicazione congelata dopo 3 s e fermata dopo 8 s di inattività. I tempi vengono da un solo orologio, dall'invio della richiesta al primo byte della risposta. L'host era carico: carico medio di macOS 12,54 12,34 12,65 prima della passata, 6,96 9,16 11,09 dopo.
Una raffica di 50 richieste su un'applicazione fermata causa un solo avvio. L'intera raffica viene servita in 244,3 ms e il primo byte più lento arriva a 240,5 ms (passata precedente: 186,9 ms e 183,3 ms).
Tempo aggiunto dall'ingress in un avvio a freddo, prima e dopo l'invio immediato del segnale di pronto (mediana, 20 prove ciascuno; p95 di 4851,1 ms e poi 23,2 ms). Prima, l'ingress veniva a sapere che l'applicazione era pronta solo al ciclo successivo di 5 secondi dell'agente.
Il primo risveglio della passata di riferimento, da congelata e poi da fermata: una sola misura ciascuno, non una mediana. Nella passata precedente il primo risveglio da fermata ha richiesto 187,6 ms: un singolo risveglio varia molto.
Da dove si partiva
Prima della modalità sospensione, un'applicazione fermata veniva riavviata solo al ciclo successivo di 5 secondi dell'agente: dall'arresto al primo 200 attraverso l'ingress occorreva una mediana di 6978,9 ms (20 prove). Inviare subito il segnale di pronto l'ha portata a 2113,8 ms, che comprende ancora l'attesa di quel ciclo. La modalità sospensione avvia l'unità non appena arriva una richiesta: 271,4 ms di mediana nella passata di riferimento. Un'applicazione congelata e scongelata dal banco stesso rispondeva in 5,7 ms (p95 6,1 ms), senza alcun ingress in grado di risvegliarla. Le tre barre provengono da banchi diversi (20 e 10 prove, primo 200 e primo byte): indicano ordini di grandezza, non un confronto controllato.
Quanto costa un avvio
Un'applicazione fermata riparte dopo circa 155 ms di preparazione (mediana 154,4 ms, 20 prove), più l'avvio dell'applicazione stessa. Due passi dominano: la creazione dello spazio dei nomi di rete privato (netns, 90,64 ms) e il lancio dell'unità (systemd-run, 52,62 ms). Ottenere configurazione e segreti dal top costa circa 1 ms (0,8 ms, più 0,0 ms per il token di Charm, con 10 impostazioni e 5 segreti). I passi sono mediane: non si sommano nel totale.
Memoria durante il congelamento
Un'applicazione congelata mantiene tutta la sua memoria: la dimensione residente (RSS), quella proporzionale (PSS) e la memoria del cgroup sono uguali a quelli a riposo. Chiedere al kernel di espellere le sue pagine con memory.reclaim, verso RAM compressa (zswap) o verso il disco di swap della VM, ne restituisce solo una parte e rallenta la ripresa. È disattivato per impostazione predefinita (gluonify.strange.process.reclaim-on-freeze).
kB per la memoria, millisecondi per la ripresa (richiesta fino al 200), 20 prove per riga. Appena avviata: tutte le pagine residenti prima di ogni prova; prove consecutive: sono tornate solo le pagine toccate dalla richiesta, più simile a un'applicazione inattiva da molto tempo. Il disco di swap è il disco virtuale della VM, probabilmente servito dalla cache della VM: la latenza di un disco reale di nodo non è stata misurata. Le pagine mandate in swap sono memoria dell'applicazione, in chiaro sul disco.
Salvare su disco: cosa è stato valutato
CRIU, che salva un processo su disco, non funziona in laboratorio: il kernel della VM di Docker Desktop non ha userfaultfd (quindi niente pagine pigre) e rifiuta le opzioni di socket di un server TCP in ascolto, il dump dell'unità reale è fallito (mount ereditati, poi un crash dell'helper iniettato), e il ripristino di un processo semplice è rimasto bloccato per più di 15 s (un tentativo). Le microVM (Firecracker, QEMU) e il checkpoint di gVisor non sono stati provati. CRaC non si applica alle immagini native. Con un riavvio di circa 0,2 s per un'applicazione nativa leggera, nessuna di queste strade viene perseguita; un kernel completo o un'applicazione più pesante potrebbero cambiare le cose, ma non è misurato.
In questa configurazione, un'applicazione congelata risponde alla prima richiesta in una mediana di 8,8 ms (p95 19,6 ms) e una fermata in 271,4 ms (p95 472,4 ms), contro 0,3 ms per una richiesta a un'applicazione sveglia. Congelare mantiene la memoria; fermare la restituisce al prezzo di un riavvio. La passata precedente ha dato 8,2 ms e 211,6 ms: la dispersione tra una passata e l'altra è reale.
gDown, il database a grafo della piattaforma, fa lo stesso con i propri database: un database inattivo restituisce la memoria (UNLOAD DATABASE, o un intervallo di inattività, 900 s consigliato sulla piattaforma) e viene ricaricato alla prima richiesta, in 82 ms per 99 MB di file e 549 ms per 982 MB su un Mac (arm64). I database dormienti di gDown
Limiti: una sola macchina (Apple M4 Max), dentro la VM Linux di Docker Desktop e non su hardware reale; solo un'applicazione nativa minimale (niente JVM, niente database, niente migrazioni), quindi un'applicazione reale partirà più lentamente, cosa non misurata; un host carico (vedi i carichi medi sopra) dove potrebbero essere state in esecuzione altre sessioni e build Docker; 10 risvegli per caso nel banco della sospensione, 20 prove altrove; un solo orchestratore Higgs con uno stato Raft locale, quindi il viaggio di andata e ritorno Raft è quello di un cluster a un membro. La regola per più orchestratori Higgs («tutti gli ingress sono d'accordo») è coperta solo da test unitari, e i contatori di carico per ingress che risvegliano repliche aggiuntive non sono testati end-to-end con più orchestratori Higgs (la politica delle repliche in sé è verificata su due nodi da e2e-sleep.sh). Il runtime containerd non sa congelare. Nessuna estrapolazione ad altre applicazioni, altri dischi o hardware reale.
Fonte: gluonify-chamber, scripts/bench-coldstart.sh, bench-sleep.sh e e2e-sleep.sh; risultati grezzi in gluonify-codex, bench/sleep-impl-2026-10-06-after-ingress-uses.json (passata di riferimento), sleep-impl-2026-10-06.json, sleep-2026-10-06.json, coldstart-2026-10-06.json e coldstart-2026-10-06-ready-push.json; progettazione in ARCHITECTURE.md ed esercizio in docs/OPERATIONS.md.