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

Cool tier is for infrequent access with immediate availability and lower storage cost than Hot.

Azure Data Explorer is purpose-built for storing and analyzing time-series and high-throughput telemetry data. Its columnar storage and specialized Kusto Query Language (KQL) engine index data by time partitions, enabling fast, server-side aggregations and native time-series functions like make-series and anomaly detection. This makes it the most appropriate choice for interactive analytics over large volumes of timestamped events.

Azure Files is a fully managed file share service that supports the SMB protocol, specifically SMB 3.0 and later, enabling a legacy application to mount a cloud-backed share just like a traditional on-premises file server. It provides native Windows and Linux client support, and with Azure Active Directory Domain Services integration, it can preserve existing SMB-based authentication and authorization, so the application continues to work without code changes.

The Azure Policy assignment uses the `deny` effect, which explicitly blocks any non-compliant create or update request. When a user attempts to deploy a storage account with `publicNetworkAccess` enabled (or leaves it at the default of `Enabled`), policy evaluation returns a 403 Forbidden error and the request fails. This prevents the storage account from ever being provisioned in a state that exposes it to the public internet, thus enforcing the rule that public network access is denied.

Correct - UserID as partition key keeps each user's posts together. A range index on Timestamp enables efficient in-partition sorting, resulting in low RU.

Partitioning by userId creates one logical partition per user, enabling efficient point reads for fetching a user's profile and subscriptions. The subscription usage query will be a cross-partition query because it scans all partitions, but that is acceptable given the workload's emphasis on low-latency profile access. This also distributes request units (RUs) evenly across partitions as user activity tends to be uniform.

Azure Cosmos DB Table API is a fully managed, schema-agnostic key-value store that excels at high-throughput, low-latency point lookups. Player session data can be naturally modeled with a partition key (e.g., player ID) and row key (e.g., session timestamp), enabling fast reads and writes at global scale. It also offers automatic indexing, configurable consistency levels, and 99.999% availability SLAs, making it ideal for the simple, high-volume key-value access patterns of mobile gaming telemetry.

The hierarchical namespace enabled property (isHnsEnabled) is set to true, which is the defining feature of Azure Data Lake Storage Gen2. This couples Blob Storage scalability with a real directory hierarchy and POSIX-style access control lists, enabling file-level and directory-level permissions. Therefore this account is confirmed to support Azure Data Lake Storage Gen2 workloads.

Cool is a valid access tier designed for data that is infrequently accessed but still must be available immediately when needed. It provides lower storage costs than Hot while incurring higher access charges, making it suitable for backups, short-term retention, or disaster recovery files. Because Cool is one of the documented access tiers for Azure Blob Storage, it is a correct answer.

Integration with Azure Active Directory (Microsoft Entra ID) is a hallmark of Azure Data Lake Storage Gen2. It uses Entra ID for OAuth 2.0 authentication, allowing users, service principals, and managed identities to be verified before accessing the storage. Authorization is then layered via Role-Based Access Control (RBAC) at the account/container scope plus POSIX ACLs at the file/directory level, giving a unified identity control plane. This is a native feature of the Data Lake Storage Gen2 account model, not an optional extra.

userId is the correct partition key because it is the field used in the most common query filter—retrieving a specific user's sessions. All documents for one user share the same logical partition, so an equality filter on userId is routed directly to a single physical partition, producing a fast, low-RU point read. With many distinct users, the workload spreads evenly while keeping each user's related data co-located.

Azure Blob Storage supports Hot, Cool, and Archive access tiers to balance performance and cost. Hot tiers serve frequently accessed data with low latency, Cool tiers are for infrequent access with a lower storage cost, and Archive offers the cheapest storage but requires rehydration before reading. This tiering capability is a key cost-optimization feature unique to object storage.

Hot tier serves the initial frequent access with low latency. Cool tier reduces storage cost during the period of occasional access (once per month) while still allowing retrieval within seconds. Archive tier provides the lowest cost for long-term compliance storage.

Azure Synapse Serverless SQL is the appropriate choice because its OPENROWSET function can query JSON (or CSV/Parquet) files directly in Azure Blob Storage or Azure Data Lake Storage Gen2 using T-SQL. It does this without requiring you to import the data into a database or provision a dedicated SQL pool, and it uses a pay-per-query model. This lets you run ad hoc analytics on IoT sensor data in place, exactly matching the requirement.

