கினிசிஸ் ஸ்ட்ரீமில் பதிவுகளைச் சேர்க்கும்போது AWS லாம்ப்டா காலாவதி சிக்கல்களைச் சரிசெய்தல்

கினெசிஸ் டேட்டா ஸ்ட்ரீம்களுக்கான AWS லாம்ப்டா காலக்கெடுவை சரிசெய்தல்

SQS இலிருந்து லாம்ப்டா செயல்பாட்டிற்கு செய்திகளை அனுப்பும் அமைப்புடன், AWS இல் நிகழ்நேர தரவு பைப்லைனை நீங்கள் உருவாக்குகிறீர்கள் என்று கற்பனை செய்து பாருங்கள். 📨 இந்த ஓட்டம் கோட்பாட்டில் தடையின்றி செயல்படுகிறது, ஆனால் சில சமயங்களில் உண்மை வேறு திட்டங்களைக் கொண்டுள்ளது. நீங்கள் ஓய்வெடுக்கத் தொடங்கும் போது, ​​உங்கள் லாம்ப்டா செயல்பாட்டுப் பதிவுகளில் ETIMEDOUT பிழை தோன்றும்.

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

இதுபோன்ற சூழ்நிலைகளில், பல டெவலப்பர்கள் "Runtime.UnhandledPromiseRejection" மற்றும் "ERR_HTTP2_STREAM_CANCEL" போன்ற ரகசிய செய்திகளால் தடுமாறியுள்ளனர். சாலை தடுப்பு.

இந்த காலக்கெடுவுக்கு என்ன காரணம், அவற்றைக் கையாளுவதற்கான நடைமுறை வழிகள் மற்றும் உங்கள் ஸ்ட்ரீமை உறுதிப்படுத்துவதற்கான திறவுகோலாக இருக்கும் AWS உள்ளமைவில் உள்ள சரிசெய்தல் ஆகியவற்றைப் பற்றி இங்கே பார்ப்போம். 🛠️ இறுதியில், ETIMEDOUT பிழைகளை எவ்வாறு சரிசெய்தல் மற்றும் சரிசெய்வது மற்றும் உங்கள் Lambda மற்றும் Kinesis ஓட்டம் சீராக இயங்குவது எப்படி என்பதை நீங்கள் அறிவீர்கள்.

கினிசிஸ் ஸ்ட்ரீம் மூலம் AWS லாம்ப்டா நம்பகத்தன்மையை மேம்படுத்துதல்

வழங்கப்பட்ட ஜாவாஸ்கிரிப்ட் ஸ்கிரிப்ட்கள் ஒரு திறமையான AWS லாம்ப்டா செயல்பாட்டை உருவாக்க வடிவமைக்கப்பட்டுள்ளன, இது SQS வரிசையில் இருந்து செய்திகளை மீட்டெடுக்கிறது, பின்னர் அவற்றை Amazon Kinesis டேட்டா ஸ்ட்ரீமில் வெளியிடுகிறது. இந்த தீர்வின் மையமானது, அடிக்கடி ஏற்படும் இணைப்புச் சிக்கல்களைத் தீர்க்கும் போது, ​​செய்திகளை ஒத்திசைவற்ற முறையில் கையாளும் Lambda செயல்பாட்டின் திறனில் உள்ளது. ETIMEDOUT பிழைகள். ஸ்கிரிப்ட்டின் ஒரு முக்கிய பகுதியின் துவக்கம் ஆகும் KinesisClient, இது பிராந்தியம், மறுமுயற்சி எண்ணிக்கை மற்றும் இணைப்பு காலாவதி போன்ற அத்தியாவசிய பண்புகளை உள்ளமைக்கிறது. இந்த உள்ளமைவுகள் மேகக்கணி அமைப்பில் முக்கியமானவை, ஏனெனில் அவை பயன்பாட்டின் வினைத்திறனைக் கட்டுப்படுத்துகின்றன மற்றும் நேரம் முடிவதற்கு முன்பு எவ்வளவு நேரம் இணைக்க முயற்சிக்கும். உயர்வை அமைப்பதன் மூலம் இணைப்பு நேரம் முடிந்தது அல்லது மறுமுயற்சி முயற்சிகளை சரிசெய்தல், செயல்பாடு நெட்வொர்க் தாமதங்களை மிகவும் திறம்பட கையாள உதவும்.

