Hubert Nguyen

Sr. Developer Advocate

Welcome to this MongoDB Stream Processing tutorial! In this guide, we will quickly set up a coding workflow and have you write and run your first Stream Processing Instance in no time. In a very short time, we'll learn how to create a new stream processor instance, conveniently code and execute stream processors from Visual Studio Code, and simply aggregate stream data, thus opening the door to a whole new field of the MongoDB Atlas developer data platform.

What we'll cover
----------------

- Prerequisites
- Setup
- Create a stream processor instance
- Set up Visual Studio Code
- The anatomy of a stream processor
- Let's execute a stream processor!
- Hard-coded data in $source declaration
- Simplest stream processor
- Stream processing aggregation
- Add time stamps to the data

Prerequisites
-------------

- Basic knowledge of the [MongoDB Aggregation Pipeline](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) and [Query API](https://www.mongodb.com/docs/manual/query-api/)

- Ideally, read the [official high-level Atlas Stream Processing overview](https://www.mongodb.com/docs/atlas/atlas-sp/overview/) 

- A live MongoDB Atlas cluster that supports stream processing

- Visual Studio Code + [MongoDB for VS Code extension](https://www.mongodb.com/products/tools/vs-code)

## Setup
### Create an Atlas stream processing instance

We need to have an Atlas Stream Processing Instance (SPI) ready. Follow the steps in the tutorial [Get Started with Atlas Stream Processing: Creating Your First Stream Processor](https://www.mongodb.com/developer/products/atlas/create-first-stream-processor/) until we have our connection string and username/password, then come back here.

Don't forget to [add your IP address to the Atlas Network Access](https://www.mongodb.com/docs/atlas/security/ip-access-list/#std-label-access-list) to allow the client to access the instance.

### Set up Visual Studio Code for MongoDB Atlas Stream Processing

Thanks to the MongoDB for VS Code extension, we can rapidly develop stream processing (SP) aggregation pipelines and run them directly from inside a VS Code MongoDB playground. This provides a much better developer experience. In the rest of this article, we'll be using VS Code.

Such a playground is a NodeJS environment where we can execute JS code interacting with a live stream processor on MongoDB Atlas. To get started, install [VS Code](https://code.visualstudio.com/) and the [MongoDB for VS Code extension](https://www.mongodb.com/products/tools/vs-code).

Below is a great tutorial about installing the extension. It also lists some shell commands we'll need later.

- **Tutorial**: [Introducing Atlas Stream Processing Support Within the MongoDB for VS Code Extension](https://www.mongodb.com/developer/products/atlas/introducing-atlas-stream-processing-support-mongodb-vs-code-extension/)

- **Goal**: If everything works, we should see our live SP connection in the MongoDB Extension tab.

![connecting an Atlas Stream Processor in Visual Studio Code][1]

The anatomy of a stream processor 
----------------------------------

Within a stream processing instance (=cluster), it is possible to create and run multiple stream processors (=stream processing pipelines) simultaneously.

A single stream processor (SP) is very similar to a [MongoDB aggregation pipeline](https://www.mongodb.com/basics/aggregation-pipeline). It is described by an array of processing stages. However, there are some differences. The most basic SP can be created using only its data source (we'll have executable examples next).

```
// our array of stages
// source is defined earlier
sp_aggregation_pipeline = [source]
sp.createStreamProcessor("SP_NAME", sp_aggregation_pipeline, <OPTIONS>)
```

A more realistic stream processor would contain at least one aggregation stage, and there can be a large number of stages performing various operations to the incoming data stream. There's a generous limit of 16MB for the total processor size.

```
sp_aggregation_pipeline = [source, stage_1, stage_2...]
sp.createStreamProcessor("SP_NAME", sp_aggregation_pipeline, <OPTIONS>)
```

To increase the development loop velocity, there's an sp.process() function which starts an ephemeral stream processor that won't persist in your stream processing instance.

Let's execute a stream processor!
---------------------------------

Let's create basic stream processors and build our way up. First, we need to have some data! Atlas Stream Processing supports [several data sources](https://www.mongodb.com/docs/atlas/atlas-sp/sp-agg-source/) for incoming streaming events. These sources include:

- Hard-coded data declaration in $source.
- Kafka streams.
- MongoDB Atlas databases.

### Hard-coded data in $source declaration

For quick testing or self-contained examples, having a small set of hard-coded data is a very convenient way to produce events. We can declare an array of events. Here's an extremely simple example, and note that we'll make some tweaks later to cover different use cases.

### Simplest stream processor

In VS Code, we run an ephemeral stream processor with sp.process(). This way, we don't have to use sp.createStreamProcessor() and sp.<SPNAME>.drop() constantly as we would for SPs meant to be saved permanently in the instance.

```
src_hard_coded = {
  $source: {
    // our hard-coded dataset
    documents: [
      {'id': 'entity_1', 'value': 1},
      {'id': 'entity_1', 'value': 3},
      {'id': 'entity_2', 'value': 7},
      {'id': 'entity_1', 'value': 4},
      {'id': 'entity_2', 'value': 1}
     ]
    }
  }
sp.process( [src_hard_coded] );
```

Upon running this playground, we should see data coming out in the VS Code "OUTPUT" tab (CTRL+SHIFT+U to make it appear)

**Note**: It can take a few seconds for the SP to be uploaded and executed, so don't expect an immediate output.

```
{
  id: 'entity_1',
  value: 1,
  _ts: 2024-02-14T18:52:33.704Z,
  _stream_meta: { timestamp: 2024-02-14T18:52:33.704Z }
}
{
  id: 'entity_1',
  value: 3,
  _ts: 2024-02-14T18:52:33.704Z,
  _stream_meta: { timestamp: 2024-02-14T18:52:33.704Z }
}
...
```

This simple SP can be used to ensure that data is coming into the SP and there are no problems upstream with our source. Timestamps data was generated at ingestion time.

Stream processing aggregation
-----------------------------

Building on what we have, adding a simple aggregation pipeline to our SP is easy. Below, we're adding a $group stage to aggregate/accumulate incoming messages' "value" field into an array for the requested interval.

Note that the "w" stage (w stands for "Window") of the SP pipeline contains an aggregation pipeline inside. With Stream Processing, we have aggregation pipelines in the stream processing pipeline.

This stage features a [$tumblingWindow](https://www.mongodb.com/docs/atlas/atlas-sp/overview/#tumbling-windows) which defines the time length the aggregation will be running against. Remember that streams are supposed to be continuous, so a window is similar to a buffer.

interval defines the time length of a window. Since the window is a continuous data stream, we can only aggregate on a slice at a time.

idleTimeout defines how long the $source can remain idle before closing the window. This is useful if the stream is not sustained.

```
src_hard_coded = {
  $source: {
    // our hard-coded dataset
    documents: [
      {'id': 'entity_1', 'value': 1},
      {'id': 'entity_1', 'value': 3},
      {'id': 'entity_2', 'value': 7},
      {'id': 'entity_1', 'value': 4},
      {'id': 'entity_2', 'value': 1}
     ]
    }
  }

w = {
  $tumblingWindow: {
    // This is the slice of time we want to look at every iteration
    interval: {size: NumberInt(2), unit: "second"},
    // If no additional data is coming in, idleTimeout defines when the window is forced to close
    idleTimeout : {size: NumberInt(2), unit: "second"},
    "pipeline": [
      {
        '$group': {
            '_id': '$id',
            'values': { '$push': "$value" }
          }
        }
      ]
    }
  }
sp_pipeline = [src_hard_coded, w];
sp.process( sp_pipeline );
```

Let it run for a few seconds, and we should get an output similar to the following. $group will create one document per incoming "id" field and aggregate the relevant values into a new array field, "values."

```
{
  _id: 'entity_2',
  values: [ 7, 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-14T19:29:46.000Z,
    windowEndTimestamp: 2024-02-14T19:29:48.000Z
  }
}
{
  _id: 'entity_1',
  values: [ 1, 3, 4 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-14T19:29:46.000Z,
    windowEndTimestamp: 2024-02-14T19:29:48.000Z
  }
}
```
Depending on the $tumblingWindow settings, the aggregation will output several documents that match the timestamps. For example, these settings...

```
...
$tumblingWindow: {
    interval: {size: NumberInt(10), unit: "second"},
    idleTimeout : {size: NumberInt(10), unit: "second"},
...
``` 

...will yield the following aggregation output:
```
{
  _id: 'entity_1',
  values: [ 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:30.000Z,
    windowEndTimestamp: 2024-02-13T14:51:40.000Z
  }
}
{
  _id: 'entity_1',
  values: [ 3, 4 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:40.000Z,
    windowEndTimestamp: 2024-02-13T14:51:50.000Z
  }
}
{
  _id: 'entity_2',
  values: [ 7, 1 ],
  _stream_meta: {
    windowStartTimestamp: 2024-02-13T14:51:40.000Z,
    windowEndTimestamp: 2024-02-13T14:51:50.000Z
  }
}
```

See how the windowStartTimestamp and windowEndTimestamp fields show the 10-second intervals as requested (14:51:30 to 14:51:40 etc.).

### Additional learning resources: building aggregations

Atlas Stream Processing uses the MongoDB Query API. You can learn more about the MongoDB Query API with the [official Query API documentation](https://www.mongodb.com/docs/manual/query-api/), [free] [interactive course](https://learn.mongodb.com/courses/mongodb-aggregation), and [tutorial](https://www.mongodb.com/developer/products/atlas/getting-started-atlas-mongodb-query-language-mql/).

Important: Stream Processing aggregation pipelines do not support all database aggregation operations and have additional operators specific to streaming, like $tumblingWindow. Check the [official Stream Processing aggregation documentation](https://www.mongodb.com/docs/atlas/atlas-sp/stream-aggregation/).

### Add timestamps to the data

Even when we hard-code data, there's an opportunity to provide a timestamp in case we want to perform $sort operations and better mimic a real use case. This would be the equivalent of an event-time timestamp embedded in the message.

There are many other types of timestamps if we use a live Kafka stream (producer-assigned, server-side, ingestion-time, and more). Add a timestamp to our messages and use the document's  "timeField" property to make it the authoritative stream timestamp.

```
src_hard_coded = {
  $source: {
    // define our event "timestamp_gps" as the _ts
    timeField: { '$dateFromString': { dateString: '$timestamp_msg' } },
    // our hard-coded dataset
    documents: [
      {'id': 'entity_1', 'value': 1, 'timestamp_msg': '2024-02-13T14:51:39.402336'},
      {'id': 'entity_1', 'value': 3, 'timestamp_msg': '2024-02-13T14:51:41.402674'},
      {'id': 'entity_2', 'value': 7, 'timestamp_msg': '2024-02-13T14:51:43.402933'},
      {'id': 'entity_1', 'value': 4, 'timestamp_msg': '2024-02-13T14:51:45.403352'},
      {'id': 'entity_2', 'value': 1, 'timestamp_msg': '2024-02-13T14:51:47.403752'}
     ]
    }
  }
```

At this point, we have everything we need to test new pipelines and create proofs of concept in a convenient and self-contained form. In a subsequent article, we will demonstrate how to connect to various streaming sources.

## Tip and tricks

At the time of publishing, Atlas Stream Processing is in public preview and there are a number of [known Stream Processing limitations](https://www.mongodb.com/docs/atlas/atlas-sp/limitations/#std-label-atlas-sp-limitations) that you should be aware of, such as regional data center availability, connectivity with other Atlas projects, and user privileges.

When running an ephemeral stream processor via sp.process(), many errors (JSON serialization issue, late data, divide by zero, $validate errors) that might have gone to a dead letter queue (DLQ) are sent to the default output to help you debug.

For SPs created with sp.createStreamProcessor(), you'll have to configure your DLQ manually. Consult the documentation for this. On the ["Manage Stream Processor" documentation page](https://www.mongodb.com/docs/atlas/atlas-sp/manage-stream-processor/), search for "Define a DLQ."

After merging data into an Atlas database, it is possible to use existing pipeline aggregation building tools in the [Atlas GUI's builder](https://www.mongodb.com/docs/atlas/atlas-ui/agg-pipeline/) or [MongoDB Compass](https://www.mongodb.com/docs/compass/upcoming/aggregation-pipeline-builder/) to create and debug pipelines. Since these tools are meant for the core database API, remember that some operators are not supported by stream processors, and streaming features like windowing are not currently available.

## Conclusion

With that, you should have everything you need to get your first stream processor up and running. In a future post, we will dive deeper into connecting to different sources of data for your stream processors.

If you have any questions, [share them in our community forum](https://www.mongodb.com/community/forums/c/atlas/stream-processing/171), meet us during local [MongoDB User Groups (MUGs)](https://www.mongodb.com/community/forums/c/user-groups/11), or come check out one of our [MongoDB .local](https://www.mongodb.com/events/mongodb-local) events.

## References

- [MongoDB Atlas Stream Processing Documentation](https://www.mongodb.com/docs/atlas/atlas-sp/overview/)

- [Introducing Atlas Stream Processing - Simplifying the Path to Reactive, Responsive, Event-Driven Apps](https://www.mongodb.com/blog/post/introducing-atlas-stream-processing-simplifying-path-reactive-responsive-even-driven-apps)

- [The Challenges and Opportunities of Processing Streaming Data](https://www.mongodb.com/blog/post/challenges-opportunities-processing-streaming-data)

- [Atlas Stream Processing is Now in Public Preview](https://www.mongodb.com/blog/post/atlas-stream-processing-now-in-public-preview) (Feb 13, 2024)


 [1]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt9fc619823204a23c/65fcd88eba94f0ad8e7d1460/atlas-stream-processor-connected-visual-studio-code.png

Learn to set up and run your first MongoDB Atlas stream processor with our straightforward tutorial. Discover how to create instances, code in Visual Studio Code, and aggregate stream data effectively.

Introduction to Atlas Stream Processing Development

A tutorial on how to use MongoDB with Laravel Eloquent, but also with the native MongoDB Query API and Aggregation Pipeline, to access the new MongoDB features.

How To Build a Laravel + MongoDB Back End Service

# Interact with MongoDB Atlas in an AWS Lambda Function Using C#

AWS Lambda is an excellent choice for C# developers looking for a solid serverless solution with many integration options with the rest of the AWS ecosystem. When a database is required, reading and writing to MongoDB Atlas at lightning speed is effortless because Atlas databases can be instantiated in the same data center as your AWS Lambda function.

In this tutorial, we will learn how to create a C# serverless function that efficiently manages the number of MongoDB Atlas connections to make your Lambda function as scalable as possible.

## The prerequisites

* Knowledge of the C# programming language.
* A MongoDB Atlas cluster with sample data, network access (firewall), and user roles already configured.
* An Amazon Web Services (AWS) account with a basic understanding of [AWS Lambda](https://aws.amazon.com/lambda/).
* [Visual Studio](https://visualstudio.microsoft.com/downloads/) with the [AWS Toolkit](https://aws.amazon.com/visualstudio/) and the Lamda Templates installed ([official tutorial](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/getting-set-up.html)).

## Create and configure your Atlas database

[This step-by-step MongoDB Atlas tutorial](https://www.mongodb.com/basics/mongodb-atlas-tutorial) will guide you through creating an Atlas database (free tier available) and loading the sample data.

Already have an AWS account? Atlas supports paying for usage via the AWS Marketplace (AWS MP) without any upfront commitment — simply <a href="https://aws.amazon.com/marketplace/pp/prodview-pp445qepfdy34?trk=38088f03-4928-4b00-9a39-86781df6ab9b&sc_channel=el" target="_blank" rel="noreferrer">sign up for MongoDB Atlas via AWS Marketplace.<a>

We will open the network access to any incoming IP to keep this tutorial simple and make it work with the free Atlas cluster tier. Here's [how to add an IP to your Atlas project](https://www.mongodb.com/docs/atlas/security/add-ip-address-to-list/). Adding 0.0.0.0 means that any external IP can access your cluster.

In a production environment, you should restrict access and follow [best MongoDB security practices](https://www.mongodb.com/features/security/best-practices), including using [network peering between AWS Lambda and MongoDB Atlas](https://www.mongodb.com/docs/atlas/manage-connections-aws-lambda/). The free cluster tier does not support peering.

## Build an AWS Lambda function with C#

In Visual Studio, create a basic AWS lambda project using the "AWS Lambda Project (.NET Core - C#)" project template with the "Empty Function" blueprint. We'll use that as the basis of this tutorial. Here's the [official AWS tutorial to create such a project](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/lambda-creating-project-in-visual-studio.html), but essentially:

1. Open Visual Studio, and on the File menu, choose New, Project.
2. Create a new "AWS Lambda Project (.NET Core - C#)" project.
3. We'll name the project "AWSLambda1."

Follow the official AWS tutorial above to make sure that you can upload the project to Lambda and that it runs. If it does, we're ready to make changes to connect to MongoDB from AWS Lambda!

In our project, the main class is called `Function`. It will be instantiated every time the Lambda function is triggered. Inside, we have a method called `FunctionHandler`, (`Function:: FunctionHandler`), which we will designate to Lambda as the entry point.

## Connecting to MongoDB Atlas from a C# AWS Lambda function

Connecting to MongoDB requires adding the MongoDB.Driver (by MongoDB Inc) package in your project's packages.
![Alt](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_aws_lambda_csharp_01_nuget_ce7cde6d21.jpg)

Next, add the following namespaces at the top of your source file:

```
using MongoDB.Bson;
using MongoDB.Driver;
```

In the Function class, we will declare a static MongoClient member. Having it as a `static` member is crucial because we want to share it across multiple instances that AWS Lambda could spawn.

Although we don't have complete control over, or visibility into, the Lambda serverless environment, this is the best practice to keep the number of connections back to the Atlas cluster to a minimum.

If we did not declare MongoClient as `static`, each class instance would create its own set of resources. Instead, the static MongoClient is shared among multiple class instances after a first instance was created (warm start). You can read [more technical details about managing MongoDB Atlas connections with AWS Lambda.](https://www.mongodb.com/docs/atlas/manage-connections-aws-lambda/#other-authentication-1)

We will also add a `CreateMongoClient()` method that initializes the MongoDB client when the class is instantiated. Now, things should look like this:

```
public class Function
{
    private static MongoClient? Client;
    private static MongoClient CreateMongoClient()
    {
            var mongoClientSettings = MongoClientSettings.FromConnectionString(Environment.GetEnvironmentVariable("MONGODB_URI"));
            return new MongoClient(mongoClientSettings);
    }

    static Function()
    {
        Client = CreateMongoClient();
    }
...
}
```

To keep your MongoDB credentials safe, your connection string can be stored in an AWS Lambda environment variable. The connection string looks like this below, and here's [how to get it in Atlas](https://www.mongodb.com/docs/guides/atlas/connection-string/).

`mongodb+srv://USER:PASSWORD@INSTANCENAME.owdak.mongodb.net/?retryWrites=true&w=majority`

**Note**: Visual Studio might store the connection string with your credentials into a aws-lambda-tools-defaults.json file at some point, so don't include that in a code repository.

If you want to use environment variables in the Mock Lambda Test Tool, you must create a specific "Mock Lambda Test Tool" profile with its own set of environment variables in `aws-lambda-tools-defaults.json` ([here's an example](https://stackoverflow.com/questions/54843650/how-do-i-set-fetch-environment-variable-in-aws-lambda-project-in-c-sharp)).

You can [learn more about AWS Lambda environment variables](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html). However, be aware that such variables can be set from within your Visual Studio when publishing to AWS Lambda or directly in the AWS management console on your AWS Lambda function page.

For testing purposes, and if you don't want to bother, some people hard-code the connection string as so:

```
var mongoClientSettings = FromConnectionString("mongodb+srv://USER:PASSWORD@instancename.owdak.mongodb.net/?retryWrites=true&w=majority");
```

Finally, we can modify the FunctionHandler() function to read the first document from the sample\_airbnb.listingsAndReviews database and collection we preloaded in the prerequisites.

The try/catch statements are not mandatory, but they can help detect small issues such as the firewall not being set up, or other configuration errors.

```
public string FunctionHandler(string input, ILambdaContext context)
{
 if (Client != null)
 {
 try
 {
 var database = Client.GetDatabase("sample_airbnb");
 var collection = database.GetCollection<BsonDocument>("listingsAndReviews");
 var result = collection.Find(FilterDefinition<BsonDocument>.Empty).First();
 return result.ToString();
 }
 catch
 {
 return "Handling failed";
 }
 } else
 {
 return "DB not initialized";
 }
}
```

Using the "listingsAndReviews" collection (a "table" in SQL jargon) in the "sample\_airbnb" database, the code fetches the first document of the collection.

`collection.Find()` normally takes a [MongoDB Query](https://www.mongodb.com/products/features/mongodb-query-api) built as a BsonDocument, but in this case, we only need an empty query.

## Publish to AWS and test

It's time to upload it to AWS Lambda. In the Solution Explorer, right-click on the project and select "Publish to AWS Lambda." Earlier, you might have done this while setting up the project using the official AWS Lambda C# tutorial.

![Alt](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_aws_lambda_csharp_02_solution_publish_to_aws_5501ab2694.jpg)

If this is the first time you're publishing this function, take the time to give it a name (we use "mongdb-csharp-function-001"). It will be utilized during the initial Lambda function creation.

In the screenshot below, the [AWS Lambda function Handler](https://docs.aws.amazon.com/lambda/latest/dg/csharp-handler.html) ("Handler") information is essential as it tells Lambda which method to call when an event is triggered. The general format is Assembly::Namespace.ClassName::MethodName

In our case, the handler is `AWSLambda1::AWSLambda1.Function::FunctionHandler`.

![Alt](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_aws_lambda_csharp_03_upload_to_aws_lambda_0245efe658.jpg)

If the option is checked, this dialog will save these options in the `aws-lambda-tools-defaults.json` file.

Click "Next" to see the second upload screen. The most important aspect of it is the environment variables, such as the connection string.

When ready, click on "Upload." Visual Studio will create/update your Lambda function to AWS and launch a test window where you can set your sample input and execute the method to see its response.

Our Lambda function expects an input string, so we'll use the "hello" string in our Sample Input, then click the "Invoke" button. The execution's response will be sent to the "Response" field to the right. As expected, the first database record is converted into a string, as shown below.

![Alt](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_aws_lambda_csharp_04_execute_in_visualstudio_52f477cf11.jpg)

## Conclusion

We just learned how to build a C# AWS Lambda serverless function efficiently by creating and sharing a MongoDB client and connecting multiple class instances. If you're considering building with a [serverless architecture](https://www.mongodb.com/serverless) and AWS Lambda, MongoDB Atlas is an excellent option.

The flexibility of our [document model](https://www.mongodb.com/docs/v5.3/core/data-modeling-introduction/) makes it easy to get started quickly and evolve your data structure over time. [Create a free Atlas cluster](https://www.mongodb.com/cloud/atlas/register) now to try it.

If you want to learn more about our [MongoDB C# driver, refer to the continuously updated documentation](https://www.mongodb.com/docs/drivers/csharp/current/). You can do much more with MongoDB Atlas, and our [C# Quick Start](https://www.mongodb.com/blog/post/quick-start-c-sharp-and-mongodb-starting-and-setup) is a great first step on your MongoDB journey.

In this tutorial, we'll see how to create a serverless function using the C# programming language and that function will connect to and query MongoDB Atlas in an efficient manner.

Interact with MongoDB Atlas in an AWS Lambda Function Using C#

Welcome to this article about MongoDB error handling in PHP. Code samples and tutorials abound on the web , but for clarity's sake, they often don't show what to do with potential errors. Our goal here is to show you common mechanisms to deal with potential issues like connection loss, temporary inability to read/write, initialization failures, and more.

This article was written using PHP 8.1 and MongoDB 6.1.1 (serverless) with the PHP Extension and Library 1.15. As things may change in the future, you can refer to our [official MongoDB PHP documentation](https://www.mongodb.com/docs/drivers/php/).

## Prerequisites

To execute the [code sample](https://github.com/mongodb-developer/php-error-handling-sample) created for this article, you will need:

* A MongoDB Atlas cluster with [sample data loaded](https://www.mongodb.com/docs/atlas/sample-data/). We have [MongoDB Atlas free tier clusters](https://www.mongodb.com/docs/atlas/tutorial/deploy-free-tier-cluster/) available to all.
* A web server with PHP and the MongoDB PHP driver installed. Ideally, follow our "[Getting Set Up to Run PHP with MongoDB](https://www.mongodb.com/developer/languages/php/php-setup/)" guide.
 * Alternatively, you can consider using [PHP's built-in webserver](https://www.php.net/manual/en/features.commandline.webserver.php), which can be simpler to set up and might avoid other web server environment variances.
* A functioning [Composer](https://getcomposer.org/) to set up the MongoDB PHP Library.
* A code editor, like [Visual Studio Code](https://code.visualstudio.com/).

We will refer to the [MongoDB PHP Driver](https://www.mongodb.com/docs/drivers/php/), which has two distinct components. First, there's the [MongoDB PHP Extension](https://php.net/mongodb), which is the system-level interface to MongoDB. 

Secondly, there's the [MongoDB PHP Library](https://www.mongodb.com/docs/php-library/current), a PHP library that is the application's interface to MongoDB. You can learn about the people behind our PHP driver [in this excellent podcast episode](https://www.mongodb.com/developer/languages/php/exploring-php-driver-jeremy-mikola/).

:youtube[]{vid=qOuGM6dNDm8}

## Initializing our code sample

Clone it from the [Github repository](https://github.com/mongodb-developer/php-error-handling-sample) to a local folder in the public section of your web server and website. You can use the command

```
git clone https://github.com/mongodb-developer/php-error-handling-sample
```

Go to the project's directory with the command

```
cd php-error-handling-sample
```

and run the command

```
composer install
```

Composer will download external libraries to the "vendor" directory (see the screenshot below). Note that Composer will check if the MongoDB PHP extension is installed, and will report an error if it is not.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/php_error_handling_02_composer_install_bf2d0ef3d6.png)

Create an .env file containing your database user credentials in the same folder as index.php. Our [previous tutorial describes](https://www.mongodb.com/developer/languages/php/php-setup/) how to do this in the "Securing Usernames and Passwords" section. The .env file is a simple text file formatted as follows:

***MDB\_USER=[user name] 
MDB\_PASS=[password]***

In your web browser, navigate to `website-url/php-error-handling-sample/`, and `index.php`  will be executed.

Upon execution, our code sample outputs a page like this, and there are various ways to induce errors to see how the various checks work by commenting/uncommenting lines in the source code.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/php_error_handling_03_app_output_14ad468a8c.jpg)

## System-level error handling

Initially, developers run into system-level issues related to the PHP configuration and whether or not the MongoDB PHP driver is properly installed. That's especially true when your code is deployed on servers you don't control. Here are two common system-level runtime errors and how to check for them:

1. Is the MongoDB extension installed and loaded?
2. Is the MongoDB PHP Library available to your code?

There are many ways to check if the MongoDB PHP extension is installed and loaded and here are two in the article, while the others are in the the code file.

1. You can call PHP's `extension_loaded()` function with `mongodb` as the argument. It will return true or false.
2. You can call `class_exists()` to check for the existence of the `MongoDB\Driver\Manager` class defined in the MongoDB PHP extension.
3. Call `phpversion('mongodb')`, which should return the MongoDB PHP extension version number on success and false on failure.
4. The MongoDB PHP Library also contains a [detect-extension.php](https://github.com/mongodb/mongo-php-library/blob/master/tools/detect-extension.php) file which shows another way of detecting if the extension was loaded. This file is not part of the distribution but [it is documented](https://www.mongodb.com/docs/php-library/current/faq/#multiple-php-runtimes-installed).

```
// MongoDB Extension check, Method #1
if ( extension_loaded('mongodb') ) {
 echo(MSG_EXTENSION_LOADED_SUCCESS);
} else {
 echo(MSG_EXTENSION_LOADED_FAIL);
}

// MongoDB Extension check, Method #2
if ( !class_exists('MongoDB\Driver\Manager') ) {
 echo(MSG_EXTENSION_LOADED2_FAIL); 
 exit();
} 
else {
 echo(MSG_EXTENSION_LOADED2_SUCCESS);
}
```

Failure for either means the MongoDB PHP extension has not been loaded properly and you should check your php.ini configuration and error logs, as this is a system configuration issue. Our [Getting Set Up to Run PHP with MongoDB](https://www.mongodb.com/developer/languages/php/php-setup/) article provides debugging steps and tips which may help you.

Once the MongoDB PHP extension is up and running, the next thing to do is to check if the MongoDB PHP Library is available to your code. You are not obligated to use the library, but we highly recommend you do. It keeps things more abstract, so you focus on your app instead of the inner-workings of MongoDB.

Look for the `MongoDB\Client` class. If it's there, the library has been added to your project and is available at runtime.

```
// MongoDB PHP Library check
if ( !class_exists('MongoDB\Client') ) {
 echo(MSG_LIBRARY_MISSING); 
 exit();
} 
else {
 echo(MSG_LIBRARY_PRESENT);
}
```

## Database instance initialization

You can now instantiate a client with your connection string . (Here's [how to find the Atlas connection string](https://www.mongodb.com/docs/guides/atlas/connection-string/).) 

The instantiation will fail if something is wrong with the connection string parsing or the driver  cannot resolve the connection's [SRV](https://en.wikipedia.org/wiki/SRV_record) (DNS) record. Possible causes for SRV resolution failures include the IP address being rejected by the MongoDB cluster or network connection issues while checking the SRV.

```
// Fail if the MongoDB Extension is not configuired and loaded
// Fail if the connection URL is wrong
try {
 // IMPORTANT: replace with YOUR server DNS name
 $mdbserver = 'serverlessinstance0.owdak.mongodb.net';

 $client = new MongoDB\Client('mongodb+srv://'.$_ENV['MDB_USER'].':'.$_ENV['MDB_PASS'].'@'.$mdbserver.'/?retryWrites=true&w=majority');
 echo(MSG_CLIENT_SUCCESS);
 // succeeds even if user/password is invalid
}
catch (\Exception $e) {
 // Fails if the URL is malformed
 // Fails without a SVR check
 // fails if the IP is blocked by an ACL or firewall
 echo(MSG_CLIENT_FAIL);
 exit();
}
```

Up to this point, the library has just constructed an internal driver manager, and no I/O to the cluster has been performed. This behavior is described in this [PHP library documentation page](https://www.mongodb.com/docs/php-library/current/reference/method/MongoDBClient__construct/#behavior) — see the "Behavior" section.

It's important to know that even though the client was successfully instantiated, it does not mean your user/password pair is valid , and it doesn't automatically  grant you access to anything . Your code has yet to try accessing any information, so your authentication has not been verified.

When you first create a MongoDB Atlas cluster, there's a "Connect" button in the GUI to retrieve the instance's URL. If no user database exists, you will be prompted to add one, and add an IP address to the access list.

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/php_error_handling_01_atlas_gui_3117d9c799.png)

In the MongoDB Atlas GUI sidebar, there's a "Security" section with links to the "Database Access" and "Network Access" configuration pages. "Database Access" is where you [create database users](https://www.mongodb.com/docs/atlas/security-add-mongodb-users/) and their privileges. "Network Access" lets you [add IP addresses to the IP access list](https://www.mongodb.com/docs/atlas/security/add-ip-address-to-list/).

Next, you can do a first operation that requires an I/O connection and an authentication, such as listing the databases  with `listDatabaseNames()`, as shown in the code block below. If it succeeds, your user/password pair is valid. If it fails, it could be that the pair is invalid or the user does not have the proper privileges.

```
try { 
 // if listDatabaseNames() works, your authorization is valid
 $databases_list_iterator = $client->listDatabaseNames(); // asks for a list of database names on the cluster

 $databases_list = iterator_to_array( $databases_list_iterator );
 echo( MSG_CLIENT_AUTH_SUCCESS );
 }
 catch (\Exception $e) {
 // Fail if incorrect user/password, or not authorized
 // Could be another issue, check content of $e->getMessage()
 echo( MSG_EXCEPTION. $e->getMessage() );
 exit();
 }
```

There are other reasons why any MongoDB command could fail (connectivity loss, etc.), and the exception message will reveal that. These first initialization steps are common points of friction as cluster URLs vary from project to project, IPs change, and passwords are reset.

## CRUD error handling

If you haven't performed CRUD operation with MongoDB before, we have a great tutorial entitled "[Creating, Reading, Updating, and Deleting MongoDB Documents with PHP](https://www.mongodb.com/developer/languages/php/php-crud/)." Here, we'll look at the error handling mechanisms.

We will access one of the sample databases called "sample\_analytics ," and read/write into the "customers" collection. If you're unfamiliar with MongoDB's terminology, here's a quick overview of the [MongoDB database and collections](https://www.mongodb.com/docs/manual/core/databases-and-collections/).

Sometimes, ensuring the connected cluster contains the expected database(s) and collection(s) might be a good idea. In our code sample, we can check as follows:

```
// check if our desired database is present in the cluster by looking up its name
 $workingdbname = 'sample_analytics';
 if ( in_array( $workingdbname, $databases_list ) ) {
 echo( MSG_DATABASE_FOUND." '$workingdbname' " );
 }
 else {
 echo( MSG_DATABASE_NOT_FOUND." '$workingdbname' " );
 exit();
 }

 // check if your desired collection is present in the database
 $workingCollectionname = 'customers';
 $collections_list_itrerator = $client->$workingdbname->listCollections();
 $foundCollection = false;
 
 $collections_list_itrerator->rewind();
 while( $collections_list_itrerator->valid() ) {
 if ( $collections_list_itrerator->current()->getName() == $workingCollectionname ) {
 $foundCollection = true;
 echo( MSG_COLLECTION_FOUND." '$workingCollectionname' " );
 break; 
 }
 $collections_list_itrerator->next();
 }

 if ( !$foundCollection ) {
 echo( MSG_COLLECTION_NOT_FOUND." '$workingCollectionname' " );
 exit();
 }
```

[MongoDB CRUD operations](https://www.mongodb.com/docs/manual/crud/) have a multitude of legitimate reasons to encounter an exception. The general way of handling these errors is to put your operation in a try/catch block to avoid a fatal error.

If no exception is encountered, most operations return a document containing information about how the operation went. 

For example, write operations return a document that contains a [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) "[isAcknowledged](https://www.mongodb.com/docs/php-library/current/reference/method/MongoDBInsertOneResult-isAcknowledged/#definition)" boolean and a [WriteResult](https://www.php.net/manual/en/class.mongodb-driver-writeresult.php) object. It has important feedback data, such as the number of matched and modified documents ([among other things](https://www.php.net/manual/en/class.mongodb-driver-writeresult.php)). Your app can check to ensure the operation performed as expected.

If an exception does happen, you can add further checks to see exactly what type of exception. For reference, look at the [MongoDB exception class tree](https://www.php.net/manual/en/mongodb.exceptions.tree.php) and keep in mind that you can get more information from the exception than just the message. The driver's [ServerException class](https://www.php.net/manual/en/class.mongodb-driver-exception-serverexception.php) can also provide the exception [error code](https://github.com/mongodb/mongo/blob/master/src/mongo/base/error_codes.yml), the source code line and the trace, and more!

For example, a common exception occurs when the application tries to insert a new document with an existing unique ID. This could happen for many reasons, including in high concurrency situations where multiple threads or clients might attempt to create identical records.

MongoDB maintains an array of tests for its PHP Library (see [DocumentationExamplesTest.php on Github](https://github.com/mongodb/mongo-php-library/blob/master/tests/DocumentationExamplesTest.php)). It contains great code examples of various queries, with error handling. I highly recommend looking at it and using it as a reference since it will stay up to date with the latest driver and APIs.

## Conclusion

This article was intended to introduce MongoDB error handling in PHP by highlighting common pitfalls and frequently asked questions we answer. Understanding the various MongoDB error-handling mechanisms will make your application rock-solid, simplify your development workflow, and ultimately make you and your team more productive.

To learn more about using MongoDB in PHP, learn from our [PHP Library tutorial](https://www.mongodb.com/docs/php-library/current/tutorial/), and I invite you to connect via the [PHP section of our developer community forums](https://www.mongodb.com/community/forums/tag/php).

## References

* [MongoDB PHP Quickstart Source Code Repository](https://github.com/mongodb-developer/php-quickstart)
* [MongoDB PHP Driver Documentation](https://docs.mongodb.com/drivers/php/) provides thorough documentation describing how to use PHP with your MongoDB cluster.
* [MongoDB Query Document](https://docs.mongodb.com/manual/tutorial/query-documents/) documentation details the full power available for querying MongoDB collections.

This article shows you common mechanisms to deal with potential PHP Errors and Exceptions triggered by connection loss, temporary inability to read/write, initialization failures, and more.


Handling MongoDB PHP Errors

In the early days, and up until a decade ago, games were mostly about graphics prowess and fun game play that keep players coming back, wanting for more. And that's still the case today, but modern games have proven that data is also a crucial part of video games.

As developers leverage a data platform like MongoDB Atlas for gaming, they can do more, faster, and make the game better by focusing engineering resources on the player's experience, which can be tailored thanks to insights leveraged during the game sessions. The experience can continue outside the game too, especially with the rise in popularity of eSports and their legions of fans who gather around a fandom.

## Yile Technology

![](https://webimages.mongodb.com/_com_assets/cms/l2gpznm8182ufgke9-Yile%20speakers.jpeg)
*Mezi Wu, Research and Development Manager at Yile Technology (left) and Yi-Zheng Lin, Senior Database Administrator of Yile Technology*

[Yile Technology Co. Ltd.](https://www.yile.com.tw/) is a mobile game development company founded in 2018 in Taiwan. Since then, it has developed social games that have quickly acquired a large audience. For example, its [Online808](https://play.google.com/store/apps/details?id=com.jumbo.yirufa&hl=en&gl=US) social casino game has rapidly crossed the 1M members mark as Yile focuses intensely on user experience improvement and game optimization.

Yile developers leverage the MongoDB Atlas platform for two primary reasons. First, it's about performance. Yile developers realized early in their success that even cloud relational databases (RDBMS) were challenging to scale horizontally. Early tests showed RDBMS could not achieve Yile's desired goal of having a 0.5s minimum game response time.

"Our team sought alternatives to find a database with much stronger horizontal scalability. After assessing the pros and cons of a variety of solutions on the market, we decided to build with MongoDB's document database," [Mezi Wu](https://www.linkedin.com/in/mezi-wu-47607669/), Research and Development Manager at Yile Technology, said.

The R&D team thought MongoDB was easy to use and supported by vast online resources, including discussion forums. It only took one month to move critical data back-end components, like player profiles, from RDBMS to MongoDB and eliminate game database performance issues.

The second is about operations. Wu said, "MongoDB Atlas frees us from the burden of basic operational maintenance and maximizes the use of our most valuable resources: our people."

That's why after using the self-managed MongoDB community version at first, Yile Technology moved to the cloud-managed version of MongoDB, MongoDB Atlas, to alleviate the maintenance and monitoring burden experienced by the R&D team after a game's launch. It's natural to overwatch the infrastructure after a new launch, but the finite engineering resources are best applied to optimizing the game and adding new features.

"Firstly, with support from the MongoDB team, we have gained a better understanding of MongoDB features and advantages and become more precise in our usage. Secondly, MongoDB Atlas provides an easy-to-use operation interface, which is faster and more convenient for database setup and can provide a high-availability architecture with zero downtime," says [Yi-Zheng Lin](https://www.linkedin.com/in/i-cheng-lin-28079a121/), Senior Database Administrator.

Having acquired experience and confidence, now validated by rapid success, Yile Technology plans to expand its usage of MongoDB further. The company is interested in the MongoDB transaction features for its cash flow data and the MongoDB aggregation pipeline to analyze users' behavior.

## Beamable

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/beamable_3449fbf69c.jpg)Based in Boston, USA, Beamable is a company that streamlines game development and deployment for game developers. Beamable does that by providing a game server architecture that handles the very common needs of backend game developers, which offloads a sizable chunk of the development process, leaving more time to fine-tune game mechanics and stickiness.

Game data (also called game state) is a very important component in game development, but the operations and tools required to maximize its utilization and efficiency are almost as critical. Building such tools and processes can be daunting, especially for smaller up-and-coming game studios, no matter how talented.

For example, Beamable lets developers integrate, manage, and analyze their data with a web dashboard called [LiveOps Portal](https://beamable.com/why-beamable/live-ops-portal) so engineers don't have to build an expensive custom live games solution. That's only one of the many game backend aspects Beamable handles, so check the whole list on their [features page](https://beamable.com/features).

Beamable's focus on integrating itself into the development workflow is one of the most crucial advantages of their offering, because every game developer wants to tweak things right in the game's editor --- for example, in Unity, for which Beamable's integration is impressive and complete.

To achieve such a feat, Beamable built the platform on top of MongoDB Atlas "from day one" according to Ali El Rhermoul ([listen to the podcast ep. 151](https://www.mongodb.com/developer/podcasts/ep-151-streamlining-game-development-with-beamable-cto-ali-el-rhermoul-insights-and-strategies-for-game-developers/)), and therefore started on a solid

and scalable developer data platform to innovate upon, leaving the database operations to MongoDB, while focusing on adding value to their customers. Beamable helps many developers, which translates into an enormous aggregated amount of data.

Additionally, MongoDB's document model works really well for games and that has been echoed many times in the games industry. Games have some of the most rapidly changing schemas, and some games offer new features, items, and rewards on a daily basis, if not hourly.

With Beamable, developers can easily add game features such as leaderboards, commerce offers, or even identity management systems that are GDPR-compatible. Beamable is so confident in its platform that developers can try for free with a solid feature set, and seamlessly upgrade to get active support or enterprise features.

## Bemyfriends

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_bemyfriends_03_138cc3baec.jpg)

[bemyfriends](https://bemyfriends.com/) is a South Korean company that built a SaaS solution called [b.stage](https://bstage.in/), which lets creators, brands, talents, and IP holders connect with their fans in meaningful, agreeable, and effective ways, including monetization. bemyfriends is different from any other competitor because the creators are in control and own entirely all data created or acquired, even if they decide to leave.

With b.stage, creators have a dedicated place where they can communicate, monetize, and grow their businesses at their own pace, free from feed algorithms. There, they can nurture their fans into super fans. b.stage supports multiple languages (system and content) out of the box. However, membership, e-commerce, live-streaming, content archives, and even community features (including token-gated ones) are also built-in and integrated to single admin.

Built-in analytics tools and dashboards are available for in-depth analysis without requiring external tool integration. Creators can focus on their content and fans without worrying about complex technical implementations. That makes b.stage a powerful and straightforward fandom solution with high-profile creators, such as eSports teams [T1](https://bemyfriends.com/article/fandom-101-post-10-en/?hl=en), [KT Rolster](https://bemyfriends.com/article/creator-stories-35-en/) and Nongshim Redforce, three teams with millions of gamer fans in South Korea and across the world.

bemyfriends uses MongoDB as its primary data platform. June Kay Kim (CTO, bemyfriends) explained that engineers initially tested with an RDBMS solution but quickly realized that scaling a relational database at the required scale would be difficult. MongoDB's scalability and performance were crucial criteria in the data platform selection.

Additionally, MongoDB's flexible schema was an essential feature for the bemyfriends team. Their highly innovative product demands many different data schemas, and each can be subject to frequent modifications to integrate the latest features creators need.

While managing massive fandoms, downtime is not an option, so the ability to make schema modifications without incurring downtime was also a requirement for the data platform. For all these reasons, bemyfriends use MongoDB Atlas to power the vast majority of the data in their SaaS solution.

Building with the corporate slogan of "Whatever you make, we will help you make more of it!," bemyfriend has created a fantastic tool for fandom business, whether their fans are into music, movies, games, or a myriad of other things --- the sky's the limit. Creators can focus on their fandom, knowing the most crucial piece of their fandom business, the data, is truly theirs.

## Diagon

![](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/diagon_68bbcee259.jpg)

[Diagon](https://diagon.io/) is a gaming company based in Lagos, Nigeria. They are building a hyper-casual social gaming platform called "[CASUAL by Diagon](https://play.google.com/store/apps/details?id=io.diagon.casual)" where users can access several games. There are about 10 games at the moment, and Diagon is currently working on developing and publishing more games on its platform, by working with new game developers currently joining the in-house team. The building of an internal game development team will be coming with the help of a fresh round of funding for the start-up (Diagon Pre-Seed Round).

The games are designed to be very easy to play so that more people can play games while having a break, waiting in line, or during other opportune times. Not only do players have the satisfaction of progressing and winning the games, but there's also a social component.

Diagon has a system of leaderboards to help the best players gain visibility within the community. At the same time, raffles make people more eager to participate, regardless of their gaming skills.

Diagon utilized MongoDB from the start, and one key defining factor was MongoDB's flexible schema. It means that the same collection ("table," in RDBMS lingo) can contain documents using multiple schemas, or schema versions, as long as the code can handle them. This flexibility allows game developers to quickly add properties or new data types without incurring downtime, thus accelerating the pace of innovation.

Diagon also runs on MongoDB Atlas, the MongoDB platform, which handles the DevOps aspect of the database, leaving developers to focus on making their games better. "Having data as objects is the future," says Jeremiah Onojah, Founder of and Product Developer at Diagon. And Diagion's engineers are just getting started: "I believe there's so much more to get out of MongoDB," he adds, noting that future apps are planned to run on MongoDB.

For example, an area of interest for Onojah is MongoDB Atlas Search, a powerful integrated Search feature, powered by Lucene. Atlas developers can tap into this very advanced search engine without having to integrate a third-party system, thanks to the unified MongoDB Query Language (MQL).

Diagon is growing fast and has a high retention rate of 20%. Currently, 80% of its user base comes from Nigeria, but the company already sees users coming from other locations, which demonstrates that growth could be worldwide. Diagon is one of the startups from the [MongoDB Startup Program](https://www.mongodb.com/startups).

## Conclusion

MongoDB Atlas is an ideal developer data platform for game developers, whether you are a solo developer or working on AAA titles. Developers agree that MongoDB's data model helps them change their data layer quicker to match the desired outcome.

All the while, MondoDB Atlas enables their applications to reach global scale and high availability (99.995% SLA) without involving complex operations. Finally, the unique Atlas data services --- like full-text search, data lake, analytics workload, mobile sync, and Charts --- make it easy to extract insights from past and real-time data.

[Create a free MongoDB Atlas cluster](https://www.mongodb.com/cloud/atlas) and [start prototyping](https://www.mongodb.com/docs/develop-applications/) your next game back end. Listen to the [gaming MongoDB podcast playlist](https://listen.casted.us/public/115/playlist/3cd02b01/share/dc7649bf) to learn more about how other developers use MongoDB. If you are going to GDC 2023, come to our booth, talks, user group meetup, and events. They are all listed at [mongodb.com/gdc](https://www.mongodb.com/developer/events/gdc-2023/).

Last and not least, if your startup uses MongoDB, our [MongoDB startup program](https://www.mongodb.com/startups) can help you reach the next level faster, with Atlas credits and access to MongoDB experts.

This article highlights startups in the games industry that use MongoDB as a backend. Their teams describe why they chose MongoDB Atlas and how it makes their development more productive.

MongoDB Atlas for Gaming, Startups to Watch in 2023

Chuck Freedman

Director of Developer Advocacy and Enablement

Apoorva Joshi

Senior AI Developer Advocate

Welcome to MongoDB Developer Day! Below you can find all the resources you will need for the day.

## Data Modeling and Design Patterns

* [Slides](https://docs.google.com/presentation/d/e/2PACX-1vSnAmKMkZfJ_fSMhsbIoJdxKN3EDor9uQ0WjtHQPjLf06AGma6u_7Z64iRufwdOWzRxNFdhkDP7Hjyj/pub?start=false&loop=true&delayms=3000) -- [PDF](https://drive.google.com/file/d/1mjdzFTDa1IstZ3FYpmYQylsUvR9Jmnum/view?usp=sharing)
* [Library application](https://potent-bulwark-400605.web.app/catalogue)
* [System requirements](https://drive.google.com/file/d/1Bsa2jWjeHx6xbGI7xZPLApDQ3Cc_durX/view?usp=drive_link)


### Hands-on exercises setup and troubleshooting
* [Self-paced content](https://mongodb-developer.github.io/intro-lab/) -- Atlas cluster creation and loading sample data.
* [Data import tool](https://mdb.link/import-library-data)
* If CodeSpaces doesn't work, try [downloading the code](https://drive.google.com/file/d/1TCpvxRQT5RNt0li-KBQUh1XBE9ENH-CZ/view?usp=drive_link).
* Import tool not working? Try downloading the [dataset](https://drive.google.com/file/d/1DktBV2z7x7QOS1o1XMdD9BgfWgjvskAx/view?usp=sharing), and ask an instructor for help on importing the data.

### Additional resources
* [Library management system code](https://github.com/mongodb-developer/library-management-system)
* [MongoDB data modeling book](https://www.amazon.com/MongoDB-Data-Modeling-Schema-Design/dp/1634621980)
* [Data Modeling course](https://learn.mongodb.com/courses/m320-mongodb-data-modeling) on MongoDB University
* [MongoDB for SQL Pros](https://learn.mongodb.com/learning-paths/mongodb-for-sql-professionals) on MongoDB University

## Aggregation Pipelines Lab
* [Aggregations hands-on exercises](https://mongodb-developer.github.io/aggregation-pipeline-lab/docs/simple-queries/match)
* [Slides](https://docs.google.com/presentation/d/e/2PACX-1vQUEYTdibY5xWAe4EGSp4IZ8Kt4hBTrz_oLGs9kNTajrNA5pwzra_fAJEbzXufDbIKg4_TgiZ3UdjLp/pub?start=false&loop=false&delayms=3000) -- [pdf](https://drive.google.com/file/d/1L1TxbJJ0XlcJt66V1OexSHd93_uBS7Ge/view?usp=sharing)

## Search Lab
* [Slides](https://docs.google.com/presentation/d/e/2PACX-1vQsQ0UQSoXF86gLhmcLBZgMTWm9ZUIbtSyLD8-dBVnaYfZO2G10s2EB-XYz_bD9z2bK166WYtq14hga/pub?start=false&loop=false&delayms=3000) -- [pdf](https://drive.google.com/file/d/1CU4N_036cLQseBBRq2zq3RvLITRUe5Ye/view?usp=drive_link)
* [Self-paced content](https://mongodb-developer.github.io/search-lab/)

### Dive deeper
Do you want to learn more about Atlas Search? Check these out.
* [Atlas Search Workshop](https://www.atlassearchworkshop.com/): An in-depth workshop that uses the more advanced features of Atlas Search

## Join us for happy hour
Join our team for a happy hour at Sinema to conclude MongoDB Developer Day in Nashville

## How was it?
Let us know what you liked about this day, and how we can improve (and get a cool 🧦 gift 🧦) by filling out this [survey](https://docs.google.com/forms/d/e/1FAIpQLScUXDY1saknRLOEgCMJO2Z4iTvwMSCrQYJRcw9UkPkn46G2Kw/viewform).

## Join the Community
Stay connected, and join our community
* [Online Forums](http://community.mongodb.com)




Join us for a full day of hands-on sessions about MongoDB. An event for developer by developers.