CCNA Describe Considerations For Working With Non Relational Data On Azure Questions

64 of 214 questions · Page 3/3 · Describe Considerations For Working With Non Relational Data On Azure topic · Answers revealed

151
MCQhard

A company stores IoT sensor data in Azure Table Storage. The data is accessed frequently for the first 30 days, then rarely. You need to minimize storage costs while ensuring data is available for queries within 24 hours of a request. What should you implement?

A.Configure a lifecycle management policy on the Table Storage account to move data to Cool tier after 30 days.
B.Store all data in Azure SQL Database and use index maintenance to improve query performance.
C.Migrate the data to Azure Cosmos DB and use Time-to-Live (TTL) to expire old data.
D.Move data older than 30 days to Azure Blob Storage Cool tier and use an Azure Data Factory pipeline to copy data back to Table Storage when requested.
AnswerD

This optimizes cost by using Cool tier for rarely accessed data and maintains availability within 24 hours.

Why this answer

Azure Table Storage does not natively support lifecycle management policies like Blob Storage does. Moving the data to Azure Storage with lifecycle management (via Azure Data Factory or AzCopy) is the correct approach. Option A is wrong because Azure Table Storage does not have automatic tiering like Blob Storage.

Option B is wrong because Azure Cosmos DB is more expensive and not necessary. Option D is wrong because Azure SQL Database is a relational option not suited for this scenario.

152
Multi-Selectmedium

Which TWO Azure services can be used to store non-relational data? (Choose two.)

Select 2 answers
A.Azure Cosmos DB
B.Azure SQL Database
C.Azure Synapse Analytics
D.Azure Database for MySQL
E.Azure Table Storage
AnswersA, E

A NoSQL database.

Why this answer

Option A (Azure Cosmos DB) is correct because it is a NoSQL database. Option D (Azure Table Storage) is correct because it is a key-value store (non-relational). Option B is wrong because Azure SQL Database is relational.

Option C is wrong because Azure Database for MySQL is relational. Option E is wrong because Azure Synapse Analytics is a relational analytics service.

153
MCQmedium

A manufacturing company stores IoT sensor data as JSON documents in Azure Cosmos DB. Each document has fields: deviceId (high cardinality, many unique values), timestamp, temperature, and humidity. The most frequent query is: 'Retrieve all readings for a specific deviceId from the last hour.' To minimize Request Unit (RU) consumption, which combination of partition key and indexing policy should be chosen?

A.Partition key: deviceId, Indexing: automatic on all properties
B.Partition key: timestamp, Indexing: automatic on all properties
C.Partition key: deviceId, Indexing: none
D.Partition key: temperature, Indexing: automatic on all properties
AnswerA

Correct. deviceId as partition key targets a single partition; automatic indexing ensures the timestamp filter uses an index, minimizing RUs.

Why this answer

Option A is correct because deviceId is the most frequently filtered attribute (in the WHERE clause), making it an ideal partition key that ensures queries are scoped to a single physical partition, minimizing cross-partition fan-out. Automatic indexing on all properties allows efficient filtering on timestamp within the partition, while the index on deviceId is not strictly needed since the partition key itself routes the query, but it does not harm RU consumption significantly. This combination balances query performance and RU cost for the described workload.

Exam trap

The trap here is that candidates often pick timestamp as the partition key because it seems logical for time-range queries, but they overlook that the most frequent query filters on deviceId, making deviceId the correct partition key to avoid cross-partition queries.

How to eliminate wrong answers

