What is the best practice for managing GridDB Cloud connections in a serverless environment like AWS Lambda?

Question

I am developing an AWS Lambda function in Node.js to interface with GridDB Cloud. I implemented a connection reuse mechanism in my code to avoid establishing a new connection on each invocation, but I am encountering intermittent connection timeouts and errors when the function is triggered concurrently.

Below is a simplified version of my code:

const griddb = require('griddb-node-client');
let storeInstance = null;

exports.handler = async (event, context) => {
  // Reuse connection if available
  if (!storeInstance) {
    const factory = griddb.StoreFactory.getInstance();
    const connectionProps = new Map();
    connectionProps.set("notificationAddress", process.env.GRIDDB_ADDRESS);
    connectionProps.set("notificationPort", process.env.GRIDDB_PORT);
    connectionProps.set("clusterName", process.env.GRIDDB_CLUSTER);
    connectionProps.set("user", process.env.GRIDDB_USER);
    connectionProps.set("password", process.env.GRIDDB_PASS);

    try {
      storeInstance = await factory.getStore(connectionProps);
      console.log("Connected to GridDB Cloud!");
    } catch (error) {
      console.error("Initial connection error:", error);
      throw error;
    }
  }

  try {
    const containerName = "LambdaContainer";
    const containerInfo = new griddb.ContainerInfo(
      containerName,
      [
        ["id", griddb.Type.INTEGER],
        ["data", griddb.Type.STRING]
      ],
      griddb.ContainerType.COLLECTION,
      true
    );

    const container = await storeInstance.putContainer(containerInfo);
    const query = container.query("select * where id > ?", 0);
    const rs = await query.fetch();
    return {
      statusCode: 200,
      body: JSON.stringify(rs)
    };
  } catch (err) {
    console.error("Query error:", err);
    throw err;
  }
};

Are there any GridDB Cloud-specific optimizations—such as connection pooling, SSL configurations, or load balancing techniques—that can help stabilize performance in a cloud-native, serverless architecture?