M

MLOG

తెలుగు

మీ Next.js అప్లికేషన్‌లోనే నేరుగా సర్వర్‌లెస్ బ్యాకెండ్‌లను నిర్మించడానికి Next.js API రూట్స్‌ను ఎలా ఉపయోగించుకోవాలో తెలుసుకోండి. ఈ గైడ్ ప్రాథమిక సెటప్ నుండి అథెంటికేషన్, డేటా పర్సిస్టెన్స్ నిర్వహణ వరకు అధునాతన టెక్నిక్‌లను కవర్ చేస్తుంది.

Next.js API రూట్స్: మీ బ్యాకెండ్‌ను సులభంగా నిర్మించడం

Next.js దాని శక్తివంతమైన ఫీచర్లు మరియు స్పష్టమైన నిర్మాణంతో ఫ్రంట్-ఎండ్ డెవలప్‌మెంట్‌ను విప్లవాత్మకంగా మార్చింది. కానీ ఇది బ్యాకెండ్ డెవలప్‌మెంట్‌ను కూడా గణనీయంగా సులభతరం చేస్తుందని మీకు తెలుసా? Next.js API రూట్స్ మీ Next.js అప్లికేషన్‌లోనే నేరుగా సర్వర్‌లెస్ API ఎండ్‌పాయింట్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి, చాలా సందర్భాలలో ప్రత్యేక బ్యాకెండ్ సర్వర్ అవసరాన్ని తొలగిస్తాయి. ఈ సమగ్ర గైడ్ Next.js API రూట్స్‌ను ఉపయోగించి ఒక దృఢమైన మరియు స్కేలబుల్ బ్యాకెండ్‌ను నిర్మించే ప్రక్రియ ద్వారా మీకు మార్గనిర్దేశం చేస్తుంది.

Next.js API రూట్స్ అంటే ఏమిటి?

API రూట్స్ అనేవి మీ Next.js ప్రాజెక్ట్‌లోని /pages/api డైరెక్టరీలో మీరు సృష్టించే సర్వర్‌లెస్ ఫంక్షన్‌లు. ఈ ఫంక్షన్‌లు ఇన్‌కమింగ్ HTTP అభ్యర్థనలను నిర్వహిస్తాయి మరియు ప్రతిస్పందనలను తిరిగి ఇస్తాయి, సాంప్రదాయ బ్యాకెండ్ API లాగానే. ముఖ్యమైన తేడా ఏమిటంటే, అవి సర్వర్‌లెస్ ఫంక్షన్‌లుగా అమలు చేయబడతాయి, అంటే మీరు సర్వర్‌లను లేదా మౌలిక సదుపాయాలను నిర్వహించాల్సిన అవసరం లేదు.

వాటిని మీ Next.js ఫ్రంట్-ఎండ్‌తో సజావుగా అనుసంధానించబడిన తేలికపాటి, ఆన్-డిమాండ్ బ్యాకెండ్ ఫంక్షన్‌లుగా భావించండి.

Next.js API రూట్స్ ఉపయోగించడం వల్ల ప్రయోజనాలు

Next.js API రూట్స్‌తో ప్రారంభించడం

ఒక సాధారణ API రూట్‌ను సృష్టిద్దాం, అది JSON ప్రతిస్పందనను తిరిగి ఇస్తుంది. ముందుగా, మీ వద్ద Next.js ప్రాజెక్ట్ సెటప్ చేయబడిందని నిర్ధారించుకోండి. లేకపోతే, దీన్ని ఉపయోగించి సృష్టించండి:

npx create-next-app my-app
cd my-app

ఇప్పుడు, /pages/api డైరెక్టరీలో hello.js అనే ఫైల్‌ను సృష్టించండి:

// pages/api/hello.js
export default function handler(req, res) {
  res.status(200).json({ name: 'John Doe' })
}

ఈ కోడ్ "John Doe" అనే పేరుతో కూడిన JSON ఆబ్జెక్ట్‌తో ప్రతిస్పందించే ఒక సాధారణ API రూట్‌ను నిర్వచిస్తుంది. ఈ API రూట్‌ను యాక్సెస్ చేయడానికి, మీ Next.js డెవలప్‌మెంట్ సర్వర్‌ను ప్రారంభించండి:

npm run dev

