DP-900 Objective 3.2: Describe Capabilities and Features of Azure Cosmos DB

Understanding Azure Cosmos DB

Azure Cosmos DB is Microsoft's globally distributed, multi-model NoSQL database service designed for mission-critical applications requiring predictable performance, high availability, and elastic scalability at global scale. Unlike traditional databases designed for single-region deployments, Cosmos DB built from ground up for global distribution, enabling data replication across any number of Azure regions with turnkey configuration. The service guarantees single-digit millisecond latencies for reads and writes at 99th percentile, supports unlimited elastic scalability of throughput and storage, and provides comprehensive SLAs covering availability (up to 99.999%), latency, throughput, and consistency—unique among database services. Cosmos DB is fully managed Platform-as-a-Service (PaaS) eliminating operational concerns like patching, scaling, replication, and failover.

What makes Cosmos DB unique is its multi-model support through different API endpoints. Instead of forcing applications into single data model, Cosmos DB supports documents (NoSQL API), key-value pairs (Table API), graph structures (Gremlin API), column-families (Cassandra API), and MongoDB compatibility (MongoDB API). This flexibility enables choosing appropriate data model for specific scenarios or migrating existing applications built with MongoDB, Cassandra, or Azure Table storage to Cosmos DB with minimal code changes while gaining global distribution, guaranteed performance, and enterprise SLAs. Cosmos DB suits internet-scale applications, IoT and telemetry platforms, retail and personalization engines, gaming, real-time analytics, and any scenario requiring global reach, predictable low latency, or flexible schemas unsuitable for rigid relational models. Understanding Cosmos DB capabilities and choosing appropriate APIs enables leveraging its strengths for modern distributed applications.

Core Capabilities and Features

Global Distribution

Azure Cosmos DB provides turnkey global distribution enabling data replication across any Azure regions worldwide with single-click or API call. Unlike traditional databases requiring complex replication setups, Cosmos DB handles distribution transparently. You select Azure regions for database presence, and Cosmos DB automatically replicates data, handles failover, and maintains consistency according to configured level. This global distribution serves several purposes: reducing latency by placing data near users—European users access European replica while Asian users access Asian replica, both reading local data with single-digit millisecond latency; ensuring high availability through redundancy across regions surviving regional outages; enabling multi-region writes allowing applications to write to nearest region rather than routing all writes to single primary region; and supporting disaster recovery with automatic failover to healthy regions when issues occur.

Global distribution configuration is dynamic—add or remove regions anytime without application downtime. Cosmos DB handles data distribution, rebalancing, and synchronization automatically. For read-heavy workloads, multi-region reads distribute query load across regions. For write-heavy workloads or applications requiring local writes, multi-region writes enable writing to any region with conflict resolution policies handling concurrent modifications. Use cases benefiting from global distribution include social networks serving users worldwide, multiplayer games with players across continents, e-commerce platforms with international customers, and IoT applications with devices globally distributed. The ability to transparently distribute data while maintaining consistency and performance makes Cosmos DB ideal for truly global applications where data locality significantly impacts user experience.

Performance and Scalability

Azure Cosmos DB guarantees single-digit millisecond latency for reads (under 10ms) and writes (under 15ms) at 99th percentile backed by SLAs. This predictable low latency enables responsive user experiences regardless of data volume or geographic location. Throughput scales elastically from hundreds to millions of requests per second per database or container. You provision throughput in Request Units per second (RU/s) representing normalized measure of compute, memory, and I/O required for operations. Cosmos DB automatically distributes throughput across partitions enabling horizontal scaling. Autoscale feature automatically adjusts provisioned throughput based on workload patterns, scaling up during peak usage and down during quiet periods, optimizing costs while maintaining performance.

Storage scales unlimited with Cosmos DB automatically adding partitions as data grows. Unlike databases with fixed capacity limits, Cosmos DB handles petabytes of data seamlessly. Partition key choice critically impacts performance and scalability—good partition keys distribute data and operations evenly across partitions preventing hot partitions. Serverless pricing model suits intermittent or unpredictable workloads, charging only for consumed resources without provisioning throughput upfront. This flexibility enables right-sizing costs for different workload patterns. The combination of guaranteed latency, elastic throughput scaling, and unlimited storage makes Cosmos DB suitable for both small applications and internet-scale services handling millions of users. Performance guarantees backed by SLAs provide confidence for production deployments where performance directly impacts business outcomes.

