Քեշինգի ճարտարապետությունը 'Redis, Memcached

Քեշինգի ճարտարապետությունը 'Redis, Memcached

1) Ե՞ րբ և ինչու՞ քեշ

Նպատակները 'նվազեցնել լատենտությունը, բեռնել BD/PSA/արտաքին API-ը և անջատել պիկի։

Կեշեյի շերտերը հաճախ բազմաբնույթ են 'in-process (L1) 240-level (Redis/Memcached L2) edge/CDN։ Ներքին քեշը արագացնում է «տաք» կարդալը, L2-ը 'ծառայությունների համար, edge-ը' հանրային բովանդակության համար։

2) Redis vs Memcached-ը հակիրճ է

Կանոնն այն է, որ եթե անհրաժեշտ են բարդ տվյալների կառուցվածքներ, անձնավորություն, pub/sub/strimes/սկրիպտներ, վերցրեք Redis-ը։ Եթե սուպեր-պարզ, արագ, էժան KV-kash շերտը առանց durability-Memcached։

3) Կեշինգի ձևանմուշները

3. 1 Cache-aside (lazy)

Դիմումը կարդում է կեշից ստացված բացթողումներից։

TTL-ի պարզ վերահսկումը, կեշից անկախությունը, հնարավոր է «փոթորիկ» բացթողումների ժամանակ։

3. 2 Read-through

Հաճախորդը/հաճախորդը ինքն է ձգում origin-ից բաց թողնելիս և դնում է կեշի մեջ։

Կենտրոնացված տրամաբանություն. &; Ավելի բարդ է ենթակառուցվածքները։

3. 3 Write-through / Write-behind

Write-through: ձայնագրությունը նախ քեշում, հետո BD-ում։

Write-behind-ը 'ձայնագրությունը հերթին, asinhron flash BD-ում (գեղեցկության պոտենցիալ կորուստ, անհրաժեշտ է ամսագիր)։

3. 4 Two-tier (L1+L2)

L1 (in-process) կարճ TTL և sporTTL, L2 (Redis/Memcached) - «կեշի ճշմարտությունը»։ Հաշմանդամությունը pub/sub միջոցով։

4) TTL, փոթորիկներ և հետևողականություն

TTL 'տվեք տվյալների փոփոխության հաճախությանը։ Տաք պարամետրերի համար օգտագործեք TTL (jitter) ռանդոմիզացիա '"ttl = bultrand (0.. base0)։ 1) "- հանում է սինխրոն կոմպոզիցիաները։

Dogpile (thundering herd) 'պաշտպանեք բացթողումները

Singleflight: Միայն մեկ գործընթաց փոխակերպում է կարևորությունը (տե՛ ս Lua-ի օրինակը)։

Sox-TTL + background refresh-ից հետո '«sport _ tl» տվեք հնացած (stale) և թարմացրեք ֆոնը։

Semaphore/lock: `SET key:lock value NX PX=2000`.

Near-stale: «stale-while-revalidate» API պատասխանների համար (տե՛ ս 8)։

5) Բանալիներ, նեյրոսպեյսներ, սերիալիզացիա

5. 1 Անուն

Ձևանմուշներ: <

Օրինակներ

`user: profile:42` `catalog:product:1001:v2` `psp:rates:2025-11-03`

Ավելացրեք սխեմայի տարբերակը («: v2»), դա հեշտացնում է զանգվածային հաշմանդամությունը։

5. 2 Նեյմսպեյսները «տարածության տարբերակի» միջոցով

Պահեք բանալին 'ns: catalog = 17 "։ Իրական բանալիները '«catalog: 17: 24t: 1001»։ Գլոբալ հաշմանդամության համար պարզապես հետաձգեք 'ns: catalog'։

5. 3 Սերիզացիա/ագրեսիա

JSON-ը հարմար է, բայց ծանր։ Օգտագործեք Pack/CBOR։

Միացրեք ագրեսիան (LZ4/ZSTD) մեծ payload (> 1-2 KB) համար։ Redis-ում հաճախորդի կողմում է։

6) Տաք բանալիներ և շարդիզացիա

