Getting Started With MongoDB Atlas Serverless, AWS CDK, and AWS Serverless Computing

1
sudo npm install -g aws-cdk

1
cdk bootstrap aws://ACCOUNT_NUMBER/REGION

1
cdk init -l typescript 

1
npm install awscdk-resources-mongodbatlas

1
#!/usr/bin/env node
2
import 'source-map-support/register';
3
import * as cdk from 'aws-cdk-lib';
4
import { AtlasBootstrapExample } from '../lib/cloudshell-user-stack'; //replace "cloudshell-user" with name of the .ts file in the lib directory
5
6
const app = new cdk.App();
7
const env = { region: process.env.CDK_DEFAULT_REGION, account: process.env.CDK_DEFAULT_ACCOUNT };
8
9
new AtlasBootstrapExample(app, 'mongodb-atlas-bootstrap-stack', { env });

1
import * as cdk from 'aws-cdk-lib'
2
import { Construct } from 'constructs'
3
import {
4
  MongoAtlasBootstrap,
5
  MongoAtlasBootstrapProps,
6
  AtlasBasicResources
7
} from 'awscdk-resources-mongodbatlas'
8
9
export class AtlasBootstrapExample extends cdk.Stack {
10
  constructor (scope: Construct, id: string, props?: cdk.StackProps) {
11
    super(scope, id, props)
12
13
    const roleName = 'MongoDB-Atlas-CDK-Excecution'
14
    const mongoDBProfile = 'development'   
15
16
    const bootstrapProperties: MongoAtlasBootstrapProps = {
17
      roleName,      secretProfile: mongoDBProfile,
18
      typesToActivate: ['ServerlessInstance', ...AtlasBasicResources]
19
    }
20
21
    new MongoAtlasBootstrap(this, 'mongodb-atlas-bootstrap', bootstrapProperties)
22
  }
23
}

1
npx cdk diff mongodb-atlas-bootstrap-stack
2
npx cdk deploy mongodb-atlas-bootstrap-stack

1
export MONGO_ATLAS_PUBLIC_KEY=’INPUT_YOUR_PUBLIC_KEY'
2
export MONGO_ATLAS_PRIVATE_KEY=’INPUT_YOUR_PRIVATE_KEY'

1
aws secretsmanager update-secret --secret-id cfn/atlas/profile/development --secret-string "{\"PublicKey\":\"${MONGO_ATLAS_PUBLIC_KEY}\",\"PrivateKey\":\"${MONGO_ATLAS_PRIVATE_KEY}\"}"

1
#!/usr/bin/env node
2
import 'source-map-support/register';
3
import * as cdk from 'aws-cdk-lib';
4
import { AtlasBootstrapExample, AtlasServerlessBasicStack } from '../lib/cloudshell-user-stack'; //update "cloudshell-user" with your stack name 
5
6
const app = new cdk.App();
7
const env = { region: process.env.CDK_DEFAULT_REGION, account: process.env.CDK_DEFAULT_ACCOUNT };
8
9
// the bootstrap stack
10
new AtlasBootstrapExample(app, 'mongodb-atlas-bootstrap-stack', { env });
11
12
type AccountConfig = {
13
  readonly orgId: string;
14
  readonly projectId?: string;
15
}
16
17
const MyAccount: AccountConfig = {
18
  orgId: '63234d3234ec0946eedcd7da', //update with your Atlas Org ID 
19
};
20
21
const MONGODB_PROFILE_NAME = 'development';
22
23
// the serverless stack with mongodb atlas serverless instance
24
const serverlessStack = new AtlasServerlessBasicStack(app, 'atlas-serverless-basic-stack', {
25
  env,
26
  ipAccessList: '46.137.146.59',  //input your static IP Address from NAT Gateway
27
  profile: MONGODB_PROFILE_NAME,
28
  ...MyAccount,
29
});

