Quickstart: Build a .NET Framework or Core application using the Azure Cosmos DB for Gremlin account

Article
02/07/2023
11 minutes to read

APPLIES TO: Gremlin

Azure Cosmos DB is Microsoft's globally distributed multi-model database service. You can quickly create and query document, key/value, and graph databases. All of which benefit from the global distribution and horizontal scale capabilities at the core of Azure Cosmos DB.

This quickstart demonstrates how to create an Azure Cosmos DB Gremlin API account, database, and graph (container) using the Azure portal. You then build and run a console app built using the open-source driver Gremlin.Net.

Prerequisites

Latest Visual Studio with the Azure development workload. You can get started with the free Visual Studio Community IDE. Enable the Azure development workload during Visual Studio setup.

If you don't have an Azure subscription, create an Azure free account before you begin.

Create a database account

In a new browser window, sign in to the Azure portal.
In the left menu, select Create a resource.
On the New page, select Databases > Azure Cosmos DB.

On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account.

Setting	Value	Description
Subscription	Subscription name	Select the Azure subscription that you want to use for this Azure Cosmos DB account.
Resource Group	Resource group name	Select a resource group, or select Create new, then enter a unique name for the new resource group.
Account Name	Enter a unique name	Enter a unique name to identify your Azure Cosmos DB account. Your account URI will be gremlin.azure.com appended to your unique account name. The account name can use only lowercase letters, numbers, and hyphens (-), and must be between 3 and 44 characters long.
API	Gremlin (graph)	The API determines the type of account to create. Azure Cosmos DB provides five APIs: NoSQL for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. You must create a separate account for each API. Select Gremlin (graph), because in this quickstart you are creating a table that works with the API for Gremlin. Learn more about the API for Gremlin.
Location	The region closest to your users	Select a geographic location to host your Azure Cosmos DB account. Use the location that is closest to your users to give them the fastest access to the data.
Capacity mode	Provisioned throughput or Serverless	Select Provisioned throughput to create an account in provisioned throughput mode. Select Serverless to create an account in serverless mode.
Apply Azure Cosmos DB free tier discount	Apply or Do not apply	With Azure Cosmos DB free tier, you will get the first 1000 RU/s and 25 GB of storage for free in an account. Learn more about free tier.

Note

You can have up to one free tier Azure Cosmos DB account per Azure subscription and must opt-in when creating the account. If you do not see the option to apply the free tier discount, this means another account in the subscription has already been enabled with free tier.

The new account page for Azure Cosmos DB

In the Global Distribution tab, configure the following details. You can leave the default values for the purpose of this quickstart:

Setting	Value	Description
Geo-Redundancy	Disable	Enable or disable global distribution on your account by pairing your region with a pair region. You can add more regions to your account later.
Multi-region Writes	Disable	Multi-region writes capability allows you to take advantage of the provisioned throughput for your databases and containers across the globe.

Note

The following options are not available if you select Serverless as the Capacity mode:

Apply Free Tier Discount
Geo-redundancy
Multi-region Writes

Optionally you can configure additional details in the following tabs:
- Networking - Configure access from a virtual network.
- Backup Policy - Configure either periodic or continuous backup policy.
- Encryption - Use either service-managed key or a customer-managed key.
- Tags - Tags are name/value pairs that enable you to categorize resources and view consolidated billing by applying the same tag to multiple resources and resource groups.
Select Review + create.
The account creation takes a few minutes. Wait for the portal to display the Congratulations! Your Azure Cosmos DB account was created page.

Add a graph

You can now use the Data Explorer tool in the Azure portal to create a graph database.

Select Data Explorer > New Graph.

The Add Graph area is displayed on the far right, you may need to scroll right to see it.

In the Add graph page, enter the settings for the new graph.

Setting	Suggested value	Description
Database ID	sample-database	Enter sample-database as the name for the new database. Database names must be between 1 and 255 characters, and can't contain `/ \ # ?` or a trailing space.
Throughput	400 RUs	Change the throughput to 400 request units per second (RU/s). If you want to reduce latency, you can scale up the throughput later. If you chose serverless capacity mode, then throughput isn't required.
Graph ID	sample-graph	Enter sample-graph as the name for your new collection. Graph names have the same character requirements as database IDs.
Partition Key	/pk	All Azure Cosmos DB accounts need a partition key to horizontally scale. Learn how to select an appropriate partition key in the Graph Data Partitioning article.

Once the form is filled out, select OK.

Clone the sample application

Now let's clone a Gremlin API app from GitHub, set the connection string, and run it. You'll see how easy it's to work with data programmatically.

Open a command prompt, create a new folder named git-samples, then close the command prompt.
```
md "C:\git-samples"
```
Open a git terminal window, such as git bash, and use the cd command to change to the new folder to install the sample app.
```
cd "C:\git-samples"
```
Run the following command to clone the sample repository. The git clone command creates a copy of the sample app on your computer.
```
git clone https://github.com/Azure-Samples/azure-cosmos-db-graph-gremlindotnet-getting-started.git
```
Then open Visual Studio and open the solution file.
Restore the NuGet packages in the project. The restore operation should include the Gremlin.Net driver, and the Newtonsoft.Json package.
You can also install the Gremlin.Net@v3.4.13 driver manually using the NuGet package manager, or the NuGet command-line utility:
```
nuget install Gremlin.NET -Version 3.4.13
```

