Community

Karen Zhang

Community author

Nowadays, choosing the right database and deployment platform can make a significant difference in your application's performance and scalability. This tutorial will guide you through creating a Flask application that uses MongoDB Atlas and deploying it on Fly.io, a platform that makes deployment and scaling a breeze.

In this tutorial, we'll build a location-based discovery API using Flask and MongoDB Atlas. By combining Flask's simplicity with MongoDB's powerful geospatial features, we'll create a RESTful API that allows users to store, search, and discover locations. Whether you're building a travel app, a local business finder, or any location-aware service, this tutorial will show you how to leverage MongoDB's GIS capabilities for spatial queries, implement text search, and use aggregation pipelines for insights. We'll use MongoDB Atlas, a fully managed cloud database service, making it easy to deploy and scale our application, and Fly.io for hosting our Flask application in the cloud. All the code can be found on [GitHub](https://github.com/Karenzhang7717/flask-mongodb-fly/tree/main).

## 1. Set up the development environment

Before we dive into coding, let's set up our development environment:

1. Install Python (if you haven't already).
2. Create a new directory for your project:

   ```sh
   mkdir flask-mongodb-fly
   cd flask-mongodb-fly
   ```

3. Create and activate a virtual environment:

   ```sh
   python -m venv venv
   source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
   ```

4. Install the required packages:

   ```sh
   pip install Flask pymongo gunicorn
   ```

   ![Installing required packages][image1]

5. Create a `requirements.txt` file:

   ```sh
   pip freeze > requirements.txt
   ```

## 2. Create a basic Flask application

Let's create a simple Flask application with routes for CRUD operations and a geospatial query. Create a file named `app.py` with the following content:

```python
import os
from flask import Flask, request, jsonify
from pymongo import MongoClient
from bson import json_util
import json

app = Flask(__name__)

# MongoDB Atlas connection string
mongodb_uri = os.environ.get("MONGODB_URI", "mongodb://localhost:27017/geoapp")
client = MongoClient(mongodb_uri)
db = client.get_database()

@app.route("/")
def hello_world():
    return "Hello, World\! This is a Flask & MongoDB app deployed on Fly.io"

@app.route("/locations", methods=["POST"])
def add_location():
    data = request.json
    result = db.locations.insert_one(data)
    return (jsonify({"message": "Location added successfully", "id": str(result.inserted_id)}), 201,)

@app.route("/locations", methods=["GET"])
def get_locations():
    locations = list(db.locations.find())
    return json.loads(json_util.dumps(locations))

@app.route("/nearby", methods=["GET"])
def find_nearby():
    lat = float(request.args.get("lat"))
    lon = float(request.args.get("lon"))
    max_distance = int(request.args.get("distance", 1000))  # Default to 1000 meters

    nearby = db.locations.find({
        "location": {
            "$near": {
                "$geometry": {
                    "type": "Point",
                    "coordinates": [lon, lat]
                },
                "$maxDistance": max_distance
            }
        }
    })

    return json.loads(json_util.dumps(list(nearby)))

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080) # change to your ip address
```

This application includes:

- A home route ("/") that returns a simple greeting.
- A route to add new locations ("/locations" - POST).
- A route to retrieve all locations ("/locations" - GET).
- A route to find nearby locations based on coordinates and distance ("/nearby" - GET).

## 3. Integrate MongoDB with Flask

To use MongoDB with our Flask application, we need to set up a MongoDB Atlas account and create a cluster:

1. Sign up for a [free MongoDB Atlas account](https://www.mongodb.com/cloud/atlas).
2. Create a new cluster (choose the free tier for testing).
3. In the Security tab, create a database user and whitelist your IP address.
   ![][image2]
   ![][image3]
4. In the Clusters tab, click "Connect" and choose "Connect your application." You need to use the Python driver. Since we already installed PyMongo in Step 4 while  setting up the development environment, we just need to add your connection string into the application code. Create an .env file in your project and add MONGODB_URI
as an environment variable. Then, copy and paste the connection string.
   ![][image4]
   ![][image5]
5. Replace `<password>` with your database user's password. This can be found in Security -> Database Access. The user should at least have read and write permission to the database.
   ![][image6]

## 4. Test the application locally

Before deploying, let's test our application locally:

1. Set the `MONGODB_URI` environment variable:

   ```sh
   export MONGODB_URI="your_mongodb_atlas_connection_string"
   ```
   Replace `your_mongodb_atlas_connection_string` with your actual connection string.

2. Run the Flask application:

   ```sh
   python app.py
   ```

3. Test the endpoints using URL:

   ```sh
   # Add a location
   curl -X POST http://localhost:8080/locations -H "Content-Type: application/json" -d '{"name": "Eiffel Tower", "location": {"type": "Point", "coordinates": [2.2945, 48.8584.}}'

   # Get all locations
   curl http://localhost:8080/locations

   # Find nearby locations
   curl "http://localhost:8080/nearby?lat=48.8584.lon=2.2945.distance=5000"
   ```

## 5. Deploy to Fly.io

Now, let's deploy our application to Fly.io:

1. Install the Fly CLI:

   ```sh
   curl -L https://fly.io/install.sh | sh
   ```

2. Sign up and log in to Fly.io:

   ```sh
   fly auth signup
   fly auth login
   ```

3. Set the MongoDB URI as a secret:

   ```sh
   fly secrets set MONGODB_URI="your_mongodb_atlas_connection_string"
   ```

   Replace `your_mongodb_atlas_connection_string` with your actual connection string.

4. Set up the configuration:

   ```sh
   fly launch
   ```

   `fly launch` is a command that initializes your application on Fly.io by creating a `fly.toml` configuration file and setting up the necessary infrastructure.

   The file.toml file will look something like this:

   ```toml
   # fly.toml app configuration file generated for flask-mongodb-fly-late-dew-6702 on 2024-11-18T15:45:10-07:00
   #
   # See https://fly.io/docs/reference/configuration/ for information about how to use this file.
   #

   app = 'your-app-name’'
   primary_region = 'sea'

   [build]

   [http_service]
   internal_port = 8080
   force_https = true
   auto_stop_machines = 'stop'
   auto_start_machines = true
   min_machines_running = 0
   processes = ['app']

   [[vm]]
   memory = '1gb'
   cpu_kind = 'shared'
   cpus = 1
   ```

5. Deploy your app:

   ```sh
   fly deploy
   ```

   ![][image7]

   After the app is successfully deployed, you can see it on Fly.io with the details:

   ![][image8]

   ![][image9]

   If we go to the URL, this is the “Hello, World\!” app that we just deployed.

   ![][image10]

## 6. Post-deployment steps

After deployment, let's verify that our application is working correctly:

1. Open your app in a browser:

   ```sh
   fly open
   ```

3. Test the endpoints using cURL:

   ```sh
   # Add a location

   curl -X POST https://flask-mongodb-fly-wild-sky-7177.fly.dev/locations -H 'Content-Type: application/json' -d '{"name": "Central Park", "location": {"type": "Point", "coordinates": [-73.965355, 40.782865.}, "description": "Famous park in Manhattan"}'
   ```

   ![][image11]

   ```sh
   # Get all locations
   curl https:flask-mongodb-fly-wild-sky-7177.fly.dev/locations
   ```

   ![][image12]

   ```sh
   # Find nearby locations
   curl "https://flask-mongodb-fly-wild-sky-7177.fly.dev/nearby?lat=40.782865.lon=-73.965355.distance=1000"

   ```

   It shows the Manhattan park that we just POST:
   `[{"_id":{"$oid":"6727b03c8fb4fcebcf186af9"},"description":"Famous park in Manhattan","location":{"coordinates":[-73.965355,40.782865.,"type":"Point"},"name":"Central Park"}]`
   
   ![][image13]

4. Monitor your app's logs:

   ```sh
   fly logs
   ```

## 7. Troubleshooting common deployment issues

If you encounter a 500 Internal Server Error or other issues:

1. Check your app's logs:

   ```sh
   fly logs
   ```

2. Verify your MongoDB connection string:

   ```sh
   fly secrets list
   ```

3. If needed, update your secrets:

   ```sh
   fly secrets set MONGODB_URI="your_updated_mongodb_uri"
   ```

4. Redeploy your application:

   ```sh
   fly deploy
   ```

## Conclusion

Through this tutorial, we've built a robust, location-based API that demonstrates the power of MongoDB Atlas's geospatial features combined with Flask's web framework capabilities. We've implemented spatial queries for finding nearby locations, text search for discovering places, and aggregation pipelines for generating insights. The application showcases real-world GIS features that can be used for location tracking.

By deploying on Fly.io and using MongoDB Atlas, we've created a scalable solution that can serve as a foundation for various location-based services. Whether you're building a travel application, a local business directory, or any location-aware service, you can extend this foundation by adding authentication, more complex queries, or additional features specific to your use case.

For questions, comments, or to see what other developers are building using MongoDB, join us in the [MongoDB Developer Community](https://www.mongodb.com/community/forums/).

[image1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6d44d2f489e4d929/67489732799856185de22d96/image4.png
[image2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt78795bdda4b9fd29/674897332452f94fb20a6b0e/image5.png
[image3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc8e63d25cee1513f/674897349457b56dd043894c/image10.png
[image4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blta218018a40179f86/6748973464eb634a08d7309f/image9.png
[image5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltd6f2a9e8a89e9230/674897754d7c436a19f62f03/image11.png
[image6]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltdf53b2a9d688fd6b/67489733ef6d5a63b82281b5/image7.png
[image7]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blte560e307b92a0a99/674897334652421c82d34ef8/image2.png
[image8]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9a3786607b32f50d/674897330da03c32e2b543f8/image6.png
[image9]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltc52114aad3043876/674897342eb39e4571afb8cf/image3.png
[image10]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9286debce106c879/67489732a1696b5f2d7a0b2f/image1.png
[image11]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt7524449b74929004/6748973348603b65cc49ac9d/image8.png
[image12]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt54ca6a4e6e8a4c62/67489774aafcfcd481addd09/image13.png
[image13]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt75a12d0a478ba7fb/674897742781189bae5d6daf/image12.png

Learn how to deploy a Flask Application with MongoDB on Fly.io

How to Deploy a Flask Application With MongoDB on Fly.io




[MongoDB Atlas](https://www.mongodb.com/docs/atlas/getting-started/) is a fully managed cloud database. It handles the tricky parts of setting up, managing, and fixing your MongoDB databases on any major cloud platform (like AWS, Azure, or GCP). It's the easiest way to get started, run, and grow your MongoDB databases in the cloud.

[Terraform](https://developer.hashicorp.com/terraform/docs) is an open-source infrastructure as code (IaC) tool used to manage and provision infrastructure across various platforms, including cloud providers and on-premise data centers. Terraform automates your infrastructure's creation, modification, and destruction, ensuring consistency and repeatability. Terraform has a [MongoDB Atlas provider](https://registry.terraform.io/providers/mongodb/mongodbatlas/latest/docs) that interacts with the resources supported by [MongoDB Atlas](https://www.mongodb.com/cloud/atlas).

In this tutorial, we’ll guide you through setting up MongoDB Atlas on the Azure platform and utilizing Terraform for deployment. The source code used in this article can be found in the [GitHub repository](https://github.com/Karenzhang7717/mongodb-atlas-deployment-to-azure/tree/main).

## Prerequisites

Before we get started, you will need to have the following accounts/tools set up:

- A MongoDB Atlas account — register to get your free [MongoDB Atlas account](https://www.mongodb.com/cloud/atlas/register).
- An Azure account — register to get your free [Azure account](https://azure.microsoft.com/en-ca/free).
- Terraform — you can follow HashiCorp Terrform’s [download page](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli).

## Setting up the environment

To set up the environment, we will first generate MongoDB Atlas API access key, and then set up a billing method.

### Generate MongoDB Atlas API access keys

After establishing an account on MongoDB Atlas and logging in, the next step is to generate an API key to verify the Terraform MongoDB Atlas Provider. To do this, select the access manager for the organization and create the access key. Follow the documentation to learn more about [creating an API key](https://www.mongodb.com/docs/atlas/configure-api-access/).

![Capture where to create an API key(screenshot from the Atlas UI representing the Organization Access Manager section)](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt5452368b91040458/6671609976906dde1a9ee7ab/image6.png)

*Capture where to create an API key* *(screenshot from the Atlas UI representing the Organization Access Manager section)*

Give your API key a clear name that reflects its purpose, like “Terraform Deployment API Key.” Next, we’ll choose the permissions needed for your Terraform tasks. Both *Organization Owner* and *Organization Project Creator* roles allow for enough access to complete this, but the *Organization Project Creator* role should be chosen following the principle of least privilege. To learn more about the user roles, follow the [Organization Roles and Project Roles](https://www.mongodb.com/docs/atlas/reference/user-roles/).

![Capture for generating an API key* (screenshot from the Atlas UI representing creating API key section)](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltab46fbe3c01b2091/667160987ef09ee2abf3fcc4/image4.png "Capture for generating an API key* (screenshot from the Atlas UI representing creating API key section)")

Copy your private key and public key, then set up the environment variables:

``` bash
export MONGODB_ATLAS_PUBLIC_KEY="<insert your public key here>"
export MONGODB_ATLAS_PRIVATE_KEY="<insert your private key here>"
```

*Capture for adding current IP to Access List Entry* *(screenshot from the Atlas UI representing adding access list entry section)*

Next, we will add an API key access list entry to ensure that API calls originating from IPs or CIDR ranges can give access. We use our current IP address and save.

### Setting up a billing method

MongoDB allows a free M0 cluster tier that you do not have to pay for. However, if you want to deploy any other clusters, we will have to set up a billing method. Follow the documentation about setting up a [billing](https://www.mongodb.com/docs/atlas/billing/) method.

## Creating Terraform configuration files — variables.tf, terraform.tfvars, and main.tf files

We are now going to create a `variables.tf` file for declaring Terraform variables, a `terraform.tfvars` file for defining variable values and secrets, and a `main.tf` for the main Terraform configuration. In Terraform, these configuration files (`variables.tf`, `terraform.tfvars`, and `main.tf`) are typically created within the root directory of your Terraform project. You can find the source code in the [GitHub repository](https://github.com/Karenzhang7717/mongodb-atlas-deployment-to-azure/tree/main).

First, we define the MongoDB Atlas and Azure Providers in `main.tf`:

``` bash
# Define the MongoDB Atlas and Azure Providers
terraform {
  required_providers {
    mongodbatlas = {
      source = "mongodb/mongodbatlas"
      version = "=1.16.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "=3.0.0"
    }
  }
}
Then, we start defining all the variables our configuration will use in the variables.tf file.
```

The code block below defines the variables used. Variables include identifiers for the project and environment, the size of the computing resources allocated, the cloud platform to use (AWS, GCP, Azure), the specific region within that platform, the desired version of MongoDB, and the IP address(es) allowed to access the database cluster.

``` bash
# Atlas Organization ID
variable "atlas_org_id" {
 type        = string
 description = "Atlas Organization ID"
}
# Atlas Project Name
variable "atlas_project_name" {
 type        = string
 description = "Atlas Project Name"
}
# Atlas Project Environment
 variable "environment" {
   type        = string
   description = "The environment to be built"
 }
# Cluster Instance Size Name
variable "cluster_instance_size_name" {
 type        = string
 description = "Cluster instance size name"
}
# Cloud Provider to Host Atlas Cluster
variable "cloud_provider" {
 type        = string
 description = "AWS or GCP or Azure"
}
# Atlas Region
variable "atlas_region" {
 type        = string
 description = "Atlas region where resources will be created"
}
# MongoDB Version
variable "mongodb_version" {
 type        = string
 description = "MongoDB Version"
}
# IP Address Access
variable "ip_address" {
 type = string
 description = "IP address used to access Atlas cluster"
}
```

In the `terraform.tfvars` file, we specify the use of MongoDB version 7.0, a M10-sized cluster in the US_EAST_2 region on Azure. If you are outside North America, you can refer to the regions supported following the documentation for [Microsoft Azure](https://www.mongodb.com/docs/atlas/reference/microsoft-azure/#std-label-microsoft-azure).

Please note that Atlas supports specific Azure regions and availability zones, and some regions do not support free clusters (M0) and shared clusters (M2/M5).

``` bash
atlas_org_id = "<UPDATE WITH YOUR ORG ID>"
atlas_project_name = "yourProjectName"
environment = "dev"
cluster_instance_size_name = "M10"
cloud_provider = "Azure"
atlas_region = "US_EAST_2"
mongodb_version = "7.0"
ip_address = "<UPDATE WITH YOUR IP>"
```

## Configuring a MongoDB Atlas project

To create a project using Terraform, we will need the **MongoDB Atlas Organization ID** with at least the Organization Project Creator role. To get this information, we can go to *Settings* on the left-hand side menu bar in the UI, and we can find *Organization Settings* with the *Organization ID*. Please refer to the documentation on [Organizations](https://www.mongodb.com/docs/cloud-manager/tutorial/manage-organizations/) for further reference.

So next, in our `main.tf`file, we will use the mongodbatlas_project resource from Terraform MongoDB Atlas Provider to create our project. We add this to `main.tf`:

``` bash
# Create a Project
resource "mongodbatlas_project" "atlas-project" {
 org_id = var.atlas_org_id
 name = var.atlas_project_name
}
```

## Creating a MongoDB Atlas user, password, and IP access list

We must add a corresponding database user to our MongoDB Atlas project. Refer to the documentation for available [user roles](https://www.mongodb.com/docs/atlas/reference/api-resources-spec/v2/#operation/createOneDatabaseUserInOneProject) in case you want to customize the user’s Role-Based Access Control.

The code block below creates a database user with a random password, and to review the password, you will need to put the `terraform output -json user_password` command in your terminal.

``` bash
# Create a Database User
resource "mongodbatlas_database_user" "db-user" {
 username = "user-1"
 password = random_password.db-user-password.result
 project_id = mongodbatlas_project.atlas-project.id
 auth_database_name = "admin"
 roles {
   role_name     = "readWrite"
   database_name = "${var.atlas_project_name}-db"
 }
}
# Create a Database Password
resource "random_password" "db-user-password" {
 length = 16
 special = true
 override_special = "_%@"
}
Next, we need to create the IP access list.

# Create Database IP Access List
resource "mongodbatlas_project_ip_access_list" "ip" {
 project_id = mongodbatlas_project.atlas-project.id
 ip_address = var.ip_address
}
We will need to put the IP address that we are connecting to the MongoDB Atlas cluster into the terraform.tfvars file.
```

## Provisioning the MongoDB Atlas cluster

We will now use the [`mongodbatlas_cluster`](https://registry.terraform.io/providers/mongodb/mongodbatlas/latest/docs/resources/cluster)[ resource](https://registry.terraform.io/providers/mongodb/mongodbatlas/latest/docs/resources/cluster) to create a MongoDB Atlas cluster. The resource lets you create, edit, and delete clusters.

``` bash
resource "mongodbatlas_cluster" "test" {
 project_id   = mongodbatlas_project.atlas-project.id
 name         = "${var.atlas_project_name}-${var.environment}-cluster"
 cluster_type = "REPLICASET"
 replication_specs {
   num_shards = 1
   regions_config {
     region_name     = var.atlas_region
     electable_nodes = 3
     priority        = 7
     read_only_nodes = 0
   }
 }
 cloud_backup     = true
 auto_scaling_disk_gb_enabled = true
 mongo_db_major_version       = "7.0"
 # Provider Settings "block"
 provider_name               = var.cloud_provider
 provider_disk_type_name     = "P6"
 provider_instance_size_name = var.cluster_instance_size_name
}
```

The code block shown above specifies a cluster named “test” with a replica set deployment type, which is ideal for applications requiring high availability and data redundancy.

The cluster is configured with a single shard and is set to automatically scale its disk storage as needed. The naming convention for the cluster incorporates variables that allow for environment-specific customization, such as `${var.atlas_project_name}-${var.environment}-cluster`.

The configuration also specifies a replica set with three electable nodes in a configurable region, ensuring that the primary node can be effectively elected. The MongoDB major version is set to "7.0," aligning the cluster with the latest stable release.

## Defining Terraform outputs

You can display information from your Terraform setup directly onto the terminal when running Terraform commands. This feature is particularly handy for obtaining values that are only determined after the resources have been created, such as a randomly generated database user password or the connection string needed for your Atlas cluster. The following code is in your `main.tf` file and will ensure that these values are shown on the terminal once Terraform has finished executing.

``` bash
output "cluster_name" {
 value = mongodbatlas_cluster.test.name
 description = "Name of the MongoDB Atlas cluster"
}
output "cluster_uri" {
 value = "mongodb://user-1:${random_password.db-user-password.result}@${mongodbatlas_cluster.test.name}.mongodb.net:27017/?authSource=admin&replicaSet=test-replicaSet"
 description = "Connection URI for the MongoDB Atlas cluster"
 sensitive = true
}
output "project_id" {
 value = mongodbatlas_cluster.test.project_id
 description = "ID of the MongoDB Atlas project where the cluster resides"
}
Initializing Terraform
```

We are now ready to run `terraform init`. This command will initialize Terraform and download Terraform Azure and MongoDB Atlas providers.

![Capture for running Terraform Init](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6af9c154669614df/667160980c0c3ee33e0391e6/image2.png "Capture for running Terraform Init")

The screenshot above shows that Terraform has been successfully initialized.

## Reviewing proposed Terraform deployment

Next, we will be using `terraform plan` to review the proposed changes.

![Capture for running Terraform Plan](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt3faae720c17962e3/66716099b00d393d6de01406/image7.png "Capture for running Terraform Plan")



The screenshot above shows that Terraform will perform the following updates.

![Capture the results of running the Terraform Plan](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt014ed6487ca02eb3/667160987b258dad25c8a8f6/image3.png "Capture the results of running the Terraform Plan")



It shows that Terraform will create the following five resources: including mongodbatlas_cluster.test, mongodbatlas_database_user.db-user, mongodbatlas_project.atlas-project, mongodbatlas_project_ip_access_list.ip, and random_password.db-user-password.

## Executing to create the resources

Now, we will execute the `terraform apply` command to initiate the deployment of the infrastructure. Upon reviewing and confirming that everything appears correct, respond with “yes” to give Terraform the go-ahead to proceed with the build.

![Screenshot representing terraform apply](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt47a9479b3c624afc/667160981774d2e080a16bc3/image10.png "Screenshot representing terraform apply")

![Capture for running Terraform Apply](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt4093cbe35078d82c/667160980c0c3e6e9d0391de/image1.png "Capture for running Terraform Apply")


It might take about 10 minutes for the cluster to deploy. Once it successfully deploys, you will be able to view it in Atlas UI. Below, we can see that an M10 cluster has been deployed to Azure in the East US 2 region.

![Capture for successfully deploying a cluster(screenshot from the Atlas UI representing the deployed cluster](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt415ea215fbf51d60/66716099053191ea1d1f713e/image9.png "Capture for successfully deploying a cluster(screenshot from the Atlas UI representing the deployed cluster)")


Congratulations! You have now successfully deployed an M10 cluster to Azure.

## Cleaning up using Terraform destroy

When ready to destroy the infrastructure created, we can use `terraform destroy` to safely tear down the infrastructure. Type “yes” to destroy all the resources deployed. Be extra careful, though, if you are trying to destroy resources in the production environment.

![Capture for running Terraform Destroy](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt6e78024cbb05ee84/66716099664d453b4e210f0d/image8.png "Capture for running Terraform Destroy")

## Conclusion

In this tutorial, we learned how to deploy a MongoDB Atlas cluster to Azure. The integration of MongoDB Atlas with Terraform on Azure offers a powerful and flexible approach to cloud database management. By leveraging Terraform’s infrastructure as code capabilities, we have streamlined the deployment process for MongoDB Atlas, ensuring that our infrastructure is both reproducible and easily manageable.


This tutorial will help you understand how to deploy Atlas cluster using Terraform. 

Karen Zhang

Content by Karen Zhang

How to Deploy a Flask Application With MongoDB on Fly.io

Deploying MongoDB Atlas With Terraform with Azure