ఆ తర్వాత, మీ బ్రౌజర్‌ను తెరిచి http://localhost:3000/api/hello కు నావిగేట్ చేయండి. మీరు ఈ క్రింది JSON ప్రతిస్పందనను చూడాలి:

{"name": "John Doe"}

API రూట్ హ్యాండ్లర్‌ను అర్థం చేసుకోవడం

మీ API రూట్‌లోని handler ఫంక్షన్ రెండు ఆర్గ్యుమెంట్‌లను అందుకుంటుంది:

వివిధ రకాల అభ్యర్థనలను నిర్వహించడానికి, అభ్యర్థన బాడీ నుండి డేటాను చదవడానికి, ప్రతిస్పందన హెడర్‌లను సెట్ చేయడానికి మరియు వివిధ రకాల ప్రతిస్పందనలను పంపడానికి మీరు ఈ ఆబ్జెక్ట్‌లను ఉపయోగించవచ్చు.

వివిధ HTTP పద్ధతులను నిర్వహించడం

ఇన్‌కమింగ్ అభ్యర్థన యొక్క HTTP పద్ధతిని గుర్తించడానికి మరియు తదనుగుణంగా విభిన్న పద్ధతులను నిర్వహించడానికి మీరు req.method ప్రాపర్టీని ఉపయోగించవచ్చు. ఉదాహరణకి:

// pages/api/method.js
export default function handler(req, res) {
  if (req.method === 'GET') {
    // GET అభ్యర్థనను నిర్వహించండి
    res.status(200).json({ message: 'This is a GET request' })
  } else if (req.method === 'POST') {
    // POST అభ్యర్థనను నిర్వహించండి
    res.status(200).json({ message: 'This is a POST request' })
  } else {
    // ఇతర పద్ధతులను నిర్వహించండి
    res.status(405).json({ message: 'Method Not Allowed' })
  }
}

ఈ ఉదాహరణలో, API రూట్ GET మరియు POST అభ్యర్థనలను రెండింటినీ నిర్వహిస్తుంది. అభ్యర్థన పద్ధతి GET అయితే, అది "This is a GET request" అనే సందేశంతో కూడిన JSON ఆబ్జెక్ట్‌తో ప్రతిస్పందిస్తుంది. అభ్యర్థన పద్ధతి POST అయితే, అది "This is a POST request" అనే సందేశంతో కూడిన JSON ఆబ్జెక్ట్‌తో ప్రతిస్పందిస్తుంది. అభ్యర్థన పద్ధతి మరేదైనా అయితే, అది 405 Method Not Allowed ఎర్రర్‌తో ప్రతిస్పందిస్తుంది.

అభ్యర్థన బాడీ నుండి డేటాను చదవడం

POST, PUT, మరియు PATCH అభ్యర్థనల కోసం, మీరు తరచుగా అభ్యర్థన బాడీ నుండి డేటాను చదవాలి. Next.js JSON మరియు URL-ఎన్‌కోడ్ చేయబడిన అభ్యర్థన బాడీలను పార్సింగ్ చేయడానికి అంతర్నిర్మిత మద్దతును అందిస్తుంది. JSON అభ్యర్థన బాడీని పార్స్ చేయడానికి, మీరు req.body ప్రాపర్టీని ఉపయోగించవచ్చు. ఉదాహరణకి:

// pages/api/post.js
export default async function handler(req, res) {
  if (req.method === 'POST') {
    const { name, email } = req.body

    // డేటాను ప్రాసెస్ చేయండి
    console.log('Name:', name)
    console.log('Email:', email)

    res.status(200).json({ message: 'Data received successfully' })
  } else {
    res.status(405).json({ message: 'Method Not Allowed' })
  }
}

ఈ API రూట్‌ను పరీక్షించడానికి, మీరు పోస్ట్‌మ్యాన్ లేదా కర్ల్ వంటి సాధనాన్ని ఉపయోగించి JSON బాడీతో POST అభ్యర్థనను పంపవచ్చు:

curl -X POST -H "Content-Type: application/json" -d '{"name": "Jane Doe", "email": "jane.doe@example.com"}' http://localhost:3000/api/post

ప్రతిస్పందన హెడర్‌లను సెట్ చేయడం

ప్రతిస్పందన హెడర్‌లను సెట్ చేయడానికి మీరు res.setHeader() పద్ధతిని ఉపయోగించవచ్చు. కంటెంట్ రకం, కాష్ కంట్రోల్ మరియు ఇతర ముఖ్యమైన సమాచారాన్ని సెట్ చేయడానికి ఇది ఉపయోగపడుతుంది. ఉదాహరణకి:

// pages/api/headers.js
export default function handler(req, res) {
  res.setHeader('Content-Type', 'application/json')
  res.setHeader('Cache-Control', 's-maxage=3600')
  res.status(200).json({ message: 'Hello, world!' })
}

ఈ ఉదాహరణలో, API రూట్ Content-Type హెడర్‌ను application/json కు సెట్ చేస్తుంది, ఇది ప్రతిస్పందన ఒక JSON ఆబ్జెక్ట్ అని సూచిస్తుంది. ఇది Cache-Control హెడర్‌ను s-maxage=3600 కు కూడా సెట్ చేస్తుంది, ఇది బ్రౌజర్ మరియు CDN కు ప్రతిస్పందనను 1 గంట వరకు కాష్ చేయమని చెబుతుంది.

ఎర్రర్ హ్యాండ్లింగ్

మీ API రూట్స్‌లో ఎర్రర్‌లను సున్నితంగా నిర్వహించడం ముఖ్యం. మినహాయింపులను పట్టుకోవడానికి మరియు క్లయింట్‌కు తగిన ఎర్రర్ ప్రతిస్పందనలను పంపడానికి మీరు ట్రై-క్యాచ్ బ్లాక్‌లను ఉపయోగించవచ్చు. ఉదాహరణకి:

// pages/api/error.js
export default async function handler(req, res) {
  try {
    // ఒక ఎర్రర్‌ను అనుకరించండి
    throw new Error('Something went wrong')
  } catch (error) {
    console.error(error)
    res.status(500).json({ message: 'Internal Server Error' })
  }
}

ఈ ఉదాహరణలో, API రూట్ ఒక కొత్త Error ఆబ్జెక్ట్‌ను విసిరివేయడం ద్వారా ఒక ఎర్రర్‌ను అనుకరిస్తుంది. క్యాచ్ బ్లాక్ ఎర్రర్‌ను పట్టుకుంటుంది, దానిని కన్సోల్‌కు లాగ్ చేస్తుంది మరియు క్లయింట్‌కు 500 ఇంటర్నల్ సర్వర్ ఎర్రర్ ప్రతిస్పందనను పంపుతుంది. ప్రొడక్షన్ వాతావరణాల కోసం సెంటిన్రీ లేదా డేటాడాగ్ వంటి దృఢమైన లాగింగ్ సిస్టమ్‌ను ఉపయోగించడాన్ని పరిగణించండి.

డేటాబేస్‌కు కనెక్ట్ అవ్వడం

API రూట్స్ కోసం అత్యంత సాధారణ వినియోగ సందర్భాలలో ఒకటి డేటాబేస్‌కు కనెక్ట్ అవ్వడం. Next.js API రూట్స్ వివిధ డేటాబేస్‌లతో సజావుగా అనుసంధానించబడతాయి, వీటితో సహా:

Next.js API రూట్‌లో MongoDB డేటాబేస్‌కు ఎలా కనెక్ట్ అవ్వాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:

// pages/api/mongodb.js
import { MongoClient } from 'mongodb'

const uri = process.env.MONGODB_URI
const options = {}

let client
let clientPromise

if (!process.env.MONGODB_URI) {
  throw new Error('Please add your Mongo URI to .env.local')
}

if (process.env.NODE_ENV === 'development') {
  // డెవలప్‌మెంట్ మోడ్‌లో, గ్లోబల్ వేరియబుల్‌ను ఉపయోగించండి, తద్వారా విలువ
  // HMR (హాట్ మాడ్యూల్ రీప్లేస్‌మెంట్) వలన కలిగే మాడ్యూల్ రీలోడ్‌ల అంతటా భద్రపరచబడుతుంది.
  if (!global._mongoClientPromise) {
    client = new MongoClient(uri, options)
    global._mongoClientPromise = client.connect()
  }
  clientPromise = global._mongoClientPromise
} else {
  // ప్రొడక్షన్ మోడ్‌లో, గ్లోబల్ వేరియబుల్‌ను ఉపయోగించకపోవడం ఉత్తమం.
  client = new MongoClient(uri, options)
  clientPromise = client.connect()
}