Provisioned throughput in Azure Cosmos DB is measured in Request Units per second (RU/s). Each operation, whether a read, write, or query, consumes a specific number of RUs based on item size, indexing, and consistency level. Increasing RU/s directly allocates more computational capacity, allowing the database to handle a higher rate of operations per second and eliminating throttling (HTTP 429 errors). This is the primary knob for scaling throughput in an Azure Cosmos DB account.

The Archive access tier provides the lowest storage cost in Azure Blob Storage, making it ideal for rarely accessed legal archives. A time-based retention policy, a type of WORM (Write Once, Read Many) immutability, locks blobs for a predefined 7-year period, preventing both deletion and overwriting until the policy expires. While retrieval requires rehydration and incurs additional costs, the combination meets the compliance requirement of a fixed retention period at minimal ongoing storage expense.

The SQL API is the native JSON document model in Azure Cosmos DB, allowing devices to be stored as schemaless JSON documents with automatic indexing and rich querying via standard SQL syntax. It provides single-digit-millisecond point reads by ID, tunable consistency, and global distribution, making it ideal for an IoT device registry.

Building a serverless workflow with Azure Functions is a valid Queue Storage use case because a queue's messages can trigger Function execution through the Queue trigger binding. This pattern lets you stage work items durably, with visibility timeouts and poison-message handling, while Azure Functions scales automatically to process the queue, enabling a reliable event-driven pipeline.

The SQL (Core) API is the correct answer for this smart city workload because it is Azure Cosmos DB's native document model, storing sensor JSON telemetry directly and providing an ANSI-SQL-like query syntax. This API supports efficient point reads via id and partition key, and it indexes all fields by default, so you can run fast range filters such as timestamp BETWEEN ... AND ... to retrieve a sensor's data over a specific time window. Given the team is already comfortable with SQL-like language, this is the most natural fit.

A composite index that includes `locale` as the leading field (and optionally another field like `region` or `level`) directly supports a query that filters on `locale` by enabling an index seek instead of a full container scan. Because the index only contains entries for documents that actually have a `locale` property, the 70% of profiles that omit the field are automatically excluded from the index scan, drastically lowering request units (RU) and improving latency. This is the recommended and simplest optimization within Cosmos DB's schema-agnostic indexing model, and it does not require schema changes or data duplication.

Strong consistency is supported only with single-region writes; multi-region writes cannot achieve strong consistency.

Azure Cosmos DB is a multi-model NoSQL database service that supports document, key-value, graph, and column-family data models, with schema-agnostic ingestion. It provides global distribution and multiple consistency levels, but it deliberately avoids relational constructs like joins and fixed schemas. This makes it one of the two non-relational answers.

Azure Blob Storage is optimized for large unstructured binary objects and supports custom metadata.

Azure Cosmos DB with the NoSQL API is a multi-model database that natively stores JSON documents and automatically indexes every property, including UserID and timestamp, enabling fast, schema-flexible queries. Its single-digit-millisecond latency and partition-based scaling suit high-volume game telemetry, while its SQL-like query syntax supports rich filters and time-range lookups on arbitrary fields without requiring a predefined schema.

Implementing shared access signatures (SAS) on the underlying blobs and using token-based authentication on the CDN is the correct method to restrict access to authorized users. A SAS token can be generated with granular permissions, such as read-only and with a specific expiration time, and appended to the video URL or used as a key for CDN token authentication. This ensures that only users with a valid, unexpired token can fetch the content from the origin, while the CDN caches and delivers it efficiently; invalid or expired tokens result in access denial.

Adding a wildcard index, such as /inventory/[]/? to the indexing policy, instructs Cosmos DB to index every element of the inventory array rather than only the first element, which is the default behavior. With that index in place, ARRAY_CONTAINS queries can use a targeted index seek instead of scanning every document, making the lookup both fast and cost-efficient in terms of request units. This is the correct configuration for a gaming company that frequently queries player profiles based on whether an array contains a specific item, because it directly aligns the index with the predicate.