லாம்ப்டா ஹேண்ட்லருக்குள், ஸ்கிரிப்ட் பலப்படுத்துகிறது Promise.allSettled(), பல ஒத்திசைவற்ற கோரிக்கைகளை செயலாக்கும் போது ஒரு விலைமதிப்பற்ற கருவி. பல பதிவுகள் ஒரே நேரத்தில் செயலாக்கப்படும் போது, ​​ஒவ்வொன்றும் வெற்றிகரமாக அல்லது பிழையுடன் முடிவடைவதை உறுதி செய்வது அவசியம். Promise.allSettled() ஒரு கோரிக்கை தோல்வியுற்றால் செயல்பாடு செயலாக்கத்தை நிறுத்தாது என்பதை உறுதி செய்கிறது; மாறாக, அது ஒவ்வொரு முடிவையும் தனித்தனியாக பதிவு செய்கிறது. நெட்வொர்க் இணைப்பு கணிக்க முடியாத சூழ்நிலைகளில் இந்த அணுகுமுறை மிகவும் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, நெட்வொர்க் சிக்கலால் ஒரு பதிவு தோல்வியடைந்தாலும் மற்றவை வெற்றியடைந்தால், செயல்பாடு தோல்வியுற்ற பதிவுகளைத் தனித்தனியாகப் பதிவுசெய்யும், டெவலப்பர்கள் முழுச் செய்திகளையும் தோல்வியடைவதற்குப் பதிலாக சிக்கல் நிகழ்வுகளைத் தனிமைப்படுத்த அனுமதிக்கிறது. 🛠️

தி செயல்முறை நிகழ்வு ஸ்கிரிப்ட்டின் செயல்பாடு மட்டு மற்றும் முக்கிய தரவு மாற்றம் மற்றும் அனுப்பும் செயல்முறையை கையாளுகிறது. இந்த செயல்பாடு SQS செய்தியை எடுத்து, அதை பாகுபடுத்தி, Kinesis தேவைப்படும் பைட் வடிவத்தில் குறியாக்கம் செய்கிறது. இங்கே, தி TextEncoder().encode() கினேசிஸ் பைனரி தரவை மட்டுமே ஏற்றுக்கொள்வதால் முறை மிகவும் முக்கியமானது; JSON இணக்கமான வடிவமைப்பிற்கு மாற்றப்பட வேண்டும். செயல்பாட்டின் இந்த பகுதியானது, லாம்ப்டா தரவை சரியாக அனுப்புவதை உறுதிசெய்கிறது, இது பொருந்தாத தரவு வடிவங்களில் இருந்து எழும் பிழைகளின் வாய்ப்பைக் குறைக்கிறது. இந்த செயல்பாடு தனிப்பயன் பகிர்வு விசை ஜெனரேட்டர் செயல்பாட்டையும் பயன்படுத்துகிறது, இது கினிசிஸ் ஸ்ட்ரீமின் துண்டுகள் முழுவதும் பதிவுகளை விநியோகிக்கும். டைனமிக் பகிர்வு விசைகளைப் பயன்படுத்துவதன் மூலம் (சீரற்ற விசைகள் போன்றவை), ஸ்கிரிப்ட் ஒரே ஷார்ட்டை மீண்டும் மீண்டும் அடிக்கும் வாய்ப்புகளை குறைக்கிறது, இது இடையூறுகளுக்கு வழிவகுக்கும் "ஹாட் ஷார்ட்களை" தடுக்கலாம்.

கடைசியாக, பல்வேறு சூழ்நிலைகளில் இந்த அமைப்பு சரியாகச் செயல்படுவதை உறுதிசெய்ய, ஸ்கிரிப்ட்கள் இணைக்கப்படுகின்றன அலகு சோதனைகள் ஜெஸ்ட்டைப் பயன்படுத்துகிறது. யூனிட் சோதனைகள் நேரடி AWS ஆதாரங்கள் தேவையில்லாமல் கினிசிஸ் கிளையண்டின் நடத்தையை உருவகப்படுத்துவதை சாத்தியமாக்குகிறது, கட்டுப்படுத்தப்பட்ட சூழலில் காலக்கெடு அல்லது தரவு மாற்ற சிக்கல்களைக் கையாளும் லாம்ப்டாவின் திறனை சோதிக்க நம்பகமான வழியை வழங்குகிறது. உதாரணமாக, Kinesis கிளையண்ட் இணைக்க முடியவில்லை என்றால், Jest mocks ஒரு காலக்கெடு பிழையை உருவகப்படுத்தலாம், இது பிழை கையாள்வதை சரிபார்க்கிறது. செயல்முறை நிகழ்வு திட்டமிட்டபடி செயல்படுகிறது. இந்த மூலோபாயம் வலுவான சரிபார்ப்பை அனுமதிக்கிறது, பல நெட்வொர்க் நிலைகளில் லாம்ப்டா நம்பகமானதாக இருப்பதை உறுதி செய்கிறது. 🧪 இந்த உறுப்புகளுடன் இணைந்து, லாம்ப்டா செயல்பாடு SQS முதல் கினேசிஸ் வரையிலான தரவை திறமையாக கையாளும் அதே வேளையில் காலக்கெடு மற்றும் பிற பொதுவான ஸ்ட்ரீமிங் பிழைகளைக் குறைக்கும்.