Consistency Models

Azure Cosmos DB provides five well-defined consistency levels enabling fine-grained tradeoff between consistency, availability, latency, and throughput. This choice addresses fundamental distributed systems challenge: CAP theorem states distributed systems can provide at most two of Consistency, Availability, and Partition tolerance. Cosmos DB's consistency levels offer spectrum between strong consistency (guaranteeing linearizability but with higher latency and lower availability) and eventual consistency (maximizing availability and performance but allowing temporary inconsistencies). The five levels are: Strong consistency guarantees linearizability where reads return most recent committed write, appearing as if single copy exists—suitable for financial transactions or inventory management where consistency cannot be compromised. Bounded staleness ensures reads lag behind writes by at most K versions or T time interval, providing consistency guarantee with better performance than strong—suitable for scenarios tolerating bounded staleness like scoreboards or social media feeds.

Session consistency guarantees consistency within client session meaning client sees its own writes (read-your-writes consistency), monotonic reads, and monotonic writes—suitable for most applications where users see their changes immediately. Consistent prefix ensures reads never see out-of-order writes, maintaining write ordering but without guarantees on lag—suitable for social media updates where order matters but immediacy doesn't. Eventual consistency provides no ordering guarantees and eventual convergence, offering highest availability and lowest latency—suitable for view counts, likes, or non-critical data. Choosing appropriate consistency level depends on application requirements. Most applications use session consistency balancing consistency guarantees with performance. Strong consistency suits scenarios requiring absolute consistency. Eventual consistency suits read-heavy workloads with non-critical data. The ability to tune consistency per operation enables different consistency levels for different data within same database, optimizing for specific requirements.

Indexing and Querying

Azure Cosmos DB automatically indexes all data without requiring schema or index definitions. Unlike traditional databases requiring explicit index creation and management, Cosmos DB uses automatic indexing policy analyzing access patterns and optimizing indexes. This eliminates index tuning and maintenance while ensuring query performance. Indexing policies are customizable for advanced scenarios—include or exclude specific paths, configure spatial indexes for geospatial queries, or optimize for write-heavy vs read-heavy workloads. The automatic indexing combined with schema-agnostic design enables flexible data models where documents in same container have different structures, accommodating evolving schemas without migrations.

Query capabilities vary by API. NoSQL API supports SQL-like queries with SELECT, WHERE, JOIN, ORDER BY enabling rich filtering, sorting, projections, and aggregations. Queries support JavaScript user-defined functions for custom logic. MongoDB API supports MongoDB query language and aggregation pipeline. Cassandra API uses CQL (Cassandra Query Language). Gremlin API uses graph traversal language for relationship-based queries. Table API supports simple filtering on partition and row keys. Change feed provides ordered log of all changes enabling reactive programming—applications subscribe to changes implementing event-driven architectures, materialized views, or replication to other systems. Server-side programming through stored procedures, triggers, and user-defined functions (available in NoSQL API) enables executing logic close to data reducing network overhead and ensuring transactional consistency within partitions.

Azure Cosmos DB APIs

NoSQL API (Native API)

Azure Cosmos DB NoSQL API (formerly called SQL API) is the native core API providing document database functionality with JSON documents and SQL-like query syntax. It's the most feature-rich API and recommended starting point for new applications. NoSQL API stores data as JSON documents in containers (analogous to tables) within databases. Documents have flexible schemas—documents in same container can have completely different structures enabling schema evolution without migrations. The SQL-like query language enables familiar querying: SELECT * FROM products p WHERE p.category = 'Electronics' ORDER BY p.price DESC. This syntax supports complex filters, joins within documents, projections selecting specific fields, aggregations calculating sums or averages, and user-defined functions.

Advanced features include server-side programming through stored procedures, triggers, and user-defined functions written in JavaScript executing close to data ensuring ACID transactions within partition and reducing network roundtrips. Change feed captures all modifications enabling reactive programming, event sourcing, or materialized views. Conflict resolution policies handle multi-region write conflicts. NoSQL API benefits from all Cosmos DB capabilities including global distribution, tunable consistency, automatic indexing, and elastic scaling. Use cases include modern application backends requiring JSON data storage, content management systems, user profile management, product catalogs with varying attributes, and scenarios needing flexible schemas and rich querying. The API provides SDKs for .NET, Java, Python, Node.js, and other languages simplifying development. NoSQL API suits applications without specific compatibility requirements, enabling full leverage of Cosmos DB's native capabilities.

