DP-420 questions and answers

Box 1: Yes
Existing "Terry John" is not the same as Item1's "terry john"

Box 2: No
Item2 "Rogers" "null" already exists.

Note: Sparse unique keys are not supported. If some unique path values are missing, they're treated as null values, which take part in the uniqueness constraint. For this reason, there can be only a single item with a null value to satisfy this constraint.

Box 3: Yes
As companyID for Item3 is 2, and not 1, this is fine.

Note: Unique key constraints in Azure Cosmos DB
Unique keys add a layer of data integrity to an Azure Cosmos DB container. You create a unique key policy when you create an Azure Cosmos DB container. With unique keys, you make sure that one or more values within a logical partition is unique. You also can guarantee uniqueness per partition key.

After you create a container with a unique key policy, the creation of a new or an update of an existing item resulting in a duplicate within a logical partition is prevented, as specified by the unique key constraint. The partition key combined with the unique key guarantees the uniqueness of an item within the scope of the container.

For example, consider an Azure Cosmos DB container with Email address as the unique key constraint and CompanyID as the partition key. When you configure the user's email address with a unique key, each item has a unique email address within a given CompanyID. Two items can't be created with duplicate email addresses and with the same partition key value. In Azure Cosmos DB's API for NoSQL, items are stored as JSON values. These JSON values are case sensitive. When you choose a property as a unique key, you can insert case sensitive values for that property. For example, if you have a unique key defined on the name property, "Gaby" is different from "gaby" and you can insert both into the container.

References:
https://learn.microsoft.com/en-us/azure/cosmos-db/unique-keys

Because the integrated cache is specific to your Azure Cosmos DB account and requires significant CPU and memory, it requires a dedicated gateway node. Connect to Azure Cosmos DB using gateway mode.

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/integrated-cache-faq

Box 1: [{"path":"/\"_etag\"/?"}],
Example:

Box 2: "/name
Example, composite index:

Python

container['indexingPolicy']['compositeIndexes'] = [
[
{
"path": "/name",
"order": "ascending"
},
{
"path": "/age",
"order": "descending"
}
]
]

Batch size: An integer that represents how many objects are being written to Cosmos DB collection in each batch. Usually, starting with the default batch size is sufficient. To further tune this value, note:

Cosmos DB limits single request's size to 2MB. The formula is "Request Size = Single Document Size *

Batch Size". If you hit error saying "Request size is too large", reduce the batch size value.
The larger the batch size, the better throughput the service can achieve, while make sure you allocate enough RUs to empower your workload.

Incorrect Answers:
A: Throughput: Set an optional value for the number of RUs you'd like to apply to your CosmosDB collection for each execution of this data flow. Minimum is 400.

B: Write throughput budget: An integer that represents the RUs you want to allocate for this Data Flow write operation, out of the total throughput allocated to the collection.

D: Collection action: Determines whether to recreate the destination collection prior to writing.

None: No action will be done to the collection.
Recreate: The collection will get dropped and recreated

References:
https://docs.microsoft.com/en-us/azure/data-factory/connector-azure-cosmos-db

Transactional batch operations in Azure Cosmos DB
Transactional batch describes a group of point operations that need to either succeed or fail together with the same partition key in a container. Operations are defined, added to the batch, and the batch is executed. If all operations succeed in the order they're described within the transactional batch operation, the transaction will be committed. However, if any operation fails, the entire transaction is rolled back.

Does Azure Cosmos DB for NoSQL support ACID (atomicity, consistency, isolation, durability) transactions?
Yes, the API for NoSQL supports cross-document transactions expressed using either batches in the SDKs or as JavaScript-stored procedures and triggers. Transactions are scoped to a single partition within each container and executed with ACID semantics as "all or nothing," isolated from other concurrently executing code and user requests. If exceptions occur, the entire transaction is rolled back.

The Azure Cosmos DB change feed is a mechanism to get a continuous and incremental feed of records from an Azure Cosmos container as those records are being created or modified. Change feed support works by listening to container for any changes. It then outputs the sorted list of documents that were changed in the order in which they were modified.

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/sql/changefeed-ecommerce-solution

Box 1: Last Write Wins (LWW) (default) mode
Last Write Wins (LWW): This resolution policy, by default, uses a system-defined timestamp property. It's based on the time-synchronization clock protocol.

Box 2: Merge Procedures (custom) mode
Custom: This resolution policy is designed for application-defined semantics for reconciliation of conflicts.
When you set this policy on your Azure Cosmos container, you also need to register a merge stored procedure. This procedure is automatically invoked when conflicts are detected under a database transaction on the server. The system provides exactly once guarantee for the execution of a merge procedure as part of the commitment protocol.

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/conflict-resolution-policies
https://docs.microsoft.com/en-us/azure/cosmos-db/sql/how-to-manage-conflicts

