Knex: AWS लैम्ब्डा के साथ Knex का उपयोग कैसे करूँ?

कनेक्स पूलिंग केवल तभी काम करती है जब कनेक्शन एक ही नोड प्रक्रिया से किए जाते हैं।

यदि AWS लैंबडा इंस्टेंसेस साझा नोड प्रक्रिया नहीं चला रहे हैं, तो आपको प्रत्येक लैम्ब्डा उदाहरण में मिनट / अधिकतम कनेक्शन 1 के साथ नया पूल बनाना होगा और आशा है कि आपके डेटाबेस में सैकड़ों युगपत कनेक्शन (आरडीएस में) की अनुमति देने के लिए पर्याप्त सेटिंग्स हैं, जो उदाहरण के आकार पर निर्भर करता है ) है।

इसे पढ़ने के बाद https://forums.aws.amazon.com/thread.jspa?threadID=216000

लगता है कि लैम्ब्डा वास्तव में कुछ प्रक्रियाओं को साझा कर रहा है, इसलिए यदि आप यह पता लगा सकते हैं कि लैम्ब्डा कंटेनरों की अधिकतम गिनती क्या है, तो यह बनाया जाता है कि आपको इष्टतम पूल आकार की गणना करने में सक्षम होना चाहिए (प्रत्येक कंटेनर में उनका अलग पूल है इसलिए डीबी के लिए कुल कनेक्शन पूल है। अधिकतम * अधिकतम कंटेनर गणना)।

वैसे भी पूल से रिक्वेस्ट करने के लिए मैनुअल कनेक्शन की जरूरत नहीं होती है, क्नेक्स अपने आप कनेक्शन के लिए इंतजार करता है और अगर कुछ ही सेकंड में सब कुछ खत्म हो जाता है, तो उस समय कोई भी टाइमआउट ट्रिगर नहीं होगा।

यदि आपको DB से त्रुटि मिल रही है जो कहती है कि अधिकतम कनेक्शन की गिनती हो गई है, तो आपको अधिकतम पूल का आकार छोटा करने की आवश्यकता है।

क्षमा करें, मैंने एक वाक्य के बीच में प्रतिबद्ध किया, मेरे बच्चे ने फर्श पर 3 लीटर पानी की तरह फेंक दिया: 1st_place_medal: मैं एक पल में ऊपर टिप्पणी को अपडेट करूंगा ...

उत्तर के लिए धन्यवाद। ऐसा लगता है कि अधिकतम पूल आकार का अनुमान लगाना मेरा सबसे अच्छा दांव होगा, भले ही समय के साथ कनेक्शन की संख्या में भारी अंतर होगा।

स्पष्ट होने के लिए, क्नेक्स में कनेक्शन बंद करने का कोई तरीका नहीं है, सही है? केवल एक कनेक्शन पूल को नष्ट करने की क्षमता? तथ्य यह है कि लैंबडा कभी-कभी हर तरह के फेंके हुए कंटेनरों का पुन: उपयोग करता है।

कनेक्शन पूल को नष्ट करना भी सभी कनेक्शनों को नष्ट कर देता है (शालीनता से प्रतीक्षा करना कि वे पहले पूरा करते हैं) और मुझे लगता है कि जब लैम्ब्डा कंटेनर को नष्ट कर देता है, तो प्रक्रिया के मरने पर इसके सभी खुले टीसीपी सॉकेट लगभग बंद हो जाएंगे।

मैं यह नहीं देखता कि क्यों प्रत्येक अनुरोध के बाद कनेक्शन को स्पष्ट रूप से बंद करने की कोशिश करनी चाहिए क्योंकि यह पूलिंग के लाभ को नष्ट कर देगा। आपको आकार 1 के साथ पूल बनाने और बाद में इसे नष्ट करने से समान प्रभाव मिलेगा।

आप पूल के लिए निष्क्रिय टाइमआउट भी कॉन्फ़िगर कर सकते हैं जो स्वचालित रूप से कनेक्शन बंद कर देगा यदि इसका उपयोग नहीं किया गया है और पूल में कार्रवाई का इंतजार कर रहा है।

