Manage Connections with AWS Lambda

string username = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY_ID");
string password = Environment.GetEnvironmentVariable("AWS_SECRET_ACCESS_KEY");
string awsSessionToken = Environment.GetEnvironmentVariable("AWS_SESSION_TOKEN");
var awsCredentials =
    new MongoCredential("MONGODB-AWS", new MongoExternalIdentity(username), new PasswordEvidence(password))
    .WithMechanismProperty("AWS_SESSION_TOKEN", awsSessionToken);
var mongoUrl = MongoUrl.Create($"<MONGODB_URI>");
var mongoClientSettings = MongoClientSettings.FromUrl(mongoUrl);
mongoClientSettings.Credential = awsCredentials;
mongoClientSettings.ServerApi = new ServerApi(ServerApiVersion.V1, strict: true);
return new MongoClient(mongoClientSettings);

private static MongoClient MongoClient { get; set; }
private static MongoClient CreateMongoClient()
{
    var mongoClientSettings = MongoClientSettings.FromConnectionString($"<MONGODB_URI>");
    mongoClientSettings.ServerApi = new ServerApi(ServerApiVersion.V1, strict: true);
    return new MongoClient(mongoClientSettings);
}
static ShareMongoClientLambdaHandler()
{
    MongoClient = CreateMongoClient();
}
public string HandleRequest(ILambdaContext context)
{
    var database = MongoClient.GetDatabase("db");
    var collection = database.GetCollection<BsonDocument>("coll");
    var result = collection.Find(FilterDefinition<BsonDocument>.Empty).First();
    return result.ToString();
}

const { MongoClient } = require('mongodb');
// Get the URI for the cluster then set AWS_ACCESS_KEY_ID as the username in the
// URI and AWS_SECRET_ACCESS_KEY as the password, then set the appropriate auth
// options. Note that MongoClient now auto-connects so no need to store the connect()
// promise anywhere and reference it.
const client = new MongoClient(process.env.MONGODB_URI, {
  auth: {
    username: process.env.AWS_ACCESS_KEY_ID,
    password: process.env.AWS_SECRET_ACCESS_KEY
  },
  authSource: '$external',
  authMechanism: 'MONGODB-AWS'
});
module.exports.handler = async function () {
  const databases = await client.db('admin').command({ listDatabases: 1 });
  return {
    statusCode: 200,
    databases: databases
  };
};

const { MongoClient } = require('mongodb');
// MongoClient now auto-connects so no need to store the connect()
// promise anywhere and reference it.
const client = new MongoClient(process.env.MONGODB_URI);
module.exports.handler = async function () {
  const databases = await client.db('admin').command({ listDatabases: 1 });
  return {
    statusCode: 200,
    databases: databases
  };
};

provider:
   environment:
      MONGODB_URI: "<connection string without credentials>"

require 'vendor/autoload.php';
use MongoDB\Client;
// Create the MongoDB client outside the handler function
$client = new Client(getenv('MONGODB_URI'));
function handler($event, $context) {
    global $client;
    
    $database = $client->getDatabase('admin');
    $result = $database->command(['ping' => 1]);
    
    return [
        'statusCode' => 200,
        'body' => json_encode($result)
    ];
}

serverless deploy

# Require the driver library.
require "mongo"
# Create a Mongo::Client instance using AWS IAM authentication.
# CRITICAL: You must create the client instance outside the handler
# so that the client can be reused across function invocations.
client = Mongo::Client.new([ENV.fetch("MONGODB_HOST")],
                           auth_mech: :aws,
                           user: ENV.fetch("AWS_ACCESS_KEY_ID"),
                           password: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
                           auth_mech_properties: {
                             aws_session_token: ENV.fetch("AWS_SESSION_TOKEN"),
                           },
                           database: ENV.fetch("MONGODB_DATABASE"))
def lambda_handler(event:, context:)
  # Use the client to return the name of the configured database.
  client.database.name
end

# Require the driver library.
require "mongo"
# Create a Mongo::Client instance.
# CRITICAL: You must create the client instance outside the handler
# so that the client can be reused across function invocations.
client = Mongo::Client.new(ENV.fetch("MONGODB_URI"))
def lambda_handler(event:, context:)
  # Use the client to return the name of the configured database.
  client.database.name
end

use lambda_runtime::{service_fn, LambdaEvent};
use mongodb::{
    bson::doc,
    options::{AuthMechanism, ClientOptions, Credential},
    Client,
};
use serde_json::Value;
use tokio::sync::OnceCell;
// Initialize a global static MongoDB Client with AWS authentication. The following environment
// variables should also be set: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and, optionally,
// AWS_SESSION_TOKEN.
static MONGODB_CLIENT: OnceCell<Client> = OnceCell::const_new();
async fn get_mongodb_client() -> &'static Client {
    MONGODB_CLIENT
        .get_or_init(|| async {
            let uri = std::env::var("MONGODB_URI")
                .expect("MONGODB_URI must be set to the URI of the MongoDB deployment");
            let mut options = ClientOptions::parse(&uri)
                .await
                .expect("Failed to parse options from URI");
            let credential = Credential::builder()
                .mechanism(AuthMechanism::MongoDbAws)
                .build();
            options.credential = Some(credential);
            Client::with_options(options).expect("Failed to create MongoDB Client")
        })
        .await
}
// Runs a ping operation on the "db" database and returns the response.
async fn handler(_: LambdaEvent<Value>) -> Result<Value, lambda_runtime::Error> {
    let client = get_mongodb_client().await;
    let response = client
        .database("db")
        .run_command(doc! { "ping": 1 })
        .await?;
    let json = serde_json::to_value(response)?;
    Ok(json)
}
#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    let service = service_fn(handler);
    lambda_runtime::run(service).await?;
    Ok(())
}

use lambda_runtime::{service_fn, LambdaEvent};
use mongodb::{bson::doc, Client};
use serde_json::Value;
use tokio::sync::OnceCell;
// Initialize a global static MongoDB Client.
static MONGODB_CLIENT: OnceCell<Client> = OnceCell::const_new();
async fn get_mongodb_client() -> &'static Client {
    MONGODB_CLIENT
        .get_or_init(|| async {
            let uri = std::env::var("MONGODB_URI")
                .expect("MONGODB_URI must be set to the URI of the MongoDB deployment");
            Client::with_uri_str(uri)
                .await
                .expect("Failed to create MongoDB Client")
        })
        .await
}
// Runs a ping operation on the "db" database and returns the response.
async fn handler(_: LambdaEvent<Value>) -> Result<Value, lambda_runtime::Error> {
    let client = get_mongodb_client().await;
    let response = client
        .database("db")
        .run_command(doc! { "ping": 1 })
        .await?;
    let json = serde_json::to_value(response)?;
    Ok(json)
}
#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    let service = service_fn(handler);
    lambda_runtime::run(service).await?;
    Ok(())
}