I've examined the implementation of Lambda that prevents DSQL maximum connection time exceeded errors

			
			import { Client } from "pg";
import { DsqlSigner } from "@aws-sdk/dsql-signer";

const region = process.env.AWS_REGION;
const clusterEndpoint = `${process.env.DSQL_CLUSTER_IDENTIFIER}.dsql.${region}.on.aws`;
const signer = new DsqlSigner({
	hostname: clusterEndpoint,
	region,
});
const token = await signer.getDbConnectAdminAuthToken();
const client = new Client({
	host: clusterEndpoint,
	port: 5432,
	database: "postgres",
	user: "admin",
	password: token,
	ssl: true,
});
await client.connect();

export const handler = async (event, context) => {
	await client.query("SELECT now()");
};

		

			
			2025-08-16T05:08:03.735Z	668be42f-8fb4-40b9-b922-917b4961fd6a	ERROR	Uncaught Exception 	
{
    "errorType": "Error",
    "errorMessage": "Connection terminated unexpectedly",
    "stack": [
        "Error: Connection terminated unexpectedly",
        "    at Connection.<anonymous> (/var/task/node_modules/pg/lib/client.js:136:73)",
        "    at Object.onceWrapper (node:events:632:28)",
        "    at Connection.emit (node:events:518:28)",
        "    at Socket.<anonymous> (/var/task/node_modules/pg/lib/connection.js:62:12)",
        "    at Socket.emit (node:events:530:35)",
        "    at TCP.<anonymous> (node:net:351:12)",
        "    at TCP.callbackTrampoline (node:internal/async_hooks:130:17)"
    ]
}
[ERROR] [1755320883795] LAMBDA_RUNTIME Failed to post handler success response. Http response code: 400.
END RequestId: 3ae7d2b9-386f-4cf5-8be4-8a07c441bb17
REPORT RequestId: 3ae7d2b9-386f-4cf5-8be4-8a07c441bb17	Duration: 424.60 ms	Billed Duration: 425 ms	Memory Size: 128 MB	Max Memory Used: 109 MB	Status: error	Error Type: Runtime.ExitError
XRAY TraceId: 1-68a01233-79a00cff59419f8a19543d5a	SegmentId: 19f811623978708f	Sampled: true
```Subsequently, logs with the same request ID were output as follows. This occurred because the asynchronous execution of Lambda from the Event Bridge scheduler failed, resulting in automatic retry by the Lambda runtime.

		

			
			
Here is the trace result linked to the target trace ID. The error occurrence and retries by the Lambda runtime are clearly displayed.

![Maximum connection time exceeded error trace result.jpg](https://devio2024-2-media.developers.io/upload/5Qv4yMS8fCvjamITH41166/2025-08-16/wt9vyeGTamcV.jpeg)

So, we've learned that maintaining a connection with DSQL without considering the maximum connection time will cause a maximum connection time exceeded error. This is definitely an important point to keep in mind when using DSQL.### Using pg's Pool

Having confirmed the maximum connection time exceeded error, let's now modify the implementation to prevent these errors. While connecting to and disconnecting from DSQL within each handler would avoid the maximum connection time exceeded error, this approach introduces unnecessary processing and prevents performance optimization, so we'll avoid it. Instead, we'll use the `pg` library's `Pool` to automatically discard connections from the connection pool after a certain time, allowing efficient use of DSQL connections.

The implementation is as follows:

```js:dsql-with-pg-pool.mjs
import { Pool } from "pg";
import { DsqlSigner } from "@aws-sdk/dsql-signer";

const region = process.env.AWS_REGION;
const clusterEndpoint = `${process.env.DSQL_CLUSTER_IDENTIFIER}.dsql.${region}.on.aws`;
const getToken = async () => {
    const signer = new DsqlSigner({
        hostname: clusterEndpoint,
        region,
    });
    return signer.getDbConnectAdminAuthToken()
}

const pool = new Pool({
	host: clusterEndpoint,
	port: 5432,
	database: "postgres",
	user: "admin",
	password: getToken,
	ssl: true,
	maxLifetimeSeconds: 60 * 50,
	idleTimeoutMillis: 1000 * 60 * 50
});

export const handler = async (event, context) => {
	await pool.query("SELECT now()");
};


		

			
			filter ispresent(attributes.db.name)
| display @timestamp, name
| sort startTimeUnixNano

		

			
			AWSTemplateFormatVersion: 2010-09-09
Transform:
- AWS::Serverless-2016-10-31
Globals:
  Function:
    Timeout: 10
    Tracing: Active
    Runtime: nodejs22.x
    Layers:
      - arn:aws:lambda:us-east-1:615299751070:layer:AWSOpenTelemetryDistroJs:8
    Environment:
      Variables:
        OTEL_NODE_ENABLED_INSTRUMENTATIONS: pg
        AWS_LAMBDA_EXEC_WRAPPER: /opt/otel-instrument
        DSQL_CLUSTER_IDENTIFIER: !Ref Dsql
Resources:  
  Dsql:
    Type: AWS::DSQL::Cluster
    Properties:
      DeletionProtectionEnabled: false
  DsqlWithPgClient:
    Type: AWS::Serverless::Function
    Properties:      
      Handler: src/dsql-with-pg-client.handler
      Role: !GetAtt LambdaRole.Arn
      Events:
        CloudWatchEvent:
          Type: Schedule
          Properties:
            Schedule: rate(5 minutes)
  DsqlWithPgPool:
    Type: AWS::Serverless::Function
    Properties:      
      Handler: src/dsql-with-pg-pool.handler
      Role: !GetAtt LambdaRole.Arn
      Events:
        CloudWatchEvent:
          Type: Schedule
          Properties:
            Schedule: rate(5 minutes)
  LambdaRole:
      Type: AWS::IAM::Role
      Properties:
        AssumeRolePolicyDocument:
          Version: '2012-10-17'
          Statement:
          - Effect: Allow
            Principal:
              Service:
              - 'lambda.amazonaws.com'
            Action: sts:AssumeRole
        Policies:
        -
          PolicyName: dsql-blog-policy
          PolicyDocument:
            Version: "2012-10-17"
            Statement:
            -
              Effect: "Allow"
              Action:
                - 'dsql:*'
                - "logs:*"
                - "xray:*"
              Resource: '*'