Tecnologia e infrastruttura di → Livello e storage dei dati

Livelli di cache e storage

1) Perché hai bisogno di una cache a più livelli

Kesh è un breve percorso di risposta senza andare nei sottosistemi «costosi» (database, API esterne, reti). La stratificazione distribuisce il carico di lavoro: il browser CDN/edge lo strato applicativo il del database/ . Gli obiettivi sono ridurre il P95/P99, scaricare origin, resistere più forte ai picchi e pagare byte.

2) Mappa dei livelli di cache

1. Браузер: `Cache-Control`, `ETag`, `Last-Modified`, `stale-while-revalidate`.
2. CDN/Edge: TTL/ключ, Vary, Signed URLs, image-resize; tiered/shield.
3. API Gateway/Service Mesh: cassetta di risposta di breve durata su GET sicuro.
4. Applicazione (in-process): LRU/LFU, near-cache per chiavi hot, millisecondi.
5. Cassetto distribuito (Redis/Memcached) - Livello principale per l'altoparlante.
6. Cache database: buffer Pg/Innodb, PgBouncer multiplexing, materialization views.
7. Gli store su disco/oggetti sono precomputed snapshots, blob-cash (ad esempio S3 + CDN).

Principio: "Più vicino all'utente, più breve è TTL e meno personalizzazione; più vicino ai dati, più ricco è la politica di consistenza".

3) Pattern di cache

Cache-Aside (Lazy) - Leggiamo il → a MISS, e lo mettiamo nella →. Semplice, dà il controllo TTL.
Read-Through - L'applicazione legge attraverso una cache che tira da una sorgente. Facile centralizzare le regole.
Write-Through - La scrittura va alla cache e alla sorgente immediatamente. Più consistente, ma più costosa.
Write-Back (Write-Behind) - Scriviamo nella cache e l'origine viene aggiornata asincrona (coda). Alta velocità, garanzia di spedizione e idepotenza.
Refresh-Ahead: le chiavi «top» aggiornano il valore prima della scadenza della TTL.

Dove: carte di gioco/catalogo - cache-aside/read-through; contatori/liderboard - write-back + CRDT/aggregazioni; riferimenti valute/limiti - read-through con TTL controllato.

4) Chiavi, segmentazione e neoming

Шаблон: `domain:entity:{id}:v{schema}|region={R}|currency={C}|lang={L}`.
Includere solo ciò che cambia realmente la risposta (regione, valuta, lingua, versione dello schema).
Versioning diagrammi - In caso di modifiche incompatibili, aumentare «vN» in chiave evitando purge di massa.
Namespacing prodotto/tenant: 'tennis: {t}:...' è critico per il multi-tennis.
Il filtro bloom per l'esistenza della chiave può ridurre le escursioni all'origine.

5) TTL, freschezza e invalidità

• statica (file hashtag): 30-365 giorni + 'immutable';
• cataloghi/banner: 5-60 minuti + 'stale-while-revalidate';
• liderboard/quotazione: 2-15 secondi;
• riferimenti (valute/limiti): 1-10 minuti.
• Disabilità eventi: pubblichiamo'product. updated → disabilità chiave/prefisso.
• Tag-based purge - Pulizia di gruppo per tag (rilascio promo/catalogo).
• Soft-Expiry - Al termine della TTL, restituiamo l'antiquato comè stale ', contemporaneamente aggiorniamo (SWR/SIE).
• Versioned Keys> purge di massa: più economico e sicuro.

6) Stampede, chiavi «hot» e competizione

• Single-flight (sollest coalescing) - Un leader aggiorna la chiave, gli altri attendono.
• TTL jitter: smontare le scadenze evitando il crollo uninominale.
• SWR locale: restituiamo il valore scaduto all'utente e aggiorniamo lo sfondo.

• Replica la chiave hot in più slot «key # 1.. N» distribuito dalla lettura;
• near-cache nella memoria del processo
• prewarm/refresh-ahead prima dei picchi (tornei/partite).
• Limiti per concarrance aggiornamenti per chiavi pesanti.

7) Consistenza e livelli crociati

Write-invalidate - Durante la scrittura all'origine, invalidare sincronicamente le chiavi corrispondenti (pub/sub).
Read-repair - In caso di soluzione temporanea, aggiornare la cache con un valore corretto.
Eventual vs Strong: transazioni di denaro critiche direttamente/con TTL breve; Vetrine UI e statistiche - avvenual.
CRDT/aggregatori: per i contatori/classificatori distribuiti - strutture «merge-safe» (G-Counter, Top-K sui flussi).
Disabilità a cascata: l'aggiornamento del «gioco» disabilita la scheda + elenco + cache raccomandata personalizzata.

8) Serializzazione, compressione e formato

Formati: protobuf/MessagPack più veloce di JSON; per CDN/browser - JSON con Brotli.
Compressione Redis: è vantaggioso per gli oggetti> 1-2 KB, ma tieni d'occhio la CPU.
Partial responses/campi su richiesta: meno byte, meno TTFB e RAM.

