Babu Srinivasan

Senior Partner Solutions Architect

Igor Alekseev

Partner Solutions Architect, Data & Analytics

Ashwin S.

Associate Architect, WeKan

In this tutorial, you'll discover how to securely host a Lambda application designed with a microservice architecture, utilizing AWS Lambda, Amazon API Gateway, and MongoDB Atlas. AWS Lambda is pivotal for enterprises, offering standardized serverless deployment, enhanced security, and streamlined management, which collectively lead to consistent performance and simplified operations. 

This guide not only details the process of setting up and deploying a MongoDB Atlas-based application with a microservice and API pattern but also provides a robust framework applicable to any such deployment. By leveraging AWS CDK for automated deployment, you ensure a scalable, efficient, and secure solution that meets enterprise needs and accelerates your deployment process across various environments.

To follow along with this tutorial, you should have intermediate proficiency with AWS and MongoDB services.

## Architecture diagram

![AWS Lambda architecture diagram][1]

The architecture described here includes the following components:

1. [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/): Public Repository for AWS Lambda application 
2. [AWS Lambda](https://aws.amazon.com/pm/lambda/): Hosts the microservices logic
3. [Amazon API Gateway](https://aws.amazon.com/es/api-gateway/): Exposes the Lambda functions as RESTful APIs
4. [MongoDB Atlas](https://www.mongodb.com/products/platform/atlas-database): Stores the application data securely

## Implementation steps to set up your Lambda application

This tutorial assumes `us-east-1` as the default region. Please update the scripts to your specific region. if required.

### Prerequisites

Before proceeding, ensure you have the following prerequisites installed:

- AWS account with IAM creation role
- AWS CLI: [Install AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)
- IAM user for AWS CLI with access keys and secret keys
- SAM CLI: [Install SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)
- Docker: [Install Docker](https://docs.docker.com/engine/install/)
- Python 3.10: [Install Python 3.10](https://www.python.org/downloads/release/python-3100/)

### Setting up the environment

Clone the application repository.

```
git clone https://github.com/mongodb-partners/Microservice-api-lambda-MongoDBAtlas
cd Microservice-api-lambda-MongoDBAtlas
```

Configure AWS CLI.

```
aws configure
```
Enter your AWS Access Key ID, Secret Access Key, and preferred region.

Set up the Python virtual environment.

```
python3 -m venv .venv
source .venv/bin/activate
pip3 install -r lambda/python-crud-lambda/requirements.txt
```
To build the project locally, execute the following command:

```
sam build
```

This command will locally build the project, and output files will be saved in the .aws-sam folder.

### Set up MongoDB Atlas 

- [Set up a MongoDB Atlas cluster](https://www.mongodb.com/pt-br/docs/atlas/tutorial/create-new-cluster/).
- Set up the [network access](https://www.mongodb.com/pt-br/docs/atlas/security/add-ip-address-to-list/).
- Set up the [database users](https://www.mongodb.com/pt-br/docs/atlas/tutorial/create-mongodb-user-for-cluster/).
- Copy and note the [connection string](https://www.mongodb.com/pt-br/docs/atlas/driver-connection/). This string will be used to set up the Lambda application.

Use an existing connection string: Ensure you have the complete MongoDB SRV connection string with your username and password included. Ensure that Lambda can access your cluster. For testing purposes, you can use `0.0.0.0/0` in your network IP access list. In production, consider setting up a VPC peering connection between your AWS VPC and the Atlas VPC. This will restrict public access and only accept connections from your VPC. Learn more about VPC peering in the [MongoDB Atlas documentation](https://docs.atlas.mongodb.com/vpc-peering/).

### Deploying the application

Execute the following command to deploy the application:

bash
```
sam deploy --guided
```

Follow the guided deploy instructions:

* Stack Name: Enter a name for your stack.
* AWS Region: Enter your preferred region.
* Parameter ConnectionString: Enter your MongoDB connection string.
* Parameter DBName: Enter the name of your MongoDB database.
* Parameter CollectionName: Enter the name of your MongoDB collection.

Sample values for deployment

```
  Setting default arguments for 'sam deploy'
        =========================================
        Stack Name [sam-app]: sam-app-api-mdb
        AWS Region [us-east-1]: 
        Parameter ConnectionString []: mongodb+srv://test1:test1@demo.mongodb.net/?retryWrites=true&w=majority
        Parameter DBName [test]: sam-app-api-mdb
        Parameter CollectionName [test]: microservice-lambda-app
        #Shows you resources changes to be deployed and require a 'Y' to initiate deploy
        Confirm changes before deploy [y/N]: y
        #SAM needs permission to be able to create roles to connect to the resources in your template
        Allow SAM CLI IAM role creation [Y/n]: y
        #Preserves the state of previously provisioned resources when an operation fails
        Disable rollback [y/N]: y
        CRUDLambda has no authentication. Is this okay? [y/N]: y
        Save arguments to configuration file [Y/n]: y
        SAM configuration file [samconfig.toml]: 
        SAM configuration environment [default]:
```

![Sample deployment screenshot][2]

Wait for the CloudFormation stack to finish creating the stack. After deployment, you will receive the API Gateway link in the outputs.

![Cloud formation stack completion][3]

![AWS Cloudformation console][4]

### Create a S3 bucket

Create an S3 public bucket to store the Lambda code and restrict the access through bucket policy.

```
aws s3api create-bucket --bucket aws-sam-cli-mongodb-app1 --region us-east-1

aws s3api put-bucket-policy --bucket my-unique-bucket-name --policy '{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service":  "serverlessrepo.amazonaws.com"
            },
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::aws-sam-cli-mongodb-app1/*",
            "Condition" : {
                "StringEquals": {
                    "aws:SourceAccount": "<aws account id >"
                }
            }
```

### Packaging the application

Package the serverless application model (SAM) deployed application to the S3 bucket created in the previous steps of SAM build.

```
sam package --template-file template.yaml --output-template-file packaged.yaml --s3-bucket aws-sam-cli-mongodb-app1
```

### Publishing the application

To publish your application as a serverless application model package, execute the following command:

bash
```
sam publish --template packaged.yml --region us-east-1
```

Follow the instructions to publish your application. By default, your application will be published as a private app. After publication, you can convert it to a public app if needed. For detailed guidance, refer to the [SAM documentation on publishing an application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html).

#### Verification and validation

Use the API Gateway link received in the deployment outputs to test the APIs. You can use Postman or any other request-making tool.

* Postman collection: Import the Postman collection `postman/Python-Microservice.postman_collection.json` into Postman to test the API.

### Clean up

Use the following command to clean up all the AWS resources created during deployment:

```
sam delete
```

### Troubleshooting

Refer to the [GitHub repository](https://github.com/mongodb-partners/Microservice-api-lambda-MongoDBAtlas) to resolve common issues encountered when using AWS SAM with MongoDB Atlas.

### Useful links

* [Serverless Application Repository (SAR)](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/what-is-serverlessrepo.html)
* [SAM deployment](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html)

### Useful commands

* `sam build`: Builds the project locally
* `sam deploy --guided`: Deploys the application with guided prompts
* `sam publish --template packaged.yaml`: Publishes the application as a SAM package
* `sam delete`: Deletes the deployed application

By following these steps, you can set up a private hosting environment for your microservices-based Lambda application using AWS services and MongoDB Atlas. This setup ensures a secure, scalable, and cost-effective solution for hosting serverless microservices applications.

Try out the AWS [API Gateway](https://aws.amazon.com/api-gateway/)! For any MongoDB related queries, visit the [MongoDB community support](https://www.mongodb.com/community/). 



  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf1cfa4e5d1b8c13e/66ec5b5afbc1b9d136d70704/aws-lambda-architecture-diagram.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0dded2b9d1c42dbb/66ec5cbc9ae20569ca6856fb/sample-deployment-screenshot.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9b404fedc472dc72/66ec5ce0164dbf1f8a5afd2f/cloud-formation-stack-completion.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt815080f2f6d5309a/66ec5d06a924ba186bdf54ee/aws-cloudformation-console.png

Learn to set up and deploy an Atlas-based application with a microservice and API pattern and get a framework applicable to any such deployment.

Ashwin S.

Conteúdo por Ashwin S.

Securely Hosting a Lambda Application With a Microservice Architecture and MongoDB Atlas