// మాడ్యూల్-స్కోప్డ్ MongoClient ప్రామిస్‌ను ఎగుమతి చేయండి. దీనిని ఒక
// ప్రత్యేక మాడ్యూల్‌లో చేయడం ద్వారా, క్లయింట్‌ను బహుళ ఫంక్షన్‌లలో సురక్షితంగా
// పునర్వినియోగించుకోవచ్చు. చూడండి: https://github.com/vercel/next.js/blob/canary/examples/with-mongodb/lib/mongodb.js
export default async function handler(req, res) {
  try {
    const client = await clientPromise
    const db = client.db(process.env.MONGODB_DB)
    const collection = db.collection('users')

    const users = await collection.find({}).toArray()

    res.status(200).json({ users })
  } catch (e) {
    console.error(e)
    res.status(500).json({ message: 'Failed to fetch users' })
  }
}

ఈ కోడ్‌ను అమలు చేయడానికి ముందు, మీరు mongodb ప్యాకేజీని ఇన్‌స్టాల్ చేశారని నిర్ధారించుకోండి:

npm install mongodb

మీరు MONGODB_URI మరియు MONGODB_DB ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌ను కూడా సెట్ చేయాలి. ఈ వేరియబుల్స్ మీ .env.local ఫైల్‌లో (లేదా ప్రొడక్షన్ కోసం మీ హోస్టింగ్ ప్రొవైడర్ యొక్క ఎన్విరాన్‌మెంట్ వేరియబుల్ సెట్టింగ్స్‌లో) నిర్వచించబడాలి. MONGODB_URI మీ MongoDB డేటాబేస్‌కు కనెక్షన్ స్ట్రింగ్‌ను కలిగి ఉంటుంది, మరియు MONGODB_DB డేటాబేస్ పేరును నిర్దేశిస్తుంది.

అథెంటికేషన్ మరియు ఆథరైజేషన్

భద్రత కోసం మీ API రూట్స్‌ను రక్షించడం చాలా ముఖ్యం. Next.js API రూట్స్‌ను వివిధ అథెంటికేషన్ మరియు ఆథరైజేషన్ టెక్నిక్‌లను ఉపయోగించి సురక్షితం చేయవచ్చు, వీటితో సహా:

JWT అథెంటికేషన్ ఉపయోగించి ఒక API రూట్‌ను ఎలా రక్షించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:

// pages/api/protected.js
import jwt from 'jsonwebtoken'

const secret = process.env.JWT_SECRET

export default function handler(req, res) {
  const token = req.headers.authorization?.split(' ')[1]

  if (!token) {
    return res.status(401).json({ message: 'Unauthorized' })
  }

  try {
    const decoded = jwt.verify(token, secret)
    // "decoded" ఆబ్జెక్ట్ టోకెన్‌లో పొందుపరచబడిన వినియోగదారు సమాచారాన్ని కలిగి ఉంటుంది
    // ఉదాహరణకు: const userId = decoded.userId;

    // అభ్యర్థనను ప్రాసెస్ చేయడం కొనసాగించండి
    res.status(200).json({ message: 'Protected resource accessed successfully' })
  } catch (error) {
    return res.status(401).json({ message: 'Invalid token' })
  }
}

ఈ కోడ్‌ను అమలు చేయడానికి ముందు, మీరు jsonwebtoken ప్యాకేజీని ఇన్‌స్టాల్ చేశారని నిర్ధారించుకోండి:

npm install jsonwebtoken

మీరు JWT_SECRET ఎన్విరాన్‌మెంట్ వేరియబుల్‌ను కూడా సెట్ చేయాలి. ఇది JWTలను సంతకం చేయడానికి మరియు ధృవీకరించడానికి ఉపయోగించే ఒక బలమైన, యాదృచ్ఛికంగా ఉత్పత్తి చేయబడిన రహస్య కీ అయి ఉండాలి. దీనిని సురక్షితంగా నిల్వ చేయండి మరియు మీ క్లయింట్-సైడ్ కోడ్‌లో ఎప్పుడూ బహిర్గతం చేయవద్దు.

మిడిల్‌వేర్

Next.js, Express.js లాగా API రూట్స్ కోసం సాంప్రదాయ మిడిల్‌వేర్‌ను అందించనప్పటికీ, మీరు మీ API రూట్ హ్యాండ్లర్‌లను పునర్వినియోగ ఫంక్షన్‌లతో చుట్టడం ద్వారా ఇలాంటి కార్యాచరణను సాధించవచ్చు. ఇది వంటి పనులను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:

ఒక సాధారణ లాగింగ్ మిడిల్‌వేర్‌ను ఎలా సృష్టించాలో ఇక్కడ ఒక ఉదాహరణ ఉంది:

// utils/middleware.js
export function withLogging(handler) {
  return async function(req, res) {
    console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`)
    return handler(req, res)
  }
}

ఈ మిడిల్‌వేర్‌ను ఉపయోగించడానికి, మీ API రూట్ హ్యాండ్లర్‌ను withLogging ఫంక్షన్‌తో చుట్టండి:

// pages/api/logged.js
import { withLogging } from '../../utils/middleware'

async function handler(req, res) {
  res.status(200).json({ message: 'This request was logged' })
}

export default withLogging(handler)

Next.js API రూట్స్ నిర్మించడానికి ఉత్తమ పద్ధతులు

అధునాతన టెక్నిక్‌లు

బ్యాక్‌గ్రౌండ్ జాబ్స్

API ప్రతిస్పందనను బ్లాక్ చేయకూడని దీర్ఘకాలిక పనుల కోసం, బ్యాక్‌గ్రౌండ్ జాబ్స్‌ను ఉపయోగించడాన్ని పరిగణించండి. మీ బ్యాక్‌గ్రౌండ్ జాబ్స్‌ను నిర్వహించడానికి మరియు వాటిని అసమకాలికంగా ప్రాసెస్ చేయడానికి మీరు BullMQ లేదా Bree వంటి లైబ్రరీలను ఉపయోగించవచ్చు.

వెబ్‌సాకెట్స్

రియల్-టైమ్ అప్లికేషన్‌ల కోసం, మీరు మీ Next.js API రూట్స్‌లో వెబ్‌సాకెట్స్‌ను ఉపయోగించవచ్చు. Socket.IO మరియు ws వంటి లైబ్రరీలు క్లయింట్ మరియు సర్వర్ మధ్య నిరంతర కనెక్షన్‌లను స్థాపించడాన్ని సులభతరం చేస్తాయి.

GraphQL

మీకు డేటాను పొందడానికి మరింత ఫ్లెక్సిబుల్ మరియు సమర్థవంతమైన మార్గం అవసరమైతే, GraphQLను ఉపయోగించడాన్ని పరిగణించండి. మీ Next.js అప్లికేషన్‌లో GraphQL API ఎండ్‌పాయింట్‌ను సృష్టించడానికి మీరు అపోలో సర్వర్ లేదా యోగా వంటి లైబ్రరీలను ఉపయోగించవచ్చు.

ముగింపు

Next.js API రూట్స్ మీ Next.js అప్లికేషన్‌లోనే నేరుగా సర్వర్‌లెస్ బ్యాకెండ్‌లను నిర్మించడానికి ఒక శక్తివంతమైన మరియు అనుకూలమైన మార్గాన్ని అందిస్తాయి. సర్వర్‌లెస్ ఆర్కిటెక్చర్ యొక్క ప్రయోజనాలను ఉపయోగించుకోవడం ద్వారా, మీరు డెవలప్‌మెంట్‌ను సులభతరం చేయవచ్చు, పనితీరును మెరుగుపరచవచ్చు మరియు ఖర్చులను తగ్గించవచ్చు. మీరు ఒక సాధారణ కాంటాక్ట్ ఫారమ్‌ను నిర్మిస్తున్నా లేదా సంక్లిష్టమైన ఇ-కామర్స్ ప్లాట్‌ఫారమ్‌ను నిర్మిస్తున్నా, Next.js API రూట్స్ మీకు సులభంగా ఒక దృఢమైన మరియు స్కేలబుల్ బ్యాకెండ్‌ను సృష్టించడానికి సహాయపడతాయి. ప్రాథమిక అంశాలపై గట్టి అవగాహనతో మరియు ఉత్తమ పద్ధతులను వర్తింపజేయడంతో, మీరు ఈ శక్తివంతమైన సాధనాన్ని సమర్థవంతమైన, సురక్షితమైన మరియు ప్రపంచవ్యాప్తంగా అందుబాటులో ఉండే అప్లికేషన్‌లను సృష్టించడానికి ఉపయోగించుకోవచ్చు.