The SQL API is the native JSON document API for Azure Cosmos DB. It stores each user profile as a self-contained JSON document and automatically indexes every property without requiring a predefined schema. Developers can query these documents using a familiar SQL-like syntax (SELECT, WHERE, JOIN, GROUP BY) over any field, including nested properties like followersCount, and perform point reads using the partition key and document ID for optimal latency.

Azure Cosmos DB with Gremlin API is the correct choice because it provides a native graph database engine built on the property graph model. Data is stored as vertices (nodes) and edges (relationships), and queries are expressed in Gremlin, a declarative graph traversal language. This allows the database to perform efficient, index-backed traversals like finding friends-of-friends in a single operation, without expensive recursive joins or multiple round trips, which is exactly what a social networking graph requires.

The NoSQL API (formerly SQL API) is the correct choice because it provides native JSON document storage with a flexible schema, automatic indexing, and a SQL-like query language (technically a dialect of SQL over JSON) that supports efficient point reads (by id and partition key) and range queries on indexed fields. It is deeply integrated into Azure Cosmos DB's core engine, meaning no translation layer or separate compatibility layer is required, which yields the lowest latency and richest querying experience for JSON logs. Unlike the other APIs, it requires no existing expertise in MongoDB, Cassandra, or graph modeling, making it the most straightforward and performant option for a team that simply wants to store and query player activity in JSON.

Azure Data Lake Storage Gen2 is a hierarchical file system built on Azure Blob Storage that stores data in open formats such as Parquet and ORC, enabling massive parallel ingestion. Synapse Serverless SQL can query files directly using the OPENROWSET function with predicate pushdown to the storage layer, making it both fast and cost-efficient for big data analytics. This alignment with the analytic workload makes it the correct choice.

This is the only correct predicate. The ARRAY_CONTAINS function in Cosmos DB SQL API scans the c.inventory array and, when the third argument is true, performs a partial match against the specified object {name: 'sword'}. Partial matching means any inventory element that has a name property equal to 'sword' will satisfy the condition, even if that element also contains other fields like durability or price. This makes ARRAY_CONTAINS the intended, index-aware way to filter documents based on nested object properties within an array.

Azure Cosmos DB SQL (Core) API is the native document model that stores JSON documents exactly as provided, preserving nested structures and supporting flexible schema evolution. It exposes a SQL-like query language that allows filtering, projection, and joins on any field within the JSON, making it ideal for both point lookups by key and ad-hoc analytical queries. This API directly satisfies the stated requirements of fast key-based access and SQL-style querying over arbitrary fields.

Azure Blob Storage is a prime location for backups and archival data because it provides highly durable, scalable, and cost-effective storage for large volumes of infrequently accessed unstructured data. Its access tiers (hot, cool, cold, and archive) and lifecycle management policies let you automatically move data to cheaper storage as it ages. Redundancy options like LRS, ZRS, GRS, or GZRS protect archived and backup data against infrastructure failures, making it far more practical than local disk or relational databases.

Enabling the Azure Cosmos DB integrated cache allows repeated point-reads and queries to be served directly from an in-memory cache inside the dedicated gateway, completely bypassing the backend engine. Because cached responses return data without touching the storage engine, they consume 0 RUs, directly reducing RU consumption for repeated reads of product catalog items. The cache is fully managed, has a default 5-minute TTL, and requires no application code changes—only enabling the dedicated gateway. This is precisely the right approach for read-heavy workloads where the same data is frequently accessed.

A synthetic partition key is constructed by concatenating or hashing multiple property values, such as a customer ID plus a date or location, to create a key with high cardinality and balanced frequency. This is necessary when natural keys have low cardinality (few distinct values) or are heavily skewed, causing uneven data distribution and hot partitions. For example, using a synthetic key like 'userId-OrderId' (or a hash of it) spreads traffic across many logical partitions while preserving query grouping.

Supports multi-region writes, flexible schema, and low latency.

Azure Storage Service Encryption (SSE) automatically encrypts all data written to Azure Blob Storage using 256-bit AES encryption. By configuring a customer-managed key (CMK) in Azure Key Vault, you gain full control over key lifecycle, rotation, and audit logging, which is essential for compliance in healthcare environments. This is the correct method to encrypt medical images at rest while maintaining auditable key management.