Note

The supported Gremlin.NET driver version for Gremlin API is available here. Latest released versions of Gremlin.NET may see incompatibilities, so please check the linked table for compatibility updates.

Review the code

This step is optional. If you're interested in learning how the database resources are created in the code, you can review the following snippets. Otherwise, you can skip ahead to Update your connection string.

The following snippets are all taken from the Program.cs file.

Set your connection parameters based on the account created above:

private static string Host => Environment.GetEnvironmentVariable("Host") ?? throw new ArgumentException("Missing env var: Host");
private static string PrimaryKey => Environment.GetEnvironmentVariable("PrimaryKey") ?? throw new ArgumentException("Missing env var: PrimaryKey");
private static string Database => Environment.GetEnvironmentVariable("DatabaseName") ?? throw new ArgumentException("Missing env var: DatabaseName");
private static string Container => Environment.GetEnvironmentVariable("ContainerName") ?? throw new ArgumentException("Missing env var: ContainerName");

private static bool EnableSSL
{
    get
    {
        if (Environment.GetEnvironmentVariable("EnableSSL") == null)
        {
            return true;
        }

        if (!bool.TryParse(Environment.GetEnvironmentVariable("EnableSSL"), out bool value))
        {
            throw new ArgumentException("Invalid env var: EnableSSL is not a boolean");
        }

        return value;
    }
}

private static int Port
{
    get
    {
        if (Environment.GetEnvironmentVariable("Port") == null)
        {
            return 443;
        }

        if (!int.TryParse(Environment.GetEnvironmentVariable("Port"), out int port))
        {
            throw new ArgumentException("Invalid env var: Port is not an integer");
        }

        return port;
    } 
}

The Gremlin commands to be executed are listed in a Dictionary:

private static Dictionary<string, string> gremlinQueries = new Dictionary<string, string>
{
    { "Cleanup",        "g.V().drop()" },
    { "AddVertex 1",    "g.addV('person').property('id', 'thomas').property('firstName', 'Thomas').property('age', 44).property('pk', 'pk')" },
    { "AddVertex 2",    "g.addV('person').property('id', 'mary').property('firstName', 'Mary').property('lastName', 'Andersen').property('age', 39).property('pk', 'pk')" },
    { "AddVertex 3",    "g.addV('person').property('id', 'ben').property('firstName', 'Ben').property('lastName', 'Miller').property('pk', 'pk')" },
    { "AddVertex 4",    "g.addV('person').property('id', 'robin').property('firstName', 'Robin').property('lastName', 'Wakefield').property('pk', 'pk')" },
    { "AddEdge 1",      "g.V('thomas').addE('knows').to(g.V('mary'))" },
    { "AddEdge 2",      "g.V('thomas').addE('knows').to(g.V('ben'))" },
    { "AddEdge 3",      "g.V('ben').addE('knows').to(g.V('robin'))" },
    { "UpdateVertex",   "g.V('thomas').property('age', 44)" },
    { "CountVertices",  "g.V().count()" },
    { "Filter Range",   "g.V().hasLabel('person').has('age', gt(40))" },
    { "Project",        "g.V().hasLabel('person').values('firstName')" },
    { "Sort",           "g.V().hasLabel('person').order().by('firstName', decr)" },
    { "Traverse",       "g.V('thomas').out('knows').hasLabel('person')" },
    { "Traverse 2x",    "g.V('thomas').out('knows').hasLabel('person').out('knows').hasLabel('person')" },
    { "Loop",           "g.V('thomas').repeat(out()).until(has('id', 'robin')).path()" },
    { "DropEdge",       "g.V('thomas').outE('knows').where(inV().has('id', 'mary')).drop()" },
    { "CountEdges",     "g.E().count()" },
    { "DropVertex",     "g.V('thomas').drop()" },
};

Create a new GremlinServer and GremlinClient connection objects using the parameters provided above:

string containerLink = "/dbs/" + Database + "/colls/" + Container;
Console.WriteLine($"Connecting to: host: {Host}, port: {Port}, container: {containerLink}, ssl: {EnableSSL}");
var gremlinServer = new GremlinServer(Host, Port, enableSsl: EnableSSL, 
                                        username: containerLink, 
                                        password: PrimaryKey);

ConnectionPoolSettings connectionPoolSettings = new ConnectionPoolSettings()
{
    MaxInProcessPerConnection = 10,
    PoolSize = 30, 
    ReconnectionAttempts= 3,
    ReconnectionBaseDelay = TimeSpan.FromMilliseconds(500)
};

var webSocketConfiguration =
    new Action<ClientWebSocketOptions>(options =>
    {
        options.KeepAliveInterval = TimeSpan.FromSeconds(10);
    });