Option B is wrong because timestamp as a partition key would cause each query for a specific deviceId to scatter across all partitions (since the same deviceId's data spans many timestamps), resulting in high RU consumption due to cross-partition queries. Option C is wrong because setting indexing to 'none' would force full scans of all documents within the partition for the timestamp filter, dramatically increasing RU cost compared to using an index. Option D is wrong because temperature has low cardinality (few unique values) and is not used in the WHERE clause, leading to hot partitions and inefficient query routing.

154
MCQmedium

A company stores IoT sensor data in Azure Blob Storage. The data is written hourly and must be retained for 90 days. After 90 days, it must be automatically deleted. Which access tier should be used for cost optimization during the retention period?

A.Premium tier
B.Archive tier
C.Cool tier
D.Hot tier
AnswerC

Cool tier is designed for infrequently accessed data with a 30-day minimum retention, matching the 90-day retention without early deletion penalty.

Why this answer

The Cool tier is optimized for data that is infrequently accessed and stored for at least 30 days, with lower storage costs and higher access costs. Hot tier is for frequent access and would be more expensive. Archive tier has a 180-day minimum retention penalty.

Premium tier is for high transaction volumes and is not cost-effective for this scenario.

155
MCQeasy

A media company needs to store thousands of high-resolution videos. Each video is up to 10 GB in size and must be accessible via HTTP/HTTPS URLs for playback. The company does not require a file system hierarchy or SMB protocol support. Which Azure storage solution is most appropriate for this scenario?

A.Azure Blob Storage
B.Azure Files
C.Azure Queue Storage
D.Azure Table Storage
AnswerA

Correct. Blob Storage is optimized for storing large amounts of unstructured data like videos and provides HTTP/HTTPS access.

Why this answer

Azure Blob Storage is designed for storing massive amounts of unstructured data, such as high-resolution videos, and provides HTTP/HTTPS access via URLs. It supports objects up to 4.77 TiB (or larger with premium block blobs), easily accommodating 10 GB files, and offers no file system hierarchy or SMB protocol, matching the company's requirements exactly.

Exam trap

The trap here is that candidates may confuse Azure Files (which supports SMB) with general file storage, but the question explicitly rules out SMB and file hierarchy, making Blob Storage the correct choice for HTTP/HTTPS-accessible binary objects.

How to eliminate wrong answers

Option B is wrong because Azure Files provides SMB and NFS protocol support and a file system hierarchy, which the company explicitly does not require. Option C is wrong because Azure Queue Storage is a messaging service for asynchronous communication between application components, not for storing or serving video files. Option D is wrong because Azure Table Storage is a NoSQL key-value store for structured data, not designed for large binary objects like videos.

156
MCQmedium

A hospital stores patient vital signs data in Azure Cosmos DB. Each document contains PatientID, Timestamp, HeartRate, BloodPressure, and other measurements. The most common query retrieves all vital signs for a specific patient within a time range (e.g., last 24 hours). Which property should be chosen as the partition key to minimize Request Unit (RU) consumption and ensure even data distribution?

A.PatientID
B.Timestamp
C.HeartRate
D.BloodPressure
AnswerA

Correct. PatientID is the natural filter for the most common query, making it single-partition. It also has high cardinality, ensuring data is spread evenly across partitions.

Why this answer

PatientID is the ideal partition key because the most common query filters by PatientID and a time range. With PatientID as the partition key, Cosmos DB can route the query to a single physical partition containing all documents for that patient, minimizing cross-partition queries and reducing RU consumption. It also ensures even data distribution since each patient generates a similar volume of vital signs data, avoiding hot partitions.

Exam trap

Microsoft often tests the misconception that Timestamp is a good partition key for time-based queries, but candidates fail to realize that Timestamp causes hot partitions and does not distribute write load evenly.

How to eliminate wrong answers

Option B (Timestamp) is wrong because using Timestamp as the partition key would cause all writes for the same time window to land on a single partition, creating a hot partition and increasing RU costs due to throttling; it also makes range queries across patients inefficient. Option C (HeartRate) is wrong because HeartRate has low cardinality (e.g., 30–250 bpm), leading to a small number of logical partitions that cannot be evenly distributed across physical partitions, causing storage and throughput imbalances. Option D (BloodPressure) is wrong because BloodPressure values are also low cardinality and often repeated across patients, resulting in uneven data distribution and poor query performance when filtering by patient and time.

157
MCQeasy

A company needs to store archived log files that are rarely accessed but must be retained for regulatory compliance. The logs are text-based and each file is about 10 MB. They want the lowest storage cost while ensuring the data is durable and can be read when needed. Which Azure Blob Storage access tier should they choose?

A.Hot
B.Cool
C.Cold
D.Archive
AnswerD

Archive tier has the lowest storage cost and is designed for data that is rarely accessed. Data can be read when needed, but retrieval takes hours, which is acceptable given the requirements.

Why this answer

The Archive tier is the correct choice because it offers the lowest storage cost for data that is rarely accessed and must be retained for long periods. Archived log files that are text-based and 10 MB each fit this profile perfectly, as the Archive tier is designed for data that can tolerate a retrieval latency of several hours (up to 15 hours for standard priority) while providing the same high durability (99.9999999999% or 11 nines) as other tiers. The data remains fully durable and can be read when needed by first rehydrating it to an online tier (Hot, Cool, or Cold) before access.

Exam trap

The trap here is that candidates often confuse 'Cold' with 'Archive' because both are low-cost tiers, but Cold is still an online tier with immediate access and higher cost, while Archive is the only offline tier designed for true archival storage with the lowest cost but significant retrieval latency.

How to eliminate wrong answers

Option A (Hot) is wrong because it is optimized for frequent access and has the highest storage cost, making it unsuitable for rarely accessed archived data. Option B (Cool) is wrong because it is designed for data accessed infrequently (about once a month) but still incurs higher storage costs than Archive, and it is not the lowest-cost option for long-term retention. Option C (Cold) is wrong because, while it is a lower-cost tier for infrequent access with a 30-day minimum storage period, it still costs more than Archive and is intended for data that may be accessed occasionally, not for rarely accessed archival data.

158
MCQmedium

A retail company is designing a product catalog for its e-commerce website. Each product has a unique ProductID, a name, a price, and a variable number of attributes (e.g., size, color, weight) that differ across product categories. The application requires ability to read a product's details by ProductID with single-digit millisecond latency from any Azure region globally. The schema must be flexible to accommodate new attributes without schema changes. Which Azure data store should the company choose?

A.Azure Cosmos DB using the NoSQL API
B.Azure Table Storage
C.Azure SQL Database
D.Azure Blob Storage
AnswerA

Correct. Azure Cosmos DB NoSQL API offers flexible schemas, global distribution, and guaranteed low-latency reads under 10 ms for point reads.

Why this answer

Azure Cosmos DB with the NoSQL API is correct because it provides a fully managed, globally distributed NoSQL database that supports flexible schemas (allowing variable product attributes without schema changes) and guarantees single-digit millisecond read latency at any scale from any Azure region via its multi-region write and read replicas. The unique ProductID serves as a natural partition key, enabling efficient point reads with consistent low latency.

Exam trap

The trap here is that candidates often confuse Azure Table Storage's flexible schema and global distribution with Cosmos DB's performance guarantees, overlooking the specific single-digit millisecond latency requirement that only Cosmos DB can consistently meet across all regions.

How to eliminate wrong answers

Option B (Azure Table Storage) is wrong because while it offers a flexible schema and global distribution, it does not guarantee single-digit millisecond latency for point reads across regions; its latency is typically higher and less consistent than Cosmos DB. Option C (Azure SQL Database) is wrong because it enforces a fixed relational schema, requiring schema changes (ALTER TABLE) to add new product attributes, and its global read latency is not optimized for single-digit millisecond reads from any region without complex geo-replication setups. Option D (Azure Blob Storage) is wrong because it is an object store for unstructured blobs, not a database; it lacks native query capabilities for individual product details by ID and cannot provide single-digit millisecond read latency for structured data access.

159
MCQeasy

A social media application stores user sessions as JSON documents. Each session document has fields like sessionId, userId, startTime, endTime, and a list of pageviews. The application needs to quickly retrieve a session by its sessionId and also run queries like 'find all sessions for a user in the last 24 hours' using SQL-like syntax. The data has no fixed schema; different sessions may include additional optional fields like 'deviceType' or 'promotionCode'. Which Azure data store should the company use?

A.Azure Cosmos DB with SQL API
B.Azure Table Storage
C.Azure SQL Database
D.Azure Blob Storage
AnswerA

Correct. Azure Cosmos DB with SQL API natively stores JSON documents, supports schema-agnostic data, provides SQL-like querying, and offers low-latency point reads by sessionId.

Why this answer

Azure Cosmos DB with SQL API is the correct choice because it natively supports storing JSON documents with flexible schemas, allows fast point reads by sessionId using a unique identifier, and enables SQL-like queries (e.g., filtering by userId and startTime) with automatic indexing. Its schema-agnostic design handles optional fields like deviceType or promotionCode without requiring schema changes, and it provides low-latency reads essential for real-time session retrieval.

Exam trap

The trap here is that candidates often confuse Azure Table Storage's key-value simplicity with JSON document support, but Table Storage does not provide SQL-like querying or native JSON handling, making Cosmos DB the only option that combines flexible schema, SQL syntax, and fast point reads.

How to eliminate wrong answers

Option B (Azure Table Storage) is wrong because it is a key-value store that does not support SQL-like query syntax or native JSON document storage; it requires a fixed schema with partition and row keys, making it unsuitable for querying by arbitrary fields like userId and startTime without expensive scans. Option C (Azure SQL Database) is wrong because it enforces a fixed relational schema, requiring predefined columns for all fields, which contradicts the requirement for a flexible schema with optional fields; adding new fields like deviceType would require ALTER TABLE statements. Option D (Azure Blob Storage) is wrong because it is an object store for unstructured binary or text data, not designed for interactive queries or indexing; retrieving a specific session by sessionId would require scanning all blobs or maintaining an external index, and it does not support SQL-like queries.

160
MCQmedium

A social media application stores user posts in Azure Cosmos DB using the NoSQL API. Each document includes: PostID (unique), UserID, Timestamp, Content. The most common query is: 'Get all posts for a specific UserID, sorted by Timestamp descending.' Which partition key should be chosen to distribute load evenly across physical partitions while also supporting this query efficiently?

A.PostID
B.UserID
C.Timestamp
D.Content
AnswerB

UserID groups all posts for a user into one logical partition, making the query efficient. With many users, the load is balanced across physical partitions, avoiding hot spots.

Why this answer

UserID is the correct partition key because it evenly distributes write operations across physical partitions (each user has a unique ID) and directly supports the most common query: filtering by UserID. With UserID as the partition key, the query 'Get all posts for a specific UserID, sorted by Timestamp descending' becomes a single-partition query (using the partition key in the WHERE clause), which is efficient and avoids cross-partition fan-out. This design also allows Cosmos DB to use the Timestamp field as a sort key within each logical partition, enabling efficient sorting without additional indexing overhead.

Exam trap

The trap here is that candidates often choose a unique identifier like PostID (Option A) thinking it guarantees even distribution, but they overlook that the partition key must also match the most frequent query filter to avoid cross-partition queries and high RU costs.

How to eliminate wrong answers

Option A is wrong because PostID is unique per document, which would create a separate logical partition for each post, leading to an extremely high number of small partitions and poor query performance for the common query (which filters by UserID, not PostID). Option C is wrong because Timestamp is a high-cardinality, monotonically increasing value; using it as a partition key would cause all new posts to land on a single hot partition (the latest timestamp), creating a throughput bottleneck and uneven load distribution. Option D is wrong because Content is a large, variable-length string with no guarantee of even distribution; it would result in unpredictable partition sizes and cannot efficiently support the required filter on UserID.

161
MCQeasy

You are storing log files from multiple applications in Azure Blob Storage. Each log file is a text file with timestamp data. You need to query logs for a specific date range using SQL. Which Azure service can query these files directly?

A.Azure Stream Analytics
B.Azure Data Lake Storage
C.Azure Synapse Serverless SQL
D.Azure Analysis Services
AnswerC

Serverless SQL can query files in Blob Storage using T-SQL.

Why this answer

Option B is correct because Azure Synapse Serverless SQL can query text files in Blob Storage using OPENROWSET. Option A is wrong because Azure Stream Analytics is for real-time streaming, not batch query. Option C is wrong because Azure Analysis Services is for semantic models.

Option D is wrong because Azure Data Lake Storage is storage, not query.

162
MCQmedium

A social media application stores user profiles as JSON documents. Each profile has standard fields like userId, name, and email, but also optional fields such as education and work history. The application needs to query profiles by userId with low latency and also run SQL-like queries to find all profiles with a specific work history value. Which Azure Cosmos DB API should they choose?

A.SQL (Core) API
B.MongoDB API
C.Gremlin (Graph) API
D.Table API
AnswerA

The SQL API supports SQL-like queries on JSON documents, ideal for flexible schema and queries by userId and optional fields.

Why this answer

The SQL (Core) API is the correct choice because it natively supports querying JSON documents with SQL-like syntax, enabling both low-latency point reads by userId and complex queries on nested fields like work history. It provides automatic indexing of all JSON properties, which ensures efficient execution of queries across optional fields without requiring schema management.

Exam trap

The trap here is that candidates often choose the MongoDB API because they associate JSON documents with MongoDB, but the question explicitly requires SQL-like queries, which is a native feature of the Core API and not MongoDB's query syntax.

How to eliminate wrong answers

Option B (MongoDB API) is wrong because while it supports JSON documents, its query language is based on MongoDB's query operators (e.g., $elemMatch) rather than standard SQL, and the requirement for SQL-like queries makes the Core API more appropriate. Option C (Gremlin (Graph) API) is wrong because it is designed for graph traversal queries on entities and relationships, not for document-level SQL queries on nested JSON fields. Option D (Table API) is wrong because it is optimized for key-value lookups with a flat schema and does not support querying nested JSON fields like work history without complex workarounds.

163
MCQhard

Refer to the exhibit. You deploy an Azure Cosmos DB account using this ARM template. Users in East US report that reads are slower than writes. What is the most likely cause?

A.The consistency level is set to Session, which requires a round-trip to the write region for every read.
B.The East US region is configured as a read region, but the client is connecting to the write endpoint in West US.
C.The failover priority for East US is 1, which means it is not enabled for reads.
D.The database account offer type is Standard, which limits throughput.
AnswerB

If clients use the write endpoint, reads will be slower due to cross-region latency.

Why this answer

The exhibit shows that the write region (failoverPriority 0) is West US, and East US is a read region (failoverPriority 1). Users in East US are reading from the local region, but because the consistency level is Session, reads may not see the latest writes if the write is still propagating from West US. However, the question asks about slower reads than writes.

The most likely cause is that read requests are being served from a different region than the user's location due to Cosmos DB's routing policy. But since East US is a read region, reads should be local. The exhibit does not show multi-region writes.

The typical cause is that reads are not local; but in this case, East US is a read region, so reads should be local. Another possibility: the consistency level Session requires a session token, but that doesn't cause slowness. The exhibit does not specify multi-region writes.

However, a common mistake is that if the account has only one write region, reads from other regions might be served from the write region if not configured properly. But the exhibit shows two regions, so reads should be local. Perhaps the issue is that the client is not using the correct endpoint.

The most likely cause from the exhibit is that the account has only one write region (West US), and reads in East US are still going to West US due to client configuration. But the exhibit does not show client config. Another possibility: the default consistency level Session can cause slightly higher latency for reads that need to check the session token.

However, the best answer is that the read requests are being routed to the write region because the client is not configured to use the local endpoint. But since the question is diagnostic, we'll go with a common issue: the client is using the write endpoint for reads. However, the options need to reflect plausible causes.

Let's design options accordingly.

164
MCQeasy

A company is migrating on-premises Hadoop HDFS data to Azure. They want to keep the same file system semantics for compatibility with existing analytics jobs. Which Azure storage solution should they use?

A.Azure Blob Storage
B.Azure SQL Database
C.Azure Data Lake Storage Gen2
D.Azure Cosmos DB
AnswerC

ADLS Gen2 supports a hierarchical namespace and is fully compatible with Hadoop analytics jobs.

Why this answer

Azure Data Lake Storage Gen2 (ADLS Gen2) provides Hadoop-compatible file system semantics (hierarchical namespace) and is built on Blob Storage. Azure Blob Storage does not have a hierarchical namespace by default. Azure Cosmos DB and Azure SQL are not file systems.

165
MCQmedium

A company develops an IoT device registry that stores device metadata as JSON documents. Each device has a unique DeviceID, and the attributes vary per device type (e.g., sensors, actuators). The application requires low-latency reads by DeviceID and needs global distribution to support devices worldwide. The team wants to use a fully managed NoSQL database in Azure. Which API should they choose for Azure Cosmos DB?

A.SQL API
B.MongoDB API
C.Cassandra API
D.Table API
AnswerA

Correct. The SQL API is the native API for JSON documents in Cosmos DB, offering rich querying and global distribution.

Why this answer

The SQL API (formerly DocumentDB API) is the native API for Azure Cosmos DB, providing full support for querying JSON documents with a SQL-like syntax. It offers the lowest latency reads by ID (point reads) and native global distribution, making it ideal for a device registry where each device has a unique DeviceID and variable attributes. The SQL API also supports indexing all properties automatically, which is critical for the varied device types.

Exam trap

The trap here is that candidates often choose the MongoDB API because they associate JSON documents with MongoDB, but the SQL API is the native Cosmos DB API that provides the best performance and feature integration for JSON workloads on Azure.

How to eliminate wrong answers

Option B (MongoDB API) is wrong because while it supports JSON documents and global distribution, it introduces unnecessary protocol overhead and is designed for MongoDB ecosystem compatibility, not for optimal point reads by ID with automatic indexing of all attributes. Option C (Cassandra API) is wrong because it uses a wide-column store model with a CQL interface, which is not optimized for JSON document storage and requires defining a schema for partition keys and clustering columns, conflicting with the requirement for variable attributes per device type. Option D (Table API) is wrong because it is designed for key-value and tabular data with a flat schema, not for nested JSON documents with varying attributes, and it lacks the rich query capabilities needed for the device registry.

166
MCQhard

A logistics company stores sensor data from delivery trucks in Azure Table Storage. Each sensor reading includes a TruckID, Timestamp, Location, and EngineTemperature. The most common query retrieves all readings for all trucks within a specific one-hour time window (e.g., between 10:00 and 11:00 on a given day). Currently, the table uses PartitionKey = TruckID and RowKey = Timestamp (ISO format). However, queries filtering by time range are slow and consume many transactions. Which design change will most improve the performance of these time-range queries?

A.Change PartitionKey to a date-based value (e.g., YYYY-MM-DD) and RowKey to a composite of TruckID and Timestamp.
B.Change RowKey to be a composite of TruckID and Timestamp while keeping PartitionKey as TruckID.
C.Use Azure Cosmos DB with a partition key on Timestamp instead of Azure Table Storage.
D.Enable indexing on the Timestamp column in Azure Table Storage.
AnswerA

This design groups all data for a given day in one partition, so a time-range query scans exactly one partition, drastically reducing transactions and cost.

Why this answer

Option A is correct because Azure Table Storage queries are most efficient when they target a specific PartitionKey and a range of RowKey values. By setting PartitionKey to a date-based value (e.g., YYYY-MM-DD), all readings for a given day are co-located in the same partition. Then, using a composite RowKey of TruckID and Timestamp allows the query to filter by time range within that partition using a single partition scan, drastically reducing the number of transactions and improving performance.

Exam trap

The trap here is that candidates often assume indexing on a column (like Timestamp) will speed up queries in Azure Table Storage, but Azure Table Storage does not support secondary indexes—only the PartitionKey and RowKey are indexed, so the only way to optimize time-range queries is to redesign the key schema to include the time dimension in the PartitionKey or RowKey.

How to eliminate wrong answers

Option B is wrong because keeping PartitionKey as TruckID scatters each truck's data across many partitions (one per truck), so a time-range query across all trucks would require a full table scan (querying every partition), which is slow and consumes many transactions. Option C is wrong because migrating to Azure Cosmos DB is not a design change to the existing Azure Table Storage schema; it introduces unnecessary cost and complexity, and the question asks for a design change to the current storage solution, not a migration. Option D is wrong because Azure Table Storage does not support secondary indexes on arbitrary columns; indexing is only available on PartitionKey and RowKey, so enabling indexing on Timestamp is not a valid operation in Azure Table Storage.

167
MCQmedium

A company stores historical sales data in Azure Blob Storage. The data is accessed about once per month and must be immediately available for read when needed. The company wants to minimize storage cost while meeting the access requirement. Which access tier should they use?

A.Hot tier
B.Cool tier
C.Cold tier
D.Archive tier
AnswerB

Correct. Cool tier provides low-latency access at a lower storage cost than Hot, suitable for data accessed monthly.

Why this answer

The Cool tier is optimal because the data is accessed only once per month, but must be immediately available for reads. Cool tier offers lower storage cost than Hot tier while maintaining low-latency access (no retrieval delay), meeting the requirement at minimal cost.

Exam trap

The trap here is that candidates may choose Hot tier because they think 'immediately available' requires the highest performance tier, overlooking that Cool and Cold tiers also provide instant access with lower storage costs.

How to eliminate wrong answers

Option A is wrong because Hot tier has the highest storage cost, which is unnecessary for data accessed only once per month. Option C is wrong because Cold tier, while cheaper for storage, is designed for data accessed less than once per quarter and may incur higher access costs for monthly reads. Option D is wrong because Archive tier requires rehydration (hours of delay) before data can be read, violating the 'immediately available' requirement.

168
Matchingmedium

Match each Azure storage redundancy option to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts
Matches

Locally redundant storage within a single datacenter

Zone-redundant storage across availability zones

Geo-redundant storage with cross-region replication

Read-access geo-redundant storage

Geo-zone-redundant storage

Why these pairings

Azure offers multiple redundancy options for data durability.

169
MCQmedium

You are designing a solution to store large binary files (videos) for a media company. The solution must support tiered storage to optimize costs based on access frequency. Which Azure storage option should you use?

A.Azure Cosmos DB
B.Azure Files
C.Azure Blob Storage
D.Azure Disk Storage
AnswerC

Azure Blob Storage supports access tiers for cost optimization.

Why this answer

Option C is correct because Azure Blob Storage supports access tiers (Hot, Cool, Archive) for cost optimization. Option A is wrong because Azure Files is for file shares, not tiered storage for videos. Option B is wrong because Azure Disk Storage is for VM disks, not object storage.

Option D is wrong because Azure Cosmos DB is a database, not for storing large binary files.

170
Multi-Selecthard

Which THREE factors should you consider when choosing between Azure Blob Storage and Azure Cosmos DB for a new application? (Choose three.)

Select 3 answers
A.Global distribution and multi-region writes
B.Data structure (unstructured vs. semi-structured)
C.Encryption at rest support
D.Scalability limits
E.Query capabilities (simple key-value vs. complex queries)
AnswersA, B, E

Cosmos DB offers global distribution with multi-region writes; Blob Storage is limited.

Why this answer

Option A (Data structure) is correct because Blob Storage stores unstructured blobs, while Cosmos DB stores structured documents. Option C (Query requirements) is correct because Cosmos DB supports complex queries, while Blob Storage does not. Option E (Global distribution) is correct because Cosmos DB offers multi-region writes, while Blob Storage does not.

Option B is wrong because both services are highly scalable. Option D is wrong because both support encryption at rest.

171
MCQmedium

You are designing a solution to store customer preferences as key-value pairs. The data will be accessed frequently and must support high availability across multiple Azure regions. The solution should minimize management overhead. Which Azure service should you use?

A.Azure SQL Database
B.Azure Cache for Redis
C.Azure Cosmos DB
D.Azure Queue Storage
AnswerC

Cosmos DB is a globally distributed, multi-model database that supports key-value and provides high availability.

Why this answer

Azure Cosmos DB provides global distribution, high availability, and low-latency access for key-value data with minimal management. Option A is wrong because Azure Cache for Redis is a cache, not a durable store. Option C is wrong because Azure SQL Database is relational and overkill.

Option D is wrong because Azure Storage Queue is for messaging.

172
MCQeasy

Your company needs to store large amounts of data that will be accessed only a few times a year for compliance audits. The data must be retained for 7 years. Which Azure Blob Storage access tier should you choose?

A.Cool
B.Premium
C.Hot
D.Archive
AnswerD

Archive tier is the lowest-cost storage for data that is rarely accessed and has a long retention period.

Why this answer

Azure Blob Storage Archive tier is the most cost-effective for data that is rarely accessed and has a long retention period. Option A is wrong because Hot tier is for frequently accessed data. Option B is wrong because Cool tier is for infrequently accessed data but cheaper than Hot; however, Archive is even cheaper.

Option D is wrong because Premium tier is for high-performance scenarios.

173
MCQeasy

A company stores JSON documents for a product catalog. Each document has a flexible schema because different product categories have different attributes. The catalog is read-heavy and requires low-latency lookups by product ID. The company expects to handle millions of products and needs to serve customers globally with low latency. Which Azure NoSQL data store should they choose?

A.Azure Table Storage
B.Azure Blob Storage
C.Azure Cosmos DB
D.Azure SQL Database
AnswerC

Azure Cosmos DB is a globally distributed NoSQL database that supports flexible schemas and document models via its SQL API. It offers low-latency reads and writes with guarantees of <10 ms for reads and can be replicated across Azure regions.

Why this answer

Azure Cosmos DB is the correct choice because it is a globally distributed, multi-model NoSQL database that natively supports JSON documents with flexible schemas, provides single-digit-millisecond latency for read-heavy workloads via automatic indexing, and offers turnkey global distribution across Azure regions to serve customers worldwide with low latency.

Exam trap

The trap here is that candidates often confuse Azure Table Storage's key-value model with a document database, overlooking that Table Storage does not support flexible JSON schemas or global distribution with low-latency reads, while Cosmos DB is explicitly designed for these requirements.

How to eliminate wrong answers

Option A is wrong because Azure Table Storage is a key-value store that does not natively support JSON documents with flexible schemas; it stores entities with a fixed set of properties and lacks the rich querying and indexing capabilities needed for product catalog lookups. Option B is wrong because Azure Blob Storage is an object storage service for unstructured binary or text data, not a NoSQL database; it cannot perform low-latency lookups by product ID without additional indexing or compute layers. Option D is wrong because Azure SQL Database is a relational database with a fixed schema, requiring predefined tables and columns, which contradicts the requirement for flexible JSON schemas across different product categories.

174
MCQhard

A global gaming company develops a multiplayer game. Player profile data (username, email, preferences) is stored as simple key-value pairs and must be accessible with single-digit millisecond latency from any region. Game session logs are stored as JSON documents with varying fields (session ID, player actions, timestamps) and must be queryable by player ID and timestamp range using SQL-like syntax. The company wants to use a single Azure database service for both workloads. Which combination of Azure Cosmos DB APIs should they choose?

A.Table API for profiles and SQL API for logs
B.SQL API for both profiles and logs
C.MongoDB API for profiles and Cassandra API for logs
D.Table API for both profiles and logs
AnswerA

The Table API provides key-value storage with single-digit millisecond latencies, ideal for player profiles. The SQL API supports JSON documents and full SQL query syntax, perfect for querying session logs by player ID and timestamp.

Why this answer

Option A is correct because the Table API provides a simple key-value store ideal for low-latency profile lookups, while the SQL API supports querying JSON documents with SQL-like syntax, enabling efficient queries on game session logs by player ID and timestamp range. This combination meets both workloads within a single Azure Cosmos DB account.

Exam trap

The trap here is that candidates assume a single API must serve both workloads, overlooking Azure Cosmos DB's ability to host multiple APIs in one account, and they may incorrectly choose the SQL API for both because it is the most versatile, ignoring the cost and simplicity benefits of the Table API for key-value data.

How to eliminate wrong answers

Option B is wrong because using the SQL API for both profiles and logs would work but is not the optimal choice; the Table API is more cost-effective and simpler for key-value profile data, and the question asks for the 'best' combination, not just a possible one. Option C is wrong because the MongoDB API is designed for document stores with MongoDB query syntax, not simple key-value pairs, and the Cassandra API is a wide-column store that does not natively support SQL-like queries on JSON documents. Option D is wrong because the Table API cannot query JSON documents with varying fields using SQL-like syntax, as it only supports simple key-value lookups by partition and row keys.

175
MCQmedium

A manufacturing company stores IoT sensor data as JSON documents in Azure Cosmos DB. Each document contains a device ID, a timestamp, and a varying set of sensor readings. The application frequently queries data by device ID and a time range to retrieve all readings for a specific device over a period. The development team wants to use an API that supports SQL-like queries on this JSON data. Which Azure Cosmos DB API should they choose?

A.Azure Cosmos DB Core (SQL) API
B.Azure Cosmos DB MongoDB API
C.Azure Cosmos DB Cassandra API
D.Azure Cosmos DB Gremlin API
AnswerA

The Core (SQL) API natively supports JSON documents and allows querying using SQL syntax, which is exactly what the application needs.

Why this answer

The Azure Cosmos DB Core (SQL) API is the correct choice because it natively supports querying JSON documents using SQL-like syntax, which aligns with the requirement to run SQL-like queries on JSON data. This API provides a rich query language for filtering by device ID and timestamp ranges, making it ideal for the described IoT scenario where documents have varying sensor readings.

Exam trap

The trap here is that candidates may confuse the MongoDB API's support for JSON documents with SQL-like querying, but MongoDB uses its own query language (e.g., db.collection.find()) rather than SQL syntax, which is a key distinction tested in the DP-900 exam.

How to eliminate wrong answers

Option B (MongoDB API) is wrong because it uses MongoDB's query language (based on BSON and MongoDB operators), not SQL-like syntax, and would require the team to adapt to a different query paradigm. Option C (Cassandra API) is wrong because it uses CQL (Cassandra Query Language) and is designed for wide-column store data, not for querying JSON documents with varying schemas. Option D (Gremlin API) is wrong because it is a graph traversal API used for graph data models, not for SQL-like queries on JSON documents.

176
MCQeasy

A company is developing a web application that stores user profiles as JSON documents. The application needs to query these documents using SQL-like queries, and must support automatic indexing of all properties. They want a fully managed, globally distributed NoSQL database with low latency. Which Azure Cosmos DB API should they use?

A.Table API
B.Cassandra API
C.SQL API
D.Gremlin API
AnswerC

The SQL API allows you to store JSON documents and query them using SQL-like syntax, with automatic indexing of all properties. It is ideal for document-based applications.

Why this answer

The SQL API (formerly DocumentDB API) is the correct choice because it natively supports querying JSON documents with SQL-like syntax (SELECT * FROM c WHERE c.property = value). It automatically indexes all properties by default, provides a fully managed, globally distributed NoSQL database with low-latency reads and writes, and is designed specifically for document-based workloads like user profiles.

Exam trap

The trap here is that candidates often confuse the SQL API with the Table API because both support querying, but the Table API lacks SQL-like syntax and automatic indexing of all properties, making it unsuitable for JSON document workloads.

How to eliminate wrong answers

Option A is wrong because the Table API is designed for key-value storage with a schema-less table structure, not for querying JSON documents with SQL-like queries; it uses OData and REST-based queries, not SQL. Option B is wrong because the Cassandra API is optimized for wide-column stores using the Cassandra Query Language (CQL), which is similar to SQL but does not natively support JSON document queries or automatic indexing of all properties. Option D is wrong because the Gremlin API is built for graph databases and uses the Gremlin traversal language for navigating relationships, not for SQL-like queries on JSON documents.

177
MCQmedium

A manufacturing company collects sensor data from thousands of IoT devices. Each sensor reading includes a timestamp, device ID, and a variable set of measurements (e.g., temperature, pressure, vibration) that differ by device type. The company needs to store this data in a globally distributed NoSQL database that supports low-latency writes and flexible schema. Which Azure data store should they choose?

A.Azure SQL Database
B.Azure Cosmos DB with the NoSQL API
C.Azure Cache for Redis
D.Azure Database for PostgreSQL
AnswerB

Azure Cosmos DB NoSQL API stores JSON documents with a flexible schema, supports global distribution, and provides low-latency writes, making it ideal for IoT sensor data with variable attributes.

Why this answer

Azure Cosmos DB with the NoSQL API is the correct choice because it is a globally distributed, multi-model database service that supports low-latency writes at scale, a flexible schema (schemaless), and automatic indexing of variable sensor measurements. Its multi-region write capability and configurable consistency levels meet the requirements of high-throughput IoT ingestion from thousands of devices.

Exam trap

The trap here is that candidates often confuse Azure Cache for Redis as a primary database for IoT data, but it is an in-memory cache without durability guarantees, not a globally distributed NoSQL store for persistent sensor readings.

How to eliminate wrong answers

Option A is wrong because Azure SQL Database is a relational database with a fixed schema, which cannot easily handle the variable set of measurements per device type and does not natively support global distribution with low-latency writes at IoT scale. Option C is wrong because Azure Cache for Redis is an in-memory data store primarily used for caching and session state, not a durable, globally distributed NoSQL database for persistent sensor data storage. Option D is wrong because Azure Database for PostgreSQL is a relational database with a fixed schema and limited global distribution capabilities compared to Cosmos DB, making it unsuitable for flexible schema and low-latency multi-region writes.

178
MCQmedium

A social media application uses Azure Cosmos DB to store user posts. When a user publishes a new post, they immediately refresh their feed and expect to see their own post right away. However, the application can tolerate temporary staleness for posts from other users. Which Azure Cosmos DB consistency level should the app use for the read operations that display the feed?

A.Strong
B.Bounded staleness
C.Session
D.Eventual
AnswerC

Session consistency guarantees that within the same client session, reads will see the latest writes. This means the user will always see their own post immediately, while reads of other users' posts may be stale. This is the most cost-effective and correct choice.

Why this answer

Session consistency guarantees monotonic reads, writes, and read-your-writes within a single client session. Because the user expects to see their own post immediately after publishing, but can tolerate staleness for others' posts, Session consistency provides the exact guarantee needed: the user's own writes are immediately visible to them, while other users' posts may be slightly stale.

Exam trap

The trap here is that candidates often pick Eventual consistency because they see 'tolerate temporary staleness' and forget that the user's own post must be immediately visible, which requires at least read-your-writes — a guarantee that Session consistency provides but Eventual does not.

How to eliminate wrong answers

Option A is wrong because Strong consistency would force all replicas to agree on the latest write before any read returns, which adds latency and is unnecessary since the app tolerates staleness for other users' posts. Option B is wrong because Bounded staleness allows a configurable lag (time or operations) but applies uniformly to all reads, not just those from other users, and would still impose a stricter guarantee than needed for the user's own posts. Option D is wrong because Eventual consistency does not guarantee read-your-writes, so the user might not see their own post immediately after refreshing, which violates the stated requirement.

179
MCQmedium

A mobile gaming company is building a new feature that stores player profiles and game settings as key-value pairs. The development team is most familiar with SQL queries and wants to minimize the learning curve. They require low-latency reads and writes, and the data does not require complex joins. Which Azure Cosmos DB API should they choose?

A.A. Core (SQL) API
B.B. Azure Cosmos DB for Table API
C.C. Azure Cosmos DB for MongoDB API
D.D. Azure Cosmos DB for Cassandra API
AnswerA

Correct. The Core (SQL) API uses a SQL-like query language, which aligns with the team's SQL skills. It handles key-value data with low latency and is the most straightforward choice.

Why this answer

The Core (SQL) API is the correct choice because it provides native support for SQL queries, which aligns with the development team's familiarity with SQL and minimizes the learning curve. It stores data in JSON documents with key-value pairs, supports low-latency reads and writes, and does not require complex joins, making it ideal for player profiles and game settings.

Exam trap

The trap here is that candidates may choose the Azure Cosmos DB for Table API (Option B) because they associate 'key-value pairs' with Table storage, but the question emphasizes SQL familiarity and low-latency reads/writes, which the Core (SQL) API directly supports with its native SQL query capability.

How to eliminate wrong answers

Option B is wrong because the Azure Cosmos DB for Table API uses OData and REST-based queries, not SQL, and is designed for key-value storage with a flat schema, which would require the team to learn a new query syntax. Option C is wrong because the Azure Cosmos DB for MongoDB API uses MongoDB's query language (based on JSON-like documents with BSON), not SQL, and would introduce a learning curve for a team familiar only with SQL. Option D is wrong because the Azure Cosmos DB for Cassandra API uses CQL (Cassandra Query Language), which is similar to SQL but has distinct syntax and limitations (e.g., no JOINs, no aggregate functions without specific configurations), requiring adaptation and not minimizing the learning curve.

180
MCQmedium

A manufacturing company installs IoT sensors on equipment in a factory. Each sensor sends a reading (device ID, timestamp, temperature, vibration) every second. The application must store these readings with extremely low write latency, support queries for the latest reading per device, and allow range queries over the last hour for a specific device. The development team expects high throughput writes (millions per day) and does not require complex joins. Which Azure data store is most appropriate for this workload?

A.Azure Cosmos DB
B.Azure Table Storage
C.Azure Blob Storage
D.Azure SQL Database
AnswerA

Correct. Azure Cosmos DB provides low-latency writes, flexible schema, and supports point reads and range queries with automatic indexing. It is designed for high-throughput, globally distributed workloads like IoT time-series data.

Why this answer

Azure Cosmos DB is the most appropriate because it offers single-digit millisecond write and read latencies at any scale, which is critical for the high-throughput, low-latency IoT sensor ingestion described. Its support for automatic indexing and efficient point reads (by device ID and timestamp) enables fast retrieval of the latest reading per device, while its native time-to-live (TTL) and range query capabilities on the timestamp field allow efficient queries over the last hour for a specific device. Additionally, Cosmos DB's schema-agnostic, non-relational model fits the simple key-value structure of sensor readings without requiring complex joins.

Exam trap

The trap here is that candidates often choose Azure Table Storage because it is a low-cost, schema-less NoSQL option, but they overlook its lack of guaranteed single-digit millisecond latency and the need for manual partition key design to avoid throttling under high-throughput IoT workloads.

How to eliminate wrong answers

Option B (Azure Table Storage) is wrong because, while it can handle high throughput and is schema-less, it does not provide single-digit millisecond write latency guarantees and lacks native support for efficient range queries on timestamps with the same low latency as Cosmos DB; its partition key design would require careful planning to avoid hot partitions under millions of writes per day. Option C (Azure Blob Storage) is wrong because it is optimized for large, unstructured binary objects (blobs) and not for high-frequency, small record writes with sub-second latency; it also does not support point queries or range queries on individual records without additional indexing layers like Azure Data Lake Storage. Option D (Azure SQL Database) is wrong because, although it supports range queries and indexing, it introduces relational overhead and higher write latency compared to Cosmos DB, and its fixed schema and transaction costs are not ideal for the high-throughput, schema-flexible IoT workload described.

181
MCQmedium

A social media analytics company needs to store large amounts of user activity logs. Each log entry contains a timestamp, user ID, activity type, and a dynamic set of custom attributes (e.g., page viewed, time spent). The application requires low-latency writes and point reads by a composite key (user ID and timestamp). The data is rarely updated after insertion. The company wants a fully managed NoSQL database that supports serverless throughput and automatic expiration of old logs (TTL). Which Azure Cosmos DB API should they choose?

A.Table API
B.NoSQL API (Core/SQL API)
C.Cassandra API
D.Gremlin API
AnswerA

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.

Why this answer

The Table API is the correct choice because it provides a fully managed, serverless NoSQL database with automatic TTL (Time-to-Live) for data expiration, low-latency point reads and writes by a composite key (partition key + row key), and is optimized for storing large volumes of structured log data with dynamic attributes. It supports the exact requirements: high-throughput writes, point queries by user ID and timestamp, and automatic expiration of old logs without manual intervention.

Exam trap

The trap here is that candidates often choose the NoSQL API (Core/SQL API) because it is the most well-known Cosmos DB API, but they overlook that the Table API is specifically optimized for high-volume, low-latency key-value workloads with composite keys and automatic TTL, making it the correct choice for log data with dynamic attributes.

How to eliminate wrong answers

Option B (NoSQL API) is wrong because while it supports serverless throughput and TTL, it is designed for document-based data with flexible schemas and requires a partition key and sort key for point reads, but it does not natively support composite key queries as efficiently as the Table API's row key design; however, the primary reason it is not the best fit is that the Table API is more cost-effective and simpler for log data with dynamic attributes. Option C (Cassandra API) is wrong because it is based on the Cassandra distributed database, which uses a different data model (wide-column stores) and does not support serverless throughput in the same way; it also requires more manual management of consistency and replication, and while it supports TTL, it is not the simplest fully managed option for this use case. Option D (Gremlin API) is wrong because it is a graph database API designed for traversing relationships between entities (e.g., social networks, recommendation engines), not for storing and querying time-series log data with composite keys; it lacks native support for TTL and serverless throughput in the same manner as the Table API.

182
MCQmedium

A company has an existing IoT application that uses Apache Cassandra for time-series sensor data. They want to migrate to Azure's fully managed NoSQL database service while continuing to use the Cassandra Query Language (CQL) and benefiting from global distribution and low latency. Which Azure Cosmos DB API should they use?

A.Core (SQL) API
B.MongoDB API
C.Cassandra API
D.Gremlin API
AnswerC

Correct. The Cassandra API provides compatibility with the Apache Cassandra wire protocol and CQL, enabling a seamless migration from a Cassandra cluster to a globally distributed, fully managed service.

Why this answer

The Cassandra API for Azure Cosmos DB is wire-protocol-compatible with Apache Cassandra, meaning you can use existing CQL (Cassandra Query Language) tools, drivers, and code with minimal changes. It provides a fully managed, globally distributed NoSQL database with low-latency reads and writes, which directly matches the company's requirement to migrate from self-managed Cassandra while preserving their CQL-based application logic.

Exam trap

The trap here is that candidates may confuse the 'Cassandra API' with the 'Core (SQL) API' because both support SQL-like syntax, but only the Cassandra API uses the native CQL wire protocol and wide-column storage model required for time-series sensor data.

How to eliminate wrong answers

Option A is wrong because the Core (SQL) API uses a SQL-like query language and a different data model (JSON documents with optional schema), not the Cassandra Query Language (CQL), so existing CQL code would not work. Option B is wrong because the MongoDB API uses the MongoDB wire protocol and BSON document model, which is incompatible with CQL and Cassandra's table/partition-key structure. Option D is wrong because the Gremlin API is designed for graph databases using the Apache TinkerPop graph traversal language, not for time-series sensor data modeled in Cassandra's wide-column format.

183
MCQhard

A global gaming company stores player profiles in Azure Cosmos DB. Each profile document contains PlayerID (unique), PlayerName, Email, and a nested array of Achievements. The most common query is to look up a player by PlayerID and retrieve their achievements. The company needs strong consistency for reads and writes to ensure that when a player earns an achievement, it is immediately visible. Which partition key and consistency level should they choose?

A.A. Partition key: PlayerID; Consistency: Eventual
B.B. Partition key: PlayerID; Consistency: Strong
C.C. Partition key: Achievements; Consistency: Strong
D.D. Partition key: Email; Consistency: Bounded staleness
AnswerB

PlayerID makes each player's document a single partition, enabling efficient lookups. Strong consistency ensures that once a write is committed, subsequent reads return the latest data.

Why this answer

Option B is correct because PlayerID is the natural partition key for the most common query (lookup by PlayerID), ensuring efficient single-partition queries. Strong consistency is required to guarantee that when a player earns an achievement, the write is immediately visible to all subsequent reads, which is critical for the gaming scenario.

Exam trap

The trap here is that candidates may confuse 'most common query' with 'partition key' and pick a non-query column (like Achievements or Email) or choose a weaker consistency level, not realizing that Strong consistency is required for immediate visibility and that PlayerID is the optimal partition key for the lookup pattern.

How to eliminate wrong answers

Option A is wrong because Eventual consistency does not guarantee immediate visibility of writes, which violates the requirement that achievements are immediately visible after earning. Option C is wrong because Achievements is a nested array, not a top-level property, and using it as a partition key would cause inefficient cross-partition queries and potential hot partitions. Option D is wrong because Email is not the primary query key (PlayerID is), and Bounded staleness, while stronger than Eventual, still allows a configurable lag, which does not meet the strict 'immediately visible' requirement.

184
MCQmedium

A global gaming company uses Azure Cosmos DB to store player scores and profiles. The application reads and writes player data from multiple regions worldwide. The company wants to ensure that when a player updates their high score in one region, any subsequent read from another region will always see the latest value, even if there is network latency between regions. Which consistency level should they choose?

A.Strong
B.Bounded staleness
C.Session
D.Eventual
AnswerA

Strong consistency ensures reads always see the latest committed write across all regions, meeting the requirement.

Why this answer

Strong consistency ensures that any read operation returns the most recent write across all regions. In Azure Cosmos DB, this is achieved by synchronously replicating writes to all replicas before acknowledging the write, guaranteeing that subsequent reads in any region always see the latest value, regardless of network latency.

Exam trap

The trap here is that candidates often confuse 'strong consistency' with 'global replication speed,' assuming that eventual or session consistency might be sufficient if the application can tolerate slight delays, but the question explicitly requires that any subsequent read from another region always sees the latest value, which only strong consistency guarantees.

How to eliminate wrong answers

Option B (Bounded staleness) is wrong because it allows reads to lag behind writes by a configurable time interval or number of versions, meaning a read in another region might not see the latest high score immediately. Option C (Session) is wrong because it guarantees monotonic reads and writes only within a single client session; reads from a different region or session could return stale data. Option D (Eventual) is wrong because it offers no ordering guarantees and reads may return outdated values for an unbounded period, which violates the requirement that any subsequent read always sees the latest value.

185
MCQhard

Your application stores millions of small log entries in Azure Table Storage. Queries by partition key and row key are fast, but you also need to query by timestamp across partitions. The query performance is slow. What is the best way to improve query performance?

A.Migrate the data to Azure Cosmos DB and use the SQL API.
B.Use Azure Cognitive Search to index the Table Storage data.
C.Create a new table with the timestamp as the partition key and copy data there for time-based queries.
D.Add a secondary index on the timestamp column.
AnswerC

This allows efficient queries by timestamp using partition key design.

Why this answer

Creating a separate table with timestamp as the partition key allows efficient range queries across all data. Option A is wrong because indexing options in Table Storage are limited. Option B is wrong because Cosmos DB is more expensive and may not be necessary.

Option D is wrong because a secondary index is not supported in Table Storage.

186
MCQmedium

Refer to the exhibit. The exhibit shows a query used in Azure Cosmos DB. What is the correct interpretation of this query?

A.It is a SQL Server query that selects from a table named 'c'.
B.It queries an Azure Cosmos DB container for items where the age property exceeds 25.
C.It executes a stored procedure in Azure Cosmos DB.
D.It retrieves all documents from the Azure Cosmos DB database named 'c'.
AnswerB

The query uses the FROM clause with alias 'c' and filters on age.

Why this answer

In Azure Cosmos DB SQL API, 'c' is an alias for each item in the container. The query retrieves all items where the 'age' property is greater than 25. Option A is wrong because it's not SQL Server.

Option C is wrong because it's not filtering documents. Option D is wrong because it's not a stored procedure.

187
MCQmedium

A media company stores large video files and associated metadata (title, duration, tags) as JSON documents. The application requires low-latency streaming of videos to users worldwide and the ability to quickly query metadata by tag. Which combination of Azure services should the company use?

A.Azure Blob Storage for videos and Azure Cosmos DB for metadata
B.Azure Blob Storage for both videos and metadata
C.Azure Cosmos DB for videos and Azure Table Storage for metadata
D.Azure Files for videos and Azure SQL Database for metadata
AnswerA

Correct. Blob Storage handles large video files efficiently, while Cosmos DB provides fast, indexed querying on flexible JSON metadata.

Why this answer

Azure Blob Storage is optimized for storing large binary objects like video files, offering high-throughput streaming via HTTP/HTTPS and integration with CDN for low-latency global delivery. Azure Cosmos DB provides single-digit millisecond read and write latencies with automatic indexing, making it ideal for quickly querying JSON metadata by tag using SQL or MongoDB API. This combination separates storage concerns (blobs for raw video, document DB for structured metadata) to meet both streaming and query performance requirements.

Exam trap

The trap here is that candidates may assume a single service (like Blob Storage or Cosmos DB) can handle both data types, but the exam tests understanding that each Azure service has specific strengths—blobs for large binary objects and Cosmos DB for low-latency document queries—and that mixing them is the correct architectural pattern.

How to eliminate wrong answers

Option B is wrong because storing metadata as blobs in Azure Blob Storage would require loading entire JSON documents to query by tag, resulting in high latency and no native indexing or query capabilities. Option C is wrong because Azure Cosmos DB is not designed for storing large video files (it has a 2 MB document size limit per item) and Azure Table Storage lacks native JSON document querying and indexing for tag-based searches. Option D is wrong because Azure Files uses SMB protocol optimized for file shares, not streaming, and Azure SQL Database is a relational store that would require schema design and normalization for JSON metadata, adding complexity and latency compared to a native document database.

188
MCQhard

A company uses Azure Databricks to process data stored in Azure Data Lake Storage Gen2. They need to enforce fine-grained access control on files and folders based on user identity. Which security feature should they implement?

A.Storage account firewall rules
B.Shared access signatures (SAS)
C.Access control lists (ACLs)
D.Azure RBAC roles on the storage account
AnswerC

ACLs provide fine-grained POSIX permissions on files and folders.

Why this answer

Access control lists (ACLs) on Azure Data Lake Storage Gen2 provide POSIX-compliant, fine-grained permissions at the file and folder level. This allows you to grant read, write, or execute permissions to specific users or groups, which is exactly what is needed for enforcing identity-based access control on individual files and folders.

Exam trap

The trap here is that candidates often confuse Azure RBAC (which controls management-plane access) with ACLs (which control data-plane access at the file/folder level), leading them to select RBAC when fine-grained data access is required.

How to eliminate wrong answers

Option A is wrong because storage account firewall rules control network-level access (IP addresses or virtual networks), not user-identity-based permissions on files or folders. Option B is wrong because shared access signatures (SAS) grant time-limited, delegated access to storage resources via a token, but they do not enforce access based on the user's identity; the token itself is the credential. Option D is wrong because Azure RBAC roles on the storage account provide coarse-grained control over management operations (e.g., read keys, list containers) but cannot enforce fine-grained permissions on individual files or folders within a container.

189
Multi-Selecteasy

Which TWO of the following are features of Azure Cosmos DB that help ensure high availability?

Select 2 answers
A.Data encryption at rest
B.Change feed
C.Automatic failover
D.Point-in-time restore
E.Multi-region writes
AnswersC, E

Automatic failover ensures continuity if a region fails.

Why this answer

Cosmos DB supports multi-region writes and automatic failover for high availability. Point-in-time restore and change feed are features but not directly for high availability.

190
MCQmedium

A travel booking application stores user itineraries in Azure Cosmos DB using the NoSQL API. Each itinerary document contains: UserID (unique to user), ItineraryID, Destination, BookingDate, and a nested array of Activities. The most common query is: 'Retrieve all itineraries for a specific UserID sorted by BookingDate descending.' To minimize Request Unit (RU) consumption, which partition key should be chosen?

A.ItineraryID
B.UserID
C.Destination
D.BookingDate
AnswerB

UserID is the most common filter. All documents for one user are stored on the same partition, making the query single-partition and highly efficient.

Why this answer

UserID is the correct partition key because the most common query filters on UserID, ensuring that all itineraries for a specific user are stored in the same physical partition. This allows the query to target a single partition, minimizing cross-partition queries and reducing Request Unit (RU) consumption. A partition key that aligns with the primary query filter is essential for optimal performance and cost efficiency in Azure Cosmos DB.

Exam trap

The trap here is that candidates often choose a unique identifier like ItineraryID as the partition key, thinking it ensures even distribution, but they overlook that the query pattern (filtering by UserID) requires the partition key to match the filter to avoid expensive cross-partition queries.

How to eliminate wrong answers

Option A (ItineraryID) is wrong because ItineraryID is unique per document, leading to a high-cardinality partition key that distributes each itinerary across different partitions; queries for a specific UserID would then require a fan-out to all partitions, increasing RU consumption. Option C (Destination) is wrong because it does not directly align with the query filter on UserID, and multiple users may share the same destination, causing hot partitions and inefficient cross-partition queries. Option D (BookingDate) is wrong because it is a time-based attribute that can create hot partitions (e.g., all bookings on the same date) and does not support the primary query pattern of filtering by UserID, forcing cross-partition scans.

191
MCQmedium

A smart home company stores device telemetry in Azure Cosmos DB using the NoSQL API. Each document contains: deviceId (string), timestamp (datetime), temperature (float), humidity (float). The most common query retrieves all documents for a specific deviceId within a time range, ordered by timestamp descending. This query performs well. However, a new query that finds devices with temperature > 50 in the last hour (without specifying deviceId) is extremely slow and consumes many request units (RUs). What is the most likely cause?

A.The temperature field is not indexed by default, so the query forces a full scan of all documents.
B.The query does not specify the partition key (deviceId), causing a cross-partition query that scans every physical partition.
C.The time range filter on timestamp cannot be combined with the temperature filter efficiently.
D.The default indexing policy only indexes strings and numbers as range indexes, but temperature is stored as a number and is indexed.
AnswerB

Cosmos DB uses partition key (deviceId) to distribute data. When a query does not include the partition key, it must fan out to all partitions, which is slow and expensive in RUs.

Why this answer

In Azure Cosmos DB NoSQL API, the partition key (deviceId) determines data distribution across physical partitions. Queries that do not include the partition key in the filter become cross-partition queries, which must fan out to every physical partition, scanning all documents. This is extremely slow and consumes many RUs, especially in large containers.

The original query specifying deviceId performs well because it targets a single partition.

Exam trap

The trap here is that candidates assume the slowness is due to a missing index on temperature, but Azure Cosmos DB automatically indexes all fields by default, so the real issue is the cross-partition query caused by omitting the partition key.

How to eliminate wrong answers

Option A is wrong because all fields in Azure Cosmos DB are automatically indexed by default, including the temperature field, so a missing index is not the cause. Option C is wrong because Azure Cosmos DB can combine filters on timestamp and temperature efficiently using its indexing; the slowness is due to the missing partition key, not the combination of filters. Option D is wrong because the default indexing policy does index numbers as range indexes, so temperature is indeed indexed; this statement is factually incorrect.

192
MCQmedium

A media company needs to store millions of high-resolution photos for a public website. Each photo can be up to 50 MB. The storage solution must support secure access via URLs. Which Azure service should they use?

A.Azure Table Storage
B.Azure Blob Storage
C.Azure Files
D.Azure SQL Database
AnswerB

Blob Storage is optimized for storing large amounts of unstructured binary data and supports direct URL access.

Why this answer

Azure Blob Storage is the correct choice because it is designed for storing massive amounts of unstructured data, such as high-resolution photos, and supports objects up to 4.7 TB per blob, easily accommodating 50 MB files. It provides secure access via URLs using shared access signatures (SAS) or public access levels, making it ideal for a public website serving media content.

Exam trap

The trap here is that candidates often confuse Azure Files with Blob Storage because both can store files, but Azure Files uses SMB protocol for network file shares, not HTTP/HTTPS URL-based access for public web serving.

How to eliminate wrong answers

Option A is wrong because Azure Table Storage is a NoSQL key-value store for structured, non-relational data, not for large binary files like photos. Option C is wrong because Azure Files provides fully managed file shares using SMB protocol, designed for shared file access across VMs or on-premises, not for serving public web content via URLs. Option D is wrong because Azure SQL Database is a relational database service for structured data with schemas, not for storing large binary objects like photos, and it lacks native URL-based access for public distribution.

193
MCQeasy

You need to store JSON documents for a web application that requires low-latency reads and writes globally. The data has no fixed schema. Which Azure service should you use?

A.Azure Table Storage
B.Azure Blob Storage
C.Azure SQL Database
D.Azure Cosmos DB
AnswerD

Cosmos DB provides global distribution, low latency, and native JSON support.

Why this answer

Azure Cosmos DB is a globally distributed, multi-model database that natively supports JSON documents with low-latency reads and writes. Option A is wrong because Azure Blob Storage is not optimized for low-latency document queries. Option B is wrong because Azure Table Storage is a key-value store, not ideal for complex JSON queries.

Option D is wrong because Azure SQL Database is relational and requires a fixed schema.

194
MCQmedium

A social media platform stores user profiles as JSON documents where each profile can have different attributes (e.g., education, work history, interests). The platform also needs to traverse friend connections to recommend new connections using graph queries. The development team wants to use a single Azure Cosmos DB account for both workloads while minimizing complexity. Which combination of Azure Cosmos DB APIs should they choose?

A.SQL API and Gremlin API
B.MongoDB API and Table API
C.Cassandra API and SQL API
D.Gremlin API only
AnswerA

Correct. The SQL API handles JSON document storage and querying, while the Gremlin API enables graph traversal for friend recommendations. Both can be used in the same account.

Why this answer

The correct choice is A because the SQL API provides native JSON document storage and querying for user profiles, while the Gremlin API supports graph traversal for friend connections. Using both APIs in a single Azure Cosmos DB account minimizes complexity by allowing each workload to use the most appropriate data model without managing separate databases.

Exam trap

The trap here is that candidates may think a single API must serve all workloads, but Azure Cosmos DB supports multiple APIs per account, and the question specifically asks for a combination that minimizes complexity while meeting both document and graph requirements.

How to eliminate wrong answers

Option B is wrong because the MongoDB API is for document storage but uses MongoDB wire protocol, not native JSON, and the Table API is for key-value/wide-column data, neither of which supports graph queries. Option C is wrong because the Cassandra API is for wide-column data and the SQL API is for documents, but neither provides graph traversal capabilities needed for friend connections. Option D is wrong because the Gremlin API alone supports graph queries but cannot efficiently handle the flexible JSON document storage required for user profiles with varying attributes.

195
MCQeasy

You need to store a collection of JSON documents that contain user profile data. The data is frequently queried by user ID and by email address. The solution must support indexing on multiple fields and provide low-latency queries. Which Azure service should you use?

A.Azure Table Storage
B.Azure Cache for Redis
C.Azure Cosmos DB
D.Azure Blob Storage
AnswerC

Supports indexing on multiple fields and low-latency queries.

Why this answer

Option C is correct because Azure Cosmos DB is a NoSQL database that supports indexing on multiple fields and provides low-latency queries on JSON documents. Option A is wrong because Azure Blob Storage does not support indexing on document fields. Option B is wrong because Azure Table Storage is a key-value store with limited indexing.

Option D is wrong because Azure Cache for Redis is an in-memory cache, not a durable indexed store.

196
MCQeasy

A startup is building a mobile app that requires offline data synchronization. The app needs to store user-generated content locally on the device and sync with Azure when connectivity is available. Which Azure service should they use for the cloud backend?

A.Azure Cosmos DB
B.Azure Blob Storage
C.Azure SQL Database
D.Azure Table Storage
AnswerA

Supports offline data sync with the Azure Mobile Apps SDK.

Why this answer

Option B is correct because Azure Cosmos DB, combined with offline data sync (via Mobile Apps SDK), provides offline capabilities. Option A is wrong because Azure Blob Storage does not have built-in offline sync for mobile apps. Option C is wrong because Azure SQL Database is relational and not the best for offline sync scenarios.

Option D is wrong because Azure Table Storage lacks robust offline sync support.

197
MCQmedium

You are designing a solution that requires storing large binary files (up to 5 TB each) that are updated frequently by multiple processes. Which Azure storage feature allows concurrent writes to the same file?

A.Azure Blob Storage with soft delete
B.Azure Files
C.Azure Disks
D.Azure NetApp Files
AnswerB

Azure Files provides fully managed file shares accessible via SMB, supporting concurrent access with file locking.

Why this answer

Azure Files supports SMB protocol with leasing and oplocks, allowing multiple clients to read/write the same file with proper coordination. Blob Storage does not support concurrent writes to the same blob without custom logic. Azure Disks are for VM disks, not shared access.

Azure NetApp Files provides shared file access but is more expensive and complex.

198
MCQeasy

A medical imaging company stores high-resolution MRI scans in Azure Blob Storage. The scans are accessed frequently for the first 6 months after being generated, then rarely after that, but must be available immediately when accessed for comparisons. The company wants to minimize storage costs. Which Azure Blob Storage access tier should they use for scans older than 6 months?

A.Hot access tier
B.Cool access tier
C.Archive access tier
D.Premium access tier
AnswerB

Cool tier is optimized for infrequently accessed data that still needs immediate availability. It offers lower storage costs than Hot tier while still allowing instant access.

Why this answer

The Cool access tier is ideal for data that is infrequently accessed but must be available immediately when needed. It offers lower storage costs than the Hot tier while maintaining low-latency retrieval, matching the requirement for scans older than 6 months that are rarely accessed but require instant availability.

Exam trap

The trap here is that candidates often confuse 'rarely accessed' with 'Archive tier,' forgetting that Archive requires hours of rehydration time, which fails the 'available immediately' constraint in the question.

How to eliminate wrong answers

Option A is wrong because the Hot access tier is optimized for frequent access and has higher storage costs, making it cost-inefficient for data accessed rarely after 6 months. Option C is wrong because the Archive access tier has the lowest storage cost but requires rehydration (which can take hours) before data can be accessed, violating the 'available immediately' requirement. Option D is wrong because the Premium access tier is designed for high-performance, low-latency workloads with transactional costs and is not cost-effective for rarely accessed data.

199
MCQmedium

A mobile app stores user preferences in Azure Cosmos DB using the NoSQL API. The app frequently reads a single user's profile by user ID (the partition key). The development team wants the fastest possible read performance globally and is willing to accept that reads might not reflect the latest write immediately. Which consistency level should they choose to minimize read latency?

A.Strong
B.Bounded staleness
C.Session
D.Eventual
AnswerD

Correct. Eventual consistency offers the lowest read latency and is optimal when eventual convergence is acceptable, as in profile viewing.

Why this answer

Eventual consistency offers the lowest read latency because it allows reads to return data from any replica without waiting for confirmation that the write has been fully replicated. Since the app can tolerate stale reads (i.e., not reflecting the latest write immediately), Eventual consistency eliminates the synchronization overhead required by stronger models, making it the fastest choice for global read performance.

Exam trap

The trap here is that candidates often confuse 'fastest read performance' with 'strongest consistency' and choose Strong or Bounded staleness, not realizing that the question explicitly allows stale reads, making Eventual the optimal choice for minimizing latency.

How to eliminate wrong answers

Option A is wrong because Strong consistency requires all replicas to acknowledge the write before the read is served, which introduces significant latency, especially across global regions. Option B is wrong because Bounded staleness still enforces a maximum lag (time or operations) before reads must reflect the latest write, adding coordination overhead that increases latency compared to Eventual. Option C is wrong because Session consistency guarantees monotonic reads and writes within a single client session, which requires session context tracking and can still introduce latency beyond the minimal possible with Eventual.

200
MCQeasy

You need to store event data from multiple sources in a schema-less format for later analysis. The data arrives as JSON and must be durable and highly available. Which Azure service should you use?

A.Azure Blob Storage
B.Azure SQL Database
C.Azure Event Hubs
D.Azure Data Factory
AnswerA

Blob Storage stores unstructured data durably.

Why this answer

Option A is correct because Azure Blob Storage provides durable, highly available storage for JSON blobs with schema-less format. Option B is wrong because Azure SQL Database requires a schema. Option C is wrong because Azure Event Hubs is for ingestion, not long-term storage.

Option D is wrong because Azure Data Factory is an orchestration service.

201
MCQmedium

A healthcare organization needs to store medical imaging files (DICOM) that average 50 MB each, with some up to 500 MB. The images must be retained for 10 years for regulatory compliance. During the first year, images are accessed frequently by radiologists. After one year, access drops to once or twice a year. The organization also needs to support application-level encryption with customer-managed keys. The storage solution must be HIPAA eligible and provide high durability. You need to recommend a storage solution. Which Azure service and configuration should you choose?

A.Azure Blob Storage in the Hot tier with a lifecycle management policy to move blobs to Cool after 30 days and to Archive after 1 year, with customer-managed encryption keys.
B.Azure Cosmos DB with a large document size limit, storing images as base64-encoded strings.
C.Azure NetApp Files with a capacity pool and export policy, using snapshots for backup.
D.Azure Files with Azure File Sync to local servers, storing all images in the Premium tier for fast access.
AnswerA

Blob Storage supports large files, lifecycle management, and customer-managed keys. HIPAA eligible.

Why this answer

Option A is correct because Azure Blob Storage is HIPAA eligible, supports large blobs, and offers lifecycle management to move blobs from Hot to Cool to Archive tiers automatically. Customer-managed keys are supported. Option B is wrong because Azure Files has a file size limit of 4 TiB and is not optimized for DICOM images.

Option C is wrong because Azure NetApp Files is expensive and not necessary. Option D is wrong because Azure Cosmos DB is not designed for large binary files.

202
MCQmedium

A ride-sharing application needs to store real-time GPS location updates from drivers and passengers. The data is ingested as key-value pairs where the key is the user ID and the value is a timestamped location. The application requires low-latency reads and writes for millions of concurrent users, and the data model is simple with no need for complex queries or joins. Which Azure NoSQL database API should be used for this workload?

A.Azure Cosmos DB Table API
B.Azure Cosmos DB SQL (Core) API
C.Azure Cosmos DB for MongoDB API
D.Azure Cosmos DB for Apache Gremlin API
AnswerA

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.

Why this answer

Azure Cosmos DB Table API is the correct choice because it provides a key-value store with low-latency reads and writes, ideal for high-throughput scenarios like real-time GPS updates. It supports a simple schema-less data model where each item is a key-value pair, and it offers single-millisecond latency at the 99th percentile for both reads and writes, meeting the requirement for millions of concurrent users without complex queries or joins.

Exam trap

The trap here is that candidates often choose the SQL (Core) API because it is the most versatile and well-known, but they overlook that the Table API is specifically optimized for simple key-value workloads with lower latency and cost, as it avoids the overhead of document parsing and indexing for complex queries.

How to eliminate wrong answers

Option B is wrong because Azure Cosmos DB SQL (Core) API is a document-oriented API that supports complex queries using SQL syntax, which is overkill for a simple key-value workload and introduces unnecessary overhead. Option C is wrong because Azure Cosmos DB for MongoDB API is designed for document data with MongoDB-compatible features like aggregation pipelines and secondary indexes, which are not needed for simple key-value pairs and may add latency. Option D is wrong because Azure Cosmos DB for Apache Gremlin API is a graph database API optimized for traversing relationships between entities, which is irrelevant for a simple key-value store with no need for joins or graph queries.

203
MCQhard

A gaming application requires a high-performance leaderboard that stores player scores and retrieves the top 10 scores quickly. The data does not require complex queries or a fixed schema. The leaderboard must support updates as new scores are submitted. Which Azure data store is most appropriate for this scenario?

A.Azure Cosmos DB with SQL API
B.Azure Table storage
C.Azure Cache for Redis
D.Azure Blob Storage
AnswerC

Correct. Redis provides sorted sets that allow efficient insertion and retrieval of top scores with low latency, making it ideal for leaderboards.

Why this answer

Azure Cache for Redis is the most appropriate choice because it provides an in-memory data structure store with native support for sorted sets (via the ZADD and ZRANGE commands), which are ideal for maintaining a real-time leaderboard. It can handle high-throughput score updates and retrieve the top 10 scores in O(log(N)) time, meeting the low-latency and performance requirements without needing a fixed schema.

Exam trap

The trap here is that candidates often choose Azure Cosmos DB (Option A) because they associate it with high performance and NoSQL, but they overlook that Azure Cache for Redis is purpose-built for in-memory, sub-millisecond operations like sorted sets, which are exactly what a leaderboard requires.

How to eliminate wrong answers

Option A is wrong because Azure Cosmos DB with SQL API, while fast, is a fully managed NoSQL database that incurs higher latency and cost for simple leaderboard operations compared to an in-memory cache, and it requires provisioning throughput (RU/s) even for simple sorted set operations. Option B is wrong because Azure Table storage is a key-value store that does not support sorted sets or built-in ranking operations; retrieving the top 10 scores would require scanning all entities and sorting client-side, which is inefficient and slow. Option D is wrong because Azure Blob Storage is designed for unstructured large object storage (blobs) and does not support atomic score updates or real-time querying of individual scores; it would require downloading and rewriting entire files for each update, making it unsuitable for a high-performance leaderboard.

204
MCQmedium

A company stores large video files in Azure Blob Storage. The files are accessed frequently for the first 30 days after upload, then rarely for the next 180 days, and after that they are only needed for compliance but never accessed. The company wants to minimize storage costs while ensuring the files remain durable and accessible. Which strategy should they implement?

A.Store all files in the Cool access tier and apply lifecycle management to move files to the Archive tier after 30 days.
B.Store files initially in the Hot tier, then use lifecycle management to move files to Cool after 30 days and to Archive after 210 days.
C.Store files in the Archive tier from the beginning to maximize cost savings.
D.Store files in the Premium tier for fast access, then manually delete files after 30 days.
AnswerB

This strategy matches the access patterns: Hot for the frequent first 30 days, Cool for the rare next 180 days, and Archive for the never-accessed compliance period. Lifecycle management automates transitions, minimizing costs.

Why this answer

Option B is correct because it aligns the access patterns with the appropriate Azure Blob Storage access tiers: Hot for frequent initial access, Cool for reduced-cost infrequent access after 30 days, and Archive for the lowest-cost long-term retention after 210 days. Azure lifecycle management policies automate these transitions, ensuring durability and accessibility while minimizing costs.

Exam trap

The trap here is that candidates often assume the Cool tier is the cheapest option for long-term storage, overlooking the Archive tier's significantly lower cost for compliance data that is never accessed, and they may also forget that lifecycle management can automate multiple tier transitions over time.

How to eliminate wrong answers

Option A is wrong because storing files in the Cool tier from the start incurs higher early-access costs and a 30-day early deletion penalty, and moving to Archive after only 30 days ignores the 180-day period of rare access where Cool is more cost-effective than Archive. Option C is wrong because storing files in the Archive tier from the beginning makes them inaccessible for immediate frequent access (Archive requires rehydration, which can take hours) and violates the requirement for frequent access in the first 30 days. Option D is wrong because the Premium tier is designed for low-latency, high-transaction workloads (e.g., Azure Virtual Desktop) and is significantly more expensive than Hot or Cool; manually deleting files after 30 days loses the 180-day rare-access period and incurs unnecessary costs.

205
MCQmedium

Refer to the exhibit. An administrator creates a storage account with the Hot tier and then creates a container with the Cool tier. Data is uploaded to the container. Which access tier applies to the uploaded blobs by default?

A.Hot, because the storage account tier is Hot.
B.No tier; blobs are not charged until accessed.
C.Archive, because no tier is set.
D.Cool, because the container's default tier is Cool.
AnswerD

Blobs inherit the container's default access tier if not specified.

Why this answer

In Azure Blob Storage, when a container has a default access tier set, blobs uploaded without specifying a tier inherit the container's default tier. The exhibit shows the container's accessTier is Cool, so blobs will be Cool. Option A is wrong because the container's tier overrides the account tier for new blobs.

Option C is wrong because this is not a serverless scenario. Option D is wrong because the cool tier is set at the container level.

206
MCQhard

A company stores customer data in Azure Table Storage. They need to query by a combination of partition key (customer region) and row key (customer ID). Which query pattern is most efficient?

A.Query using RowKey only
B.Scan all entities
C.Query using both PartitionKey and RowKey
D.Query using PartitionKey only
AnswerC

This is a point query that directly accesses the entity, the most efficient pattern in Table Storage.

Why this answer

Table Storage is optimized for point queries using both PartitionKey and RowKey. Using both keys allows direct access to the entity without scanning. Filtering only by RowKey across partitions results in a full table scan.

Using only PartitionKey retrieves all rows in that partition, which is less efficient. Scanning all entities is the worst.

207
MCQmedium

A global social media platform allows users to like posts. The platform is designed to prioritize availability and partition tolerance over strong consistency across its globally distributed Azure Cosmos DB instance. When a user likes a post, the like count may not be immediately visible to all users, but it will eventually become consistent across all regions. Which consistency model does this application follow?

A.Strong consistency
B.Bounded staleness consistency
C.Session consistency
D.Eventual consistency
AnswerD

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.

Why this answer

Eventual consistency is the correct choice because the platform prioritizes availability and partition tolerance (AP from the CAP theorem) over strong consistency. In Azure Cosmos DB, eventual consistency guarantees that all replicas will converge to the same value over time without any ordering guarantees, which matches the scenario where like counts are not immediately visible but become consistent eventually.

Exam trap

The trap here is that candidates often confuse 'eventual consistency' with 'session consistency' because both involve delays, but session consistency is scoped to a single client session and provides stronger guarantees like monotonic reads, whereas eventual consistency has no such session-level guarantees and is the weakest model in Cosmos DB.

How to eliminate wrong answers

Option A is wrong because strong consistency guarantees linearizability—reads always return the most recent write—which would sacrifice availability and partition tolerance, contradicting the platform's design priorities. Option B is wrong because bounded staleness consistency allows a configurable lag (time or version count) but still provides a bounded guarantee, not the unbounded eventual convergence described. Option C is wrong because session consistency guarantees monotonic reads and writes within a single client session, but the scenario describes global, cross-region behavior without session scope.

208
Drag & Dropmedium

A data engineering team is designing an ELT (Extract, Load, Transform) pipeline using Azure Data Lake Storage Gen2. They will ingest raw sales data from multiple sources, store it in the data lake, transform it using Azure Databricks, and finally store the transformed data in a curated zone for analytics. Place the steps in the correct order for an ELT pipeline.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order
1Step 1
2Step 2
3Step 3
4Step 4

Why this order

In an ELT pipeline, data is first extracted and loaded into the data lake, then transformed. This order follows the ELT paradigm: extract, load, transform.

209
MCQmedium

A media company stores video metadata in Azure Table Storage. Each video has a unique VideoID, and the application frequently queries for videos uploaded on a specific date. The current table uses PartitionKey = VideoID and RowKey = UploadDate. Queries filtering by UploadDate are slow and consume many transactions. Which design change will most optimize queries that retrieve all videos from a given date?

A.A. Use UploadDate as the RowKey only, but keep PartitionKey as VideoID.
B.B. Create a secondary index on UploadDate.
C.C. Change the PartitionKey to a date-based value (e.g., YYYY-MM-DD) and use VideoID as the RowKey.
D.D. Migrate the data to Azure Cosmos DB Table API for better indexing.
AnswerC

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.

Why this answer

Option C is correct because Azure Table Storage queries are most efficient when the PartitionKey is used as the primary filter. By changing the PartitionKey to a date-based value (e.g., YYYY-MM-DD), queries for all videos uploaded on a specific date become partition scans, which are fast and consume minimal transactions. Using VideoID as the RowKey still allows unique identification of each video within that date partition.

Exam trap

The trap here is that candidates often assume secondary indexes (like in SQL databases) exist in Azure Table Storage, or they think changing RowKey alone is sufficient, failing to realize that PartitionKey is the only partition-level filter and must align with the query pattern.

How to eliminate wrong answers

Option A is wrong because keeping PartitionKey as VideoID and only using UploadDate as RowKey does not help; queries filtering by UploadDate would still require a full table scan since the PartitionKey is not used in the filter. Option B is wrong because Azure Table Storage does not support secondary indexes; it only provides a single index on (PartitionKey, RowKey). Option D is wrong because migrating to Azure Cosmos DB Table API would not inherently optimize the query; the same partition key design issue would persist, and the cost and complexity of migration are unnecessary when a simple schema redesign solves the problem.

210
MCQmedium

A healthcare application stores patient medical records as JSON documents. Each document contains a variable set of fields depending on the patient's conditions. The application needs to query records by any field and support high write throughput. Which Azure data store is most appropriate?

A.Azure Blob Storage
B.Azure Synapse Analytics
C.Azure Cosmos DB with SQL API
D.Azure Table Storage
AnswerC

Correct because Cosmos DB supports schema-agnostic JSON documents, automatic indexing, and high throughput, ideal for this use case.

Why this answer

Azure Cosmos DB with SQL API is the most appropriate choice because it natively supports storing and querying JSON documents with variable schemas, enabling efficient queries on any field. Its multi-model architecture and configurable indexing policies allow high write throughput while maintaining low-latency queries, which is critical for healthcare applications with dynamic patient records.

Exam trap

The trap here is that candidates often confuse Azure Table Storage's key-value capabilities with JSON document support, but Table Storage does not allow querying on arbitrary fields within a JSON document—it only supports queries on the partition key and row key, making it unsuitable for variable-schema medical records.

How to eliminate wrong answers

Option A is wrong because Azure Blob Storage is an object store for unstructured binary data (e.g., images, backups) and does not support native JSON querying or indexing on arbitrary fields. Option B is wrong because Azure Synapse Analytics is a distributed analytics service designed for large-scale data warehousing and batch processing, not for high-throughput transactional writes or real-time queries on individual JSON documents. Option D is wrong because Azure Table Storage is a NoSQL key-value store that does not support querying on arbitrary fields within JSON documents—it requires a fixed partition key and row key schema, and lacks native JSON document querying capabilities.

211
MCQmedium

A mobile game company stores player scores in Azure Cosmos DB. Each document contains the fields PlayerID (unique to the player), GameID, Score, and Timestamp. The most common query is: 'Retrieve all scores for a specific GameID, ordered by Score descending.' Which property should be chosen as the partition key to minimize Request Unit (RU) consumption?

A.PlayerID
B.GameID
C.Score
D.Timestamp
AnswerB

GameID is the filter in the most common query. Using it as the partition key keeps all scores for the same game on one partition, making the query single-partition and efficient.

Why this answer

GameID is the correct partition key because the most common query filters on GameID, and using it as the partition key ensures that all documents for a given GameID are stored in the same physical partition. This allows the query to target a single partition, minimizing cross-partition fan-out and reducing Request Unit (RU) consumption. A partition key that matches the query filter is essential for efficient, low-latency reads in Azure Cosmos DB.

Exam trap

The trap here is that candidates often choose PlayerID because it is unique and seems like a natural key, but they overlook that a partition key must align with the most common query filter to avoid cross-partition queries and high RU costs.

How to eliminate wrong answers

Option A (PlayerID) is wrong because PlayerID is unique per player, so each partition would contain only one document, causing every query to fan out across all partitions and consume high RUs. Option C (Score) is wrong because Score is a high-cardinality, frequently changing value, which would lead to hot partitions and inefficient range queries; it also does not align with the query filter on GameID. Option D (Timestamp) is wrong because Timestamp is a monotonically increasing value that would create hot partitions (all writes to the latest partition) and does not group data by GameID, forcing cross-partition queries.

212
Drag & Dropmedium

Drag and drop the steps to configure a geo-replication for Azure Cosmos DB in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps
Order

Why this order

Geo-replication is configured by selecting regions and enabling multi-region writes if needed, then saving to initiate replication.

213
MCQhard

A company stores IoT temperature readings in Azure Cosmos DB using the NoSQL API. Each document contains: DeviceID, Timestamp, Temperature, Location. Data is ingested at a rate of 10,000 documents per second from thousands of devices. The most common query is 'Get all readings for a specific DeviceID in the last hour.' Which partition key should be chosen to avoid hot partitions while still supporting the query efficiently?

A.DeviceID
B.Timestamp (e.g., per minute)
C.Location
D.A synthetic key combining DeviceID and Timestamp (e.g., DeviceID_yyyy-MM-dd-HH)
AnswerD

This distributes writes across partitions because the suffix changes each hour, preventing a single device from overloading one partition. For the query 'get readings for DeviceID in the last hour', the application can compute the exact partition key(s) for the relevant hour(s) and perform efficient point or limited cross-partition queries.

Why this answer

Option D is correct because a synthetic key combining DeviceID and Timestamp (e.g., DeviceID_yyyy-MM-dd-HH) ensures that data for a specific device is distributed across multiple physical partitions based on the hour, preventing a single partition from becoming a hot spot. This design still supports the most common query efficiently by allowing Cosmos DB to route the query to only the partitions containing the relevant hour's data, using the partition key in the WHERE clause.

Exam trap

The trap here is that candidates often choose DeviceID (Option A) because it seems natural for the query, but they overlook the hot partition problem caused by high-ingestion devices, failing to realize that partition key choice must balance query efficiency with write distribution.

How to eliminate wrong answers

Option A is wrong because using DeviceID alone as the partition key would cause a hot partition for any device that generates a high volume of data (e.g., thousands of readings per second), as all data for that device would be stored on a single physical partition, throttling performance. Option B is wrong because using Timestamp (e.g., per minute) would scatter data for a single device across many partitions, making the query 'Get all readings for a specific DeviceID in the last hour' require a cross-partition query (fan-out) that scans all partitions, which is inefficient and costly. Option C is wrong because Location is likely to have low cardinality (e.g., only a few distinct values), leading to uneven data distribution and hot partitions, and it does not directly support the query filtering by DeviceID and time range.

214
MCQhard

A company uses Azure Cosmos DB with the MongoDB API for a customer profile service. The service handles 10,000 writes per second and 50,000 reads per second. The data is 1 KB per document. The company needs to reduce read latency for frequently accessed customers and minimize RU consumption. Currently, the service reads the entire document for every request. They decide to implement a materialized view pattern using Azure Cosmos DB change feed and a separate container. Which additional step should they take to optimize read performance and cost?

A.Create a materialized view container with a partition key optimized for the read queries.
B.Use stored procedures to aggregate data on read.
C.Increase the provisioned RU/s on the source container.
D.Enable Time-to-Live (TTL) on the source container to automatically expire old data.
AnswerA

Materialized views with optimized partition keys reduce RU consumption and latency for common queries.

Why this answer

Using a separate container with a different partition key (option B) allows the materialized view to be optimized for the read pattern, reducing RU cost and latency. Option A (increasing RU) does not address the root cause. Option C (adding TTL) would delete data, not improve reads.

Option D (using stored procedures) is for transactional logic, not read optimization.

← PreviousPage 3 of 3 · 214 questions total

Ready to test yourself?

Try a timed practice session using only Describe Considerations For Working With Non Relational Data On Azure questions.