Azure Cache for Redis is built on an in-memory data store that provides native sorted set data structures (e.g., ZADD, ZRANGE, ZREVRANK). Leaderboard operations such as inserting a player's score, retrieving the top N players, and finding a player's exact rank execute in O(log N) time with sub-millisecond latency, making it purpose-built for real-time scenarios where millions of players update scores concurrently.

Azure Cosmos DB is a globally distributed, multi-model NoSQL database that natively supports schema-flexible JSON documents, making it ideal for player profiles whose attributes evolve over time. It provides turnkey global distribution with multi-region writes, and its SLA guarantees point reads under 10 ms at the 99th percentile from any Azure region, directly meeting both the low-latency and flexible-schema requirements of a mobile gaming startup. Cosmos DB also offers automatic indexing, tunable consistency levels, and RU-based throughput scaling, which together support fast, consistent player-profile lookups without the need for costly schema redesigns.

Azure Cosmos DB's globally distributed, multi-master architecture and automatic indexing capabilities are fundamental to its ability to guarantee single-digit millisecond latency for reads and writes at the 99th percentile. This performance commitment is enshrined in its financially-backed Service Level Agreement (SLA), ensuring predictable and consistent high-speed data access. This accurately describes a core truth about Azure Cosmos DB, directly satisfying the question's requirement to identify a true characteristic.

Azure Blob Storage is purpose-built for storing unstructured binary data like JPEG images, offering massive scalability and low cost per gigabyte. Pairing it with Azure CDN caches image copies at edge locations worldwide, dramatically reducing latency for global users. Azure Cosmos DB's SQL API stores each log entry as a JSON document and supports querying with familiar SQL-like syntax, accommodating the variable structure of the logs without requiring a predefined schema. This combination directly satisfies the requirements for unstructured image storage and flexible, queryable log storage.

A synthetic partition key that concatenates userId and postId (for example, "user_12345_post_67890") gives every individual post its own logical partition. Because a single post document is typically a few kilobytes at most, no logical partition can realistically approach the 20 GB limit, regardless of how many posts a single user creates. This high-cardinality key distributes data evenly across physical partitions and is the standard pattern for avoiding hot partitions in Cosmos DB when one entity can have unbounded data growth.

The SQL API stores JSON documents and supports querying with a SQL dialect. Point reads by partition key (playerId) are low-latency, and SQL queries can easily filter on optional fields like achievements. This makes it the best choice.

Clustered columnstore indexes store data column-wise rather than row-wise, enabling high compression and eliminating unnecessary column scans. For large data warehousing fact tables in Azure Synapse Analytics, this index type is explicitly recommended because it dramatically reduces storage footprint and accelerates analytical queries through batch-mode processing and column elimination. The script's CREATE TABLE command specified this index, making it the accurate description.

Azure Cosmos DB is a multi-model NoSQL database with native JSON support and schema-agnostic automatic indexing, allowing queries on any attribute such as category or price without predefined schema. Its low-latency index on every property makes it ideal for product catalogs where different items have varying attributes and customers filter by arbitrary combinations. Cosmos DB also offers predictable throughput scaling, ensuring consistent query performance as catalog size grows.

Correct. The Gremlin API is a graph database that efficiently stores and queries relationships between entities, ideal for recommendation engines based on friend connections.

Azure Storage (including Table storage) automatically encrypts all data written to the service using 256-bit AES encryption, with keys managed by Microsoft (or customer-managed keys). This server-side encryption is enabled by default for all storage accounts and requires no configuration or additional cost. Therefore, user session data stored in Azure Table Storage is already protected at rest without any admin action.

Azure Cosmos DB is a fully managed NoSQL database that supports key-value stores via its Table API or Core (SQL) API, delivering single-digit-millisecond read/write latencies and turnkey global distribution across any number of Azure regions. Its multiple, well-defined consistency models — including the default Session consistency — align naturally with user-session data, where a user always reads their own writes. Because sessions benefit from automatic TTL expiration and elastic throughput, Cosmos DB is specifically architected for globally distributed, high-throughput key-value workloads rather than just tolerated as a secondary option.

