CCNA Describe considerations for working with non-relational data on Azure Questions

Azure Cosmos DB is a multi-model NoSQL database with single-digit-millisecond write and read latencies, automatic indexing, and tunable consistency, making it ideal for high-throughput IoT telemetry from manufacturing sensors. Its schema-agnostic JSON documents easily accommodate varying sensor payloads, and its partitioning enables efficient point reads and time-based range queries. Support for global distribution and a 99.999% SLA further justify it as the purpose-built choice for per-second equipment data ingestion.

The Table API is built for key-value stores and supports a schema-less design with composite keys (PartitionKey + RowKey). It also supports serverless throughput and TTL (time-to-live) to automatically delete old entries, fitting the activity log use case.

The Cassandra API provides a native compatibility layer for the Apache Cassandra wire protocol and CQL, allowing existing Cassandra drivers, queries, and schemas to work with minimal changes. This makes it the only option that supports a seamless migration from an on-premises Cassandra cluster to Azure Cosmos DB while preserving the time-series data model and query patterns. Cosmos DB then adds global distribution, multi-region writes, and a fully managed SLA on top of that Cassandra compatibility.

PlayerID is an ideal partition key because it matches the application's point-lookup pattern: every read and write for a player can be routed to a single physical partition, avoiding cross-partition queries. Strong consistency in Azure Cosmos DB ensures that a write is acknowledged only after it is durably committed, and every subsequent read that uses the same partition key returns that committed value. This directly satisfies the requirement that profile updates be immediately and reliably visible. Note that strong consistency is supported only with single-region writes, which is an appropriate choice for this workload.

In Azure Table Storage, the only supported primary key is the pair of PartitionKey and RowKey, and queries that filter by PartitionKey are served directly without a full scan. By creating a new table with the timestamp as the PartitionKey and copying the data there, you make time-based queries use an equality comparison on PartitionKey (e.g., a specific date or hour) and optionally a range on RowKey, which is the most performant pattern. This is the correct answer because it applies the service's native indexing model without reintroducing scanning or paying for a separate service.

Azure Blob Storage is purpose-built for large unstructured binary data: it offers high-throughput write/read, configurable access tiers, and HTTPS-based access suitable for storing and delivering video files at scale. Azure Cosmos DB complements this by storing video metadata as flexible JSON documents, with automatic indexing and sub-millisecond point reads that support rich queries on tags, durations, and upload dates. This pairing keeps the media payload and its searchable catalog decoupled, so storage optimization and query performance are each handled by the most appropriate service.

Access control lists (ACLs) in Azure Data Lake Storage Gen2 provide fine-grained, POSIX-compliant permissions on every file and directory, exactly what is required to control data access within Azure Databricks. Each ACL entry associates a specific user, group, or the owning principal with a combination of read, write, and execute permissions on a specific object, enabling precise authorization separate from network or token-based mechanisms. Databricks clusters can leverage the cluster's managed identity or service principal to authenticate, and then ACLs govern which identities can traverse, list, read, or modify each folder and file down to the leaf level. This makes ACLs the correct choice for enforcing user-level data permissions on data stored in Azure Storage that Databricks processes.

Automatic failover is a core high-availability feature in Azure Cosmos DB that continuously monitors the health of regions and, if the primary region becomes unavailable, automatically redirects traffic to a secondary region without manual intervention. This ensures that the database remains accessible and can continue to serve read and write requests (depending on the consistency configuration) during an outage. It directly addresses the need for uptime and resilience, which makes it a correct answer for a high-availability question.

UserID is the ideal partition key here because it is both the most common filter in the application's queries ("show me my itineraries") and a high-cardinality value that naturally distributes data across many logical partitions. All documents for a given user are co-located in a single logical partition, so queries for that user's itineraries are single-partition operations, consuming minimal RUs and returning quickly. This directly matches the access pattern and avoids the cross-partition overhead that the other options create.

The WHERE clause filters only on timestamp and temperature, not on deviceId—the container's partition key. To satisfy the query, Cosmos DB must issue the query to every physical partition and merge results, a pattern called a cross-partition query or fan-out, which consumes significantly more request units and has higher latency than a query scoped to a single partition key. Adding deviceId to the filter, or redesigning the model to avoid needing to scan all partitions, aligns the query with the partition-key distribution and reduces scanning.

Azure Blob Storage is Microsoft's object storage solution optimized for massive volumes of unstructured binary data, perfect for high-resolution photos. Each block blob can hold up to 4.75 TB and you can store millions of blobs, each directly addressable via a unique HTTPS URL—making it trivial to serve images to browsers or mobile apps and integrate with Azure CDN for global scalability. It also offers tiered storage (hot, cool, archive) to balance cost and access frequency, which is essential for media companies.

Azure Cosmos DB is a globally distributed, multi-model database that natively supports JSON documents with low-latency reads and writes.

Azure Cosmos DB is a globally distributed, multi-model database service with native support for JSON documents and automatic indexing of every property. Its index engine allows filtering, ordering, and joining on any field without pre-defining schemas or secondary indexes, ensuring low-latency queries even at scale. With tunable consistency levels and a SQL API, it is the ideal choice for a collection of JSON documents that require flexible querying and indexing on multiple fields.