import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis";
const KINESIS_CLIENT = new KinesisClient({
  region: 'us-west-2',
  maxRetries: 3,
  requestHandler: {
    connectionTimeout: 5000, // Lower timeout for quicker retries
  },
});
export const handler = async (event) => {
  const promises = event.Records.map(record => processEvent(record.body));
  const results = await Promise.allSettled(promises);
  results.forEach(result => {
    if (result.status !== "fulfilled") {
      console.error("Failed:", result.reason);
    }
  });
};
async function processEvent(body) {
  const data = JSON.parse(body);
  const partitionKey = generatePartitionKey(data);
  const encodedData = new TextEncoder().encode(JSON.stringify(data));
  try {
    await KINESIS_CLIENT.send(new PutRecordCommand({
      Data: encodedData,
      StreamName: 'InputEventStream',
      PartitionKey: partitionKey
    }));
  } catch (error) {
    console.error("Error putting record:", error);
    throw error;
  }
}
function generatePartitionKey(data) {
  return data.userId ? data.userId.toString() : Date.now().toString();
}

import { KinesisClient, PutRecordCommand } from "@aws-sdk/client-kinesis";
const KINESIS_CLIENT = new KinesisClient({
  region: 'us-west-2',
  maxRetries: 5,
  httpOptions: {
    connectTimeout: 15000, // Extended timeout
    timeout: 20000 // Total request timeout
  }
});
export const handler = async (event) => {
  const results = await Promise.allSettled(event.Records.map(async (record) => {
    await processEvent(record.body);
  }));
  results.forEach((result) => {
    if (result.status !== "fulfilled") {
      console.log("Unsuccessful attempt:", result.reason);
    }
  });
};
async function processEvent(body) {
  const parsedData = JSON.parse(body);
  const partitionKey = `pk-${Math.random()}`;
  try {
    await KINESIS_CLIENT.send(new PutRecordCommand({
      StreamName: "InputEventStream",
      Data: new TextEncoder().encode(JSON.stringify(parsedData)),
      PartitionKey: partitionKey
    }));
  } catch (err) {
    if (err.name === "TimeoutError") {
      console.warn("Retry on timeout:", err);
    }
    throw err;
  }
}

import { handler, processEvent } from './your-lambda-file.js';
import { KinesisClient } from "@aws-sdk/client-kinesis";
jest.mock("@aws-sdk/client-kinesis");
describe('Lambda Handler and Kinesis Integration', () => {
  it('should call processEvent for each record in the event', async () => {
    const mockEvent = {
      Records: [{ body: '{"userId": 1, "data": "test"}' }]
    };
    await handler(mockEvent);
    expect(KinesisClient.prototype.send).toHaveBeenCalledTimes(1);
  });
  it('should handle timeout errors gracefully', async () => {
    KinesisClient.prototype.send.mockRejectedValueOnce(new Error('TimeoutError'));
    await expect(processEvent('{"userId": 2}')).rejects.toThrow('TimeoutError');
  });
});

AWS லாம்ப்டா-கினிசிஸ் ஒருங்கிணைப்புகளில் காலக்கெடு பிழைகளைப் புரிந்துகொள்வது