GameID is the attribute used in the query filter. Choosing it as the partition key ensures that all scores for a given game are co-located in one partition, allowing a point query to that single partition and minimizing RU cost.

Correct. Azure Cosmos DB with the SQL API is a schema-agnostic, multi-model database that offers single-digit-millisecond point reads by session ID, turnkey global distribution, and five consistency levels ranging from eventual to strong. Session records are naturally modeled as JSON documents keyed by session ID, and the SQL API supports SQL querying over those documents while maintaining a 99.999% availability SLA. This combination of low-latency point lookups, global reads/writes, and tunable strong consistency is exactly what a social media session store requires.

This design localizes all posts for a user in one partition and uses an index that directly supports the filter and sort order.

In Azure Cosmos DB NoSQL API, Eventual consistency is the weakest consistency level and the default; updates replicate asynchronously with no ordering guarantee, so reads can be served from any replica with minimal latency and maximum availability. A user viewing a social feed may briefly see missing or old posts, but replication converges once writes stop, and read performance is not constrained by quorum acknowledgments.

Azure Cosmos DB is the correct choice because it is a multi-model NoSQL database service that natively supports document, key-value, graph, and column-family data models. Its schema-agnostic nature allows each product to have a different set of attributes (e.g., a shirt has size/color, a laptop has RAM/CPU) without requiring migrations or null placeholders. Cosmos DB also provides single-digit-millisecond read/write latency, automatic indexing, and turnkey global distribution, which are essential for a retail product catalog that must be fast and available across regions.

Azure Table Storage is a schema-less NoSQL key-value store that enables fast, cost-effective point lookups via a partition key and row key. It automatically indexes these keys and has no minimum throughput provisioning, so you pay only for the structured storage you actually use. For a single-region, latency-tolerant mobile app with simple key-value data, it delivers the lowest cost with sufficient performance.

Lifecycle management automates moving blobs between tiers (Hot, Cool, Archive) based on age, optimizing cost while keeping frequently accessed data in Hot tier.

Azure Data Explorer (ADX) is a fully managed analytics database purpose-built for high-volume time-series and log data. Its columnar storage engine uses advanced indexing and compression to ingest millions of events per second while retaining interactive query performance via Kusto Query Language (KQL). KQL includes native time-series functions like bin(), summarize, and percentiles, enabling near-real-time telemetry analytics without external processing. This makes ADX the optimal choice for telemetry pipelines that demand fast ingestion, long-term retention, and complex temporal queries.

Correct. Strong consistency provides immediate global consistency, but it requires a single write region. This trade-off meets the guarantee at the cost of slightly higher write latency for remote users.

The Cool access tier is correct because it is designed for data that is infrequently accessed and retained for at least 30 days, such as historical sensor readings. It has significantly lower storage cost than Hot, and while reads cost more per transaction, the data remains immediately readable or can be retrieved in minutes without the long rehydration wait of Archive. This satisfies the 15-minute availability requirement at a lower cost.

SQL (Core) API is a native, schema-agnostic document API for Azure Cosmos DB that stores each player session JSON as a resource and lets you query it with standard SQL syntax, including SELECT, WHERE, and even JOINs across documents. It automatically indexes all JSON properties without requiring a predefined schema, making it ideal for the flexible, evolving session data described. Because the requirement is explicitly SQL query support over JSON documents, this API directly matches the scenario.

Correct. Cosmos DB's NoSQL API natively supports JSON documents with flexible schema. It offers low-latency reads on the partition key and allows secondary indexes to support queries on other attributes like UserID.

Azure Cosmos DB (SQL API) is a purpose-built NoSQL document database that stores data natively as JSON. Its schema-agnostic model lets each user profile contain a different set of attributes without migrations, while automatic indexing on every property enables fast, attribute-level queries via SQL syntax. This directly matches the requirement for flexible JSON documents with varying structures.

This query is correct because it uses the proper Cosmos DB SQL API syntax: single quotes for the string literal, the AND operator to enforce both conditions, and the default alias 'c' for the container. The WHERE clause filters documents where the category property equals 'Electronics' AND the price property is less than 200, returning only the items that meet both criteria. This matches the expected business requirement exactly.