MongoDB API

Azure Cosmos DB MongoDB API provides wire protocol compatibility with MongoDB enabling MongoDB applications, drivers, and tools to work with Cosmos DB with minimal or no code changes. This API suits organizations with MongoDB expertise, existing MongoDB applications, or development teams preferring MongoDB's document model and query language. MongoDB API supports MongoDB query language, aggregation pipeline, indexes, and operators. It's compatible with MongoDB drivers in various programming languages—applications connect using standard MongoDB connection strings pointing to Cosmos DB endpoint. The API supports multiple MongoDB versions (currently 3.6, 4.0, and 4.2) providing flexibility for different application requirements.

Key benefits over running MongoDB yourself include fully managed service eliminating cluster management, automatic scaling handling throughput and storage, global distribution replicating data across regions (not available in standard MongoDB), enterprise SLAs for availability and performance, built-in security and compliance, and seamless Azure ecosystem integration. Use cases include migrating existing MongoDB applications to Azure without code rewrites, new applications leveraging MongoDB expertise, scenarios requiring MongoDB compatibility with cloud benefits, and development teams skilled in MongoDB seeking managed service. The MongoDB API translates MongoDB wire protocol to Cosmos DB's underlying engine, meaning applications use familiar MongoDB SDKs and syntax while benefiting from Cosmos DB's global distribution, consistency models, and guaranteed performance. Organizations choosing between MongoDB Atlas and Cosmos DB MongoDB API consider Azure integration, specific feature requirements, global distribution needs, and cost comparisons.

Cassandra API

Azure Cosmos DB Cassandra API provides wire protocol compatibility with Apache Cassandra enabling Cassandra applications and tools to work with Cosmos DB. This API suits organizations with Cassandra expertise or applications using Cassandra's wide-column data model. Cassandra API supports Cassandra Query Language (CQL), Cassandra data types, and keyspace/table concepts. It's compatible with Cassandra drivers enabling existing applications to connect with minimal changes. The column-family data model organizes data in tables with rows identified by primary keys and columns grouped into column families. This model excels at time-series data, IoT sensor readings, and scenarios requiring high write throughput with efficient range queries on time-based data.

Benefits over self-managed Cassandra include eliminated operational overhead (no node management, compaction, repairs), automatic scaling, global distribution with multi-region writes, comprehensive SLAs, and Azure integration. Use cases include migrating Cassandra applications to Azure, IoT and telemetry using Cassandra's data model for time-series storage, applications requiring wide-column storage, and scenarios needing Cassandra compatibility with managed convenience. Cassandra API particularly suits write-heavy workloads with time-series data where Cassandra's log-structured merge tree storage engine and wide-column model excel. Organizations with existing Cassandra investments or applications architected for Cassandra's eventual consistency and partition-tolerance model benefit from migrating to Cosmos DB Cassandra API gaining managed service benefits while preserving application compatibility. The API provides familiar Cassandra interface while leveraging Cosmos DB's infrastructure for scaling, distribution, and reliability.

Gremlin API (Graph Database)

Azure Cosmos DB Gremlin API provides graph database capabilities using Apache TinkerPop Gremlin graph query language. Graph databases excel at scenarios where relationships between data are as important as the data itself, modeling data as networks of connected entities. Gremlin API uses vertices (nodes) representing entities and edges representing relationships between entities, with properties on both. For example, social network might have Person vertices with Friend edges connecting them, or e-commerce graph with Customer, Product, and Purchase vertices connected by Bought, Viewed, and Recommended edges. Graph queries traverse these relationships: g.V().hasLabel('Person').has('name','Alice').out('Friend').out('Friend') finds friends of friends.

Use cases include social networks analyzing connections, friend suggestions, influence analysis, or community detection; recommendation engines analyzing purchase patterns, user similarities, and product relationships; fraud detection identifying suspicious patterns in transaction networks like rings of accounts or unusual relationship patterns; knowledge graphs representing interconnected information with semantic relationships; network and IT operations mapping dependencies between services, servers, and applications; and supply chain management tracking relationships between suppliers, components, products, and customers. Gremlin API benefits from Cosmos DB's global distribution, elastic scaling, and SLAs while providing graph semantics. Graph queries that would require complex self-joins in relational databases or multiple queries in document databases become simple traversals in graph databases. Choosing Gremlin API suits scenarios where relationships are first-class concerns, queries involve multiple levels of connections, or data naturally forms networks rather than hierarchies or collections.