using (var gremlinClient = new GremlinClient(
    gremlinServer, 
    new GraphSON2Reader(), 
    new GraphSON2Writer(), 
    GremlinClient.GraphSON2MimeType, 
    connectionPoolSettings, 
    webSocketConfiguration))
{

Execute each Gremlin query using the GremlinClient object with an async task. You can read the Gremlin queries from the dictionary defined in the previous step and execute them. Later get the result and read the values, which are formatted as a dictionary, using the JsonSerializer class from Newtonsoft.Json package:

foreach (var query in gremlinQueries)
{
    Console.WriteLine(String.Format("Running this query: {0}: {1}", query.Key, query.Value));

    // Create async task to execute the Gremlin query.
    var resultSet = SubmitRequest(gremlinClient, query).Result;
    if (resultSet.Count > 0)
    {
        Console.WriteLine("\tResult:");
        foreach (var result in resultSet)
        {
            // The vertex results are formed as Dictionaries with a nested dictionary for their properties
            string output = JsonConvert.SerializeObject(result);
            Console.WriteLine($"\t{output}");
        }
        Console.WriteLine();
    }

    // Print the status attributes for the result set.
    // This includes the following:
    //  x-ms-status-code            : This is the sub-status code which is specific to Cosmos DB.
    //  x-ms-total-request-charge   : The total request units charged for processing a request.
    //  x-ms-total-server-time-ms   : The total time executing processing the request on the server.
    PrintStatusAttributes(resultSet.StatusAttributes);
    Console.WriteLine();
}

Update your connection string

Now go back to the Azure portal to get your connection string information and copy it into the app.

From the Azure portal, navigate to your graph database account. In the Overview tab, you can see two endpoints-

.NET SDK URI - This value is used when you connect to the graph account by using Microsoft.Azure.Graphs library.

Gremlin Endpoint - This value is used when you connect to the graph account by using Gremlin.Net library.

For this sample, record the Host value of the Gremlin Endpoint. For example, if the URI is https://graphtest.gremlin.cosmosdb.azure.com, the Host value would be graphtest.gremlin.cosmosdb.azure.com.
Next, navigate to the Keys tab and record the PRIMARY KEY value from the Azure portal.
After you've copied the URI and PRIMARY KEY of your account, save them to a new environment variable on the local machine running the application. To set the environment variable, open a command prompt window, and run the following command. Make sure to replace <cosmos-account-name> and <cosmos-account-primary-key> values.
- Windows
- Linux / macOS
```
setx Host "<cosmos-account-name>.gremlin.cosmosdb.azure.com"
setx PrimaryKey "<cosmos-account-primary-key>"
```
```
export Host=<cosmos-account-name>.gremlin.cosmosdb.azure.com
export PrimaryKey=<cosmos-account-primary-key>
```
Open the Program.cs file and update the "database and "container" variables with the database and container (which is also the graph name) names created above.

private static string database = "your-database-name"; private static string container = "your-container-or-graph-name";
Save the Program.cs file.

You've now updated your app with all the info it needs to communicate with Azure Cosmos DB.

Run the console app

Select CTRL + F5 to run the application. The application will print both the Gremlin query commands and results in the console.

The console window displays the vertexes and edges being added to the graph. When the script completes, press ENTER to close the console window.

Browse using the Data Explorer

You can now go back to Data Explorer in the Azure portal and browse and query your new graph data.

In Data Explorer, the new database appears in the Graphs pane. Expand the database and container nodes, and then select Graph.
Select the Apply Filter button to use the default query to view all the vertices in the graph. The data generated by the sample app is displayed in the Graphs pane.

You can zoom in and out of the graph, you can expand the graph display space, add extra vertices, and move vertices on the display surface.

Review SLAs in the Azure portal

The Azure portal monitors your Azure Cosmos DB account throughput, storage, availability, latency, and consistency. Charts for metrics associated with an Azure Cosmos DB Service Level Agreement (SLA) show the SLA value compared to actual performance. This suite of metrics makes monitoring your SLAs transparent.

To review metrics and SLAs:

Select Metrics in your Azure Cosmos DB account's navigation menu.
Select a tab such as Latency, and select a timeframe on the right. Compare the Actual and SLA lines on the charts.
Review the metrics on the other tabs.

Clean up resources

When you're done with your app and Azure Cosmos DB account, you can delete the Azure resources you created so you don't incur more charges. To delete the resources:

In the Azure portal Search bar, search for and select Resource groups.
From the list, select the resource group you created for this quickstart.
On the resource group Overview page, select Delete resource group.
In the next window, enter the name of the resource group to delete, and then select Delete.

Next steps

In this quickstart, you've learned how to create an Azure Cosmos DB account, create a graph using the Data Explorer, and run an app. You can now build more complex queries and implement powerful graph traversal logic using Gremlin.

Query using Gremlin

Quickstart: Build a .NET Framework or Core application using the Azure Cosmos DB for Gremlin account

Prerequisites

Create a database account

Add a graph

Clone the sample application

Review the code

Update your connection string

Run the console app

Browse using the Data Explorer

Review SLAs in the Azure portal

Clean up resources

Next steps

Feedback

Additional resources

Additional resources