Babu Srinivasan

Senior Partner Solutions Architect

MongoDB

Anuj Panchal

Partner Solutions Architect

Igor Alekseev

Partner Solutions Architect, Data & Analytics

In this tutorial, you'll find a tangible showcase of how AWS Glue, Amazon Kinesis, and MongoDB Atlas seamlessly integrate, creating a streamlined data streaming solution alongside extract, transform, and load (ETL) capabilities. This repository also harnesses the power of AWS CDK to automate deployment across diverse environments, enhancing the efficiency of the entire process.

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

## Architecture diagram

![architecture diagram][1]

In the architecture described above, various streams of data, such as Order and Customer, are retrieved via the Amazon Kinesis stream. Subsequently, AWS Glue Studio is utilized to enrich the data. The enriched data is backed up in an S3 bucket, while the consolidated stream is stored in MongoDB Atlas and made accessible for downstream systems.

## Implementation steps

### Prerequisites

 - [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installed and configured
 - [NVM/NPM](https://nvm.sh/) installed and configured
 - [AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) installed and configured
 - [MongoDB Atlas account](https://www.mongodb.com/docs/atlas/tutorial/create-atlas-account/), with the [Organization](https://www.mongodb.com/docs/atlas/government/tutorial/create-organization/#create-an-organization) set up
 - [Python packages](https://www.python.org/downloads/)
     - Python3 - `yum install -y python3`
     - Python Pip - `yum install -y python-pip`
     - Virtualenv - `pip3 install virtualenv`

>This repo is developed taking us-east-1 as the default region. Please update the scripts to your specific region (if required). This repo will create a MongoDB Atlas project and a free-tier database cluster automatically. No need to create a database cluster manually. This repo is created for a demo purpose and IP access is not restricted (0.0.0.0/0). Ensure you strengthen the security by updating the relevant IP address (if required).

### Setting up the environment

#### Get the application code

`git clone https://github.com/mongodb-partners/Stream_Data_into_MongoDB_AWS_Glue
cd kinesis-glue-aws-cdk`

#### Prepare the dev environment to run AWS CDK

a. Set up the AWS Environment variable AWS Access Key ID, AWS Secret Access Key, and optionally, the AWS Session Token.

```
export AWS_ACCESS_KEY_ID = <"your AWS access key">
   export AWS_SECRET_ACCESS_KEY =<"your AWS secret access key">
   export AWS_SESSION_TOKEN = <"your AWS session token">
```
b. We will use CDK to make our deployments easier. 

You should have npm pre-installed.
If you don’t have CDK installed:
`npm install -g aws-cdk`

Make sure you’re in the root directory.
`python3 -m venv .venv`
`source .venv/bin/activate`
`pip3 install -r requirements.txt`

> For development setup, use requirements-dev.txt.

c. Bootstrap the application with the AWS account.

`cdk bootstrap`

d. Set the ORG_ID as an environment variable in the .env file. All other parameters are set to default in global_args.py in the kinesis-glue-aws-cdk folder. MONGODB_USER and MONGODB_PASSWORD parameters are set directly in mongodb_atlas_stack.py and glue_job_stack.py

The below screenshot shows the location to get the Organization ID from MongoDB Atlas.

![Organization ID in MongoDB Atlas][3]

Please note that using "0.0.0.0/0" as an IP_ADDRESS, we are allowing access to the database from anywhere. This might be suitable for development or testing purposes but is highly discouraged for production environments because it exposes the database to potential attacks from unauthorized sources.

e. List the CDKs:

`cdk ls`

You should see an output of the available stacks:

    `aws-etl-mongo-atlas-stack`
    `aws-etl-kinesis-stream-stack`
    `aws-etl-bucket-stack`
   ` aws-etl-glue-job-stack`

### Deploying the application

Let’s walk through each of the stacks:

**Stack for MongoDB Atlas: aws-etl-mongo-atlas-stack**
This stack will create a MongoDB Atlas project and a free-tier database cluster with user and network permission (open).

#### Prerequisites

a. Create an AWS role with its trust relationship as a CloudFormation service.

Use the [template](https://github.com/mongodb/mongodbatlas-cloudformation-resources/blob/master/examples/execution-role.yaml) to create a new [CloudFormation stack](https://console.aws.amazon.com/cloudformation/home#/stacks/create) to create the execution role.

![Creating a new CloudFormation stsack][4]

b.The following Public Extension in the CloudFormation Registry should be activated with the Role created in the earlier step. After logging into the AWS console, use this link to register extensions on CloudFormation.

```
          MongoDB::Atlas::Project,
          MongoDB::Atlas::DatabaseUser,
          MongoDB::Atlas::Cluster,
          MongoDB::Atlas::ProjectIpAccessList
```
Pass the ARN of the role from the earlier step as input to activate the MongoDB resource in Public Extension.

MongoDB Resource Activation in Public Extension:

![Activation of Registry Public Extensions][5]

The above screenshot shows the activation of the Registry Public Extensions for the MongoDB::Atlas::Cluster.

Alternatively, you can activate the above public extension through AWS CLI.

Command to list the MongoDB Public Extensions. Note down the arns for the above four public extensions.

```
aws cloudformation list-types \
  --visibility PUBLIC \
  --filters "Category=THIRD_PARTY,TypeNamePrefix=Mongodb"
```

Command to activate the Public Extension. Use this command to activate all four public extensions mentioned in the previous steps.

```
aws cloudformation activate-type --region us-east-1 --public-type-arn "<arn for the public extension noted down in the previous step>" --execution-role-arn "<arn of the role created in step a>"
```

c. Log into the MongoDB console and note down the organization ID. Ensure the Organization ID is updated in the global_args.py

![Cluster organization settings][6]

The above screenshot shows the MongoDB Cluster Organization settings.

d. Create an API Key in an organization with Organization Owner access. Note down the API credentials.

![Edit API key][7]

The above screenshot shows the access managers for the API Key created in the MongoDB Atlas cluster.

Restrict the access to the Organization API with the API Access list. We provided an open access 0.0.0.0/1 for demo purposes only. We strongly discourage the use of this in any production environment or equivalent.

e. A profile should be created in the AWS Secrets Manager containing the MongoDB Atlas Programmatic API Key.

Use the [template](https://github.com/mongodb/mongodbatlas-cloudformation-resources/blob/master/examples/profile-secret.yaml) to create a new CloudFormation [stack](https://console.aws.amazon.com/cloudformation/home#/stacks/create) for the default profile that all resources will attempt to use unless a different override is specified.

#### Profile secret stack

![AWS CloudFormation stack][8]

The above screenshot shows the parameters for the AWS CloudFormation stack.

Initiate the deployment with the following command:

```bash
  cdk deploy aws-etl-mongo-atlas-stack
  ```
After successfully deploying the stack, validate the Outputs section of the stack and MongoDB Atlas cluster. You will find the stdUrl and stdSrvUrl for the connection string.

#### Stack:

![Output of CloudFormation stack][8]

The above screenshot shows the output of the CloudFormation stack.

#### MongoDB Atlas cluster:

![Creation of a MongoDB Atlas cluster][9]

The above screenshot shows the successful creation of the MongoDB Atlas cluster.

### Stack for creating the Kinesis stream: aws-etl-kinesis-stream-stack

This stack will create two Kinesis data streams. Each producer runs an ingesting stream of events for different customers with their orders.

Initiate the deployment with the following command:

  ```bash
  cdk deploy aws-etl-kinesis-stream-stack
  ```
After successfully deploying the stack, Check the Outputs section of the stack. You will find the CustomerOrderKinesisDataStream Kinesis function.

#### Stack:

![Output of the CloudFormation stack][10]

The above screenshot shows the output of the CloudFormation stack for Kinesis streams.

#### Amazon Kinesis data stream:

![Kinesis stream][11]

The above screenshot shows the Kinesis stream created.

### Stack for creating the S3 bucket: aws-etl-bucket-stack

This stack will create an S3 bucket that will be used by AWS Glue jobs to persist the incoming customer and order details.

  ```bash
  cdk deploy aws-etl-bucket-stack
  ```
After successfully deploying the stack, check the Outputs section of the stack. You will find the 
S3SourceBucket resource.

#### Stack:

![Output of the CloudFormation stack][12]

The above screenshot shows the Output of the CloudFormation stack.

AWS S3 Bucket:

![S3 buckets created][13]

The above screenshot shows the S3 buckets created.

### Stack for creating the AWS Glue job and parameters: aws-etl-glue-job-stack

This stack will create two AWS Glue jobs: one job for the customer and another for the order. The code is in the location glue_job_stack/glue_job_scripts/customer_kinesis_streams_s3.py and glue_job_stack/glue_job_scripts/order_kinesis_streams_s3.py.

  ```bash
  cdk deploy aws-etl-glue-job-stack
  ```
#### Stack:

![Output of CloudFormation stack][14]

The above screenshot shows the output of the CloudFormation stack.

#### AWS Glue job:

![AWS Glue Studio][15]

The above screenshot shows the AWS Glue Studio job to set up the job.

#### Note

The MongoDB URL of the newly created cluster and other parameters will be passed to the AWS Glue job programmatically. Update these parameters to your values (if required).

"Spark UI logs path" and "Temporary path" details will be maintained in the same bucket location with folder name /sparkHistoryLogs and /temporary.

#### Spark UI logs path:

  `s3://<S3_BUCKET_NAME>/sparkHistoryLogs` 

#### Temporary path:

  `s3://<S3_BUCKET_NAME>/temporary/`

#### Screenshot of the AWS Glue parameters

![AWS Glue parameters][16]

The above screenshot shows the AWS Glue parameters.

Once you are ready with all stacks, start the producers for the customer and order. The code is in this location, to ingest data into a kinesis data stream and also start the Glue job for both.

  `producer/customer.py` and `producer/order.py`

#### Sample record in MongoDB Atlas:

```
{
  "_id": "1",
  "country_id": "1",
  "customer_name": "NICK",
  "email_id": "nick@gmail.com",
  "orders": [
    {
      "order_id": "8",
      "product_name": "Artisanal Cheese Selection",
      "quantity": "8",
      "price": "29.17"
    }
  ]
}
```

## Clean up

Use `cdk destroy` to clean up all the AWS CDK resources. 

## Troubleshooting

Refer to [GitHub](https://github.com/mongodb/mongodbatlas-cloudformation-resources/tree/master#troubleshooting) to resolve some common issues encountered when using AWS CloudFormation/CDK with MongoDB Atlas Resources.

## Useful commands

`cdk ls` lists all stacks in the app.
`cdk synth` emits the synthesized CloudFormation template.
`cdk deploy` deploys this stack to your default AWS account/region.
`cdk diff` compares the deployed stack with the current state.
`cdk docs` opens CDK documentation.


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt23fd6a56157b9c41/675b1787cc57be7a2703736d/img-1-fix.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt95d66e4812fd56ed/661e9e36e9e603e1aa392ef0/architecture-diagram.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt401e52a6c6ca2f6f/661ea008f5bcd1bf540c99bd/organization-settings.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltffa00dde10848a90/661ea1fe190a257fcfbc5b4e/cloudformation-stack.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltcc9e58d51f80206d/661ea245ad926e2701a4985b/registry-public-extensions.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc5a089f4695e6897/661ea2c60d5626cbb29ccdfb/cluster-organization-settings.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt1a0bed34c4fbaa4f/661ea2ed243a4fa958838c90/edit-api-key.png
  [8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt697616247b2b7ae9/661ea35cdf48e744da7ea2bd/aws-cloud-formation-stack.png

In this tutorial, find a tangible showcase of how AWS Glue, Amazon Kinesis, and MongoDB Atlas seamlessly integrate.

Stream Data Into MongoDB Atlas Using AWS Glue

Partner

Dan Kiuna

Specialist Solutions Architect at AWS

In today’s fast-paced digital landscape, turning innovative ideas into fully functional applications quickly and efficiently is essential for developers, startups, and business consultants. This repository is designed to empower you to do just that. By leveraging [AWS Amplify](https://aws.amazon.com/amplify) for seamless front-end development, [AWS AppSync](https://aws.amazon.com/pm/appsync/) for robust and scalable backend services, and [MongoDB Atlas](https://www.mongodb.com/products/platform/atlas-database) for a flexible and powerful database solutions, developers can build  comprehensive, low-code solutions while drastically reducing coding time and maintaining high standards of performance and scalability.

This tutorial and repository provides a starter template for building applications with React and AWS Amplify, seamlessly connecting to MongoDB Atlas. It simplifies the setup for authentication, API integration, and database capabilities. With a foundational React application pre-integrated with AWS Amplify, this template is optimized for scalability and performance, making it perfect for developers, startups, and business consultants seeking to jumpstart their projects with pre-configured AWS services like Cognito, AppSync, and MongoDB Atlas


# AWS Amplify

AWS Amplify simplifies the creation of full-stack applications with minimal configuration. It provides a set of tools and services that integrate seamlessly with popular frameworks like React, Angular, and Vue, enabling developers to easily set up scalable backends, manage authentication, and deploy applications with a few simple commands. Amplify recently launched "Amplify Gen 2" which enhances support for CI/CD workflows, improves the developer experience with the Amplify CLI, and expands capabilities for backend infrastructure as code. These updates facilitate easier management and deployment of cloud resources, integration of serverless functions, and connection to MongoDB Atlas data sources through AWS AppSync and Lambda, thus significantly reducing the time and effort required to build and scale modern applications


# AWS AppSync

AWS AppSync is a fully managed service that simplifies the development of GraphQL APIs by automatically handling data fetching, real-time updates, and offline synchronization. It seamlessly integrates with various data sources, including MongoDB Atlas, allowing developers to build scalable and flexible applications with ease. AppSync’s features include built-in support for real-time data updates and offline access, reducing the complexity of managing data interactions and enhancing application performance


# MongoDB Atlas

MongoDB Atlas is a fully managed cloud database service known for its operational excellence and scalability. It offers advanced features like [automated backups](https://www.mongodb.com/docs/atlas/backup-restore-cluster/), [scaling](https://www.mongodb.com/docs/atlas/cluster-autoscaling/), and [monitoring](https://www.mongodb.com/docs/atlas/monitoring-alerts/), ensuring high availability and performance. Notably, Atlas includes [Vector Search](https://www.mongodb.com/products/platform/atlas-vector-search) capabilities, which are optimized for Generative AI use cases, enabling efficient search and retrieval of high-dimensional data. This feature enhances the ability to perform complex queries and data analysis, making it ideal for applications requiring sophisticated data interactions and AI-driven insights


# Application Features

In this blog we implement a Todo Application that supports authentication by leveraging Amazon Cognito.  The application frontend is written in React, while the backend is a GraphQL API powered by AWS AppSync and AWS Lambda.  The persistence layer is provided by MongoDB Atlas.  For the application’s CI/CD and hosting we rely on out-of-the-box capabilities for AWS Amplify. 


# Reference Architecture

![Reference Architecture][1]

# Prerequisites

In order to deploy the application you need to have [MongoDB Atlas Cluster](https://www.mongodb.com/docs/atlas/reference/amazon-aws/) created and an AWS Account.


# Deploying to AWS


## Step 1 

Create a fork of this repository: `https://github.com/mongodb-partners/amplify_appsync_mongodb_atlas_startup.git`


## Step 2

Set up the MongoDB Atlas cluster.  Follow the [link](https://www.mongodb.com/docs/atlas/tutorial/create-atlas-account/) to the setup the [MongoDB Atlas cluster](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/), Database, [User](https://www.mongodb.com/docs/atlas/security-add-mongodb-users/) and [Network access](https://www.mongodb.com/docs/atlas/security/add-ip-address-to-list/).


## Step 3

Obtain a connection URL

![Obtain Connection URL][2]

## Step 4

Deploy the To-do Application in AWS Amplify.  Open the AWS Amplify console and select the Github option

![Deploy to Amplify][3]

Authenticate to GitHub and select the repository you created earlier by forking.

![Authenticate to Github][4]

Set all other options to default and deploy

![Set options and deploy][5]

Configure the Environment Variables.  Note the deployments will not succeed until the environment variables are set.

![Configure Environment Variables][6]

## Step 5

Test the deployed application

![Test Deployed App][7]

Verify objects are being stored in the MongoDB Atlas Collection

![Verify Objects in Atlas][8]

# Conclusion

In this tutorial we showed how to deploy an application using MongoDB Atlas and AWS Amplify.  If you have ideas on how to enhance the application, please submit a pull request for this [repository](https://github.com/mongodb-partners/amplify_appsync_mongodb_atlas_startup.git).  Try out [Amplify](https://aws.amazon.com/amplify) and [MongoDB Atlas](https://www.mongodb.com/products/platform/atlas-cloud-providers/aws). 


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta049d55e02416f45/67476b746cdeea5d78739042/1_image.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta216e9c18d842ecd/67476b7590460d1dc6eec0c1/2_image.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt96b97ad3d3a74d5b/67476b75de20c047b3d2e24d/3_image.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt84a5be280ad41dc8/67476b74e19373eaeca5c960/4_image7.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt0ad8b3e59f91dcd2/67476b743aff4e4673d5ffaf/5_image.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt13b8f42aef4040fc/67476b744dc5f075b29ba75e/6_image.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt47ec9c14b9922001/67476b749a83052898868d03/7_image.png
  [8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta3205cb067033e6e/67476b7546524214bfd349fa/8_image.png

This article and repository provides a starter template for building applications with React and AWS Amplify, seamlessly connecting to MongoDB Atlas. It simplifies the setup for authentication, API integration, and database capabilities.

Fullstack Application Development with AWS Amplify, AppSync, and MongoDB Atlas

Venkatesh Shanbhag

Partner Solution Architect

[AWS Glue](https://aws.amazon.com/glue/) is a serverless data integration service. It simplifies data processing for customers. Migrating data between MongoDB Atlas and AWS becomes efficient with AWS Glue's visual ETL (Extract, Transform, and Load) capabilities. The visual interface and built-in features allow data extraction and insertion to and from MongoDB Atlas collections, with optional transformations, before loading it to the target location. This serverless and scalable approach ensures cost-effective data movement while maintaining security through IAM roles. In this post, we will go through a visual approach to utilize MongoDB Atlas and AWS Glue for building pipelines between the two platforms. 

To follow this post and test out AWS Glue’s capabilities with MongoDB Atlas, we need an [AWS account](https://aws.amazon.com/free/) and a subscription to MongoDB Atlas. You can subscribe to MongoDB Atlas from the [AWS marketplace](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092). 

The post describes a process for transferring data between MongoDB Atlas and [AWS S3](https://aws.amazon.com/s3/) using AWS Glue's visual ETL capabilities. These capabilities allow developers to create ETL pipelines without the knowledge of Spark or SQL by leveraging [AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html). This post highlights the benefits of using AWS Glue for data transformation and integration with other AWS services. AWS S3—being highly scalable, durable, and cost-effective object storage—can be used as data lakes, a data warehousing solution, machine learning, media streaming, backup and recovery, and web hosting.


## Set up MongoDB Atlas



1. Configure a MongoDB cluster on AWS. For instructions, refer to [How to Set Up a MongoDB Cluster](https://www.mongodb.com/basics/clusters/mongodb-cluster-setup).
2. Configure PrivateLink by following the steps described in [Connecting Applications Securely to a MongoDB Atlas Data Plane with AWS PrivateLink](https://aws.amazon.com/blogs/apn/connecting-applications-securely-to-a-mongodb-atlas-data-plane-with-aws-privatelink/). With AWS PrivateLink, we will simplify our networking architecture and make sure the traffic stays on the AWS network.
3. To obtain your MongoDB cluster connection string from the Connect UI on the MongoDB Atlas console, navigate to your Atlas home screen and click on **Connect** for the AWS cluster you want to connect. Select the Private Endpoint and Connection Method.
4. Copy the SRV connection string. We use this SRV connection string in the subsequent steps.

![Image 1: Connect to MongoDB Atlas using connection string][1]

The following screenshot shows that we have loaded a sample collection (in this case, sample weather data) in MongoDB Atlas, which we will connect to in the next steps. Note: The records in this collection include several arrays as well as nested data.

![Image 2: MongoDB Sample dataset][2]

## Set up the MongoDB Atlas connection with AWS Glue

Before we can configure the AWS Glue crawler, we need to create the MongoDB Atlas connection in AWS Glue.

1. On the AWS Glue Studio console, choose **Connectors** in the navigation pane.
2. Choose **Create connection**.

![Image 3: AWS Glue Data Connections interface][3]

1. When filling out the connection details, use the SRV connection string we obtained earlier in MongoDB Atlas.
2. In the Network options section, add the VPC and subnet. Important: The VPC and the subnet must correspond to the PrivateLink settings you configured earlier.

![Image 4: Create Glue connection for MongoDB Atlas][4]

## **Create and run an ETL job to extract data from MongoDB Atlas into S3**

Once the connection is configured, Navigate to the Glue | ETL jobs | Visual ETL to create the ETL job. 

To open the Glue visual editor, either click on **Visual ETL** or **Author and edit ETL jobs**, and then click on **visual ETL** on the next screen. 

![Image 5: Navigation to AWS Glue ETL interface][5] 

If you have saved jobs, you can access them from the AWS Glue studio, as well. 

![Image 6: Creating a Visual ETL job on AWS Glue][6] 

Click on **(+)** on the home screen of the Glue visual editor to add nodes. Search for MongoDB and select MongoDB as the source to read from the previously created connection. 

![Image 7: MongoDB connector on AWS Glue visual ETL][7] 

Select the MongoDB connection and provide the database and collection name. Save the pipeline. 

![Image 8: Configuring the connector on AWS Glue Visual ETL][8]

Click on **(+)** to add one more node and search for S3. Select Amazon S3 as Target. Select MongoDB as Node parent.

![Image 9: Configuring S3 bucket connection AWS Glue Visual ETL][9]

Select the data format for your destination data file. Select the S3 bucket where you want to write the data and click on **Save**.

![Image 10:  Configuring S3 bucket connection AWS Glue Visual ETL][10]

Run the job by clicking the button in the top right corner. 

![Image 11: Run ETL job to move data between MongoDB Atlas and AWS S3][11]

The job will take a few minutes to complete. You can monitor your job on the **Runs** tab, as shown below.

![Image 12: Visualizing the ETL job running][12]

You can verify your data written to S3 by navigating to your S3 bucket.

![ Image 13: Verify the the document moved to S3 bucket in parquet format][13]

Watch this Video to see the steps in action 

:youtube[]{vid=s6tcfJmCfOk}

AWS Glue Visual ETL simplifies creating and managing data transformations, allowing developers to create ETL pipelines without the specialized knowledge of data engineering tools.  It offers connectors to numerous third-party and AWS-native products and services. This enables you to enrich data from various sources for analysis in data warehousing, while building efficient pipelines effortlessly with Glue Visual ETL. For advanced data transformations involving MongoDB Atlas, refer to the AWS Glue [documentation](https://docs.aws.amazon.com/glue/latest/dg/setting-up.html). 

> Questions? Join us in the [MongoDB Developer Community](https://www.mongodb.com/community/forums/).


  [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4a9fa2fff6d9b885/673fc6d8465242c67fd32c47/1_image9.png
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt970ab5fff863c851/673fc6d89a8305490a866d95/2_image1.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt22a70c1fe48d3154/673fc6d86cdeea0ea5737347/3_image10.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt00d124b5c42f118c/673fc6d8cf4732173a8c0809/4_image6.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltbc5a422b09e24d5d/673fc6d856ed541fae12a76b/5_image12.png
  [6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt494761313ed4d15f/673fc6d8cf47324a718c080d/6_image2.png
  [7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt891755349ade2bb9/673fc6d91621f678eb6e565c/7_image13.png
  [8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd93f53ca66c2cae6/673fc6d890460d596ceea3be/8_image7.png
  [9]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltcfa835145afef9da/673fc6d827811852005d4c20/9_image8.png
  [10]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltcdd49bd11d835f96/673fc72456ed5472ed12a774/10_image3.png
  [11]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6a05686e42a4c2dd/673fc7244b282e80cc80d01c/11_image4.png
  [12]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt017f5312b77c02c3/673fc72412a5ea220b93319b/12_image11.png
  [13]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blted39ae527c5bb575/673fc72456ed548c5812a772/13_image5.png

This post highlights the benefits of using AWS Glue for your data in MongoDB Atlas for data transformation and integration with other AWS services. 

Anuj Panchal

Content by Anuj Panchal

Stream Data Into MongoDB Atlas Using AWS Glue

Fullstack Application Development with AWS Amplify, AppSync, and MongoDB Atlas

AWS Glue Visual ETL for Your Data in MongoDB Atlas