Hot-keys: Վերահսկեք top-N-ը hit/miss/byte-ով։ Ծայրահեղ տաք կոմպոզիցիաների համար

Replicated read pattern: կրկնօրինակեք նշանակությունը մի քանի shard-infot 'hot: k: 1.. N', ընտրեք պատահական ընթերցման ժամանակ։

Մոնրեալի L1 'պահեք հիշողության մեջ, որը ունի հաշմանդամություն։

Շարդինգը

Redis Cluster-ը նորաձև է (16384 hash-slots)։

Memcached-ը հաճախորդի կոնսիստենտ հեշ է։

Hash-2019 Redis 'com... com-ը ձայնագրում է մի փունջ ՝ «user: + 42, profile» և «user: + 42 + limits» -ի համար մեկ շարքի վրա։

7) Հեռացման քաղաքականությունները և չափերը

Redis `maxmemory-policy`: `allkeys-lru`, `volatile-lru`, `allkeys-lfu`, `noeviction` и т. д. Քեշի համար սովորաբար «allkeys-lru »/« allkeys-lfu»։

Memcached — LRU на item-slab.

Ստեղնաշարի և վալուի չափը հետևեք max item size (Memcached լռելյայն 1 MB, slab թյունինգը)։

Հիշողության ավելցուկը պետք է դեգրադացնի կանխատեսելի, ոչ թե «eviction» ակտիվ ճանապարհին։

Redis wing (հատված)

maxmemory 32gb maxmemory-policy allkeys-lfu hz 50 tcp-keepalive 60

8) Փոթորիկներից պաշտպանվելու պատրանքները կոդն են։

8. 1 Redis Lua singleflight (կեղծ)

lua
-- KEYS[1] = data_key, KEYS[2] = lock_key
-- ARGV[1] = now_ms, ARGV[2] = soft_ttl_ms, ARGV[3] = hard_ttl_ms, ARGV[4] = lock_ttl_ms local payload = redis. call("GET", KEYS[1])
if payload then local meta = redis. call("HGETALL", KEYS[1].. ":meta")
local last = tonumber(meta[2] or "0")
if tonumber(ARGV[1]) - last < tonumber(ARGV[2]) then return { "HIT", payload }
end if redis. call ("SET," KEYS [2], "1," "NX," "PX," ARGV [4]) then return {"REFRESH," payload} - one worker updates, the rest give stale end return {"STALE," payload}
end if redis. call("SET", KEYS[2], "1", "NX", "PX", ARGV[4]) then return { "MISS", nil }
end return { "BUSY", nil }

8. 2 Node. js cache-aside (պարզեցված)

js const v = await redis. get(key);
if (v) return decode(v);
const lock = await redis. setNX(key+":lock", "1", { PX: 1500 });
if (lock) {
const fresh = await loadFromDB(id);
await redis. set(key, encode(fresh), { EX: ttl, NX: false });
await redis. del(key+":lock");
return fresh;
} else {
await sleep(60);           // short backoff const retry = await redis. get (key) ;//give someone's already filled return decode (retry);
}

9) Հաշմանդամություն և ներդաշնակություն

Իրադարձությունը հետևյալն է. Եթե BD-ում փոփոխություններ կատարեք 'pub/sub' իրադարձություն 'www.alidate: wwww.ds: wwwww.id _ wwwww.r.ru բաժանորդները։

Թայմերը 'կարճ TTL-ը հաճախ փոխվող տվյալների համար։

Տարբերակումը ՝ տե՛ ս «ns: » բանալիներ։

Medibox-ը 'հաշմանդամության առաքման երաշխիք (իրադարձություն լոգ/տոպիկ, ռեգրանտներ)։

Քեշի հետ գործողությունների համադրելիությունը 'օգտագործեք «SETXX/SETNX», տարբերակները («etag») և ծանր դաշտերը քրոմենտի համար։

10) Վերափոխում, կլաստեր, failover

10. 1 Redis

Sentinel: ավտոմատ failover proter-replica (steitFUL IP/անունը)։

Cluster: Շարդինգը + ավտոմատ failover; հաճախորդները պետք է աջակցեն «MOVED/ASK»։

