मुझे एडब्ल्यूएस लैम्ब्डा फ़ंक्शन से रेडिस इंस्टेंस से कैसे जुड़ना चाहिए?

मैंने अब अपनी समस्या स्वयं हल कर ली है, और मुझे आशा है कि मैं भविष्य में इस समस्या का सामना करने वाले किसी व्यक्ति की सहायता कर सकूंगा।

डेटाबेस से कनेक्ट करते समय दो प्रमुख विचार हैं जैसे मैंने लैम्ब्डा फ़ंक्शन से उपरोक्त कोड में किया था:

1. एक बार context.succeed() , context.fail() , या context.done() कहा जाता है, AWS ऐसी किसी भी प्रक्रिया को फ़्रीज़ कर सकता है जो अभी तक समाप्त नहीं हुई है। यही कारण है कि एडब्ल्यूएस लॉग इन कर रहा था Connection closed मेरे एपीआई एंडपॉइंट पर दूसरी कॉल पर- रेडिस के बंद होने से ठीक पहले प्रक्रिया को फ्रीज कर दिया गया था, फिर अगली कॉल पर पिघलाया गया, जिस बिंदु पर यह वहीं जारी रहा, जहां उसने छोड़ा था, यह रिपोर्ट करते हुए कि कनेक्शन बंद था। टेकअवे:यदि आप अपना डेटाबेस कनेक्शन बंद करना चाहते हैं, तो सुनिश्चित करें कि यह पहले . पूरी तरह से बंद है आप उन तरीकों में से एक कहते हैं। आप किसी ईवेंट हैंडलर में कॉलबैक डालकर ऐसा कर सकते हैं जो एक कनेक्शन बंद होने से ट्रिगर होता है (.on('end') , मेरे मामले में)।
2. यदि आप अपने कोड को अलग-अलग फाइलों में विभाजित करते हैं और require उन्हें प्रत्येक फ़ाइल के शीर्ष पर, जैसे मैंने किया, अमेज़ॅन स्मृति में जितना संभव हो उतने मॉड्यूल को कैश करेगा। यदि इससे समस्या हो रही है, तो require() . को स्थानांतरित करने का प्रयास करें फ़ाइल के शीर्ष के बजाय किसी फ़ंक्शन के अंदर कॉल करता है, फिर उस फ़ंक्शन को निर्यात करता है। जब भी फ़ंक्शन चलाया जाएगा तब उन मॉड्यूल को फिर से आयात किया जाएगा।

यहाँ मेरा अद्यतन कोड है। ध्यान दें कि मैंने अपनी रेडिस कॉन्फ़िगरेशन को एक अलग फ़ाइल में भी रखा है, ताकि मैं कोड को डुप्लिकेट किए बिना इसे अन्य लैम्ब्डा फ़ंक्शंस में आयात कर सकूं।

ईवेंट हैंडलर

'use strict'

const lib = require('../lib/related')

module.exports.handler = function (event, context) {
  lib.respond(event, (err, res) => {
    if (err) {
      return context.fail(err)
    } else {
      return context.succeed(res)
    }
  })
}

Redis कॉन्फ़िगरेशन

module.exports = () => {
  const redis = require('redis')
  const jsonify = require('redis-jsonify')
  const redisOptions = {
    host: process.env.REDIS_URL,
    port: process.env.REDIS_PORT,
    password: process.env.REDIS_PASS
  }

  return jsonify(redis.createClient(redisOptions))
}

कार्य

'use strict'

const rt = require('./ritetag')

module.exports.respond = function (event, callback) {
  const redis = require('./redis')()

  const tag = event.hashtag.replace(/^#/, '')
  const key = 'related:' + tag
  let error, response

  redis.on('end', () => {
    callback(error, response)
  })

  redis.on('ready', function () {
    redis.get(key, (err, res) => {
      if (err) {
        redis.quit(() => {
          error = err
        })
      } else {
        if (res) {
          // Tag is found in Redis, so send results directly.
          redis.quit(() => {
            response = res
          })
        } else {
          // Tag is not yet in Redis, so query Ritetag.
          rt.hashtagDirectory(tag, (err, res) => {
            if (err) {
              redis.quit(() => {
                error = err
              })
            } else {
              redis.set(key, res, (err) => {
                if (err) {
                  redis.quit(() => {
                    error = err
                  })
                } else {
                  redis.quit(() => {
                    response = res
                  })
                }
              })
            }
          })
        }
      }
    })
  })
}

यह ठीक उसी तरह काम करता है जैसे इसे करना चाहिए—और यह बहुत तेज़ भी हो रहा है।