कैशिंग आर्किटेक्चर: रेडिस, मेमकैच

कैशिंग आर्किटेक्चर: रेडिस, मेमकैच

1) कब और क्यों कैश

उद्देश्य: विलंबता को कम करना, डीबी/पीएसपी/बाहरी एपीआई को कम करना और चोटियों को कम करना।

कैश परतें अक्सर मल्टीलेवल होती हैं: इन-प्रोसेस (L1) → सर्विस-लेवल (Redis/Memcathed L2) → edge/CDN। आंतरिक कैश गर्म रीड को गति देता है, एल 2 सेवाओं के लिए आम है, किनारा सार्वजनिक सामग्री के लिए है।

2) रेडिस बनाम मेमकैच - संक्षिप्त

नियम: यदि आपको जटिल डेटा संरचनाओं, दृढ़ ता, पब/सब/स्ट्रीम/स्क्रिप्ट की आवश्यकता है - रेडिस लें। यदि स्थायित्व के बिना सुपर-सरल, तेज, सस्ती केवी कैश परत मेमकैच है।

3) कैशिंग पैटर्न

3. 1 कैश-एक तरफ (आलसी)

एप्लिकेशन कैश से पढ़ ता है - एक मिस - डेटाबेस से पढ़ ता है - इसे टीटीएल के साथ कैश में रखता है।

सरल टीटीएल नियंत्रण, कैश स्वतंत्रता। − संभावित "तूफान" यादों के मामले में।

3. 2 पढ़ ने के माध्यम से

ग्राहक/प्रॉक्सी खुद एक मिस पर मूल से खींचता है और इसे कैश में डालता है।

केंद्रीकृत तर्क। − अधिक जटिल अवसंरचना।

3. 3 राइट-थ्रू/राइट-पीछे

राइट-थ्रू: पहले कैश पर लिखना, फिर डेटाबेस पर।

लिखने के पीछे: कतार में लिखना, डेटाबेस में अतुल्यकालिक फ्लैश (दुर्घटनाग्रस्त होने पर संभावित नुकसान - आपको एक लॉग की आवश्यकता है)।

3. 4 टू-टियर (L1 + L2)

छोटे TTL और सॉफ्ट TTL, L2 (Redis/Memcatched) के साथ L1 (इन-प्रक्रिया) - "कैश सत्य। "पब/उप के माध्यम से विकलांगता।

4) टीटीएल, तूफान और स्थिरता

TTL-सेट डेटा परिवर्तन की आवृत्ति के करीब है। गर्म कुंजियों के लिए, TTL (जिटर) रैंडमाइजेशन का उपयोग करें: 'ttl = base rand (0.. आधार 0। 1) '- तुल्यकालिक बहिर्वाह को हटाता है।

• सिंगलफ्लाइट: केवल एक प्रक्रिया मूल्य को बढ़ाती है (लुआ उदाहरण देखें)।
• सॉफ्ट-टीटीएल + बैकग्राउंड रिफ्रेश: 'सॉफ्ट _ ttl' के बाद, इसे बासी दें और पृष्ठभूमि के साथ अपडेट करें।
• सेमाफोर/लॉक: 'SET कुंजी: लॉक मान NX PX = 2000'.
• निकट-बासी: प्रतिक्रिया एपीआई के लिए 'बासी-जबकि-पुनर्नवीनीकरण' (धारा 8 देखें)।

5) कुंजियाँ, नामस्थान, क्रमबद्धता

5. 1 कुंजी नामकरण

साँचा: '{domain}: {entity}: {id}: {field}'

• 'प्रयोक्ता: प्रोफ़ाइल: 42' कैटलॉग: उत्पाद: 1001: v2 '' psp: दरें: 2025-11-03 '

एक स्कीमा संस्करण जोड़ें (': v2') - यह बड़े पैमाने पर विकलांगता को सुविधाजनक बनाता है।

5. 2 नीमस्पेस "अंतरिक्ष संस्करण" के माध्यम से

कुंजी 'ns: catalog = 17' को पकड़े रखें। असली कुंजी: 'कैटलॉग: 17: उत्पाद: 1001'। वैश्विक निर्देशिका विकलांगता के लिए, बस वृद्धि 'एनएस: कैटलॉग'।

5. 3 क्रमबद्धता/संपीड़न

JSON सुविधाजनक है, लेकिन भारी है। MessagePack/CBOR का उपयोग करें।

बड़े पेलोड (> 1-2 KB) के लिए संपीड़न (LZ4/ZSTD) सक्षम करें। Redis में - ग्राहक की तरफ।

6) गर्म चाबियाँ और शार्डिंग

• दोहराया पढ़ा पैटर्न: कई शार्ड कुंजियों में मूल्य की नकल करें: k: 1। N ', पढ़ ते समय यादृच्छिक चुनें।
• स्थानीय L1: विकलांगता सदस्यता प्रक्रिया को ध्यान में रखें।