क्या मैं Knex का उपयोग RedShift क्लस्टर में COPY क्वेरी भेजने के लिए कर सकता हूं, और परिणामों की प्रतीक्षा नहीं कर सकता?

Pg पूल के साथ ऐसा करने से लैम्बडा फ़ंक्शन के अंत तक पहुँचते ही क्वेरी समाप्त हो जाती है।

@BardiaAfshin अगर लैम्ब्डा कंटेनर को नष्ट कर दिया जाता है और लैम्ब्डा फ़ंक्शन के अंत तक पहुंचने पर इसकी सभी सॉकेट्स को मुक्त कर दिया जाता है, तो उस स्थिति में भी डीबी क्वेरी मर जाएगी और समाप्त नहीं हो सकती है।

मुझे यकीन है कि या तो पोस्टग्रैक्स्ल क्लाइंट-साइड कनेक्शन को समाप्त करने के लिए प्रतिक्रिया नहीं करता है, अगर COPY क्वेरी परिणाम मानों को पढ़ने से पहले निहित लेनदेन समाप्त नहीं होने के कारण वापस लुढ़क जाएगी ...

वैसे भी अगर क्वेरी भेजी जा सकती है या नहीं, तो यह तरीका शूरवीरों तक नहीं है, लेकिन यह इस बात पर निर्भर करता है कि लैंबडा और पोस्टग्रेजल कैसे काम करते हैं।

मेरा अवलोकन यह है कि क्वेरी RedShift पर मारी जाती है और इसे वापस ले जाया जाता है।

वैसे भी पूल से रिक्वेस्ट करने के लिए मैनुअल कनेक्शन की जरूरत नहीं होती है, क्नेक्स अपने आप कनेक्शन के लिए इंतजार करता है और अगर कुछ ही सेकंड में सब कुछ खत्म हो जाता है, तो उस समय कोई भी टाइमआउट ट्रिगर नहीं होगा।

मैं एक db लोड परीक्षण स्क्रिप्ट चला रहा हूं और यह सच नहीं लगता। खुले कनेक्शन की प्रतीक्षा करने के बजाय 30 समकालिक कनेक्शनों की तुलना में उच्चतर कुछ भी तुरंत बाहर हो जाते हैं।

क्या क्वेरी के किए जाने के बाद वर्तमान में उपयोग किए गए कनेक्शन को मैन्युअल रूप से रिलीज़ करने का कोई तरीका है?

क्या किसी के पास उदाहरण कोड है जो वे उन लोगों के लिए साझा कर सकते हैं जो केवल AWS लाम्बा में प्राप्त कर रहे हैं? मैं उम्मीद कर रहा हूं कि कोई व्यक्ति knex / postgres / lambda के पैटर्न और / या विरोधी पैटर्न साझा कर सकता है।

यहाँ मैं अभी क्या उपयोग कर रहा हूँ - मुझे यकीन है कि इसमें सुधार किया जा सकता है, लेकिन कुछ छोटे-छोटे बदलावों की उम्मीद करना कि क्या मैं सही रास्ते पर हूँ या नहीं ...

'use strict';
var pg = require('pg');

function initKnex(){
  return require('knex')({
      client: 'pg',
      connection: { ...details... }
  });
}

module.exports.hello = (event, context) =>
{
  var knex = initKnex();

  // Should I be returning knex here or in the final catch?
  knex
  .select('*')
  .from('my_table')
  .then(function (rows) {
    context.succeed('Succeeded: ' + JSON.stringify(rows || []));
  })
  .catch(function (error) {
    context.fail(error);
  })
  .then(function(){
    // is destroy overkill? - is there an option for knex.client.release, etc?
    knex.destroy();
  })
}

मैं एक ही नाव में हूँ - अभी भी पता नहीं चला है कि चारों ओर से गुगली करने और परीक्षण करने के बावजूद सबसे अच्छा तरीका क्या है। मैं अभी क्या कर रहा हूँ:

const dbConfig = require('./db');
const knex = require('knex')(dbConfig);