AOF/RDB 'քեշի համար սովորաբար «appendfsync everysec», դուք կարող եք առանց անձնավորության (որպես մաքուր քեշ)։

10. 2 Memcached

Տուփից ոչ մի վերարտադրություն չկա։ Մոսկվա - բազմաշերտ գնդակի միջոցով + խոհարար 'n' (client-side)։

Երբ նոդան ընկավ, բացթողումների աճը և կեշի «փոխպատվաստումը»։

10. 3 K8s և ցանցային ասպեկտներ

Redis/Memcached-ը չի սիրում pod's հաճախակի վերադասավորումը։ Օգտագործեք StatefullPro + հակադոպները AZ-ով, որոնք ֆիքսված են PVC/POD IP-ով։

Տեղադրեք PodPrup.Budget-ը և TopologySpreadConstrainment-ը։

11) Գործարքներ, ջութակներ և ատոմականություն (Redis)

INCR/DECR, HINCRBY - հաշվիչներ, քվոտաներ, rate-limits (միայն հաշվի առեք persist)։

MMS I/EXEC-ը ատոմային թիմերի պաչկ է։

Lua (EVAL) - read-modify-write առանց մրցավազքի։

Pipeline - նվազեցնում է RTT (հատկապես ցանցային հոփում)։

Rate-limit (token bucket, պարզեցված)։

lua
-- KEYS[1]=bucket, ARGV[1]=capacity, ARGV[2]=refill_rate_per_sec, ARGV[3]=now_ms
-- Returns 1 if the token is issued, otherwise 0

12) Գծեր, pub/sub և Streams (Redis)

Pub/Sub 'հաշմանդամություն, ազդանշաններ։ Առանց պահպանելու, միայն առցանց լսողները։

Streams: Իրադարձությունների հերթերը, որոնք ապացուցում են (ACK), սպառողների խմբերը, retrai-ը հարմար է write-behind/fan-աուտների համար։

Lisault («BRPOP») - պարզ գծեր։

Մի օգտագործեք Redis-ը որպես «միակ անվադողը» առանց bakapa - սա kash/արագ անվադողեր է, ոչ Kafka։

13) Անվտանգություն և հասանելիություն

Ցանցերի մեկուսացումը/MSC, mTSA ingress մակարդակում, ACL/գաղտնաբառ («requirepass »/ACL Redis 6 +)։

Dangerous-ի թիմերը Redis-ում («MS III», «FLUSHALL», «KEYS») ACL-ի միջոցով։

Memcached-ի համար հանրային ինտերֆեյսներ չլսելը, «-U 0» (առանց UDP), միայն մասնավոր ցանցերը։

PII չպահպանել; Եթե դուք պետք է կարճ TTL + կոդավորումը դիմումի մակարդակում։

14) Դիտողությունն ու ծառայությունը

Հիմնական մետրերը

Hit ratio/Miss ratio (namespace/երթուղով)։

Latency p95/p99 թիմերը 'GET/CSA/MGET ", timeouts։

Evictions и OOM errors.
Replication lag (Redis), cluster state, migrate/rehash events.

Top-N keys-ը օպտիկայի/բայթերի վրա (sempling)։

Լոգները 'դանդաղ թիմերը («slowlog»), ցանցի սխալները։

Dashbords: Ընդհանուր (CPU/RAM/connections), թիմեր, հետախուզական արցունքներ, sentinels, անցնելով Prometheus բաժնետերերի միջոցով։

15) Ջորջներն ու հյուրանոցները օրինակներ են

15. 1 Redis Sentinel (հատված)

port 6379 protected-mode yes appendonly yes appendfsync everysec maxmemory-policy allkeys-lfu

sentinel monitor m1 10. 0. 0. 11 6379 2 sentinel auth-pass m1 sentinel down-after-milliseconds m1 5000 sentinel failover-timeout m1 60000

15. 2 Redis Cluster (helm values, պարզեցված)

yaml cluster:
enabled: true nodes: 6  # 3 masters + 3 replicas persistence:
size: 100Gi resources:
requests: { cpu: "500m", memory: "2Gi" }

