Cosmos DB overview and use cases in Azure - Commands & Configuration

Introduction

Sometimes apps need to store data that can be accessed quickly from anywhere in the world. Cosmos DB is a cloud database that helps apps do this by keeping data close to users and making it easy to find and update.

When you want your app to work fast for users in different countries by storing data near them.

When your app needs to handle lots of users reading and writing data at the same time without slowing down.

When you want to store different types of data like documents, key-value pairs, or graphs in one place.

When you want your app to keep working even if one part of the cloud has a problem.

When you want to easily scale your database up or down as your app grows or shrinks.

Commands

This command creates a new Cosmos DB account named 'example-cosmosdb' in the resource group 'example-group' with the East US region. It sets the consistency level to Session for balanced speed and accuracy.

Terminal

az cosmosdb create --name example-cosmosdb --resource-group example-group --locations regionName=EastUS failoverPriority=0 isZoneRedundant=false --default-consistency-level Session --kind GlobalDocumentDB

Expected Output

{

  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/example-group/providers/Microsoft.DocumentDB/databaseAccounts/example-cosmosdb",

  "name": "example-cosmosdb",

  "type": "Microsoft.DocumentDB/databaseAccounts",

  "location": "eastus",

  "properties": {

    "databaseAccountOfferType": "Standard",

    "consistencyPolicy": {

      "defaultConsistencyLevel": "Session"

    },

    "locations": [

      {

        "locationName": "East US",

        "failoverPriority": 0,

        "isZoneRedundant": false

      }

    ]

  }

}

→

--name - Sets the name of the Cosmos DB account

→

--resource-group - Specifies the Azure resource group to use

→

--default-consistency-level - Defines how consistent the data reads are

This command creates a new SQL API database called 'example-database' inside the Cosmos DB account.

Terminal

az cosmosdb sql database create --account-name example-cosmosdb --resource-group example-group --name example-database

Expected Output

{

  "id": "/dbs/example-database",

  "resource": {

    "id": "example-database"

  },

  "_rid": "someRid",

  "_self": "dbs/someRid/",

  "_etag": "\"0000\"",

  "_colls": "colls/",

  "_users": "users/"

}

→

--account-name - Specifies which Cosmos DB account to use

→

--name - Sets the name of the new database

This command creates a container named 'example-container' inside the 'example-database'. The container uses '/category' as the partition key to organize data efficiently.

Terminal

az cosmosdb sql container create --account-name example-cosmosdb --resource-group example-group --database-name example-database --name example-container --partition-key-path /category

Expected Output

{

  "id": "/dbs/example-database/colls/example-container",

  "resource": {

    "id": "example-container",

    "partitionKey": {

      "paths": [

        "/category"

      ],

      "kind": "Hash"

    }

  },

  "_rid": "someRid",

  "_self": "dbs/someRid/colls/someRid/",

  "_etag": "\"0000\""

}

→

--database-name - Specifies the database to add the container to

→

--partition-key-path - Defines the key used to split data for performance

This command shows details about the 'example-container' to confirm it was created correctly.

Terminal

az cosmosdb sql container show --account-name example-cosmosdb --resource-group example-group --database-name example-database --name example-container

Expected Output

{

  "id": "/dbs/example-database/colls/example-container",

  "resource": {

    "id": "example-container",

    "partitionKey": {

      "paths": [

        "/category"

      ],

      "kind": "Hash"

    }

  },

  "_rid": "someRid",

  "_self": "dbs/someRid/colls/someRid/",

  "_etag": "\"0000\""

}

Key Concept

If you remember nothing else from this pattern, remember: Cosmos DB stores data close to users worldwide and organizes it for fast, reliable access.

Common Mistakes

Not specifying a partition key when creating a container

Without a partition key, Cosmos DB cannot distribute data efficiently, causing slow performance and limits on data size.

Always set a meaningful partition key path that matches how your app queries data.

Using strong consistency in global apps without considering latency

Strong consistency can slow down data access for users far from the main region.

Use session or eventual consistency for better speed in global apps.

Summary

Create a Cosmos DB account with az cosmosdb create to set up your global database.

Add a SQL API database inside the account to organize your data.

Create containers with partition keys to store and access data efficiently.

Use show commands to verify your resources are created correctly.

Practice

1. What is the main benefit of using Azure Cosmos DB for global applications?

easy

A. It provides low latency and high availability worldwide.

B. It only supports SQL queries.

