Scalare le app SaaS: architettura e performance
La maggior parte delle app SaaS non si rompe perché il codice è scadente. Si rompe perché l'architettura che ti ha portato a 100 clienti non può reggerne 10.000. Questa guida percorre le leve che spostano davvero l'ago quando scali un'applicazione SaaS, nell'ordine in cui dovresti tirarle.
Indice7
- Performance e scalabilità non sono lo stesso problema
- Scegli un modello di multi-tenancy di proposito, non per default
- Imponi l'isolamento dei tenant nel database, non solo nell'app
- Ottimizza il database prima di scalarlo
- Caching: la leva a più alto impatto che hai
- Bilanciamento del carico, servizi stateless e autoscaling
- Prendi le decisioni di scaling dal monitoraggio, non a sensazione
Performance e scalabilità non sono lo stesso problema
Vale la pena essere precisi, perché i team sprecano mesi confondendo i due. La performance è quanto è reattivo il tuo sistema con le risorse che ha proprio adesso. Se metti in cache una query, sfrondi un payload o aggiungi un indice, hai migliorato la performance. La scalabilità è se quella reattività regge quando il traffico raddoppia, e poi raddoppia di nuovo. Un servizio può essere veloce e non scalabile, come un endpoint che risponde in 2ms ma crolla a 100 richieste al secondo. Le due metriche che contano sono la latenza (tempo per richiesta, tracciata come p50, p95, p99) e il throughput (richieste gestite al secondo). Il tuning della performance ha un soffitto. Man mano che il carico sale, la latenza striscia verso l'alto e poi schizza, e oltre quel punto solo capacità reale, macchine più numerose o più grandi usate bene, ti tiene in vita. La regola pratica: ottimizza la performance finché non sbatti contro il muro, poi progetta per la scala. Non saltare direttamente all'aggiunta di infrastruttura, perché codice lento su più server è solo codice lento più costoso.
Scegli un modello di multi-tenancy di proposito, non per default
Il multi-tenancy è la decisione architetturale che plasma tutto ciò che viene dopo. Ci sono tre pattern. Il pool (schema condiviso) tiene tutti i tenant nelle stesse tabelle, separati da una colonna tenant_id, ed è il più efficiente in termini di risorse. Il bridge (uno schema per tenant) dà a ciascun tenant uno schema in un solo database, con isolamento più forte ma migrazioni più difficili attraverso N schemi. Il silo (un database per tenant) dà a ciascun tenant un database dedicato, l'isolamento più forte e il più costoso da gestire. La trappola è trattare questo come un'unica scelta globale. Il pattern verso cui converge la maggior parte dei team SaaS maturi nel 2025 e nel 2026 è ibrido: i clienti del livello standard condividono infrastruttura in pool, mentre gli account enterprise con esigenze di conformità o carichi pesanti ottengono uno schema o un database isolato. Questo rispecchia direttamente i tuoi livelli di prezzo. Un avvertimento netto: un database per tenant non scala a decine di migliaia di tenant su Postgres o MySQL. Ottieni gonfiore del catalogo, colli di bottiglia DDL e una bolletta cloud che può minacciare l'azienda. Se prevedi di spostare clienti tra i livelli, costruisci presto gli strumenti di migrazione, perché aggiungerli dopo è doloroso.
Imponi l'isolamento dei tenant nel database, non solo nell'app
In un modello in pool, l'unica cosa che si frappone tra i dati del Tenant A e quelli del Tenant B è una clausola WHERE tenant_id = ?, e affidarsi a ogni sviluppatore perché la ricordi a ogni query è una fuga di dati in attesa di accadere. Lo standard del 2025 è spingere quell'imposizione dentro il motore usando la Row-Level Security (RLS) di PostgreSQL. Una volta che la sessione imposta il contesto del tenant, il database filtra ogni query automaticamente, per costruzione anziché per abitudine. Il contesto del tenant viaggia di solito nel token di sessione come claim JWT, e il tuo livello di autorizzazione dovrebbe rivalidare a ogni richiesta che il tenant del token corrisponda all'utente autenticato, non solo al login. Un dettaglio che i team trascurano: l'isolamento deve estendersi a tutto lo stack, non solo al database primario. Anche la tua cache, le code di messaggi, l'archiviazione file e gli indici di ricerca devono essere delimitati per tenant. Un pattern comune per la ricerca è uno schema di denominazione con un indice per tenant, così impostazioni e regole di ciclo di vita restano separate.
Ottimizza il database prima di scalarlo
La scalabilità del database è il punto in cui azzeccare l'ordine rende i dividendi più grandi, perché il database è di solito il fattore vincolante mentre i server applicativi scalano orizzontalmente con facilità. Le query inefficienti sono responsabili di una larga fetta dei colli di bottiglia reali, spesso la maggioranza. Inizia profilando le query lente e aggiungendo gli indici di cui i tuoi pattern di accesso più comuni hanno davvero bisogno. Un'indicizzazione adeguata può ridurre drasticamente i tempi di query. Dai la caccia ai pattern di query N+1 nel tuo ORM, dove elencare elementi innesca una query extra per riga, accettabile a 10 righe e rovinoso a 10.000. Usa il pooling delle connessioni così da non pagare decine di millisecondi di costo di setup per richiesta. Solo dopo che le query sono pulite metti mano a cambiamenti strutturali: partizionare una tabella grande in pezzi perché il motore possa potare quelli irrilevanti, repliche di lettura per carichi a forte componente di lettura e infine sharding tra server quando una singola istanza davvero non riesce a contenere i dati. La sequenza conta perché ogni passo aggiunge complessità operativa, e quella complessità vuoi spenderla solo dove l'ottimizzazione ha già esaurito il margine.
Caching: la leva a più alto impatto che hai
Il caching è il cambiamento più efficace e meno dirompente che puoi apportare alla performance del database. Uno strato Redis o Memcached ben configurato può servire dalla memoria una larga maggioranza delle letture, spesso dal 70 al 90 percento, così da non toccare mai il database. L'approccio comune è il cache-aside (caricamento pigro): l'app controlla prima la cache e, su un miss, legge dal database e popola la cache. Le cache a vita breve funzionano bene per gli aggregati di dashboard che tollerano qualche secondo di obsolescenza. Ma il caching è un compromesso, non velocità gratis. I dati obsoleti quando l'invalidazione fallisce, e i picchi di carico quando una cache cade e il traffico si riversa sul database, sono modalità di guasto reali. Progetta per loro: TTL sensati, invalidazione deliberata e un comportamento dignitoso quando la cache è fredda. Le repliche di lettura si accoppiano naturalmente con il caching per un SaaS a forte componente di lettura, con l'unica avvertenza del ritardo di replica. Se un utente aggiorna il proprio profilo e lo rilegge subito da una replica, potrebbe vedere il valore vecchio, quindi instrada i percorsi di lettura dopo scrittura verso il primario.
Bilanciamento del carico, servizi stateless e autoscaling
La scalabilità orizzontale funziona solo se i tuoi server applicativi sono stateless. Quando nessun server tiene lo stato di sessione in memoria, qualsiasi server può gestire qualsiasi richiesta, e un bilanciatore di carico può distribuire il traffico liberamente mentre maschera i guasti con gli health check. Spingi la sessione e lo stato condiviso in Redis o nel database. Con i servizi stateless al loro posto, l'autoscaling adegua la capacità al carico. Il target-tracking (tenere la CPU vicino al 70 percento, per esempio) e lo scaling pianificato per i picchi noti coprono la maggior parte delle esigenze, con scaling predittivo e basato su code per carichi più avanzati. Su Kubernetes questo si mappa sull'Horizontal Pod Autoscaler per il numero di pod, il Vertical Pod Autoscaler per le risorse per pod e il Cluster Autoscaler per i nodi. Aggiungi cooldown di scale-in e scale-out, nell'ordine di diversi minuti, per impedire al sistema di oscillare. La disciplina chiave: quando un SLO viene sforato e il servizio ha ancora margine, scala il calcolo, ma se il database è il collo di bottiglia, rivolgiti prima a partizionamento, repliche e caching. Lanciare server applicativi contro un problema di database non fa che spostare la coda.
Prendi le decisioni di scaling dal monitoraggio, non a sensazione
Non puoi gestire ciò che non puoi misurare, e ogni leva qui sopra dipende da telemetria reale. Definisci cosa significa buono come SLO: un obiettivo di latenza p95, un tetto al tasso di errore, la CPU in una banda sana. Traccia i segnali di supporto, latenza e throughput delle richieste, performance delle query di database, profondità delle code, saturazione di CPU e memoria, con dashboard in qualcosa come Prometheus e Grafana. Poi prendi in prestito dall'SRE l'idea dell'error budget: il tuo budget è il 100 percento meno il tuo SLO. Un obiettivo di disponibilità mensile del 99,9 percento lascia all'incirca 43 minuti di downtime consentito. Quando il budget è sano, rilascia funzionalità con fiducia. Quando si sta bruciando, rallenta i cambiamenti rischiosi e scopri cosa lo sta divorando. Questo riformula l'affidabilità come una risorsa che prodotto e ingegneria si dividono, anziché un litigio. Ti dice anche quando scalare: una pressione persistente sugli SLO sotto carico reale è il segnale di aggiungere capacità, e un sistema tranquillo con budget in avanzo è il segnale che hai spazio per spingere.
Pronto a rilasciare?
Dicci dove sei bloccato. Lo esaminiamo e ti inviamo una raccomandazione mirata entro un giorno lavorativo.
Domande frequenti
Quando dovrei iniziare a scalare la mia applicazione SaaS?
Scala quando il monitoraggio mostra una pressione sostenuta sui tuoi SLO sotto carico reale: la latenza p95 che striscia verso l'alto, i tassi di errore che salgono durante i picchi, o le code che si accumulano. Prima di quel punto, investi nell'ottimizzazione della performance, query più veloci, indici e caching, dato che è più economica e compra margine reale. Un segnale chiaro che l'ottimizzazione si è esaurita sono gli errori 5xx nelle ore di punta, il che significa che è il momento di aggiungere capacità vera anziché spremere altra velocità.
Quale modello di multi-tenancy dovrei scegliere?
La maggior parte dei team dovrebbe partire con un modello a schema condiviso in pool protetto dalla row-level security, perché è il più efficiente in termini di costo e consegna funzionalità a tutti in una volta. Man mano che cresci, passa a un modello ibrido: tieni i clienti standard in pool e dai agli account enterprise con esigenze di conformità o di carichi pesanti uno schema isolato o un database dedicato. Evita il database per tenant come scelta predefinita, dato che non scala oltre le migliaia di tenant su Postgres o MySQL e gonfia la tua bolletta dell'infrastruttura.
Dovrei aggiungere prima il caching o le repliche di lettura?
Aggiungi prima il caching. Uno strato Redis o Memcached è il cambiamento meno dirompente e può servire la grande maggioranza delle letture dalla memoria, togliendo carico immediato al database. Le repliche di lettura sono il passo successivo per i carichi a forte componente di lettura, ma introducono ritardo di replica, quindi instrada i percorsi di lettura dopo scrittura verso il primario. Fai entrambe le cose solo dopo aver profilato e sistemato le query lente e gli indici mancanti, dato che mettere in cache query lente non fa che nascondere il problema.
Perché il database è di solito il collo di bottiglia dello scaling?
I server applicativi scalano orizzontalmente quasi banalmente perché possono essere stateless, quindi ne aggiungi semplicemente di più dietro un bilanciatore di carico. Il database detiene lo stato, coordina le scritture ed è molto più difficile da suddividere, ed è per questo che diventa il vincolo. L'ordine di intervento è prima l'ottimizzazione (indici, tuning delle query, eliminazione dei pattern N+1), poi il caching, poi le repliche di lettura, poi il partizionamento, e solo sharding o SQL distribuito quando una singola istanza davvero non ce la fa più.
Quali metriche dovrei tracciare per scalare bene?
Traccia la latenza come percentili (p50, p95, p99) anziché come medie, più il throughput in richieste al secondo, il tasso di errore, la performance delle query di database, la profondità delle code e la saturazione di CPU e memoria. Trasforma quelle importanti in SLO con un error budget, la tua inaffidabilità consentita, così che le decisioni di scaling e deployment diventino guidate dai dati. Qui contano dati ad alta risoluzione e in tempo reale, perché i buchi nel monitoraggio portano a budget imprecisi e ad allarmi mancati.
I miei servizi devono essere stateless per scalare orizzontalmente?
Di fatto sì. Se un server tiene la sessione o altro stato nella propria memoria, le richieste si fissano a server specifici e un bilanciatore di carico non può distribuire il traffico liberamente né riprendersi da un nodo caduto. Sposta i dati di sessione e lo stato condiviso in una cache come Redis o nel database, così che qualsiasi server possa gestire qualsiasi richiesta. Il design stateless è la precondizione che permette ad autoscaling e bilanciamento del carico di fare il loro lavoro.
Spunti operativi ogni settimana
Unisciti ai responsabili di aziende di servizi che ricevono ogni settimana uno spunto concreto su operazioni, automazione e crescita.
Niente spam. Disiscriviti quando vuoi.
Iscrizione completata! Cerca il prossimo numero nella tua casella di posta.
Invio non riuscito. Riprova o scrivi a [email protected].