Redis Node.js இல் பிழைகளைக் கையாளுதல் மற்றும் சரிசெய்தல்

NodeJS ஒரு பயன்பாட்டில் ஒருங்கிணைக்கும்போது பிழைகளை சரிசெய்தல் மற்றும் கையாளுதல் Redis என்பது பயன்பாட்டின் நிலைத்தன்மை மற்றும் செயல்திறனை உறுதி செய்வதற்கான இன்றியமையாத செயலாகும்.

Redis ஒரு பயன்பாட்டில் பணிபுரியும் போது சரிசெய்தல் மற்றும் பிழை கையாளுதல் ஆகியவற்றை எவ்வாறு செய்வது என்பது பற்றிய சில விவரங்கள் மற்றும் எடுத்துக்காட்டுகள் கீழே உள்ளன NodeJS.

காண்க Redis log

Redis முக்கியமான நிகழ்வுகள், எச்சரிக்கைகள் மற்றும் பிழைகளை பதிவு செய்ய பதிவுகளை வழங்குகிறது. இந்த பதிவுகள், உடன் சிக்கல்களைத் தீர்க்க பயனுள்ளதாக இருக்கும் Redis. உள்நுழைவை இயக்க Redis, நீங்கள் உள்ளமைவு கோப்பை மாற்ற வேண்டும் redis.conf மற்றும் பொருத்தமான பதிவு நிலை அமைக்க வேண்டும்.

ஒரு கோப்பில் உள்நுழைவதை இயக்குவதற்கான எடுத்துக்காட்டு இங்கே:

# In redis.conf  
logfile /var/log/redis/redis.log  
loglevel verbose  

log கோப்பு அடைவு உள்ளது மற்றும் செயல்முறை மூலம் எழுதக்கூடியது என்பதை உறுதிப்படுத்தவும் Redis.

பயன்படுத்தவும் Redis Monitor

Redis Monitor Redis சர்வரில் செயல்படுத்தப்படும் நிகழ்நேர கட்டளைகளை கண்காணிக்க உங்களை அனுமதிக்கும் உள்ளமைக்கப்பட்ட கட்டளை. க்கு அனுப்பப்படும் உண்மையான கட்டளைகளைப் புரிந்துகொள்ள இது உதவியாக இருக்கும் Redis.

Redis Monitor பயன்பாட்டில் "ioredis" நூலகத்தைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே NodeJS:

const Redis = require('ioredis');  
const redis = new Redis();  
  
redis.monitor((err, monitor) => {  
  console.log('Started monitoring Redis commands');  
  monitor.on('monitor',(time, args, source, database) => {  
    console.log('Command:', args);  
  });  
});  

இந்த குறியீடு சர்வரால் பெறப்பட்ட ஒவ்வொரு கட்டளையையும் நிகழ்நேரத்தில் Redis அச்சிடும் மானிட்டரை அமைக்கிறது. Redis

ஒத்திசைவற்ற பிழைகளைக் கையாளவும்

Redis ஒரு பயன்பாட்டில் பணிபுரியும் போது NodeJS, ​​பல Redis செயல்பாடுகள் ஒத்திசைவற்றவை, அதாவது அவை பயன்படுத்தும் callback அல்லது Promises.

செயலிழப்பைத் தவிர்க்க, பிழைகளைச் சரியாகக் கையாள்வது முக்கியம். பிழைகளைக் கையாள்வதற்கான எடுத்துக்காட்டு இங்கே callback:

const Redis = require('ioredis');  
const redis = new Redis();  
  
redis.get('key',(err, result) => {  
  if(err) {  
    console.error('Error:', err);  
    return;  
  }  
  console.log('Result:', result);  
});  

மற்றும் async/await பயன்படுத்தி Promises:

const Redis = require('ioredis');  
const redis = new Redis();  
  
async function getValue() {  
  try {  
    const result = await redis.get('key');  
    console.log('Result:', result);  
  } catch(err) {  
    console.error('Error:', err);  
  }  
}  
  
getValue();  

Redis இணைப்புகளை நிர்வகிக்கவும்

இணைப்புகளை நிர்வகிக்க Redis, கிளையன்ட் லைப்ரரி வழங்கிய இணைப்புக் குளத்தைப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது Redis. எடுத்துக்காட்டாக, "ioredis" உடன்:

const Redis = require('ioredis');  
const redis = new Redis({  
  // connection options here  
});  

கிளையன்ட் தானாகவே இணைப்புகளை நிர்வகித்து அவற்றை திறமையாக மீண்டும் பயன்படுத்துவார்.

வழக்குகள் Redis கிடைக்காத போது கையாளவும்

Redis கிடைக்காத அல்லது மெதுவாகப் பதிலளிக்கும் போது வழக்குகளைக் கையாள, பொருத்தமான காலக்கெடுவை அமைத்து, இணைப்புப் பிழைகளை அழகாகக் கையாளவும்.

const Redis = require('ioredis');  
const redis = new Redis({  
  retryStrategy:(times) => {  
    return Math.min(times * 50, 2000); // Retry with exponential backoff up to 2 seconds  
  },  
});  

பயன்படுத்தவும் Redis Sentinel

Redis Sentinel க்ளஸ்டர்களுக்கு அதிக இருப்பு மற்றும் கண்காணிப்பை வழங்குகிறது Redis. முதன்மை முனை கிடைக்காதபோது அது தானாகவே தோல்விகளைக் கையாளுகிறது.

இங்கே ஒரு எடுத்துக்காட்டு உள்ளமைவு:

sentinel monitor mymaster 127.0.0.1 6379 2  
sentinel down-after-milliseconds mymaster 5000  
sentinel failover-timeout my  

மேலே உள்ள உள்ளமைவு, 5000மி.ஸின் கீழ்-மில்லி விநாடிகள் த்ரெஷோல்ட், 10000எம்.எஸ் தோல்வி-நேரம் மற்றும் 1 இணையான ஒத்திசைவு ஆகியவற்றைக் கொண்ட ஒரு மாஸ்டரைக் Redis Sentinel கண்காணிக்கும். Redis

இந்தப் படிகள் மற்றும் எடுத்துக்காட்டுகளைப் பின்பற்றுவதன் மூலம், உங்கள் பயன்பாட்டின் நம்பகத்தன்மையையும் செயல்திறனையும் உறுதிசெய்து, Redis ஒரு பயன்பாட்டில் பணிபுரியும் போது பிழைகளைச் சரிசெய்து கையாளலாம். NodeJS