C. It requires manual scaling of resources.

D. It is designed for local, single-region apps only.

Solution

1. Step 1: Understand Cosmos DB's global distribution

   Cosmos DB is designed to replicate data across multiple regions to provide fast access and high availability.

2. Step 2: Identify the benefit for global apps

   This replication ensures low latency and continuous availability for users worldwide.

3. Final Answer:

   It provides low latency and high availability worldwide. -> Option A

4. Quick Check:

   Global apps need low latency and high availability = A [OK]

Hint: Global apps need fast, reliable data access worldwide [OK]

Common Mistakes:

• Thinking Cosmos DB only supports SQL
• Assuming manual scaling is required
• Believing it's for single-region use only

2. Which of the following is a supported API model in Azure Cosmos DB?

easy

A. Oracle SQL API

B. MySQL API

C. MongoDB API

D. PostgreSQL API

Solution

1. Step 1: Recall Cosmos DB supported APIs

   Azure Cosmos DB supports multiple APIs including SQL, MongoDB, Cassandra, Gremlin, and Table APIs.

2. Step 2: Identify the correct API from options

   MongoDB API is officially supported, while Oracle, MySQL, and PostgreSQL APIs are not.

3. Final Answer:

   MongoDB API -> Option C

4. Quick Check:

   MongoDB API is supported by Cosmos DB = B [OK]

Hint: Remember Cosmos DB supports MongoDB API, not Oracle or MySQL [OK]

Common Mistakes:

• Confusing Cosmos DB with relational databases
• Assuming all SQL-based APIs are supported
• Selecting unsupported database APIs

3. Given this Cosmos DB use case: A global e-commerce app needs to store product catalog data with fast reads and writes worldwide. Which Cosmos DB feature best supports this?

medium

A. Local SSD caching only

B. Multi-region replication with automatic failover

C. Single-region write with manual backups

D. Manual sharding without replication

Solution

1. Step 1: Analyze the requirement for global fast reads and writes

   The app needs data available quickly everywhere and must handle writes globally.

2. Step 2: Match Cosmos DB features to requirements

   Multi-region replication with automatic failover allows writes and reads in multiple regions with high availability and low latency.

3. Final Answer:

   Multi-region replication with automatic failover -> Option B

4. Quick Check:

   Global fast reads/writes need multi-region replication = C [OK]

Hint: Global writes need multi-region replication with failover [OK]

Common Mistakes:

• Choosing single-region write limits scalability
• Confusing caching with replication
• Ignoring automatic failover importance

4. You created a Cosmos DB container but notice your app experiences high latency when accessing data globally. What is the most likely cause?

medium

A. The container is configured with single-region write and no multi-region replication.

B. The container uses multi-region replication with automatic failover.

C. The container has indexing enabled for all properties.

D. The container is using the MongoDB API.

Solution

1. Step 1: Understand latency causes in global apps

   High latency often happens if data is only written and read from one region far from users.

2. Step 2: Identify configuration causing latency

   Single-region write without multi-region replication means users far from that region experience delays.

3. Final Answer:

   The container is configured with single-region write and no multi-region replication. -> Option A

4. Quick Check:

   Single-region write without replication causes high latency = A [OK]

Hint: Check if multi-region replication is enabled to reduce latency [OK]

Common Mistakes:

• Assuming indexing causes latency
• Confusing API choice with latency issues
• Believing multi-region replication increases latency

5. A company wants to build a globally distributed IoT app that collects sensor data continuously and requires automatic scaling and low latency. Which Cosmos DB feature combination best fits this use case?

hard

A. Gremlin API with no replication and fixed throughput

B. Single API support with manual scaling and single-region writes

C. Table API with single-region replication and manual failover

D. Multi-model support with multi-region writes and automatic scaling

Solution

1. Step 1: Identify IoT app requirements

   The app needs to handle continuous data ingestion globally with automatic scaling and low latency.

2. Step 2: Match Cosmos DB features to these needs

   Multi-model support allows flexible data types; multi-region writes enable global data ingestion; automatic scaling handles variable loads.

3. Final Answer:

   Multi-model support with multi-region writes and automatic scaling -> Option D

4. Quick Check:

   IoT needs global writes and scaling = D [OK]

Hint: IoT needs multi-region writes plus auto scaling [OK]

Common Mistakes:

• Choosing single-region writes limits global data ingestion
• Ignoring automatic scaling for variable IoT loads
• Selecting APIs without replication support