1
import * as path from 'path';
2
import {
3
  App, Stack, StackProps,
4
  Duration,
5
  CfnOutput,
6
  SecretValue,
7
  aws_secretsmanager as secretsmanager,
8
} from 'aws-cdk-lib';
9
import * as cdk from 'aws-cdk-lib';
10
import { SubnetType } from 'aws-cdk-lib/aws-ec2';
11
import {
12
  MongoAtlasBootstrap,
13
  MongoAtlasBootstrapProps,
14
  AtlasBasicResources,
15
  AtlasServerlessBasic,
16
  ServerlessInstanceProviderSettingsProviderName,
17
} from 'awscdk-resources-mongodbatlas';
18
import { Construct } from 'constructs';
19
20
21
export class AtlasBootstrapExample extends cdk.Stack {
22
  constructor (scope: Construct, id: string, props?: cdk.StackProps) {
23
    super(scope, id, props)
24
25
    const roleName = 'MongoDB-Atlas-CDK-Excecution'
26
    const mongoDBProfile = 'development'   
27
28
    const bootstrapProperties: MongoAtlasBootstrapProps = {
29
      roleName: roleName,
30
      secretProfile: mongoDBProfile,
31
      typesToActivate: ['ServerlessInstance', ...AtlasBasicResources]
32
    }
33
34
    new MongoAtlasBootstrap(this, 'mongodb-atlascdk-bootstrap', bootstrapProperties)
35
  }
36
}
37
38
export interface AtlasServerlessBasicStackProps extends StackProps {
39
  readonly profile: string;
40
  readonly orgId: string;
41
  readonly ipAccessList: string;
42
}
43
export class AtlasServerlessBasicStack extends Stack {
44
  readonly dbUserSecret: secretsmanager.ISecret;
45
  readonly connectionString: string;
46
  constructor(scope: Construct, id: string, props: AtlasServerlessBasicStackProps) {
47
    super(scope, id, props);
48
49
    const stack = Stack.of(this);
50
    const projectName = `${stack.stackName}-proj`;
51
52
    const dbuserSecret = new secretsmanager.Secret(this, 'DatabaseUserSecret', {
53
      generateSecretString: {
54
        secretStringTemplate: JSON.stringify({ username: 'serverless-user' }),
55
        generateStringKey: 'password',
56
        excludeCharacters: '%+~`#$&*()|[]{}:;<>?!\'/@"\\=-.,',
57
      },
58
    });
59
60
    this.dbUserSecret = dbuserSecret;
61
    const ipAccessList = props.ipAccessList;
62
63
    // see https://github.com/mongodb/awscdk-resources-mongodbatlas/blob/main/examples/l3-resources/atlas-serverless-basic.ts#L22
64
    const basic = new AtlasServerlessBasic(this, 'serverless-basic', {
65
      serverlessProps: {
66
        profile: props.profile,
67
        providerSettings: {
68
          providerName: ServerlessInstanceProviderSettingsProviderName.SERVERLESS,
69
          regionName: 'EU_WEST_1',
70
        },
71
      },
72
      projectProps: {
73
        orgId: props.orgId,
74
        name: projectName,
75
      },
76
      dbUserProps: {
77
        username: 'serverless-user',
78
      },
79
      ipAccessListProps: {
80
        accessList: [
81
          { ipAddress: ipAccessList, comment: 'My first IP address' },
82
        ],
83
      },
84
      profile: props.profile,
85
    });
86
87
    this.connectionString = basic.mserverless.getAtt('ConnectionStrings.StandardSrv').toString();
88
89
    new CfnOutput(this, 'ProjectName', { value: projectName });
90
    new CfnOutput(this, 'ConnectionString', { value: this.connectionString });
91
  }
92
}

1
npx cdk diff atlas-serverless-basic-stack
2
npx cdk deploy atlas-serverless-basic-stack

1
atlas config init

1
atlas dbusers update serverles-user --password INSERT_YOUR_AWS_SECRET_MANAGER_PASSWORD

1
aws ec2 describe-vpcs 

