पाठ 12 / 32

Databases for Serverless Workloads

यह पाठ अभी हिंदी में अनुवादित नहीं है, इसलिए अंग्रेज़ी में दिखाया जा रहा है।

Avoid connection storms, reuse clients across invocations, and choose data stores and placement that suit functions.

लेखक: · 15 साल से वेब डेवलपर

Databases when compute scales out

Traditional relational databases assume a few long-lived app servers holding pooled connections. Serverless breaks that assumption: a traffic spike can create hundreds of function instances, each opening its own connection, until the database hits its connection limit and starts refusing clients. The options: put a connection pooler in between (Amazon RDS Proxy, PgBouncer) so many functions share a few database connections; create clients outside the handler so warm invocations reuse them; cap function concurrency so it never exceeds what the database can take; or pick data stores built for this pattern, such as DynamoDB-style key-value stores reached over HTTP, or managed Postgres and MySQL services that offer HTTP or WebSocket drivers suited to short-lived and edge runtimes. Also respect data gravity: a function should normally run in the same region as its primary database, because every query pays the network round trip.

A client created once per environment

The pool lives at module scope, so warm invocations reuse its connection. Since a standard Lambda environment handles one event at a time, one connection per environment is enough.

import pg from 'pg';

// Created during Init, reused by every warm invocation.
const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL, // ideally a pooler or proxy endpoint
  max: 1,                                     // one event at a time per environment
  idleTimeoutMillis: 60_000,
});

export const handler = async (event) => {
  const { rows } = await pool.query(
    'SELECT name, branch FROM students WHERE roll_no = $1',
    [event.rollNo],
  );
  return rows[0] ?? null;
};

Parameterised queries, always

The $1 placeholder in the example is not decoration. Building SQL with string concatenation from event fields invites SQL injection, and event data is untrusted input, exactly like a form on a website.

त्वरित जाँच: A spike creates 800 concurrent Lambda environments, each opening one Postgres connection, and the database allows 200. What is the most direct fix?

  • Increase the function memory
  • Route connections through a pooler such as RDS Proxy and limit function concurrency
  • Move the function to another region
  • Open a fresh connection inside the handler on every call
Answer

Route connections through a pooler such as RDS Proxy and limit function concurrency — A pooler multiplexes many clients onto few connections, and a concurrency cap keeps the function from overrunning the database. Opening per-call connections makes it worse.