Calling the MongoDB Atlas API - How to do it from Node, Python, and Ruby

#Python

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

1
import os
2
import requests
3
from requests.auth import HTTPDigestAuth
4
import pprint
5
6
baseurl = "https://cloud.mongodb.com/api/atlas/v1.0/"
7
8
response=requests.get(baseurl, auth=HTTPDigestAuth(
9
   os.environ["ATLAS_USER"], os.environ["ATLAS_USER_KEY"]))
10
11
pprint.pprint(response.json())

In the Python version, we lean on the requests library for most of the heavy lifting. 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...

We have our API response.

#Node.js

For Node.js, it is a matter of finding a package which does HTTP fetching with digest authentication. There's a whole ecosystem of packages out there and one that we found that worked was digest-fetch which wraps the very popular node-fetch library with what it needs to do HTTP Digest authentication. After installing the required libraries

1
npm install digest-fetch crypto-js node-fetch --save

We can now create our code:

1
const DigestFetch = require("digest-fetch");
2
3
const client = new DigestFetch(
4
process.env.ATLAS_USER,
5
process.env.ATLAS_USER_KEY,
6
{ }
7
);
8
9
const urlbase = "https://cloud.mongodb.com/api/atlas/v1.0/";
10
11
client
12
.fetch(urlbase,{})
13
.then(res => res.json())
14
.then(json => console.log(JSON.stringify(json,null," ")));

Taking it from the top... We first require and import the digest-fetch package. It'll pull in the other needed packages. Then we create our DigestFetch client, giving it the user and key values from the environment and an empty set of options. After setting the API's URL base value we then processed to client.fetch() from it. We're using promises and so the next two thens see the data converted to JSON and then pretty-printed on the console. And we're ready to run:

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, first up, gem install httparty to get the party started. 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:

1
require 'httparty'
2
require 'json'
3
4
auth={:username=>ENV['ATLAS_USER'],:password=>ENV['ATLAS_USER_KEY']}
5
baseurl='https://cloud.mongodb.com/api/atlas/v1.0/'
6
7
result=HTTParty.get(baseurl,  { :digest_auth => auth } )
8
9
pp JSON.parse(result.body())

We require in 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 now, and in the options - the second parameter of the get - 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:

#Next Stop - The API

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 and see what you can automate today.