Next.js మీకు నేరుగా అందించేవి

  • Data cache – Next.js 13+లో ప్రతి fetch() కాల్ ఒక per-request మెమరీ క్యాష్‌లో నిక్షిప్తమవుతుంది. revalidate ఆప్షన్‌ను జోడించడం ద్వారా, ఒక నిర్ణీత సమయం తర్వాత డేటాను రిఫ్రెష్ చేయమని రన్‌టైమ్‌కు చెప్పవచ్చు, దీనివల్ల అవసరమైనప్పుడు మాత్రమే API కాల్ జరుగుతుంది.
  • Full-route cache – ఈ ఫ్రేమ్‌వర్క్ రెండర్ చేయబడిన HTML మరియు మొత్తం రూట్‌కు అవసరమైన డేటాను భద్రపరుస్తుంది. సర్వర్ మళ్ళీ రెండరింగ్ చేయనందున, తిరిగి వచ్చే సందర్శకులు తక్షణమే పేజీని చూడగలరు.
  • ISR – పాత వెర్షన్ ట్రాఫిక్‌ను అందిస్తున్నప్పుడే, బ్యాక్‌గ్రౌండ్‌లో స్టాటిక్ పేజీలు తిరిగి జనరేట్ అవుతాయి. కంటెంట్ మారిన ప్రతిసారీ పూర్తి రీబిల్డ్ చేయకుండానే, పెద్ద సైట్‌ను స్టాటిక్‌గా ఉంచడానికి ఇది అనుమతిస్తుంది.
  • Server Component cache() – React యొక్క cache హెల్పర్ ఒకే రిక్వెస్ట్ కాలపరిమితిలో ఖరీదైన గణనలు (calculations) లేదా డేటాబేస్ కనెక్షన్‌లను మెమోయిజ్ (memoize) చేస్తుంది, తద్వారా పేజీ యొక్క కాంపోనెంట్ ట్రీలో డూప్లికేట్ పనులను నివారిస్తుంది.

ఈ క్యాష్‌లు “first-hit” సమస్యను పరిష్కరిస్తాయి, కానీ ఇవి ఇంకా Node ప్రాసెస్‌లోనే ఉంటాయి. సర్వర్ మరియు డేటాబేస్‌ను రక్షించడానికి, క్యాషింగ్‌ను బయటి పొరలకు (outward) విస్తరించండి.

మీరు జోడించగల బాహ్య పొరలు (External layers)

పొర (Layer) ఇది దేనిని నిల్వ చేస్తుంది సాధారణంగా వాడే సాధనం ఇది ఎలా సహాయపడుతుంది
CDN Static assets, HTML, API JSON Cloudflare, Akamai, AWS CloudFront కంటెంట్‌ను ఎడ్జ్ లొకేషన్‌లకు తరలించి, యూజర్‌కు చేరుకోవడానికి పట్టే సమయాన్ని తగ్గిస్తుంది
Reverse proxy Node కి చేరుకోకముందే పూర్తి పేజీ స్పందనలు Nginx, Varnish క్యాష్ చేయబడిన పేజీలను నేరుగా అందిస్తుంది, దీనివల్ల Next.js ఇన్‌స్టాన్స్ పై లోడ్ తగ్గుతుంది
Application-level cache ఖరీదైన DB క్వెరీల లేదా API కాల్‌ల ఫలితాలు Redis, Memcached సర్వర్ రీస్టార్ట్‌ల సమయంలో కూడా డేటాను నిల్వ ఉంచే వేగవంతమైన కీ-వాల్యూ స్టోర్‌ను అందిస్తుంది మరియు దీనిని బహుళ యాప్ ఇన్‌స్టాన్స్‌ల మధ్య పంచుకోవచ్చు

ప్రతి పొర ఒరిజినల్ డేటాబేస్ నుండి దూరంగా ఉంటుంది, కాబట్టి ఒక స్థాయిలో క్యాష్ దొరకకపోతే (miss), అది తదుపరి స్థాయికి వెళ్తుంది. చివరికి, అత్యంత అవసరమైనప్పుడు మాత్రమే అది డేటాబేస్‌ను చేరుకుంటుంది.

క్యాష్‌లను తాజాగా (fresh) ఉంచడం

క్యాష్ ఇన్‌వాలిడేషన్ (Invalidation) అనేది చాలా టీమ్‌లకు సవాలుగా మారుతుంది. దీని కోసం మూడు ఆచరణాత్మక పద్ధతులు బాగా పనిచేస్తాయి:

  • Time-based (TTL) – క్యాష్ ఎంట్రీకి ఒక నిర్ణీత గడువును (expiration) కేటాయించండి. దీనిని కాన్ఫిగర్ చేయడం సులభం, కానీ టైమర్ ముగిసే వరకు పాత డేటాను చూపించే అవకాశం ఉంది.
  • Event-driven – కంటెంట్ మారినప్పుడు వెబ్‌హుక్ (webhook) పంపే మీ CMS లేదా ఏదైనా డేటా సోర్స్‌తో దీనిని అనుసంధానించండి. ఆ వెబ్‌హుక్ సంబంధిత క్యాష్ ఎంట్రీని తొలగించడానికి (purge) ప్రేరేపిస్తుంది.
  • Tag-based – ఫెచ్‌ల సమూహానికి ఒక లాజికల్ ట్యాగ్‌ను జోడించండి (ఉదాహరణకు, product-list). ఆ సమూహంలోని ఏదైనా అంశం మారినప్పుడు, revalidateTag('product-list') అనే ఒకే కాల్ ఆ ట్యాగ్‌ను కలిగి ఉన్న ప్రతి ఎంట్రీని క్లియర్ చేస్తుంది.

