DJ Walker

Stanimira Vlaeva



<div class="introduction">

The real power of a cloud-hosted, fully managed service like [MongoDB Atlas](https://www.mongodb.com/cloud/atlas) is that you can create whole new database deployment architectures automatically, using the services API. Getting to the [MongoDB Atlas Administration API](https://docs.atlas.mongodb.com/api/) is relatively simple and, once unlocked, it opens up a massive opportunity to integrate and automate the management of database deployments from creation to deletion. The API itself is an extensive REST API. There's role-based access control and you can have [user or app-specific credentials](https://docs.atlas.mongodb.com/configure-api-access/) to access it.

There is one tiny thing that can trip people up though. The credentials have to be passed over using the [digest authentication mechanism](https://en.wikipedia.org/wiki/Digest_access_authentication), not the more common basic authentication or using an issued token. Digest authentication, at its simplest, waits to get an HTTP `401 Unauthorized` response from the web endpoint. That response comes with data and the client then sends an encrypted form of the username and password as a digest and the server works with that.

And that's why we’re here today: to show you how to do that with the least fuss in Python, Node, and Ruby. In each example, we'll try and access the base URL of the Atlas Administration API which returns a JSON document about the underlying applications name, build and other facts.
You can find all code samples in the dedicated [Github repository](https://github.com/mongodb-developer/atlas-admin-api-digest-auth).

## Setup

To use the Atlas Administration API, you need… a MongoDB Atlas cluster! If you don’t have one already, follow the [Get Started with Atlas](https://www.mongodb.com/docs/atlas/getting-started/) guide to create your first cluster.

The next requirement is the organization API key. You can set it up in two steps:

[Create an API key](https://www.mongodb.com/docs/atlas/configure-api-access/#std-label-create-org-api-key) in your Atlas organization. Make sure the key has the Organization Owner permission.
Add your IP address to the [API Access List for the API key](https://www.mongodb.com/docs/atlas/configure-api-access/#add-an-api-access-list-entry).

Then, open a new terminal and export the following environment variables, where `ATLAS_USER` is your public key and `ATLAS_USER_KEY` is your private key.

```
export ATLAS_USER=<public_key>
export ATLAS_USER_KEY=<private_key>
```

You’re all set up! Let’s see how we can use the Admin API with Python, Node, and Ruby.

</div>

<div class="content">

## Python

We start with the simplest and most self-contained example: Python.

In the Python version, we lean on the `requests` library for most of the heavy lifting. We can install it with `pip`:

``` bash
python -m pip install requests
```

The implementation of the digest authentication itself is the following:

``` python
import os
import requests
from requests.auth import HTTPDigestAuth
import pprint

base_url = "https://cloud.mongodb.com/api/atlas/v1.0/"
auth = HTTPDigestAuth(
   os.environ["ATLAS_USER"],
   os.environ["ATLAS_USER_KEY"]
)

response = requests.get(base_url, auth = auth)
pprint.pprint(response.json())
```

As well as importing `requests`, we also bring in `HTTPDigestAuth` from requests' `auth` module to handle digest authentication. The `os` import is just there so we can get the environment variables `ATLAS_USER` and `ATLAS_USER_KEY` as credentials, and the `pprint` import is just to format our results.

The critical part is the addition of `auth = HTTPDigestAuth(...)` to the `requests.get()` call. This installs the code needed to respond to the server when it asks for the digest.

If we now run this program...

![Screenshot of the terminal emulator after the execution of the request script for Python. The printed message shows that the request was successful.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/atlaspython_tin8y89s18_02b8a26fbe.png)

…we have our API response.


## Node.js

For Node.js, we’ll take advantage of the `urllib` package which supports digest authentication.

``` bash
npm install urllib
```

The code for the Node.js HTTP request is the following:

``` javascript
const urllib = require('urllib');

const baseUrl = 'https://cloud.mongodb.com/api/atlas/v1.0/';
const { ATLAS_USER, ATLAS_USER_KEY } = process.env;
const options = {
  digestAuth: `${ATLAS_USER}:${ATLAS_USER_KEY}`,
};

urllib.request(baseUrl, options, (error, data, response) => {
  if (error || response.statusCode !== 200) {
    console.error(`Error: ${error}`);
    console.error(`Status code: ${response.statusCode}`);
  } else {
    console.log(JSON.parse(data));
  }
});
```

Taking it from the top… we first require and import the `urllib` package. Then, we extract the `ATLAS_USER` and `ATLAS_USER_KEY` variables from the process environment and use them to construct the authentication key. Finally, we send the request and handle the response in the passed callback. 

And we’re ready to run:

![Screenshot of the terminal emulator after the execution of the request script for Node.js. The printed message shows that the request was successful.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/atlasnode_8rd944aaw7_048b949048.png)

On to our final language...

## Ruby

HTTParty is a widely used Gem which is used by the Ruby and Rails community to perform HTTP operations. It also, luckily, supports digest authentication. So, to get the party started:

``` bash
gem install httparty
```

There are two ways to use HTTParty. One is creating an object which abstracts the calls away while the other is just directly calling methods on HTTParty itself. For brevity, we'll do the latter. Here's the code:

``` ruby
require 'httparty'
require 'json'

base_url = 'https://cloud.mongodb.com/api/atlas/v1.0/'
options = {
  :digest_auth => {
    :username=>ENV['ATLAS_USER'],
    :password=>ENV['ATLAS_USER_KEY']
  }
}

result = HTTParty.get(base_url, options)

pp JSON.parse(result.body())
```

We require the HTTParty and JSON gems first. We then create a dictionary with our username and key, mapped for HTTParty's authentication, and set a variable to hold the base URL. We're ready to do our GET request now, and in the `options` (the second parameter of the GET request), we pass `:digest_auth=>auth` to switch on the digest support. We wrap up by JSON parsing the resulting body and pretty printing that. Put it all together and run it and we get:

![Screenshot of the terminal emulator after the execution of the request script for Ruby. The printed message shows that the request was successful.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/atlasruby_e82kmt50uy_d1e1a11ad7.png)

</div>

<div class="summary">

## Next Stop - The API

In this article, we learned how to call the [MongoDB Atlas Administration API](https://docs.atlas.mongodb.com/api/) using digest authentication. We took advantage of the vast library ecosystems of Python, Node.js, and Ruby, and used the following open-source community libraries:

Requests for Python
urllib for JavaScript
httparty for Ruby

If your project requires it, you can implement digest authentication yourself by following the [official specification](https://datatracker.ietf.org/doc/html/rfc7616). You can draw inspiration from the implementations in the aforementioned libraries.

Additionally, you can find all code samples from the article in Github.

With the authentication taken care of, just remember to be fastidious with your API key security and make sure you revoke unused keys. You can now move on to explore the API itself. Start in the [documentation](https://docs.atlas.mongodb.com/api/) and see what you can automate today.


</div>


Learn how to use digest authentication for the MongoDB Atlas Administration API from Python, Node.js, and Ruby.

Calling the MongoDB Atlas Administration API: How to Do it from Node, Python, and Ruby

Rachelle Palmer

## TLDR
MongoDB will continue to support JRuby.

## Background
In April 2021, our Ruby team began to discuss the possibility of removing MongoDBs official support for JRuby. At the time, we decided to shelve these discussions and revisit in a year. In March 2022, right on schedule, we began examining metrics and reviewing user feedback around JRuby, as well as evaluating our backlog of items around this runtime.

JRuby itself is still actively maintained and used by many Ruby developers, but our own user base tends toward MRI/CRuby or ‘vanilla Ruby’. We primarily looked at telemetry from active [MongoDB Atlas](https://www.mongodb.com/docs/atlas/) clusters, commercial support cases, and a number of other sources, like Stack Overflow question volume, etc.

We decided based on the data available that it would be safe to drop support for JRuby from our automated tests, and stop accepting pull requests related to this runtime.

We did not expect this decision to be controversial.

## User Feedback
As a company that manages numerous open source projects we work in a public space. Our JIRA and GitHub issues are available to peruse. And so it was not very long before a user commented on this work and asked us *not to do this please.*

One of the core JRuby maintainers, Charles Nutter, also reached out on the Ruby ticket to discuss this change.

Upon opening [a pull request](https://github.com/mongodb/mongoid/pull/5187) to action this decision, the resulting community feedback encouraged us to reconsider this decision. As the goal of any open source project is to bolster adoption and engagement ultimately we chose to [reverse course](https://jira.mongodb.org/browse/RUBY-2960) for the time being, especially seeing as JRuby had subsequently [tweeted out](https://twitter.com/jruby/status/1514318556871208969) their upcoming 9.4 release would be compatible with both Rails 7 and Ruby 3.1.

Following the JRuby announcement, [TruffleRuby 22.1 was released](https://twitter.com/TruffleRuby/status/1519020440764788736), so it seems the JVM-based Ruby ecosystem is more active than we anticipated.

You can see the back and forth on [RUBY-2781](https://jira.mongodb.org/browse/RUBY-2781) and [RUBY-2960](https://jira.mongodb.org/browse/RUBY-2960).

## Decision
We decided to reverse our decision around JRuby, quite simply, because the community asked us to.  Our decisions should be informed by the open source community - not just the developers who work at MongoDB - and if we are too hasty, or wrong, we would like to be able to hear that without flinching and respond appropriately.

So. Though we weren’t at [RailsConf 22](https://railsconf.org/) this year, know that if your next application is built using JRuby you should be able to count on MongoDB Atlas being ready to host your application’s data.
 


A Plan for MongoDB and JRuby

Alex Bevilacqua

Before discovering Ruby and Ruby on Rails, I was a .NET developer. At that time, I'd make ad-hoc changes to my development database, export my table/function/stored procedure/view definitions to text files, and check them into source control with any code changes. Using `diff` functionality, I'd compare the schema changes that the DBAs needed to apply to production and we'd script that out separately.

I'm sure better tools existed (and I eventually started using some of [RedGate's tools](https://www.red-gate.com/solutions/role/development)), but I was looking for a change. At that time, the real magic of Ruby on Rails for me was the [Active Record Migrations](https://guides.rubyonrails.org/active_record_migrations.html) which made working with my database fit with my programming workflow. Schema management became less of a chore and there were `rake` tasks for anything I needed (applying migrations, rolling back changes, seeding a test database).

Schema versioning and management with Rails was leaps and bounds better than what I was used to, and I didn't think this could get any better — but then I found MongoDB. 

When working with MongoDB, there's no need to `CREATE TABLE foo (id integer, bar varchar(255), ...)`; if a collection (or associated database) doesn't exist, inserting a new document will automatically create it for you. This means Active Record migrations are no longer needed as this level of schema change management was no longer necessary.
 
Having the flexibility to define my data model directly within the code without needing to resort to the intermediary management that Active Record had facilitated just sort of made sense to me. I could now persist object state to my database directly, embed related model details, and easily form queries around these structures to quickly retrieve my data.

## Flexible schema

Data in MongoDB has a flexible schema as [collections](https://www.mongodb.com/docs/manual/reference/glossary/#std-term-collection) do not enforce a strict [document](https://www.mongodb.com/docs/manual/reference/glossary/#std-term-document) structure or schema by default. This flexibility gives you data-modeling choices to match your application and its performance requirements, which aligns perfectly with Ruby's focus on simplicity and productivity.

## Let's try it out

We can easily demonstrate how to quickly get started using the [MongoDB Ruby Driver](https://www.mongodb.com/docs/ruby-driver/master/) using the following simple Ruby script that will connect to a cluster, insert a document, and read it back:
 
```ruby
require 'bundler/inline'
 
gemfile do
  source 'https://rubygems.org'
  gem 'mongo'
end
 
client = Mongo::Client.new('mongodb+srv://username:password@mycluster.mongodb.net/test')
collection = client[:foo]
collection.insert_one({ bar: "baz" })
 
puts collection.find.first 
# => {"_id"=>BSON::ObjectId('62d83d9dceb023b20aff228a'), "bar"=>"baz"}
```
 
When the document above is inserted, an `_id` value of `BSON::ObjectId('62d83d9dceb023b20aff228a')` is created. All documents must have an [`_id` field](https://www.mongodb.com/docs/manual/core/document/#the-_id-field). However, if not provided, a default `_id` of type [`ObjectId`](https://www.mongodb.com/docs/manual/reference/bson-types/#std-label-objectid) will be generated. When running the above, you will get a different value for `_id`, or you may choose to explicitly set it to any value you like!
 
Feel free to give the above example a spin using your existing MongoDB cluster or [MongoDB Atlas](https://www.mongodb.com/atlas) cluster. If you don't have a MongoDB Atlas cluster, [sign up for an always free tier](https://www.mongodb.com/cloud/atlas/signup) cluster to get started.
 
## Installation
 
The MongoDB Ruby Driver is hosted at [RubyGems](https://rubygems.org/gems/mongo), or if you'd like to explore the source code, it can be found on [GitHub](https://github.com/mongodb/mongo-ruby-driver).
 
To simplify the example above, we used `bundler/inline` to provide a [single-file solution using Bundler](https://bundler.io/guides/bundler_in_a_single_file_ruby_script.html). However, the `mongo` gem can be just as easily added to an existing `Gemfile` or installed via [`gem install mongo`](https://guides.rubygems.org/rubygems-basics/#installing-gems).
 
## Basic CRUD operations
 
Our sample above demonstrated how to quickly create and read a document. Updating and deleting documents are just as painless as shown below:
 
```ruby
# set a new field 'counter' to 1
collection.update_one({ _id: BSON::ObjectId('62d83d9dceb023b20aff228a')}, :"$set" => { counter: 1 })
 
puts collection.find.first 
# => {"_id"=>BSON::ObjectId('62d83d9dceb023b20aff228a'), "bar"=>"baz", "counter"=>1}
 
# increment the field 'counter' by one
collection.update_one({ _id: BSON::ObjectId('62d83d9dceb023b20aff228a')}, :"$inc" => { counter: 1 })
 
puts collection.find.first 
# => {"_id"=>BSON::ObjectId('62d83d9dceb023b20aff228a'), "bar"=>"baz", "counter"=>2}
 
# remove the test document
collection.delete_one({ _id: BSON::ObjectId('62d83d9dceb023b20aff228a') })
```
 
## Object document mapper
 
Though all interaction with your Atlas cluster can be done directly using the MongoDB Ruby Driver, most developers prefer a layer of abstraction such as an [ORM or ODM](https://medium.com/spidernitt/orm-and-odm-a-brief-introduction-369046ec57eb). Ruby developers can use the [Mongoid ODM](https://www.mongodb.com/docs/mongoid/current/) to easily model MongoDB collections in their code and simplify interaction using a fluid API akin to [Active Record's Query Interface](https://guides.rubyonrails.org/active_record_querying.html).
 
The following example adapts the previous example to use Mongoid:
```ruby
require 'bundler/inline'
 
gemfile do
  source 'https://rubygems.org'
 
  gem 'mongoid'
end
 
Mongoid.configure do |config|
  config.clients.default = { uri: "mongodb+srv://username:password@mycluster.mongodb.net/test" }
end
 
class Foo
  include Mongoid::Document
 
  field :bar, type: String
  field :counter, type: Integer, default: 1
end
 
# create a new instance of 'Foo', which will assign a default value of 1 to the 'counter' field
foo = Foo.create bar: "baz"
 
puts foo.inspect 
# => <Foo _id: 62d84be3ceb023b76a48df90, bar: "baz", counter: 1>
 
# interact with the instance variable 'foo' and modify fields programmatically
foo.counter += 1
 
# save the instance of the model, persisting changes back to MongoDB
foo.save!
 
puts foo.inspect 
# => <Foo _id: 62d84be3ceb023b76a48df90, bar: "baz", counter: 2>
```
 
## Summary
 
Whether you're using Ruby/Rails to build a script/automation tool, a new web application, or even the next [Coinbase](https://blog.coinbase.com/scaling-connections-with-ruby-and-mongodb-99204dbf8857), MongoDB has you covered with both a Driver that simplifies interaction with your data or an ODM that seamlessly integrates your data model with your application code.
 
## Conclusion

Interacting with your MongoDB data via Ruby — either using the Driver or the ODM — is straightforward, but you can also directly interface with your data from MongoDB Atlas using the built in [Data Explorer](https://www.mongodb.com/docs/atlas/atlas-ui/). Depending on your preferences though, there are options:
 
* [MongoDB for Visual Studio Code](https://www.mongodb.com/products/vs-code) allows you to connect to your MongoDB instance and enables you to interact in a way that fits into your native workflow and development tools. You can navigate and browse your MongoDB databases and collections, and prototype queries and aggregations for use in your applications.

* [MongoDB Compass](https://www.mongodb.com/products/compass) is an interactive tool for querying, optimizing, and analyzing your MongoDB data. Get key insights, drag and drop to build pipelines, and more.

* [Studio 3T](https://studio3t.com/) is an extremely easy to use 3rd party GUI for interacting with your MongoDB data.

* [MongoDB Atlas Data API](https://www.mongodb.com/docs/atlas/api/data-api/) lets you read and write data in Atlas with standard HTTPS requests. To use the Data API, all you need is an HTTPS client and a valid API key.
  
Ruby was recently added as a [language export option to both MongoDB Compass and the MongoDB VS Code Extension](https://www.mongodb.com/blog/post/ruby-added-mongodb-export-language-compass-vs-code). Using this integration you can easily convert an [aggregation pipeline](https://www.mongodb.com/docs/manual/core/aggregation-pipeline/) from either tool into code you can copy/paste into your Ruby application.

Find out what makes MongoDB a great fit for your next Ruby on Rails application! 

Why Use MongoDB with Ruby

Though developers have always been capable of manually writing complex queries to interact with a database, this approach can be tedious and error-prone. [Object-Relational Mappers](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping) (or ORMs) improve the developer experience, as they accomplish multiple meaningful tasks:

* Facilitating interactions between the database and an application by abstracting away the need to write raw SQL or database query language.
* Managing serialization/deserialization of data to objects.
* Enforcement of schema.

So, while it’s true that MongoDB offers [Drivers](https://www.mongodb.com/docs/drivers/) with idiomatic APIs and helpers for most  programming languages, sometimes a higher level abstraction is desirable. Developers are used to interacting with data in a more declarative fashion (LINQ for C#, ActiveRecord for Ruby, etc.) and an ORM facilitates code maintainability and reuse by allowing developers to interact with data as objects.

MongoDB provides a number of ORM-like libraries, and our [community](https://www.mongodb.com/docs/drivers/community-supported-drivers/) and partners have as well! These are sometimes referred to as ODMs (Object Document Mappers), as MongoDB is not a relational database management system. However, they exist to solve the same problem as ORMs do and the terminology can be used interchangeably.

The following are some examples of the best MongoDB ORM or ODM libraries for a number of programming languages, including Ruby, Python, Java, Node.js, and PHP.

## Beanie

Beanie is an Asynchronous Python object-document mapper (ODM) for MongoDB, based on [Motor](https://www.mongodb.com/docs/drivers/motor/) (an asynchronous MongoDB driver) and [Pydantic](https://pydantic-docs.helpmanual.io/).

When using Beanie, each database collection has a corresponding document that is used to interact with that collection. In addition to retrieving data, Beanie allows you to add, update, and delete documents from the collection. Beanie saves you time by removing boilerplate code, and it helps you focus on the parts of your app that actually matter.

See the [Beanie documentation](https://beanie-odm.dev/) for more information.

## Doctrine

Doctrine is a PHP MongoDB ORM, even though it’s referred to as an ODM. This library provides PHP object mapping functionality and transparent persistence for PHP objects to MongoDB, as well as a mechanism to map embedded or referenced documents. It can also create references between PHP documents in different databases and work with GridFS buckets.

See the [Doctrine MongoDB ODM documentation](https://www.doctrine-project.org/projects/doctrine-mongodb-odm/en/latest/index.html) for more information.

## Mongoid

Most Ruby-based applications are built using the [Ruby on Rails](https://rubyonrails.org/) framework. As a result, Rails’ [Active Record](https://guides.rubyonrails.org/active_record_basics.html) implementation, conventions, CRUD API, and callback mechanisms are second nature to Ruby developers. So, as far as a MongoDB ORM for Ruby, the Mongoid ODM provides API parity wherever possible to ensure developers working with a Rails application and using MongoDB can do so using methods and mechanics they’re already familiar with.

See the [Mongoid documentation](https://www.mongodb.com/docs/mongoid/current/) for more information.

## Mongoose

If you’re seeking an ORM for NodeJS and MongoDB, look no further than Mongoose. This Node.js-based Object Data Modeling (ODM) library for MongoDB is akin to an Object Relational Mapper (ORM) such as [SQLAlchemy](https://www.sqlalchemy.org/). The problem that Mongoose aims to solve is allowing developers to enforce a specific schema at the application layer. In addition to enforcing a schema, Mongoose also offers a variety of hooks, model validation, and other features aimed at making it easier to work with MongoDB.

See the [Mongoose documentation](https://mongoosejs.com/) or [MongoDB & Mongoose: Compatibility and Comparison](https://www.mongodb.com/developer/languages/javascript/mongoose-versus-nodejs-driver/) for more information.

## MongoEngine

MongoEngine is a Python ORM for MongoDB. Branded as a Document-Object Mapper, it uses a simple declarative API, similar to the Django ORM.

It was first released in 2015 as an open-source project, and the current version is built on top of [PyMongo](https://www.mongodb.com/docs/drivers/pymongo/), the official Python Driver by MongoDB.

See the [MongoEngine documentation](http://mongoengine.org/) for more information.

## Prisma

Prisma is a [new kind of ORM](https://www.prisma.io/docs/concepts/overview/prisma-in-your-stack/is-prisma-an-orm) for Node.js and Typescript that fundamentally differs from traditional ORMs. With Prisma, you define your models in the declarative [Prisma schema](https://www.prisma.io/docs/concepts/components/prisma-schema), which serves as the single source of truth for your database schema and the models in your programming language. The Prisma Client will read and write data to your database in a type-safe manner, without the overhead of managing complex model instances. This makes the process of querying data a lot more natural as well as more predictable since Prisma Client always returns plain JavaScript objects.

Support for MongoDB was one of the most requested features since the initial release of the Prisma ORM, and was added in version 3.12.

See [Prisma & MongoDB](https://www.prisma.io/mongodb) for more information.

## Spring Data MongoDB

If you’re seeking a Java ORM for MongoDB, Spring Data for MongoDB is the most popular choice for Java developers. The [Spring Data](https://spring.io/projects/spring-data) project provides a familiar and consistent Spring-based programming model for new datastores while retaining store-specific features and capabilities.

Key functional areas of Spring Data MongoDB that Java developers will benefit from are a POJO centric model for interacting with a MongoDB DBCollection and easily writing a repository-style data access layer.

See the [Spring Data MongoDB documentation](https://spring.io/projects/spring-data-mongodb) or the [Spring Boot Integration with MongoDB Tutorial](https://www.mongodb.com/compatibility/spring-boot) for more information.

## Go Build Something Awesome!

Though not an exhaustive list of the available MongoDB ORM and ODM libraries available right now, the entries above should allow you to get started using MongoDB in your language of choice more naturally and efficiently.

If you’re looking for assistance or have any feedback don’t hesitate to engage on our [Community Forums](https://www.mongodb.com/community/forums/).

MongoDB has a number of ORMs, ODMs, and Libraries that simplify the interaction between your application and your MongoDB cluster. Build faster with the best database for Ruby, Python, Java, Node.js, and PHP using these libraries, ORMs, and ODMs.

MongoDB ORMs, ODMs, and Libraries

[TableCheck](https://tablecheck.com/) is the world’s premiere booking and guest platform. Headquartered in Tokyo, they empower restaurants with tools to elevate their guest experience and create guests for life with features like booking forms, surveys, marketing automation tools and an ecosystem of powerful solutions for restaurants to take their business forward.

## Architectural overview of TableCheck

Launched in 2013, TableCheck began life as a [Ruby on Rails](https://rubyonrails.org/) monolith. Over time, the solution has been expanded to include satellite microservices. However, one constant that has remained throughout this journey was MongoDB.

Originally, TableCheck managed their own MongoDB Enterprise clusters. However, once MongoDB Atlas became available, they migrated their data to a managed replica set running in AWS.

According to CTO Johnny Shields, MongoDB was selected initially as the database of choice for TableCheck as it was _"love at first sight"_. Though MongoDB was a much different solution in 2013, even in the database product’s infancy, it fit perfectly with their development workflow and allowed them to work with their data easily and quickly while building out their APIs and application.

## Ruby on Rails + MongoDB

Any developer familiar with Ruby on Rails knows that the [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping) layer (via [Active Record](https://guides.rubyonrails.org/active_record_basics.html)) was designed to support relational databases. MongoDB’s [Mongoid ODM](https://www.mongodb.com/docs/mongoid/current/) acts as a veritable "drop-in" replacement for existing Active Record adapters so that MongoDB can be used seamlessly with Rails. The CRUD API is familiar to Ruby on Rails developers and makes working with MongoDB extremely easy.

When asked if MongoDB and Ruby were a good fit, Johnny Shields replied:
> _"Yes, I’d add the combo of MongoDB + Ruby + Rails + Mongoid is a match made in heaven. Particularly with the Mongoid ORM library, it is easy to get MongoDB data represented in native Ruby data structures, e.g. as nested arrays and objects"._

This has allowed TableCheck to ensure MongoDB remains the "golden-source" of data for the entire platform. They currently replicate a subset of data to Elasticsearch for deep multi-field search functionality. However, given the rising popularity and utility of [Atlas Search](https://www.mongodb.com/docs/atlas/atlas-search/), this part of the stack may be further simplified.
 
As MongoDB data changes within the TableCheck platform, these changes are broadcast over [Apache Kafka](https://kafka.apache.org/) via the [MongoDB Kafka Connector](https://www.mongodb.com/docs/kafka-connector/current/) to enable downstream services to consume it. Several of their microservices are built in [Elixir](https://elixir-lang.org/), including a data analytics application. PostgreSQL is being used for these data analytics use cases as the only MongoDB Drivers for Elixir and managed by the community (such as [`elixir-mongo/mongodb`](https://github.com/elixir-mongo/mongodb) or [`zookzook/elixir-mongodb-driver`](https://github.com/zookzook/elixir-mongodb-driver)). However, should an official Driver surface, this decision may change.

## Benefits of the Mongoid ODM for Ruby on Rails development

The "killer feature" for new users discovering Ruby on Rails is [Active Record Migrations](https://guides.rubyonrails.org/active_record_migrations.html). This feature of Active Record provides a DSL that enables developers to manage their relational database’s schema without having to write a single line of SQL. Because MongoDB is a NoSQL database, migrations and schema management are unnecessary!

Johnny Shields shares the following based on his experience working with MongoDB and Ruby on Rails:
> _"You can add or remove data fields without any need to migrate your database. This alone is a "killer-feature" reason to choose MongoDB. You do still need to consider database indexes however, but MongoDB Atlas has a profiler which will monitor for slow queries and auto-suggest if any index is needed."_

As the Mongoid ODM supports large portions of the Active Record API, another powerful productivity feature TableCheck was able to leverage is the use of [Associations](https://www.mongodb.com/docs/mongoid/current/reference/associations/). Cross-collection referenced associations are available. However, unlike relational databases, [embedded associations](https://www.mongodb.com/docs/mongoid/current/reference/associations/#embedded-associations) can be used to simplify the data model.

## Open source and community strong

Both [`mongodb/mongoid`](https://github.com/mongodb/mongoid) and [`mongodb/mongo-ruby-driver`](https://github.com/mongodb/mongo-ruby-driver) are licensed under OSI approved licenses and MongoDB encourages the community to contribute feedback, issues, and pull requests!

Since 2013, the TableCheck team has contributed nearly 150 PRs to both projects. The majority tend to be quality-of-life improvements and bug fixes related to edge-case combinations of various methods/options. They’ve also helped improve the accuracy of documentation in many places, and have even helped the MongoDB Ruby team setup Github Actions so that it would be easier for outsiders to contribute. 

With so many contributions under their team’s belt, and clearly able to extend the Driver and ODM to fit any use case the MongoDB team may not have envisioned, when asked if there were any use-cases MongoDB couldn’t satisfy within a Ruby on Rails application, the feedback was:
> _"I have not encountered any use case where I’ve felt SQL would be a fundamentally better solution than MongoDB. On the contrary, we have several microservices which we’ve started in SQL and are moving to MongoDB now wherever we can."_

The TableCheck team are vocal advocates for things like better changelogs and more discipline in following semantic versioning best practices. These have benefited the community greatly, and Johnny and team continue to advocate for things like adopting static code analysis (ex: via [Rubocop](https://github.com/rubocop/rubocop)) to improve overall code quality and consistency.

## Overall thoughts on working with MongoDB and Ruby on Rails

TableCheck has been a long-time user of MongoDB via the Ruby driver and Mongoid ODM, and as a result has experienced some growing pains as the data platform matured. When asked about any challenges his team faced working with MongoDB over the years, Johnny replied: 
> _"The biggest challenge was that in earlier MongoDB versions (3.x) there were a few random deadlock-type bugs in the server that bit us. These seemed to have gone away in newer versions (4.0+). MongoDB has clearly made an investment in core stability which we have benefitted from first-hand. Early on we were maintaining our own cluster, and from a few years ago we moved to Atlas and MongoDB now does much of the maintenance for us"._

We at MongoDB continue to be impressed by the scope and scale of the solutions our users and customers like TableCheck continue to build. Ruby on Rails continues to be a viable framework for enterprise and best-in-class applications, and our team will continue to grow the product to meet the needs of the next generation of Ruby application developers.

Johnny presented at [MongoDB Day Singapore](https://www.mongodb.com/events/mongodb-days-apac-2022/singapore) on November 23, 2022 ([view presentation](https://vimeo.com/780220683)). His talk covered a number of topics, including his experiences working with MongoDB and Ruby.

TableCheck's CTO Johnny Shields discusses their development experience working with the MongoDB Ruby ODM (mongoid) and how they accelerated and streamlined their development processes with these tools.

TableCheck: Empowering Restaurants with Best-in-Class Booking Tools Powered by MongoDB

An interpreted, high-level, general-purpose programming language which supports multiple programming paradigms. Very popular for web development.

Ruby

All Ruby Content

TableCheck: Empowering Restaurants with Best-in-Class Booking Tools Powered by MongoDB

MongoDB ORMs, ODMs, and Libraries

Why Use MongoDB with Ruby

A Plan for MongoDB and JRuby

Calling the MongoDB Atlas Administration API: How to Do it from Node, Python, and Ruby

Related Topics