Correct. The Cosmos DB SQL API natively stores JSON documents, supports indexing on any field, and allows rich SQL-like queries. It offers global distribution, low latency, and scalable throughput, making it ideal for this scenario.

Session consistency uses a session token to ensure that within the same client session, reads reflect the writes made by that client. This satisfies the requirement that the user sees their own post immediately, while other reads may see slightly stale data.

A document database, such as Azure Cosmos DB, stores each social media post as an independent JSON document and can index individual fields and nested properties for queries. The schema is flexible, so different posts can contain different fields without migrations, matching the naturally evolving JSON structure of user-generated content. This native JSON support with dot-notation field access and rich indexing is exactly why this scenario points to a document data store.

The Cassandra API for Azure Cosmos DB is specifically activated by the 'EnableCassandra' capability flag in the account configuration, and the exhibit clearly shows this property set to true. This flag tells Azure to expose Cassandra-compatible endpoints that accept CQL and work with existing Cassandra drivers. When this flag is enabled, Cosmos DB manages Cassandra tables, partitions, and replication under the hood, giving you Cassandra's query language with Cosmos DB's global distribution. Therefore, the presence of EnableCassandra definitively identifies this as a Cassandra API account.

A shared access signature (SAS) is a signed URI that grants time-bound and permission-limited access to a specific blob without revealing the account key. It lets you specify exact start/expiry times, allowed IP ranges, and supported protocols, making it ideal for controlled temporary access. Additionally, you can use a stored access policy to revoke the SAS before its expiry, offering a clean way to manage short-lived delegated access.

Cool is a valid online access tier optimized for data that is infrequently accessed but still requires immediate availability. It provides lower storage costs than Hot while maintaining millisecond read and write latency, making it well-suited for backups, short-term disaster recovery, and old media files. Because Cool is an online tier, no rehydration step is needed before reading the data.

Azure Cosmos DB is a fully managed NoSQL document database that stores each JSON document natively, with automatic indexing of every property and a SQL API for rich querying over the JSON structure, plus optimized point reads by document ID and partition key, making it the clear choice for this workload.

Azure Cosmos DB with the NoSQL API is the optimal choice because it natively stores schema-less JSON documents, allowing player profiles and game telemetry to evolve without migration. It provides turnkey global distribution, single-digit-millisecond latency at any scale, and supports high-throughput point reads/writes with a SQL-like query engine over JSON. This matches the gaming company's need for a flexible, globally available data layer.

The Archive tier offers the lowest storage cost for data that is rarely accessed and can tolerate a retrieval latency of up to 15 hours. This matches the company's requirements of access only a few times per year and a 24-hour recovery window.

Azure Cosmos DB with the Table API is a globally distributed, fully managed NoSQL key-value store that offers single-digit-millisecond reads and writes at any scale. It provides automatic turnkey multi-region replication with multiple consistency models and active-active multi-region writes, making it ideal for a session store that must be accessible with low latency worldwide. The service guarantees 99.999% availability and elastic horizontal scaling, so session data remains durable and highly available without manual partitioning or failover management.

Strong consistency delivers linearizable reads, meaning every read returns the most recently committed write regardless of which replica or region serves the request. In Cosmos DB this is achieved by requiring writes to be acknowledged by a quorum of replicas before the write is confirmed, so no replica can serve a stale read afterward. For a global e-commerce platform, this prevents overselling and ensures order and inventory data are always current, though it increases write latency and can reduce availability under network partitions.

Azure Cool tier is designed for data that is infrequently accessed and will be stored for at least 30 days, offering a lower per-gigabyte storage price than Hot while still providing millisecond read latency. Since the log data is massive but rarely read, Cool minimizes storage cost without introducing the multi-hour rehydration delay of Archive, thus satisfying both the cost minimization and the 15-minute availability requirements.

Hot tier should be selected for the media company's large video files because it is the default online access tier optimized for frequent read/write operations. It delivers the lowest latency of the standard access tiers, which supports daily editing and streaming workloads without rehydration delays or early-deletion penalties. Although its per-GB storage price is higher than Cool or Archive, the absence of retrieval charges for these actively accessed files makes it the appropriate trade-off.