Table API

Azure Cosmos DB Table API provides key-value storage compatible with Azure Table storage but with premium capabilities. This API uses same data model as Azure Table storage—entities (rows) identified by partition key and row key combination—enabling straightforward migration from Azure Table storage to Cosmos DB Table API by changing endpoint. Table API provides significant advantages over Azure Table storage: turnkey global distribution replicating data worldwide, dramatically lower latency with single-digit millisecond performance compared to Table storage's higher latency, comprehensive SLAs covering availability and performance, tunable consistency levels beyond Table storage's eventual consistency, automatic indexing enabling queries on any property not just keys, and better throughput scalability.

Use cases include applications currently using Azure Table storage requiring better performance, global distribution, or improved SLAs; new applications needing simple key-value storage with partition and row keys; scenarios requiring low-latency access to structured data at global scale; and applications needing Table storage compatibility with premium features. Table API suits similar use cases as Azure Table storage—user profiles, session state, metadata, device information, and scenarios with simple access patterns based on keys rather than complex queries. Organizations choose Table API over Azure Table storage when performance, global distribution, or SLAs justify higher costs. The API maintains Table storage interface simplicity while leveraging Cosmos DB infrastructure. Choosing between Azure Table storage and Cosmos DB Table API depends on performance requirements, global distribution needs, SLA requirements, and budget—Table API costs significantly more but provides enterprise features for mission-critical scenarios.

Cosmos DB Use Cases

Global Applications

Azure Cosmos DB excels for globally distributed applications serving users worldwide. Social media platforms need low latency regardless of user location—Cosmos DB replicates data across regions with users reading from and writing to nearest region. Multi-region writes enable localized updates without routing all writes to distant primary region. Consistency levels balance availability and consistency—social media might use eventual consistency for likes or views but session consistency for posts ensuring users see their own content immediately. International e-commerce platforms serve product catalogs globally with regional inventories. Customers in Europe browse European-hosted data while Asian customers access Asian replicas, both experiencing single-digit millisecond latencies. Price and currency adjustments per region store alongside products. Cosmos DB's global distribution without complex replication logic simplifies architecture.

Multiplayer games require low latency for responsive gameplay. Game state, player profiles, leaderboards, and matchmaking data store in Cosmos DB with players connecting to nearest region. Multi-region writes enable players anywhere to update state without cross-region latency. Session consistency ensures players see game state consistently within their session. Content delivery applications serving streaming video metadata, article content, or user-generated content distribute content globally. Users access metadata from nearby region reducing load times. Cosmos DB's change feed enables cache invalidation or content distribution workflows. Global distribution combined with predictable performance makes Cosmos DB ideal for applications where user location varies and latency directly impacts experience. The ability to add or remove regions dynamically enables expansion into new markets without architectural changes.

IoT and Real-Time Analytics

IoT applications generate massive volumes of telemetry from sensors, devices, and equipment requiring high ingestion throughput and flexible schemas accommodating diverse device types. Cosmos DB handles millions of writes per second ingesting sensor readings, device state, and events. Partition key selection by device ID or sensor ID distributes load evenly. Time-series data benefits from Cassandra API's column-family model or NoSQL API with appropriate partition strategy. Change feed enables real-time processing—as telemetry arrives, downstream systems process data for dashboards, alerting, or machine learning. Eventual consistency suits telemetry ingestion where immediate consistency isn't critical but high availability and throughput matter.

Real-time analytics applications process streaming data for operational intelligence. Manufacturing equipment monitoring ingests sensor data, detects anomalies, and triggers alerts—Cosmos DB stores current state and historical data with single-digit millisecond reads enabling dashboard queries. Retail analytics track inventory, sales, and customer behavior in real-time—stores update inventory as sales occur with Cosmos DB propagating updates across locations. Financial services process trading data, detect fraud, and analyze market conditions in real-time. Vehicle telematics collects GPS, speed, fuel consumption, and diagnostic data from fleets—Cosmos DB handles high write throughput from thousands of vehicles while enabling queries for fleet management dashboards. The combination of high ingestion throughput, global distribution, and real-time query capabilities makes Cosmos DB suitable for IoT and real-time scenarios impossible with traditional databases.