9) Criteri di espulsione e dimensioni

LRU (impostazione predefinita) - Sicuro; LFU è meglio per contenuti «popolari».
Dimensioni chiavi/valori - Tieni sotto controllo (metriche «avg value size», «max»).
Quote di namespace/tenant in modo che un prodotto non «mangia» l'intero kash.

10) Sicurezza e PII/PCI

Dati personali/finanziari: non memorizzare su CDN/edge e su livelli comuni; usate i token/proiezioni.
Crittografia dei valori sensibili in Redis tramite client-side crypto (con attenzione alle perdite di controllo TTL).
ACL rigorose e isolamento delle reti; NAT/IP fissi per egress ai provider.

11) Osservabilità e CLO

• Hit Ratio (livelli e prefissi), Origin Offload.
• TTFB/P95/P99 prima/dopo la macchia, Latency Redis.
• Evictions, OOM, keyspace hits/misses.
• Stampede rate (percentuale di aggiornamenti paralleli), refresh time.
• Stale served % и Freshness lag.

• Il catalogo dei giochi è Hit Ratio, 85%, TTFB P95, 150 ms (edge).
• API: Revalidation-hit 60%, P95 200 ms.
• Redis: P99 ≤ 5 ms, non più dell '1% all'ora.

12) FinOps: costo della cache

$/GB-mese RAM vs $/RPS origin - Calcola il punto di ritorno.
Offload ed egress: CDN + Redis riducono il traffico in uscita dalla regione-origin.
Image/WebP/AVIF e denormalizzazione fanno risparmiare più byte.
Limitate «care MISS», analista di byte x MISS x Regione.

13) Esempi (frammenti)

13. 1 Cache-Aside con single-flight (pseudocode)

python def get(key, ttl, loader):
val = redis. get(key)
if val: return val with single_flight (key): # only one updates val = redis. get (key) # double check if val: return val data = loader () # request to source redis. setex(key, ttl_with_jitter(ttl), serialize(data))
return data

13. 2 Pubblicazione invalidità per evento

json
{
"event": "game. updated",
"game_id": "g123",
"affected": ["catalog:list:region=TR", "game:card:g123:"]
}

La consolle è iscritta al canale e rende «DEL »/« PUBLISH» le chiavi/tag corrispondenti.

13. 3 Chiave con la versione di schema e locale

game:card:v2:id=g123    region=BR    currency=BRL    lang=pt-BR

14) Assegno foglio di implementazione

1. Mappa dei livelli di cache e matrice TTL (statico/semistatico/API).
2. Nayming chiavi: dominio, versione del circuito, locale/regione/valuta, tenant.
3. Seleziona un pattern per-endpoint (aside/read-through/write-through/back).
4. SWR/SIE, single-flight e TTL-jitter contro stampede.
5. Disabilità eventi (pub/sub), tag-purge per gruppi.
6. Near-cache per chiavi «hot» e prewarm prima dei picchi.
7. Formati e compressione (protobuf/MsgPack, Brotli), controllo delle dimensioni.
8. Regole LRU/LFU, quote namespace/tenant.
9. SLO/метрики: hit ratio, latency, evictions, stale %, freshness lag.
10. Sicurezza: no-store per personale, tornizzazione, rete/ACL.

15) Anti-pattern

«no-cache» «per sicurezza» e gli abbandoni di TTL - offload zero.
La chiave include tutte le query/intestazioni dell'esplosione della cardinalità.
Purge di massa «tutto CDN/Redis» a ogni comunicato.
Nessuna protezione da stampede e una singola interruzione delle «chiavi top».
Comune unico Redis senza quote/isolamento; «hot» tenant si mangia tutto.
Memorizzazione delle risposte personali a edge/CDN.
Nessuna telemetria freshness/evictions, controllo cieco.

16) Contesto iGaming/fintech: note pratiche

Liderboard/rating: TTL 2-10 c, aggregate-thread + CRDT, SWR in caso di guasti.
Catalogo giochi/banner: CDN + Redis; chiave: regione/valuta/lingua; disabilità con tag promo: update.
Stato di pagamento: nessuna cache sul percorso di scrittura; lettura - TTL breve (≤3 -5 c) o richiesta diretta.
Le risposte KYC/AML sono: nascondete i derivati non-PII (states), non memorizzate immagini/documenti in Redis.
Percorso VIP: singolo namespace/pool Redis, servizio prioritario.

Totale

Una forte strategia di kash è l'architettura dei livelli, i pattern di aggiornamento corretti, la TTL/invalidità elaborata, la resistenza alle stampe, le chiavi e le versioni accurate e l'osservabilità e la FinOps. Seguendo questi principi, si stabilizzano le code P95/P99, si riduce la pressione sulle fonti e si ottiene un costo prevedibile di millisecondi, esattamente dove ciò è più importante per il prodotto e il business.