exports.handler = function (event, context, callback) {
...
connection = {..., pool: { min: 1, max: 1 },

इस तरह कनेक्शन (अधिकतम 1 प्रति कंटेनर) जीवित रहेगा, ताकि कंटेनर को आसानी से पुन: उपयोग किया जा सके। मैं अंत में अपने कनेक्शन को नष्ट नहीं करता।

http://blog.rowanudell.com/database-connections-in-lambda/

यकीन नहीं होता कि यह सबसे अच्छा तरीका है लेकिन यह मेरे लिए अब तक का काम है।

/ श्रग

@austingayler

मुझे बिल्कुल यकीन नहीं है कि const knex घोषित होने पर क्या होता है - क्या यह वह जगह है जहां प्रारंभिक कनेक्शन सेटअप है? क्या कोई स्पष्ट कर सकता है? (मैं मान रहा हूँ कि आपके dbConfig में कनेक्शन की जानकारी है)

आपके कोड में, क्या कनेक्शन स्वयं अधिलेखित नहीं किया जाता है और हैंडलर कहा जाता है?

बस एक ही नाव में रहने वाले किसी व्यक्ति को चीमिंग करते हुए , मुझे कंटेनर के पूल आकार (

const knex = require('knex');

const client = knex(dbConfig);

client(tableName).select('*')
  .then((result) => { 

    return Promise.all([
      result,
      client.destroy(),
    ])  
  })
  .then(([ result ]) => {

    return result;
  });

TL; DR: कॉलबैक से पहले बस context.callbackWaitsForEmptyEventLoop = false सेट करें।

AWS लैंबडा खाली ईवेंट लूप (डिफ़ॉल्ट रूप से) की प्रतीक्षा करता है। इसलिए फ़ंक्शन टाइमआउट त्रुटि को कॉलबैक निष्पादित भी कर सकता है।

कृपया विवरण के लिए नीचे दिए गए लिंक देखें:
https://github.com/apex/apex/commit/1fe6e91a46e76c2d5c77877be9ce0c206e9ef9fb

To @elhigu @tgriesser : यह एक नेक्सस मुद्दा नहीं है। यह निश्चित रूप से लैम्ब्डा पर्यावरण का मुद्दा है। मुझे लगता है कि इस मुद्दे को टैग करना चाहिए और इसे बंद करना अच्छा होना चाहिए :)

@mooyoul हाँ, निश्चित रूप से knex मुद्दा नहीं है, लेकिन शायद दस्तावेज़ीकरण मुद्दा ... हालांकि मुझे लगता है कि मैं नहीं चाहता कि कोई भी व्यक्ति लैम्ब्डा विशिष्ट सामान को knex डॉक्स के लिए बंद कर सके।

कृपया इस लिंक को देखें
https://stackoverflow.com/questions/49347210/why-aws-lambda-keeps-timing-out-when-using-knex-js
आपको db कनेक्शन को बंद करने की आवश्यकता है अन्यथा लैम्बडा रन आउट होने तक चलता है।

क्या किसी ने एक पैटर्न पाया है जो लैम्ब्डा के साथ क्नेक्स का उपयोग करने के लिए निर्दोष रूप से काम करता है?

क्या आपके पास कोई अन्य समस्या है जब आप ठीक से कनेक्शन बंद करते हैं?

मैं जिस चीज से बचने की कोशिश कर रहा हूं वह कनेक्शन को बंद कर रही है और इसे लैंबडा कॉल में उपलब्ध करा रही है।

क्या आप सुनिश्चित हैं कि लैंबडा कॉल के बीच स्थिति बनाए रखने की अनुमति देता है?

Https://scalegrid.io/blog/how-to-use-mongodb-connection-pooling-on-aws-lambda/ के नोड.जेएस भाग की जाँच करें। यह गैर-खाली ईवेंट लूप पर लटकने के लिए एक समाधान सुझाता है।

मुझे इस तरह से धागा उछालना पसंद नहीं है, लेकिन जब से मुझे लगता है कि यह टिप्पणियों में खो रहा है, @mooyoul का जवाब हमारे लिए बहुत अच्छा है।

यदि आप उस झंडे को झूठा नहीं करते हैं, तो लैंबडा इवेंट लूप खाली होने का इंतजार करता है। यदि आप करते हैं, तो जैसे ही आप कॉलबैक कॉल करते हैं, फ़ंक्शन समाप्त हो जाता है।

मेरे लिए, इसने मेरी स्थानीय मशीन पर काम किया लेकिन तैनाती के बाद नहीं। मैं गुमराह होने की तरह था।

यह पता चला है कि आरडीएस इनबाउंड स्रोत मेरे लैंबडा फ़ंक्शन के लिए खुला नहीं है। स्टैक ओवरफ़्लो में मिला समाधान: या तो RDS इनबाउंड स्रोत को 0.0.0.0/0 बदलना या VPC का उपयोग करना।

आरडीएस इनबाउंड स्रोत को अपडेट करने के बाद, मैं कैनेक्स के साथ सफलतापूर्वक लंबोदर कर सकता हूं।

मैं जिस लैम्ब्डा रनटाइम का उपयोग कर रहा हूं वह Node.js 8.10 पैकेज के साथ है:

knex: 0.17.0
pg: 7.11.0

Async का उपयोग करके नीचे दिया गया कोड भी काम करता है

const Knex = require('knex');

const pg = Knex({ ... });

module.exports. submitForm = async (event) => {
  const {
    fields,
  } = event['body-json'] || {};

  return pg('surveys')
    .insert(fields)
    .then(() => {
      return {
        status: 200
      };
    })
    .catch(err => {
      return {
        status: 500
      };
    });
};

उम्मीद है कि यह उन लोगों की मदद करेगा जो भविष्य में इसी मुद्दे को पूरा कर सकते हैं।

कुछ ऐसा जो मैं लोगों का ध्यान आकर्षित करना चाहता हूं, वह है सर्वर रहित-mysql पैकेज, जो मानक mysql ड्राइवर को लपेटता है, लेकिन कनेक्शन थ्रेड प्रबंधन के आसपास बहुत सारे लैम्ब्डा-विशिष्ट दर्द बिंदुओं को संभालता है जो इस धागे में वर्णित हैं।

हालांकि मुझे नहीं लगता कि इस समय Knex serverless-mysql ( इस मुद्दे के अनुसार) के साथ काम करेगा, क्योंकि एक अलग ड्राइवर में स्वैप करने का कोई तरीका नहीं है। कॉलबैक के बजाय serverless-mysql उपयोग वादों के बाद भी असंगतताएं हो सकती हैं।

सबसे अच्छा दृष्टिकोण शायद क्नेक्स में एक नया ग्राहक कार्यान्वयन जोड़ना है। मुझे यह शॉट देने में खुशी होगी, लेकिन किसी और को Knex से परिचित होना पसंद करेंगे, तो मुझे बताएं कि क्या उन्हें उचित / उचित लगता है?

इस बीच, इस बीच में सोच रहा था, मैं Knex का उपयोग _build_ but _not execute_ MySQL प्रश्नों के लिए कर सकता था। तो बस toSQL() कॉल करें और निष्पादित करने के लिए serverless-mysql आउटपुट पास करें।

हालांकि मैं सोच रहा था कि क्या Knex को किसी db कनेक्शन के बिना कॉन्फ़िगर किया जा सकता है? ऐसा कोई अर्थ नहीं है जो एक कनेक्शन खोल रहा हो जो कभी उपयोग नहीं किया गया हो।

निम्नलिखित काम करेगा?

connection = {..., pool: { min: 0, max: 0 ) },

@disbelief आप कनेक्शन के बिना knex को इनिशियलाइज़ कर सकते हैं। डॉक्स https://knexjs.org/#Installation -client में इस धर्म के अंत में इसे कैसे करना है, इसका एक उदाहरण है

const knex = require('knex')({client: 'mysql'});

const generatedQuery = knex('table').where('id',1).toSQL().toNative();

@elhigu आह शांत, धन्यवाद। अंतरिम में एक शॉट देगा।

अद्यतन: ऊपर काम करने के लिए प्रकट नहीं होता है। यदि यह db कनेक्शन स्थापित नहीं कर सकता है, तो Knex एक त्रुटि फेंकता है, भले ही किसी क्वेरी को निष्पादित करने के लिए कोई कॉल न हो।

@disbelief क्या आपने इसके लिए कोई समाधान खोजा?

@fdecampredon नोप । फिलहाल मैं केवल स्क्वेल के साथ प्रश्नों का निर्माण कर रहा हूं, उन पर toString() कॉल कर रहा हूं, और उन्हें serverless-mysql क्लाइंट में पास कर रहा हूं।

@disbelief यह मेरे लिए आश्चर्यजनक है कि प्रश्नों का निर्माण बिना db कनेक्शन के विफल हो गया।

क्या आप नक्स क्लाइंट बनाने के लिए उपयोग किए जा रहे कोड और कॉन्फिग को पोस्ट करने का मन करेंगे? इसके अलावा knex संस्करण।

निम्नलिखित मेरे साथ ठीक काम करता है
नोड v8.11.1
mysql : 2.13.0
knex : 0.18.3

const k = require('knex')

const client = k({ client: 'mysql' })

console.log('Knex version:', require('knex/package.json').version)
// => 0.18.3
console.log('sql:', client('table').where('id',1).toSQL().toNative())
// => { sql: 'select * from `table` where `id` = ?', bindings: [ 1 ] }

लैम्बडा के रिसाइकिलिंग के काम करने के तरीके के अनुसार, Knex उदाहरण हमेशा किसी फंक्शन या क्लास के बाहर रखा जाना चाहिए। इसके अलावा, पूल में कनेक्शन के लिए अधिकतम 1 होना महत्वपूर्ण है।

कुछ इस तरह:

const Knex = require('knex');
let instance = null;

module.exports = class DatabaseManager {
  constructor({ host, user, password, database, port = 3306, client = 'mysql', pool = { min: 1, max: 1 }}) {
    this._client = client;
    this._poolOptions = pool;
    this._connectionOptions = {
      host: DB_HOST || host,
      port: DB_PORT || port,
      user: DB_USER || user,
      password: DB_PASSWORD || password,
      database: DB_NAME || database,
    };
  }

  init() {
    if (instance !== null) {
      return;
    }

    instance = Knex({
      client: this._client,
      pool: this._poolOptions,
      connection: this._connectionOptions,
      debug: process.env.DEBUG_DB == true,
      asyncStackTraces: process.env.DEBUG_DB == true,
    });
  }

  get instance() {
    return instance;
  }
}

इस तरह, आप लैंबडा के पुनर्चक्रण का सबसे अधिक लाभ उठाएंगे, अर्थात प्रत्येक सक्रिय (फ्रीजेड) कंटेनर केवल एक ही कनेक्शन रखेगा।

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

मैंने बिना किसी समस्या के अब लगभग एक साल तक लैंबडा में Knex को चलाया है। मैं अपने लैंबडा फंक्शन के बाहर अपना क्नेक्स इंस्टेंस घोषित कर रहा हूं और अन्य पोस्ट में context.callbackWaitsForEmptyEventLoop = false का उपयोग कर रहा हूं।

कहा कि, पिछले दिनों, लैम्बडा की ओर से कुछ बदल गया है क्योंकि मैं अब पोस्टग्रैज में एक विशाल कनेक्शन स्पाइक देख रहा हूं; कनेक्शन बंद होना प्रतीत नहीं होता है।

क्या किसी और ने उक्त दृष्टिकोण का उपयोग करते हुए पिछले दिन या किसी भी मौके को देखा है?

@jamesdixon ने अभी यह पढ़ते हुए लैंबडा पर हमारे कुछ शूरवीरों को लागू किया। इस पर कोई अपडेट? क्या context.callbackWaitsForEmptyEventLoop = false ने काम करना बंद कर दिया है?