15. 3 Memcached (deployment)

yaml containers:
- image: memcached:1. 6 args: ["-m", "32768", "-I", "2m", "-v", "-t", "8", "-o", "modern"]
ports: [{ containerPort: 11211 }]

15. 4 NGINX-ը որպես read-through (wwww.API)

nginx proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=api:100m max_size=10g inactive=10m;
map $request_uri $cache_key { default "api:$request_uri"; }
location /api/ {
proxy_cache api;
proxy_cache_valid 200 1m;
proxy_cache_use_stale updating error timeout http_500 http_502 http_503 http_504;
proxy_cache_lock on;      # singleflight на уровне NGINX proxy_cache_key $cache_key;
proxy_pass http://backend;
}

16) Փորձարկումներ և խաղեր

Բեռի պրոֆիլները «սառը/տաք/տաք քեշ»։

Պրոմախների միգրացիան (purge զանգվածային) - origin պետք է դիմանա «փոխպատվաստման»։

Ալբերտները 'hit-ratio-ի կտրուկ անկումը, miss latency, evictions լավինը, timeouts աճը։

17) Anti-patterna

Պահել «ճշմարտությունը» Redis-ում առանց AOF/RDB-ի և առանց պայմանագրերի։

TTL = 0 (անսահման) ալատիլային տվյալների համար հավիտենական նեկոնսիստենտություն է։

Զանգվածային «KEYS» վաճառքում։

Jitter/sport-TTL-ի բացակայությունը հաստատվում է սինխրոն և փոթորիկ։

Մի ինստանս բոլոր թիմերի վրա առանց շարդիզացիայի/կրկնօրինակի։

Օգտագործել Memcached-ը ատոմային/ջութակի պահանջող խնդիրների համար։

18) Ներդրման թուղթ (0-45 օր)

0-10 օր

Ընտրել ձևանմուշներ (cache-aside + L1/L2), նկարագրել բանալիները, TTL-ը, նյարդային սպեյսները։

Ներառել jitter/soft-TTL, singleflight; հիմնական alerts/dashbords։

Redis-ի համար ACL-ն, directed-mode, slowlog, maxmemory-policy-ը։

11-25 օր

Գնալ շարդիզացիայի (Redis Cluster կամ հաճախորդի հեշ), կրկնօրինակներ։

Հաշմանդամությունը pub/sub միջոցով կամ նյարդային սպեյսի տարբերակը։ Box BD-ում։

Ծանրաբեռնված թեստեր «վերապատրաստման» կեշի; limiting origin.

26-45 օր

Autropromo/kanarech TTL-ը, տաքացնելով ռոտացիայի առջև։

Streams-ը write-behind/ֆոնային հատվածների համար։

Շաբաթական հաշվետվություններ hit-ratio, առաջին բեկորները, հիշողության արժեքը։

19) Հասունության մետրերը

Hit-ratio L2-80 տոկոսը (վիճակագրությունը/նյարդային սպեյսների)։

P95 GET <2-3 ռուբլիներ (in-DC), պրոմախի

0 փոթորիկ զանգվածային հաշմանդամության դեպքում (ապացուցված է թեստերով)։

Ավտոմատ հաշմանդամություն և նյարդային սպեյսների տարբերակումը։

Շարդինգը/կրկնապատկումը ծածկում են 1 հանգույցի մերժումը առանց նկատելի քայքայման։

20) Եզրակացություն

Քեշի ուժեղ ճարտարապետությունը ռուսական և TTL-ի կարգապահությունն է, պաշտպանությունը փոթորիկից, ճիշտ շարդինգը և կանխատեսելի փոխարինումը։ Redis-ը տալիս է հարուստ սեմանտիկա, անձնավորություն և ատոմականություն։ Memcached-ը ամենապարզ պարզությունն ու արագությունն է։ Ավելացրեք դիտարկումը, հաշմանդամությունը իրադարձությունների միջոցով, L1 + L2, և քեշը կդառնա պլատֆորմի արագացուցիչ, ոչ թե պատահական անկման և «առեղծվածային» ուղիների աղբյուրը։