போன்ற காலக்கெடு பிழைகள் ETIMEDOUT AWS இல் லாம்ப்டா செயல்பாடுகள் பெரும்பாலும் வெறுப்பாக இருக்கலாம், குறிப்பாக அமேசான் கினிசிஸ் உடன் தரவு ஸ்ட்ரீமிங் சம்பந்தப்பட்ட ஒருங்கிணைப்புகளில். பெரும்பாலான சந்தர்ப்பங்களில், நெட்வொர்க் இணைப்பு நேர வரம்புகளை மீறும் Lambda செயல்பாடு காரணமாக இந்த பிழைகள் ஏற்படுகின்றன, பொதுவாக a KinesisClient கோரிக்கை. லாம்ப்டாவில் உள்ள இயல்புநிலை அமைப்புகள் எப்போதும் இந்த வகையான நெட்வொர்க் கோரிக்கைகளுக்கு இடமளிக்காது, குறிப்பாக உயர்-செயல்திறன் ஸ்ட்ரீம்கள் அல்லது பெரிய அளவிலான தரவைக் கையாளும் போது. உதாரணமாக, சரிசெய்தல் connectTimeout அல்லது maxRetries உள்ளமைவுகள் இந்தச் சிக்கலைத் தணிக்க உதவும், இது லாம்ப்டாவை கினேசிஸுடன் வெற்றிகரமாக இணைக்க முயற்சி செய்ய அதிக நேரத்தை அனுமதிக்கிறது. மாறி நெட்வொர்க் தாமதம் அல்லது அதிக தேவையின் கீழ் உள்ள சூழ்நிலைகளில் இந்த வகையான தேர்வுமுறை பெரும்பாலும் அவசியம். 🛠️

காலாவதி பிழைகளைக் குறைப்பதில் மற்றொரு முக்கிய அம்சம் தரவு குறியாக்கம் மற்றும் பகிர்வை திறம்பட நிர்வகிப்பது. AWS Kinesis க்கு பைனரி வடிவத்தில் தரவு தேவைப்படுகிறது, இதன் மூலம் அடைய முடியும் TextEncoder().encode(). இந்த மாற்றம் கினேசிஸுக்கு தரவு பரிமாற்றத்தின் இணக்கத்தன்மை மற்றும் நெறிப்படுத்தலை உறுதி செய்கிறது. கூடுதலாக, சிந்தனையான பகிர்வு முக்கிய மேலாண்மை முக்கியமானது. சீரான அல்லது மாறும் வகையில் உருவாக்கப்பட்ட பகிர்வு விசையைப் பயன்படுத்துவது கினசிஸ் ஷார்ட்ஸ் முழுவதும் தரவை சமமாக விநியோகிக்க உதவுகிறது, "ஹாட் ஷார்ட்களை" தவிர்க்கிறது, அவை விகிதாசார எண்ணிக்கையில் பதிவுகளை பெறும் துண்டுகளாகும். உயர் அதிர்வெண் ஸ்ட்ரீமிங் காட்சிகளில், டைனமிக் விசைகள் இடையூறுகளைத் தடுக்கலாம் மற்றும் இணைப்பு சிக்கல்களின் நிகழ்தகவைக் குறைக்கலாம், குறிப்பாக பெரிய தரவுத்தொகுப்புகளைக் கையாளும் போது பயனுள்ளதாக இருக்கும்.

இந்த Lambda-Kinesis தொடர்புகளின் நம்பகத்தன்மையை சரிசெய்து மேம்படுத்த, அலகு சோதனைகளைச் சேர்ப்பது அவசியம். யூனிட் சோதனைகள் சாத்தியமான நெட்வொர்க் சிக்கல்களை உருவகப்படுத்தவும், தரவு குறியாக்கத்தை சரிபார்க்கவும் மற்றும் செயல்பாடு மறுமுயற்சிகளைச் சரியாகக் கையாளும் என்பதை உறுதிப்படுத்தவும் உங்களை அனுமதிக்கின்றன. உதாரணமாக, கேலி செய்வதன் மூலம் KinesisClient அலகு சோதனைகளில், நீங்கள் Kinesis இலிருந்து பலவிதமான பதில்களை உருவகப்படுத்தலாம் நேரம் முடிந்தது பிழைகள் அல்லது வெற்றி வழக்குகள், இது லாம்ப்டா குறியீட்டிற்குள் பிழை கையாளுதல் மற்றும் இணைப்பு மேலாண்மை ஆகியவற்றை நன்றாகச் சரிசெய்ய உதவுகிறது. வளர்ச்சியில் இதுபோன்ற பிழை நிகழ்வுகளைச் சோதிப்பது மிகவும் நெகிழ்வான வரிசைப்படுத்தலுக்கு வழிவகுக்கும், உற்பத்தியில் நேரம் முடிவடையும் வாய்ப்பைக் குறைக்கிறது மற்றும் உங்கள் உள்ளமைவில் பலவீனமான புள்ளிகளைக் கண்டறிவதை எளிதாக்குகிறது.