Azure Cosmos DB

1. What is Azure Cosmos DB?

• It supports multiple data models: document, key-value, graph, column-family.

• Offers turnkey global distribution across Azure regions with multi-master writes.

• Provides comprehensive SLAs covering throughput, latency, availability, and consistency.

• Enables schema-agnostic, JSON-based data storage with automatic indexing.

• Supports multiple APIs (Core SQL, MongoDB, Cassandra, Gremlin, Table).

2. Core Architecture and Resource Model

• Database Account: The top-level resource managing global distribution and API type.

• Databases: Logical containers of data sets.

• Containers (collections, tables, graphs): Store user data in schema-agnostic documents or records.

• Items: Individual data entries (e.g., JSON documents).

• Partitions: Physical partitions split data horizontally using a partition key for scalability.
• Each physical partition can store up to 50 GB and handle 10,000 request units per second (RU/s).
• Logical partitions store data grouped by partition key, up to 20 GB each.

• Throughput: Provisioned in Request Units (RU/s), a normalized measure of CPU, IOPS, and memory needed per operation.

• Multi-master / Multi-region replication for active-active globally distributed apps.

• Consistency Models: Five well-defined levels from strong to eventual consistency with tradeoffs between latency and availability.

3. Data Models and APIs Supported

4. Key Features

• Global Distribution: Add multiple Azure regions and replicate data transparently.

• Elastic Scalability: Scale throughput (RU/s) and storage independently.

• Multi-API Support: Develop using familiar APIs like MongoDB, Cassandra.

• Automatic Indexing: Schema-agnostic indexing with customizable policies.

• Comprehensive SLAs: Covers latency (<10 ms reads, <15 ms writes), throughput, availability (99.999% single region, 99.99% multi-region).

• Multi-master Writes: Concurrent writes across regions with Conflict Resolution.

• Consistency Levels: Strong, Bounded Staleness, Session, Consistent Prefix, Eventual.

• Integration: Azure Functions, Logic Apps, Synapse, Azure Search.

• Change Feed: Stream of changes data for event-driven architectures.

5. Pricing and Scaling

• Pricing Model:
• Based on provisioned Request Units per second (RU/s) consumed by your workloads.
• Storage size (GB) used for data and indexes.
• Number of regions configured for replication.

• Autoscale: Dynamic RU/s scaling based on load, capped at max RU/s.

• Serverless Mode: Pay-per-use with built-in auto-scaling, suitable for spiky workloads.

• Multi-region writes: Additional charges for replication traffic.

6. Development

• SDKs available for .NET, Java, Python, JavaScript, Node.js, Go, and others.

• Rich query support with SQL-like syntax (for Core SQL API).

• Support for stored procedures, triggers, user-defined functions (server-side JavaScript).

• Use Cosmos DB Emulator for local development.

Simple Sample: Create and Query Container (C#)

using Microsoft.Azure.Cosmos;
using System.Threading.Tasks;

string endpoint = "<your-endpoint>";
string key = "<your-key>";
string databaseId = "SampleDB";
string containerId = "Items";
int throughput = 400;

CosmosClient client = new CosmosClient(endpoint, key);

// Create database and container
Database db = await client.CreateDatabaseIfNotExistsAsync(databaseId);
Container container = await db.CreateContainerIfNotExistsAsync(containerId, "/partitionKey", throughput);

// Insert an item
dynamic item = new { id = "1", partitionKey = "users", name = "Cosmos User" };
await container.CreateItemAsync(item, new PartitionKey(item.partitionKey));

// Query items
var query = container.GetItemQueryIterator<dynamic>("SELECT * FROM c WHERE c.partitionKey = 'users'");
while (query.HasMoreResults)
{
    foreach (var result in await query.ReadNextAsync())
    {
        Console.WriteLine(result.name);
    }
}

7. Security and IAM

• Supports Azure Active Directory (Azure AD) authentication.

• Role-Based Access Control (RBAC) integrated with Azure AD.

• Resource tokens: scoped permissions for clients.

• Network restrictions via Virtual Network Service Endpoints, Private Endpoints (Azure Private Link).

• Data encrypted at rest by default using Microsoft-managed keys; optional Customer Managed Keys (CMK).

• Encryption in transit with TLS.

• Advanced Threat Protection and Firewall rules.

8. Consistency Models Explained

9. Deployment and Configuration

• Provision Cosmos DB accounts with desired APIs, region(s), and consistency.

• Configure throughput at the database or container level.

• Manage indexing policies, Time to Live (TTL) on items, and analytical store (Synapse Link).

• Set up multi-region writes and failover priorities.

• Use ARM templates, Azure CLI, PowerShell, or Azure Portal for deployment automation.

• Monitor via Azure Monitor, Cosmos DB metrics, and diagnostic logs.

10. Advanced Features

• Change Feed: Stream item-level changes for real-time event processing.

• Synapse Link: Analytics store for near real-time analytics with Azure Synapse without ETL.

• Multi-master: Provide write availability and low latency globally.

• Backup & Restore: Automatic backups with restore capabilities.

• Time to Live (TTL): Auto-delete expired data.

• Custom Conflict Resolution: When multi-master conflicts occur, custom policies can be used.

11. Monitoring and Troubleshooting

• Monitor RU consumption, latency, availability using Azure metrics.

• Use diagnostic logs for detailed operation insights.

• Cosmos DB account health and throughput metrics in Azure Monitor.

• Query and indexing performance analysis.

• Alerts and autoscale configuration for cost/performance management.

12. Summary Table: Azure Cosmos DB

FAQ

• Document Model: via Core (SQL) API and MongoDB API (JSON documents)

• Key-Value Model: via Table API

• Graph Model: via Gremlin API for graph traversals

• Column-Family Model: via Cassandra API
This allows developers to use familiar tools and access patterns per application needs.

• Strong: Linearizability; reads always see the latest writes.

• Bounded Staleness: Reads lag behind writes by some staleness window.

• Session: Guarantees monotonic reads/writes within a client session.

• Consistent Prefix: Reads see writes in order but possibly delayed.

• Eventual: No ordering guarantees; lowest latency and highest availability.

Intermediate Interview Questions and Answers

Advanced and Tricky Interview Questions and Answers

Scenario-Based Interview Questions and Answers