Best Practices and a Tutorial for Using Google Cloud Functions with MongoDB Atlas

1
{
2
  "dependencies": {
3
    "@google-cloud/functions-framework": "^3.0.0",
4
    "mongodb": "latest"
5
  }
6
}

1
// Global (instance-wide) scope
2
// This code runs once (at instance cold-start)
3
const { http } = require('@google-cloud/functions-framework');
4
const { MongoClient } = require('mongodb');
5
6
http('createDocument', async (req, res) => {
7
    // Function scope
8
    // This code runs every time this function is invoked
9
    const client = new MongoClient(process.env.ATLAS_URI);
10
    client.on('connectionCreated', () => {
11
        console.log('New connection created!');
12
    });
13
14
    // Connect to the database in the function scope
15
    try {
16
        await client.connect();
17
18
        const collection = client.db('test').collection('documents');
19
20
21
        const result = await collection.insertOne({ source: 'Cloud Functions' });
22
23
        if (result) {
24
            console.log(`Document ${result.insertedId} created!`);
25
            return res.status(201).send(`Successfully created a new document with id ${result.insertedId}`);
26
        } else {
27
            return res.status(500).send('Creating a new document failed!');
28
        }
29
    } catch (error) {
30
        res.status(500).send(error.message);
31
    }
32
});

1
// Global (instance-wide) scope
2
// This code runs once (at instance cold-start)
3
const { http } = require('@google-cloud/functions-framework');
4
const { MongoClient } = require('mongodb');
5
6
// Use lazy initialization to instantiate the MongoDB client and connect to the database
7
let client;
8
async function getConnection() {
9
    if (!client) {
10
        client = new MongoClient(process.env.ATLAS_URI);
11
        client.on('connectionCreated', () => {
12
            console.log('New connection created!');
13
        });
14
15
        // Connect to the database in the global scope
16
        await client.connect();
17
    }
18
19
    return client;
20
}
21
22
http('createDocument', async (req, res) => {
23
    // Function scope
24
    // This code runs every time this function is invoked
25
    const connection = await getConnection();
26
    const collection = connection.db('test').collection('documents');
27
28
    try {
29
        const result = await collection.insertOne({ source: 'Cloud Functions' });
30
31
        if (result) {
32
            console.log(`Document ${result.insertedId} created!`);
33
            return res.status(201).send(`Successfully created a new document with id ${result.insertedId}`);
34
        } else {
35
            return res.status(500).send('Creating a new document failed!');
36
        }
37
    } catch (error) {
38
        res.status(500).send(error.message);
39
    }
40
});

1
seq 50 | xargs -Iz -n 1 -P 50 \
2
  gcloud functions call \
3
  create-document-function-scope \
4
  --region us-central1 \
5
  --gen2

1
gcloud functions logs read \
2
  create-document-function-scope \
3
  --region us-central1 \
4
  --gen2 \
5
  --limit 500 \
6
  | grep "New connection created"

1
gcloud functions logs read \
2
 create-document-function-scope \
3
 --region us-central1 \
4
 --gen2 \
5
 --limit 500 \
6
 | grep "New connection created" \
7
 | wc -l

1
seq 50 | xargs -Iz -n 1 -P 50 \
2
  gcloud functions call \
3
  create-document-global-scope \
4
  --region us-central1 \
5
  --gen2

1
gcloud functions logs read \
2
  create-document-global-scope \
3
  --region us-central1 \
4
  --gen2 \
5
  --limit 500 \
6
  | grep "New connection created"

1
const { cloudEvent } = require('@google-cloud/functions-framework');
2
const { MongoClient } = require('mongodb');
3
4
// Use lazy initialization to instantiate the MongoDB client and connect to the database
5
let client;
6
async function getConnection() {
7
    if (!client) {
8
        client = new MongoClient(process.env.ATLAS_URI);
9
        await client.connect();
10
    }
11
12
    return client;
13
}
14
15
cloudEvent('processMessage', async (cloudEvent) => {
16
  let message;
17
  try {
18
    const base64message = cloudEvent?.data?.message?.data;
19
    message = Buffer.from(base64message, 'base64').toString();
20
  } catch (error) {
21
    console.error('Invalid message', cloudEvent.data);
22
    return Promise.resolve();
23
  }
24
25
  try {
26
    await store(message);
27
  } catch (error) {
28
    console.error(error.message);
29
    throw new Error('Storing message in the database failed.');
30
  }
31
32
  if (!notify()) {
33
    throw new Error('Notification service failed.');
34
  }
35
});
36
37
async function store(message) {
38
  const connection = await getConnection();
39
  const collection = connection.db('test').collection('messages');
40
  await collection.insertOne({
41
    text: message
42
  });
43
}
44
45
// Simulate a third-party service with a 50% fail rate
46
function notify() {
47
  return Math.floor(Math.random() * 2);
48
}

1
db.messages.createIndex({ "event_id": 1 }, { unique: true })

1
const { cloudEvent } = require('@google-cloud/functions-framework');
2
const { MongoClient } = require('mongodb');
3
4
// Use lazy initialization to instantiate the MongoDB client and connect to the database
5
let client;
6
async function getConnection() {
7
    if (!client) {
8
        client = new MongoClient(process.env.ATLAS_URI);
9
        await client.connect();
10
    }
11
12
    return client;
13
}
14
15
cloudEvent('processMessage', async (cloudEvent) => {
16
  let message;
17
  try {
18
    const base64message = cloudEvent?.data?.message?.data;
19
    message = Buffer.from(base64message, 'base64').toString();
20
  } catch (error) {
21
    console.error('Invalid message', cloudEvent.data);
22
    return Promise.resolve();
23
  }
24
25
  try {
26
    await store(cloudEvent.id, message);
27
  } catch (error) {
28
    // The error E11000: duplicate key error for the 'event_id' field is expected when retrying
29
    if (error.message.includes('E11000') && error.message.includes('event_id')) {
30
      console.log('Skipping retrying because the error is expected...');
31
      return Promise.resolve();
32
    }
33
    
34
    console.error(error.message);
35
    throw new Error('Storing message in the database failed.');
36
  }
37
38
  if (!notify()) {
39
    throw new Error('Notification service failed.');
40
  }
41
});
42
43
async function store(id, message) {
44
  const connection = await getConnection();
45
  const collection = connection.db('test').collection('messages');
46
  await collection.insertOne({
47
    event_id: id,
48
    text: message
49
  });
50
}
51
52
// Simulate a third-party service with a 50% fail rate
53
function notify() {
54
  return Math.floor(Math.random() * 2);
55
}