ఈ పద్ధతులను కలిపి ఉపయోగించడం ద్వారా, డేటా యొక్క తాజాతనం (freshness) మరియు క్యాష్-హిట్ రేట్ల మధ్య సమతుల్యతను సాధించవచ్చు.

చాలా టీమ్‌లకు ఉపయోగపడే క్రమానుగత శ్రేణి (Hierarchy)

  1. Browser cache – స్టాటిక్ అసెట్స్ (CSS, JS, చిత్రాలు) కు సుదీర్ఘమైన max-age ఇవ్వబడుతుంది, తద్వారా యూజర్ పరికరం మళ్ళీ నెట్‌వర్క్‌ను అడగాల్సిన అవసరం ఉండదు.
  2. CDN – ఎడ్జ్ నోడ్స్ పూర్తి HTML పేజీలు మరియు API JSONలను క్యాష్ చేస్తాయి, మీరు Next.jsలో సెట్ చేసిన Cache-Control హెడర్‌లను ఇవి గౌరవిస్తాయి.
  3. Reverse proxy – Nginx లేదా Varnish ఇన్‌స్టాన్స్ Next.js సర్వర్‌కు ముందు ఉంటుంది, ఇది అరుదుగా మారే రూట్‌ల కోసం క్యాష్ చేయబడిన స్పందనలను అందిస్తుంది.
  4. Next.js internal cache – ఫ్రేమ్‌వర్క్ యొక్క డేటా మరియు రూట్ క్యాష్‌లు per-request మెమోయిజేషన్ మరియు ISRని నిర్వహిస్తాయి.
  5. Application cache – Redis భారీ డేటాబేస్ క్వెరీల ఫలితాలను క్వెరీ పారామీటర్లు లేదా ట్యాగ్‌ల ద్వారా నిల్వ చేస్తుంది.
  6. Database – ఇది అంతిమ సమాచార మూలం, పై స్థాయిలన్నింటిలో క్యాష్ దొరకనప్పుడు మాత్రమే దీనిని క్వెరీ చేస్తారు.

ఒక రిక్వెస్ట్ వచ్చినప్పుడు, అది ఏదైనా ఒక పొర సమాధానం ఇచ్చే వరకు ఈ జాబితాలో కిందకు వెళ్తుంది. అత్యంత వేగవంతమైన సమాధానం లభిస్తుంది, మరియు ఆ స్పందన భవిష్యత్తు రిక్వెస్ట్‌ల కోసం తిరిగి పైకి సేవ్ చేయబడుతుంది.

అన్నింటినీ కలిపి అమలు చేయడం

  1. మీ API రూట్‌లలో Cache-Control హెడర్‌లను సెట్ చేయండి
  2. మీ CDNని కాన్ఫిగర్ చేయండి – HTML మరియు JSON ఎండ్‌పాయింట్‌ల కోసం ఎడ్జ్ క్యాషింగ్‌ను ఎనేబుల్ చేయండి మరియు CDN Cache-Controlను అనుసరిస్తుందని నిర్ధారించుకోండి.
  3. రివర్స్ ప్రాక్సీని డిప్లాయ్ చేయండి – మీ Next.js సర్వర్‌కు ముందు Nginxని ఉంచండి.
  4. Redisని జోడించండి – ఖరీదైన డేటాబేస్ క్వెరీల ఫలితాలను క్యాష్ చేయండి.
  5. మీ కాంపోనెంట్లలో revalidateTagని ఉపయోగించండి – ఒక నిర్దిష్ట ట్యాగ్ కోసం Next.js అంతర్గత క్యాష్‌ను క్లియర్ చేయడానికి revalidateTagని కాల్ చేయండి.

ముగింపు (Takeaway)

Next.js లోపల ఉన్న ఒకే ఒక క్యాష్ మొదటి రిక్వెస్ట్‌ను వేగవంతం చేస్తుంది, కానీ నిజమైన స్కేలబిలిటీ క్రమబద్ధమైన స్టాక్ నుండి వస్తుంది: browser → CDN → reverse proxy → framework → Redis → database. ప్రతి పొరను కాన్ఫిగర్ చేయండి, సమయం, ఈవెంట్‌లు మరియు ట్యాగ్‌లతో ఇన్‌వాలిడేషన్‌ను నిర్వహించండి మరియు మీ మెట్రిక్స్‌ను గమనించండి. దీనివల్ల బ్యాకెండ్ ట్రాఫిక్ పెరుగుదలలను తట్టుకుంటుంది మరియు లాటెన్సీ (latency) తక్కువగా ఉంటుంది.