1
#!/usr/bin/env node
2
import 'source-map-support/register';
3
import * as path from 'path';
4
import {
5
  aws_ec2 as ec2,
6
  aws_lambda as lambda,
7
  aws_apigateway as apigw,
8
  Duration,
9
} from 'aws-cdk-lib';
10
import * as cdk from 'aws-cdk-lib';
11
import { SubnetType } from 'aws-cdk-lib/aws-ec2';
12
import { AtlasBootstrapExample, AtlasServerlessBasicStack } from '../lib/cloudshell-user-stack'; //update "cloudshell-user" with your .ts filename
13
14
const app = new cdk.App();
15
const env = { region: process.env.CDK_DEFAULT_REGION, account: process.env.CDK_DEFAULT_ACCOUNT };
16
17
// the bootstrap stack
18
new AtlasBootstrapExample(app, 'mongodb-atlas-bootstrap-stack', { env });
19
20
type AccountConfig = {
21
  readonly orgId: string;
22
  readonly projectId?: string;
23
}
24
25
const MyAccount: AccountConfig = {
26
  orgId: '63234d3234ec0946eedcd7da', //update with your Atlas Org ID 
27
};
28
29
const MONGODB_PROFILE_NAME = 'development';
30
31
// the serverless stack with mongodb atlas serverless instance
32
const serverlessStack = new AtlasServerlessBasicStack(app, 'atlas-serverless-basic-stack', {
33
  env,
34
  ipAccessList: '46.137.146.59',  //input your static IP Address from NAT Gateway
35
  profile: MONGODB_PROFILE_NAME,
36
  ...MyAccount,
37
});
38
39
// Reference your VPC ID created in your AWS Account 
40
const vpc = ec2.Vpc.fromLookup(serverlessStack, 'VPC', {
41
  vpcId: 'vpc-0060b48b973dbe4a5', // Use your actual VPC ID here
42
});
43
44
// The demo lambda function.
45
const handler = new lambda.Function(serverlessStack, 'LambdaFunc', {
46
  code: lambda.Code.fromAsset(path.join(__dirname, '../lambda/playground')),
47
  runtime: lambda.Runtime.PYTHON_3_10,
48
  handler: 'index.handler',
49
  timeout: Duration.seconds(30),
50
51
  vpc,
52
  vpcSubnets: {
53
    subnetType: SubnetType.PRIVATE_WITH_EGRESS,
54
  },
55
56
  environment: {
57
    CONN_STRING_STANDARD: serverlessStack.connectionString,
58
    DB_USER_SECRET_ARN: serverlessStack.dbUserSecret.secretArn,
59
  },
60
});
61
62
// allow the handler to read the db user secret
63
serverlessStack.dbUserSecret.grantRead(handler);
64
65
// create the API Gateway REST API with the lambda handler.
66
new apigw.LambdaRestApi(serverlessStack, 'RestAPI', { handler });

1
mkdir -p lambda/playground
2
touch lambda/playground/index.py

1
from datetime import datetime, timedelta
2
from pymongo.mongo_client import MongoClient
3
from pymongo.server_api import ServerApi
4
import random, json, os, re, boto3
5
6
# Function to generate a random datetime between two dates
7
def random_date(start_date, end_date):
8
    time_delta = end_date - start_date
9
    random_days = random.randint(0, time_delta.days)
10
    return start_date + timedelta(days=random_days)
11
12
def get_private_endpoint_srv(mongodb_uri, username, password):
13
    """
14
    Get the private endpoint SRV address from the given MongoDB URI.
15
    e.g. `mongodb+srv://my-cluster.mzvjf.mongodb.net` will be converted to 
16
    `mongodb+srv://<username>:<password>@my-cluster-pl-0.mzvjf.mongodb.net/?retryWrites=true&w=majority`
17
    """
18
    match = re.match(r"mongodb\+srv://(.+)\.(.+).mongodb.net", mongodb_uri)
19
    if match:
20
        return "mongodb+srv://{}:{}@{}-pl-0.{}.mongodb.net/?retryWrites=true&w=majority".format(username, password, match.group(1), match.group(2))
21
    else:
22
        raise ValueError("Invalid MongoDB URI: {}".format(mongodb_uri))