• रेडिस क्लस्टर - देशी (16384 हैश स्लॉट)।
• Memcatched एक ग्राहक-पक्ष सुसंगत हैश है।
• Redis '{...}' में हैश टैग कुंजियों के सेट के लिए एक स्लॉट को ठीक करता है: 'उपयोगकर्ता: {42}: प्रोफाइल' और 'उपयोगकर्ता: {42}: लिमिट' एक ही कार्ड पर होगा।

7) पूर्वनिर्धारण नीतियां और आकार

Redis 'maxmemory-policy': 'allkeys-lru', 'volatile-lru', 'allkeys-lfu', 'noevicion' и т। д. कैश के लिए, आमतौर पर 'allkeys-lru '/' allkeys-lfu'।

Memcatched - LRU на आइटम-स्लैब।

कुंजी आकार और मान: अधिकतम आइटम आकार के लिए देखें (डिफ़ॉल्ट रूप से 1 MB, ट्यूनिंग स्लैब).

स्मृति से अधिक को अनुमानित रूप से नीचा दिखाना चाहिए: सक्रिय पथ पर 'नोएविक्शन' नहीं।

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

8) तूफान सुरक्षा पैटर्न - कोड

8. 1 रेडिस लुआ सिंगलफ्लाइट (छद्म)

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 नोड। जेएस कैश-एक तरफ (सरलीकृत)

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) विकलांगता और सुसंगतता

घटना के अनुसार: डेटाबेस में बदलते समय, 'पब/सब' इवेंट 'अमान्य प्रकाशित करें: {ns}: {id}' - ग्राहक कुंजी को हटा देते हैं।

टाइमर द्वारा: अक्सर डेटा बदलने के लिए छोटा टीटीएल।

Versioning: 'ns:' कुंजी देखें।

आउटबॉक्स: विकलांगता वितरण गारंटी (लॉग/टॉपिक इवेंट, रेट्राई)।

कैश संचालन पहचान: वेतन वृद्धि के लिए 'SETXX/SETNX', संस्करण ('etag') और हैश फ़ील्ड का उपयोग करें।

10) प्रतिकृति, क्लस्टर, विफल

10. 1 रेडिस

प्रहरी: स्वचालित विफलता मास्टर-प्रतिकृति (राज्य FUL IP/नाम)।

क्लस्टर: शार्डिंग + स्वचालित विफलता; ग्राहकों को 'TOVED/ASK' पुनर्निर्देशन का समर्थन करना चाहि

AOF/RDB: कैश के लिए आमतौर पर 'एपेंडफ्सिंक एवरीसेक', यह दृढ़ ता (शुद्ध कैश की तरह) के बिना संभव है।

10. 2 मेमकैच

बॉक्स से कोई प्रतिकृति नहीं। विश्वसनीयता - मल्टी-सर्वर शार्ड + रिपीट 'एन' (क्लाइंट-साइड) के माध्यम से।

जब नोड्स गिरते हैं, तो मिस में वृद्धि होती है और कैश की "रिट्रेनिंग" होती है।

10. 3 K8s और नेटवर्किंग

Redis/Memcatched फली के लगातार पुन: निर्माण को पसंद नहीं करते हैं; Stat Set + AZ antipodes, फिक्स्ड PVC/POD IP का उपयोग करें।

PodDis बजट और TopologyScredConctrents सेट करें।

11) लेन-देन, स्क्रिप्ट और परमाणु (रेडिस)

INCR/DECR, HINCRBY - काउंटर, कोटा, दर-सीमा (बस विचार करें)।

मल्टी/एक्सेक - परमाणु आदेशों का एक बंडल।

लुआ (EVAL) - रेसिंग के बिना पढ़ें-संशोधित-लेखन।

पाइपलाइन - आरटीटी (विशेष रूप से नेटवर्क हॉप्स में) को कम करता है।

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) कतारें, पब/उप और धाराएँ (रेडिस)

पब/उप: विकलांगता, संकेत। कोई बचत नहीं, केवल ऑनलाइन श्रोता।

धाराएँ: पुष्टिकरण घटना कतार (ACK), उपभोक्ता समूह, रिट्राई - राइट-बैक/फैन-आउट के लिए आसान।

सूची ('BRPOP'): सरल कतारें।

रेडिस का उपयोग बैकअप के बिना "सब कुछ की एकल बस" के रूप में न करें - यह एक कैश/फास्ट बस है, न कि काफ्का।

13) सुरक्षा और पहुंच

नेटवर्क आइसोलेशन/वीपीसी, इंग्रेस स्तर पर एमटीएलएस, एसीएल/पासवर्ड (रेडिस 6 + में 'आवश्यक पास '/एसीएल)।

Redis में खतरनाक कमांड अक्षम करें ('CONFIG', 'FLUSHALL', 'KEYS') ACL के माध्यम से.

Memcatched के लिए - सार्वजनिक इंटरफेस को न सुनें, '-U 0' (UDP के बिना), केवल निजी नेटवर्क।