Azure Cosmos DB is the correct choice because the Azure Mobile Apps SDK provides first-class offline data sync for Cosmos DB as the backend. The SDK embeds a local SQLite cache on the device, tracks all pending create, update, and delete operations, and automatically reconciles them with the cloud when connectivity returns. It also supports multi-master writes with conflict-resolution policies, such as last-write-wins or custom resolution, making it uniquely suited for a mobile app that must function offline and re-sync later.

Azure Files is the correct choice because it provides fully managed, cloud-native file shares accessible via the SMB protocol, which supports mandatory file and byte-range locking. This enables multiple VMs or processes to safely read from and write to the same large file concurrently without application-level coordination. Azure Files handles the underlying storage, offering high availability and low latency, while the SMB locking semantics ensure that writes are serialized appropriately. This directly satisfies the requirement for concurrent access to a single large binary.

Because older MRI scans are rarely accessed but must be instantly retrievable during follow-ups or legal review, the Cool tier is the optimal trade-off. Cool charges lower per-gigabyte storage fees than Hot while preserving zero-latency reads, so you avoid the high cost of Hot without accepting the multi-hour rehydration delay of Archive. This matches the requirement to minimize cost while maintaining immediate availability.

Eventual consistency is the default in Cosmos DB for multi-region writes and offers the lowest latency and highest availability because replicas converge asynchronously without waiting for quorum. For mobile user preferences, the profile is typically read frequently and written occasionally; if a user updates a preference and reads it a moment later, eventual might show the old value briefly, but it will converge quickly. Because user preferences are non-critical and tolerate a brief stale read, eventual provides the optimal balance of performance and cost, making it the correct choice.

Azure Blob Storage is the correct option because it is a durable, massively scalable object storage service that can hold event data from any number of sources in its native format, such as JSON, Avro, or CSV, without requiring a predefined schema. It supports schema-on-read, meaning the structure can be inferred or defined later during analysis, and it integrates with Azure Data Lake Gen2 for big data workloads. Storing raw events in Blob Storage also preserves them for long-term retention, auditing, and reprocessing, which is exactly what this scenario requires.

The Table API is designed for key-value storage with simple queries by partition key and row key, providing low-latency access at global scale. It is ideal for this type of high-throughput, simple data access pattern.

Azure Cache for Redis is the correct choice because Redis natively supports sorted sets, a data structure perfect for leaderboards. Commands like ZADD and ZINCRBY update scores in O(log N) time, and ZREVRANGE retrieves the top scores in O(log N+M), all while data is held in RAM for sub-millisecond latency. This purpose-built in-memory design handles thousands of concurrent player updates and queries per second, making it the standard solution for real-time gaming leaderboards. Although Redis persistence is optional and typically not the primary concern, it can be configured to maintain data across restarts if needed.

The Hot tier optimizes the initial 30 days when end users actively upload and retrieve video files; its storage cost is higher but it has no retrieval penalty, making frequent data movement inexpensive. A lifecycle management policy then automatically transitions each blob to Cool after 30 days because Cool reduces storage charges for the 180-day period of rare access, despite a small per-GB retrieval cost. After 210 days, the policy moves the blob to Archive, which provides the lowest storage cost for the compliance period when files are never accessed but must be retained. This staged approach exactly aligns costs with the actual access pattern while avoiding manual intervention and the risk of premature transitions.

When a blob is uploaded without an explicit access tier, Azure applies the default access tier of its parent container. Here the container's default tier is Cool, so the blob inherits Cool regardless of the storage account's own tier setting. This inheritance ensures consistent billing for all blobs in the container that do not have a per-blob tier override. The blob's effective tier is Cool, making this answer correct.

Querying with both PartitionKey and RowKey forms a point query that uniquely identifies a single entity, since their combination is the primary key of the table. The PartitionKey narrows the search to a specific partition, and the RowKey directly locates the entity within that partition's index. This is the most efficient, lowest-latency, and least costly operation Azure Table Storage supports for data retrieval.

Eventual consistency is the weakest consistency level, prioritizing availability and low latency. It guarantees that if no new writes are made, all replicas will converge to the same state over time. This aligns with the platform's design goals.

By using a date as the PartitionKey, all videos uploaded on the same date are stored in the same partition. A query filtering by date can then fetch all rows from that single partition using the PartitionKey, which is extremely fast and cost-efficient.

Azure Cosmos DB with the SQL API is the correct choice because it is a schema-agnostic document database that natively stores JSON, automatically indexes every property for efficient point reads and SQL-style queries, and scales horizontally with guaranteed single-digit-millisecond latency and throughput managed in request units. Unlike relational databases, it does not require a fixed schema and is designed for high write and read throughput on document workloads. The SQL API also supports rich queries over nested JSON fields, making it ideal for patient records with varying structures that require fast, interactive access.

GameID is the filter in the dominant query, so it is the natural partition key. Cosmos DB places all items with the same GameID in the same logical partition, allowing a query such as 'SELECT * FROM scores s WHERE s.GameID = @gameId' to target a single partition and complete efficiently. Provided the number of games is large enough to avoid a single game exceeding the 10 GB logical partition limit, GameID gives good distribution and aligns perfectly with the workload.