The indexing policy has an includedPaths array that contains only one path: /product/brand/ . This means that only the properties under /product/brand will be indexed.
The symbol indicates that only scalar values will be indexed, not arrays or objects 1.
The excludedPaths array contains a single path: /* .
This means that all other properties will be excluded from indexing.
The * symbol indicates a wildcard that matches any property name 1.
Therefore, the paths /product/category , /product/[ ]/category , and /product/brand/tailspin will not be indexed.

Box 1: Service endpoint
Block access to the public endpoint of account 1.

Configure access to Azure Cosmos DB from virtual networks (VNet)
You can configure the Azure Cosmos DB account to allow access only from a specific subnet of a virtual network (VNET). Enable service endpoint on a subnet within a virtual network to control access to Azure Cosmos DB. The traffic from that subnet is sent to Azure Cosmos DB with the identity of the subnet and Virtual Network. Once the Azure Cosmos DB service endpoint is enabled, you can limit access to the subnet by adding it to your Azure Cosmos DB account.

Note: You can configure Azure Cosmos DB accounts to allow access from only a specific subnet of an Azure virtual network. To limit access to an Azure Cosmos DB account with connections from a subnet in a virtual network:

1. Enable the service endpoint for Azure Cosmos DB to send the subnet and virtual network identity to Azure Cosmos DB.

2. Add a rule in the Azure Cosmos DB account to specify the subnet as a source from which the account can be accessed.

Box 2: Network security group (NSG) outbound rules
Allow only VM1 to access account 1.

Network security groups and service endpoints help you secure your virtual machines and Azure services from unauthorized network access.

Security rules
A network security group contains one or more security rules. You can configure security rules to either allow or deny traffic.

The names of the users who created the blog post and added the comments

Change feed in Azure Cosmos DB is a persistent record of changes to a container in the order they occur.
Change feed support in Azure Cosmos DB works by listening to an Azure Cosmos DB container for any changes. It then outputs the sorted list of documents that were changed in the order in which they were modified.

Incorrect:
Not C: a post-trigger¨
The post-trigger could be defined on the blog post container when a new blog post is created, not on the User container.

Note: Azure Cosmos DB supports pre-triggers and post-triggers. Pre-triggers are executed before modifying a database item, and post-triggers are executed after modifying a database item. Triggers aren't automatically executed. They must be specified for each database operation where you want them to execute.

Box 1: ORDER BY c.name DESC, c.age DESC
Queries that have an ORDER BY clause with two or more properties require a composite index.

The following considerations are used when using composite indexes for queries with an ORDER BY clause with two or more properties:
1. If the composite index paths do not match the sequence of the properties in the ORDER BY clause, then the composite index can't support the query.
2. The order of composite index paths (ascending or descending) should also match the order in the ORDER BY clause.
3. The composite index also supports an ORDER BY clause with the opposite order on all paths.

Box 2: At the same time as the item creation Azure Cosmos DB supports two indexing modes:
1. Consistent: The index is updated synchronously as you create, update or delete items. This means that the consistency of your read queries will be the consistency configured for the account.
2. None: Indexing is disabled on the container.

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/index-policy

Azure Cosmos DB supports queries with parameters expressed by the familiar @ notation. Parameterized SQL provides robust handling and escaping of user input, and prevents accidental exposure of data through SQL injection.

For example, you can write a query that takes lastName and address.state as parameters, and execute it for various values of lastName and address.state based on user input.

SELECT *
FROM Families f WHERE f.lastName = @lastName AND f.address.state = @addressState

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/sql/sql-query-parameterized-queries

Box 1: Gateway mode with a dedicated Gateway Connectivity mode

How to configure the Azure Cosmos DB integrated cache

Provision the dedicated gateway 1. Navigate to an Azure Cosmos DB account in the Azure portal and select the Dedicated Gateway tab.

2. Fill out the Dedicated gateway form with the following details:

*-> Dedicated Gateway - Turn on the toggle to Provisioned.
SKU - Select a SKU with the required compute and memory size. The integrated cache will use approximately 50% of the memory, and the remaining memory is used for metadata and routing requests to the backend partitions.
Number of instances - Number of nodes. For development purpose, we recommend starting with one node of the D4 size. Based on the amount of data you need to cache and to achieve high availability, you can increase the node size after initial testing.

3. Select Save and wait about 5-10 minutes for the dedicated gateway provisioning to complete. When the provisioning is done, you'll see the following notification:

Box 2: session
Consistency level

Adjust request consistency
You must ensure the request consistency is session or eventual. If not, the request will always bypass the integrated cache. The easiest way to configure a specific consistency for all read operations is to set it at the account-level. You can also configure consistency at the request-level, which is recommended if you only want a subset of your reads to utilize the integrated cache.

4 days is 96 (4x24) hours. A backup every 2 hours will give 48 backups within 4 days. 2 copies are free. 46 of the copies will incur additional charges.

Note: Backups are retained for 8 hours by default, but you can request retention for up to 30 days if you need. However, this is where you begin to incur charges for periodic backups, since the longer you retain backups, the more snapshot copies need to be kept in Azure Blob Storage - and only the first two are free.
So depending on how frequently you set the backup interval, and how long you request backup retention -

Cosmos DB may keep anywhere from 2 to 720 snapshots in Azure Blob Storage available for restore.

Box 1: No
Azure Cosmos DB's change feed is a great choice as a central data store in event sourcing architectures where all data ingestion is modeled as writes (no updates or deletes).

Note: The change feed does not capture deletes. If you delete an item from your container, it is also removed from the change feed. The most common method of handling this is adding a soft marker on the items that are being deleted. You can add a property called "deleted" and set it to "true" at the time of deletion. This document update will show up in the change feed. You can set a TTL on this item so that it can be automatically deleted later.

Box 2: No
The_etag format is internal and you should not take dependency on it, because it can change anytime.

Box 3: Yes
Change feed support in Azure Cosmos DB works by listening to an Azure Cosmos container for any changes.

References:
https://docs.microsoft.com/en-us/azure/cosmos-db/sql/change-feed-design-patterns
https://docs.microsoft.com/en-us/azure/cosmos-db/change-feed

The compute containers are shared among all materialized views within an Azure Cosmos DB account.
Each provisioned compute container initiates multiple tasks that read the change feed from the base container partitions and write data to the target materialized view or views. The compute container transforms the data per the materialized view definition for each materialized view in the account.

Note: Materialized views for Azure Cosmos DB for NoSQL (preview)
Applications frequently are required to make queries that don't specify a partition key. In these cases, the queries might scan through all data for a small result set. The queries end up being expensive because they inadvertently run as a cross-partition query.

Materialized views, when defined, help provide a way to efficiently query a base container in Azure Cosmos DB by using filters that don't include the partition key. When users write to the base container, the materialized view is built automatically in the background. This view can have a different partition key for efficient lookups. The view also contains only fields that are explicitly projected from the base container.
This view is a read-only table.

With a materialized view, you can:

Use the view as a lookup or mapping container to persist cross-partition scans that would otherwise be expensive queries.
Provide a SQL-based predicate (without conditions) to populate only specific fields.
Use change feed triggers to create real-time views to simplify event-based scenarios that are commonly stored as separate containers.

According to the Azure Cosmos DB documentation12, the change feed is a persistent record of changes to a container in the order they occur. The change feed outputs the sorted list of documents that were changed in the order in which they were modified.
The Azure function that has a trigger on the change feed receives all the properties of the updated items 2.
The change feed does not include the original items or only the changed properties. The change feed also includes some system-defined properties such as_ts (the last modified timestamp) and_lsn (the logical sequence number)3.
Therefore, the correct answer is "all the properties of the updated items"

It's the best practice to have a partition key with many distinct values, such as hundreds or thousands. The goal is to distribute your data and workload evenly across the items associated with these partition key values. If such a property doesn't exist in your data, you can construct a synthetic partition key.

Concatenate multiple properties of an item
You can form a partition key by concatenating multiple property values into a single artificial partitionKey property. These keys are referred to as synthetic keys. For example, consider the following example document:

{
"deviceId": "abc-123",
"date": 2018
}

Transactions (in stored procedures or triggers) are allowed only against items in a single logical partition.

A logical partition also defines the scope of database transactions. You can update items within a logical partition by using a transaction with snapshot isolation. When new items are added to a container, the system transparently creates new logical partitions. You don't have to worry about deleting a logical partition when the underlying data is deleted.

Transactions (in stored procedures or triggers) are allowed only against items in a single logical partition.

Step 1: Increase the retention period of the account Request data restoration from an Azure Cosmos DB backup
If you accidentally delete your database or a container, you can file a support ticket or call the Azure support to restore the data from automatic online backups.

In order to prevent the backup from being overwritten, increase the backup retention for your account to at least seven days. It's best to increase your retention within 8 hours from the data corruption.

Step 2: Submit a request ticket
The following screenshot illustrates how to create a support request for a container(collection/graph/table) to restore data by using Azure portal. Provide other details such as type of data, purpose of the restore, time when the data was deleted to help us prioritize the request.

Step 3: Migrate the data Post-restore actions
The primary goal of the data restore is to recover the data that you've accidentally deleted or modified. So, we recommend that you first inspect the content of the recovered data to ensure it contains what you are expecting. If everything looks good, you can migrate the data back to the primary account. Although it's possible to use the restored account as your new active account, it's not a recommended option if you have production workloads.

After you restore the data, you get a notification about the name of the new account (it's typically in the format <original-name>-restored1) and the time when the account was restored to. The restored account
has the same provisioned throughput, indexing policies and it is in same region as the original account. A user who is the subscription admin or a coadmin can see the restored account.

Migrate data to the original account
The following are different ways to migrate data back to the original account:

Use the Azure Data Factory.
Use the change feed in Azure Cosmos DB.
You can write your own custom code.
It's advised that you delete the container or database immediately after migrating the data. If you don't delete the restored databases or containers, they incur cost for request units, storage, and egress.