PII संग्रहीत न करें; यदि आवश्यक हो - अनुप्रयोग स्तर पर छोटा TTL + एन्क्रिप्शन।

14) अवलोकन और रखरखाव

• हिट अनुपात/मिस अनुपात (नेमस्पेस/रूट द्वारा)।
• लेटेंसी p95/p99 'GET/SET/MGET' कमांड, टाइमआउट।
• निष्कासन и OOM त्रुटियां।
• प्रतिकृति अंतराल (रेडिस), क्लस्टर राज्य, माइग्रेट/रीहैश घटनाएं।
• ट्रैफिक/बाइट्स (नमूना) द्वारा शीर्ष-एन कुंजी।
• लॉग: धीमे कमांड ('स्लॉग'), नेटवर्क त्रुटियाँ.
• डैशबोर्ड: सामान्य (सीपीयू/रैम/कनेक्शन), कमांड, क्लस्टर स्लॉट, प्रहरी, प्रोमेथियस निर्यातकों से गुजरते हुए।

15) कॉन्फ्रेंस और तैनाती - उदाहरण

15. 1 रेडिस सेंटिनल (स्निपेट)

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 रेडिस क्लस्टर (पतवार मूल्य, सरलीकृत)

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

15. 3 मेमकैच (तैनाती)

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

15. 4 NGINX रीड-थ्रू प्रॉक्सी (एपीआई लूप) के रूप में

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) परीक्षण और द्वार

ठंडा/गर्म/गर्म कैश लोड प्रोफाइल।

यादों का इंजेक्शन (शुद्ध एन मस्से) - मूल को "पीछे हटना" चाहिए।

अलर्ट: हिट-अनुपात में तेज गिरावट, मिस लेटेंसी में वृद्धि, बेदखली का हिमस्खलन, टाइमआउट में वृद्धि।

17) एंटी-पैटर्न

एओएफ/आरडीबी के बिना और अतिरेक के बिना रेडिस में "सत्य" स्टोर करें।

अस्थिर डेटा के लिए TTL = 0 (स्थायी) → स्थायी असंगति।

मास 'कीज़' प्रोड।

जिटर/सॉफ्ट-टीटीएल → सिंक्रोनस आउटेज और स्टॉर्म की अनुपस्थिति।

बिना शार्डिंग/प्रतिकृतियों के सभी आदेशों के लिए एक उदाहरण।

परमाणुता/स्क्रिप्ट की आवश्यकता वाले कार्यों के लिए मेमकैच का उपयोग करें।

18) कार्यान्वयन चेकलिस्ट (0-45 दिन)

0-10 दिन

टेम्पलेट चुनें (कैश-अलग + L1/L2), वर्णन कुंजी, TTL, namespaces.

जिटर/सॉफ्ट-टीटीएल, सिंगल फ्लाइट सक्षम करें; बुनियादी अलर्ट/डैशबोर्ड।

Redis के लिए - ACL, संरक्षित-मोड, स्लॉग, मैक्समेमोरी-पॉलिसी कॉन्फ़िगर करें।

11-25 दिन

शार्डिंग (रेडिस क्लस्टर या क्लाइंट हैश), प्रतिकृतियों पर स्विच करें।

पब/उप या नीमस्पेस संस्करण के माध्यम से विकलांगता; डेटाबेस में आउटबॉक्स।

कैश "रिट्रेनिंग" लोड परीक्षण; उत्पत्ति को सीमित करना।

26-45 दिन

ऑटोप्रोमो/कैनरी टीटीएल, रिलीज से पहले वार्म-अप।

राइट-बैक/बैकग्राउंड रीसेम्बली के लिए धाराएँ।

हिट-अनुपात, शीर्ष कुंजी, मेमोरी लागत पर साप्ताहिक रिपोर्ट।

19) परिपक्वता मैट्रिक्स

हिट-अनुपात L2 ≥ 80% (मार्गों/नेमस्पेस पर आंकड़े)।

P95 <2-3 ms (इन-डीसी), याद आती है

बड़े पैमाने पर विकलांगता में 0 तूफान (परीक्षण द्वारा सिद्ध)

स्वचालित विकलांगता और निमस्पेस संस्करण।

शार्डिंग/प्रतिकृति में प्रशंसनीय गिरावट के बिना 1 नोड विफलता शामिल है।

20) निष्कर्ष

मजबूत कैश आर्किटेक्चर चाबियों और टीटीएल का अनुशासन, तूफान सुरक्षा, उचित शार्डनेस और पूर्वानुमानित पूर्वनिर्धारण है। रेडिस समृद्ध शब्दार्थ, दृढ़ ता और परमाणुता देता है; Memcacched - अधिकतम सादगी और गति। अवलोकन, घटना विकलांगता, L1 + L2 जोड़ें, और कैश एक मंच त्वरक बन जाता है, न कि आकस्मिक बूंदों और "रहस्यमय" कीड़े का स्रोत।