Retail and Personalization

Retail applications leverage Cosmos DB's flexible schemas and low latency for product catalogs, shopping carts, and customer profiles. Product catalogs have varying attributes—electronics have technical specifications, clothing has sizes and colors, groceries have nutritional information. Flexible schema accommodates diverse product types in single container without complex schema management. Categories, pricing, inventory, and images store with products. Global distribution serves international customers with localized pricing and inventory. Shopping carts require low latency as customers add items, calculate totals, and apply promotions—delays cause frustration and abandonment. Session consistency ensures customers see cart updates immediately even with replicated data.

Personalization engines analyze customer behavior, preferences, and interactions recommending products or content. Cosmos DB stores user profiles, browsing history, purchase patterns, and recommendations. Change feed enables real-time personalization—as users interact with site, updates flow through change feed to recommendation engine recalculating suggestions. Graph capabilities using Gremlin API model relationships between customers, products, and behaviors enabling collaborative filtering and network-based recommendations. Customer segmentation and A/B testing store user assignments and results. Order history and loyalty programs track purchases and rewards. The combination of flexible schemas, low latency, and global distribution enables responsive personalized experiences at scale. Retail scenarios particularly benefit from multi-region writes as customers transact from various locations expecting consistent experience regardless of region.

Gaming

Gaming applications demand single-digit millisecond latencies preventing lag affecting gameplay. Cosmos DB stores player profiles, game state, inventories, achievements, and social connections. Multiplayer games synchronize state across players in real-time—Cosmos DB's low latency and high throughput handle rapid updates. Multi-region distribution places game servers and data near players reducing network latency critical for competitive gaming. Leaderboards track scores and rankings queryable with low latency. Cosmos DB scales elastically handling usage spikes during game launches or special events. In-game economies manage virtual currencies, items, and trading requiring transactional consistency within partitions preventing duplication exploits.

Mobile games synchronize progress across devices—players start game on mobile and continue on tablet. Cosmos DB replicates player data ensuring consistency across devices. Session storage tracks active games, matchmaking, and temporary state. Social features including friends lists, clans, and messaging store in graph structure using Gremlin API or documents with references. Game analytics track player behavior, progression, monetization, and retention feeding business intelligence. Change feed enables real-time analytics and personalization adjusting difficulty, offers, or content based on player actions. The performance guarantees, global distribution, and elastic scaling make Cosmos DB excellent choice for gaming backends where latency and availability directly impact player experience and business outcomes.

Real-World Cosmos DB Scenarios

Scenario 1: Global Social Media Platform

Scenario 2: IoT Fleet Management

Scenario 3: E-Commerce Product Recommendations

Exam Preparation Tips

Key Concepts to Master

• Cosmos DB capabilities: Global distribution, low latency (single-digit ms), elastic scaling, comprehensive SLAs
• Consistency levels: Strong, bounded staleness, session, consistent prefix, eventual
• Use cases: Global apps, IoT/telemetry, real-time analytics, gaming, retail, personalization
• NoSQL API: Native document database with JSON and SQL-like queries, recommended for new apps
• MongoDB API: MongoDB compatibility for existing MongoDB applications and expertise
• Cassandra API: Wide-column model for time-series data and Cassandra compatibility
• Gremlin API: Graph database for relationship-focused data and traversal queries
• Table API: Key-value storage compatible with Azure Table storage with premium features
• API selection: Choose based on data model, existing expertise, migration scenarios, query needs

Practice Questions

Hands-On Practice Lab

Lab Activities

Lab Outcomes

After completing this lab, you'll understand Azure Cosmos DB's globally distributed, multi-model capabilities including turnkey global distribution, guaranteed low latency, elastic scaling, and comprehensive SLAs. You'll know five APIs (NoSQL for documents, MongoDB for compatibility, Cassandra for wide-column, Gremlin for graphs, Table for key-value) and when to use each. You'll understand consistency levels enabling tradeoffs between consistency and performance. You'll recognize appropriate use cases including global applications, IoT, real-time analytics, gaming, and retail. This knowledge demonstrates Cosmos DB understanding tested in DP-900 exam and provides foundation for leveraging Cosmos DB in modern distributed applications.

Frequently Asked Questions