23
24
def get_public_endpoint_srv(mongodb_uri, username, password):
25
    """
26
    Get the private endpoint SRV address from the given MongoDB URI.
27
    e.g. `mongodb+srv://my-cluster.mzvjf.mongodb.net` will be converted to 
28
    `mongodb+srv://<username>:<password>@my-cluster.mzvjf.mongodb.net/?retryWrites=true&w=majority`
29
    """
30
    match = re.match(r"mongodb\+srv://(.+)\.(.+).mongodb.net", mongodb_uri)
31
    if match:
32
        return "mongodb+srv://{}:{}@{}.{}.mongodb.net/?retryWrites=true&w=majority".format(username, password, match.group(1), match.group(2))
33
    else:
34
        raise ValueError("Invalid MongoDB URI: {}".format(mongodb_uri))
35
36
37
  client = boto3.client('secretsmanager')
38
  conn_string_srv = os.environ.get('CONN_STRING_STANDARD')
39
  secretId = os.environ.get('DB_USER_SECRET_ARN')
40
  json_secret = json.loads(client.get_secret_value(SecretId=secretId).get('SecretString'))
41
  username = json_secret.get('username')
42
  password = json_secret.get('password')
43
44
def handler(event, context):
45
#   conn_string_private = get_private_endpoint_srv(conn_string_srv, username, password)
46
  conn_string = get_public_endpoint_srv(conn_string_srv, username, password)
47
  print('conn_string=', conn_string)
48
49
  client = MongoClient(conn_string, server_api=ServerApi('1'))
50
51
  # Select the database to use.
52
  db = client['mongodbVSCodePlaygroundDB']
53
54
  # Create 20 sample entries with dates spread between 2021 and 2023.
55
  entries = []
56
57
  for _ in range(20):
58
      item = random.choice(['abc', 'jkl', 'xyz', 'def'])
59
      price = random.randint(5, 30)
60
      quantity = random.randint(1, 20)
61
      date = random_date(datetime(2021, 1, 1), datetime(2023, 12, 31))
62
      entries.append({
63
          'item': item,
64
          'price': price,
65
          'quantity': quantity,
66
          'date': date
67
      })
68
69
  # Insert a few documents into the sales collection.
70
  sales_collection = db['sales']
71
  sales_collection.insert_many(entries)
72
73
  # Run a find command to view items sold in 2023.
74
  sales_2023 = sales_collection.count_documents({
75
      'date': {
76
          '$gte': datetime(2023, 1, 1),
77
          '$lt': datetime(2024, 1, 1)
78
      }
79
  })
80
81
  # Print a message to the output window.
82
  print(f"{sales_2023} sales occurred in 2023.")
83
84
  pipeline = [
85
      # Find all of the sales that occurred in 2023.
86
      { '$match': { 'date': { '$gte': datetime(2023, 1, 1), '$lt': datetime(2024, 1, 1) } } },
87
      # Group the total sales for each product.
88
      { '$group': { '_id': '$item', 'totalSaleAmount': { '$sum': { '$multiply': [ '$price', '$quantity' ] } } } }
89
  ]
90
91
  cursor = sales_collection.aggregate(pipeline)
92
  results = list(cursor)
93
  print(results)
94
  response = {
95
        'statusCode': 200,
96
        'headers': {
97
            'Content-Type': 'application/json'
98
        },
99
        'body': json.dumps({
100
            'sales_2023': sales_2023,
101
            'results': results
102
        })
103
    }
104
105
  return response

1
touch lambda/playground/requirements.txt 

1
pymongo
2
requests
3
boto3
4
testresources
5
urllib3==1.26

1
cd lambda/playground 
2
pip install -r requirements.txt -t .

1
npx cdk diff atlas-serverless-basic-stack
2
npx cdk deploy atlas-serverless-basic-stack

1
 curl -s https://[REDACTED].execute-api.eu-west-1.amazonaws.com/prod/ | jq -r .

1
npx cdk destroy atlas-serverless-basic-stack

1
npx cdk destroy mongodb-atlas-bootstrap-stack