+>[!NOTE]

+>Users with no MFA methods registered will be prompted to download the Authenticator App when they begin registration flow. For the most seamless Authenticator Lite registration experience, [provision your users a TAP](https://learn.microsoft.com/azure/active-directory/authentication/howto-authentication-temporary-access-pass) (temporary access pass) which they can use during registration.

+## Known Issues (Public preview)

+### SSPR Notifications

+TOTP codes from Outlook will work for SSPR, but the push notification will not work and will return an error.

+### Conditional Access Registration Policies

+CA policies for registration do not currently apply in Outlook registration flows.

+The business logic of an application determines how authorization should be handled. The general approach to authorization based on token claims, and which claims should be used, is described below.

+After a token is validated with the correct `aud` claim, the token tenant, subject, actor must be authorized.

+#### Tenant

+First, always check that the `tid` in a token matches the tenant ID used to store data with the application. When information is stored for an application in the context of a tenant, it should only be accessed again later in the same tenant. Never allow data in one tenant to be accessed from another tenant.

+#### Subject

+Next, to determine if the token subject, such as the user (or app itself in the case of an app-only token), is authorized, either check for specific `sub` or `oid` claims, or check that the subject belongs to an appropriate role or group with the `roles`, `groups`, `wids` claims.

+For example, use the immutable claim values `tid` and `oid` as a combined key for application data and determining whether a user should be granted access.

+The `roles`, `groups` or `wids` claims can also be used to determine if the subject has authorization to perform an operation. For example, an administrator may have permission to write to an API, but not a normal user, or the user may be in a group allowed to do some action.

+> [!WARNING]

+> Never use `email` or `upn` claim values to store or determine whether the user in an access token should have access to data. Mutable claim values like these can change over time, making them insecure and unreliable for authorization.

+#### Actor

+Lastly, when an app is acting for a user, this client app (the actor), must also be authorized. Use the `scp` claim (scope) to validate that the app has permission to perform an operation.

+Scopes are defined by the application, and the absence of `scp` claim means full actor permissions.

+> [!NOTE]

+> An application may handle app-only tokens (requests from applications without users, such as daemon apps) and want to authorize a specific application across multiple tenants, rather than individual service principal IDs. In that case, check for an app-only token using the `idtyp` optional claim and use the `appid` claim (for v1.0 tokens) or the `azp` claim (for v2.0 tokens) along with `tid` to determine authorization based on tenant and application ID.

+## REST API reference

+You can configure token lifetime policies and assign them to apps and service principals using Microsoft Graph. For more information, see the [tokenLifetimePolicy resource type](/graph/api/resources/tokenlifetimepolicy) and its associated methods.

+- By configuring Azure AD Connect to create them and to sync data into them from on-premises AD. See [Azure AD Connect Sync Directory Extensions](../hybrid/how-to-connect-sync-feature-directory-extensions.md).

+### Emitting claims with data from directory extension attributes created with Azure AD Connect

+Directory extension attributes created and synced using Azure AD Connect are always associated with the application ID used by Azure AD Connect. These attributes can be used as a source for claims both by configuring them as claims in the **Enterprise Applications** configuration in the Portal UI for SAML applications registered using the Gallery or the non-Gallery application configuration experience under **Enterprise Applications**, and via a claims-mapping policy for applications registered via the Application registration experience. Once a directory extension attribute created via AD Connect is in the directory, it will show in the SAML SSO claims configuration UI.

+It is recommended to specify an audience, as many tenants, and the applications deployed in them will have guest users. If your application will have external users, the endpoints of `common` and `organization` are best avoided. If you don't specify an audience, your app will target Azure AD and personal Microsoft accounts as an audience and will behave as though `common` were specified.

+

+ >[!WARNING]

+ > If the settings **If reviewers don't respond** is set to **Remove access** or **Take recommendations** and **Auto apply results to resource** is enabled, all access to this resource could risk being revoked if the reviewers fail to respond.

+- Make sure to exclude the Entitlement Management app from any Conditional Access policies that impact guest users. Otherwise, a conditional access policy could block them from accessing MyAccess or being able to sign in to your directory. For example, guests likely don't have a registered device, aren't in a known location, and don't want to re-register for multi-factor authentication (MFA), so adding these requirements in a Conditional Access policy will block guests from using entitlement management. For more information, see [What are conditions in Azure Active Directory Conditional Access?](../conditional-access/concept-conditional-access-conditions.md).

+- A common policy for Entitlement Management customers is to block all apps from guests except Entitlement Management for guests. This policy allows guests to enter MyAccess and request an access package. This package should contain a group (it is called Guests from MyAccess in the example below), which should be excluded from the block all apps policy. Once the package is approved, the guest will be in the directory. Given that the end user has the access package assignment and is part of the group, the end user will be able to access all other apps. Other common policies include excluding Entitlement Management app from MFA and compliant device.

+> The Entitlement Management app includes the entitlement management side of MyAccess, the Entitlement Management side of Azure Portal and the Entitlement Management part of MS graph. The latter two require additional permissions for access, hence won't be accessed by guests unless explicit permission is provided.

+ > When creating a new Logic App in this modal, the length of "/subscriptions/{SubscriptionId}/resourceGroups/{RG Name}/providers/Microsoft.Logic/workflows/{Logicapp Name}" cannot exceed 150 characters.

+## View and Edit Existing Custom Extensions for a Catalog

+**Prerequisite roles:** Global administrator, Identity Governance administrator, or Catalog owner

+1. Navigate to the Custom Extensions tab within a Catalog as mentioned earlier.

+1. Here, you can view all the custom extensions you've created, along with the associated Logic App and information about the custom extension type.

+ :::image type="content" source="media/entitlement-management-logic-apps/custom-extension-list.png" alt-text="Screenshot of a list of custom extensions." lightbox="media/entitlement-management-logic-apps/custom-extension-list.png":::

+1. Along with the Logic App name, the column Type dictates whether the custom extension was created in the new V2 auth model (after March 17, 2023), or the original model. If a custom extension was created in the new model, the Type column matches the selected type from the configuration modal that is either ΓÇ£*assignment request*ΓÇ¥ or ΓÇ£*pre-expiration*ΓÇ¥. For older custom extensions, the type shows ΓÇ£*custom access package*ΓÇ¥.

+1. The Token Security column shows the associated auth security framework used when creating the custom extension. New V2 custom extensions show ΓÇ£*proof-of-possession*ΓÇ¥ (PoP) as the token security type. Older custom extensions show ΓÇ£regularΓÇ¥.

+1. Old style custom extensions are no longer able to be created from the UI, however existing ones can be converted to new style custom extensions from the UI.

+ :::image type="content" source="media/entitlement-management-logic-apps/convert-token-security-extension.png" alt-text="Screenshot of converting old security token to new.":::

+1. Selecting the three dots at the end of the row of an old custom extension allows you to update the custom extension to a new type quickly.

+ > [!NOTE]

+ > Custom extensions can only be converted to the new type if they are not in use, or if they are in use exclusively for policy stages of one specific extension type (assignment request stages or pre expiration stages).

+1. You can also edit any custom extension. This allows you to update the name, description, and other field values. This can be accomplished by selecting **Edit** inside the three-dot pane for any custom extension.

+1. Old style custom extensions can continue to be used and edited even if not converted, even though they can no longer be created.

+1. If an old style custom extension can't be updated to the new type because it's being used for policy stages, of **BOTH** assignment request and pre expiration types, then in order to update it you must either remove it from all linked policies or ensure it's only used for policy stages associated with **ONE** type (assignment request, or pre expiration).  

+## Add custom extension to a policy in an access package

+**Prerequisite roles:** Global administrator, Identity Governance administrator, Catalog owner, or Access package manager

+1. Sign in to the [Azure portal](https://portal.azure.com).

+1. In the Azure portal, select **Azure Active Directory** and then select **Identity Governance**.

+1. In the left menu, select **Access packages**.

+1. Select the access package you want to add a custom extension (logic app) to from the list of access packages that have already been created.

+ > [!NOTE]

+ > Select **New access package** if you want to create a new access package.

+ > For more information about how to create an access package, see [Create a new access package in entitlement management](entitlement-management-access-package-create.md). For more information about how to edit an existing access package, see [Change request settings for an access package in Azure AD entitlement management](entitlement-management-access-package-request-policy.md#open-and-edit-an-existing-policys-request-settings).

+1. Change to the policy tab, select the policy and select **Edit**.

+1. In the policy settings, go to the **Custom Extensions (Preview)** tab.

+1. In the menu below **Stage**, select the access package event you wish to use as trigger for this custom extension (Logic App). For example, if you only want to trigger the custom extension Logic App workflow when a user requests the access package, select **Request is created**.

+1. In the menu below **Custom Extension**, select the custom extension (Logic App) you want to add to the access package. The action you select executes when the event selected in the *when* field occurs.

+1. Select **Update** to add it to an existing access package's policy.

+ 

+## Edit a linked Logic App's workflow definition 

+**Prerequisite roles:** Global administrator, Identity Governance administrator, or Catalog owner

+For newly created Logic Apps linked to custom extensions, these Logic Apps begin blank. To create the workflows in the Logic Apps that will be triggered by the extension when the linked access package policy condition is triggered, you need to edit the definition of the Logic App workflow in Logic App designer. To accomplish this, you'd follow these steps:

+1. Navigate to the Custom Extensions tab within a Catalog as mentioned in the above section.

+1. Select the custom extension for whom you want to edit the Logic App.

+1. Select the Logic App under the Logic app column for the associated custom extension row. This allows you to edit or create the workflow in Logic App designer.

+For more information on creating logic app workflows, see [Quickstart: Create an example Consumption workflow in multi-tenant Azure Logic Apps with the Azure portal](../../logic-apps/quickstart-create-example-consumption-workflow.md).

+This pause process allows admins to have control of workflows theyΓÇÖd like to run before continuing with access lifecycle tasks in entitlement management. The only exception to this is if a timeout occurs. Launch and wait processes require a timeout of up to 14 days noted in minutes, hours, or days. If a resume response isn't sent back to entitlement management by the time the ΓÇ£timeoutΓÇ¥ period elapses, the entitlement management request workflow process pauses.

+The following flow diagram shows the entitlement management callout to Logic Apps workflow:

+## Extension end-user experience

+### Approver experience

+An approver sees the string specified in the resume request payload under `customExtensionStageInstanceDetail` as shown in the payload located in [Configuring custom extensions that pause entitlement management processes](entitlement-management-logic-apps-integration.md#configuring-custom-extensions-that-pause-entitlement-management-processes).

+### Requestor experience

+When an access package has a custom extension with launch and wait functionality, and the Logic App is triggered when the access package request is created, requestors can see their request status within request history in MyAccess.

+The following status updates are displayed to users based on their custom extension stage:

+|Custom Extension stage |Message displayed to requestor in MyAccess request history |

+|||

+|When the extension is being processed | Waiting for information before proceeding |

+|When the extension fails | Process expired |

+|When the extension resumes | Process continues |

+This is an example of a MyAccess request history from a requestor after the extension resumes:

+ :::image type="content" source="media/entitlement-management-logic-apps/extensibility-requestor-experience.png" alt-text="Screenshot of the requestor screen." lightbox="media/entitlement-management-logic-apps/extensibility-requestor-experience.png":::

+- [Create and manage a catalog of resources in entitlement management](entitlement-management-catalog-create.md)

+1. Using your new VPN, navigate to [https://myapps.microsoft.com](https://myapps.microsoft.com) and enter the credentials of your test account.

+2. When signing in with your test account, fail the multifactor authentication (MFA) challenge by not passing the MFA challenge.

+The AD FS application activity report in the [Entra portal](https://entra.microsoft.com) lets you quickly identify which of your applications are capable of being migrated to Azure AD. It assesses all AD FS applications for compatibility with Azure AD, checks for any issues, and gives guidance on preparing individual applications for migration. With the AD FS application activity report, you can:

+The AD FS application activity report is available in the [Entra portal](https://entra.microsoft.com) under Azure AD **Usage & insights** reporting. The AD FS application activity report analyzes each AD FS application to determine if it can be migrated as-is, or if additional review is needed.

+1. Sign in to the [Entra portal](https://entra.microsoft.com) with an admin role that has access to AD FS application activity data (global administrator, reports reader, security reader, application administrator, or cloud application administrator).

+1. In the **Admin Credentials** section, input your Alinto Protect Tenant URL as `https://cloud.cleanmail.eu/api/v3/scim2 ` and corresponding Secret Token obtained from Step 2. Click **Test Connection** to ensure Azure AD can connect to Alinto Protect. If the connection fails, ensure your Alinto Protect account has Admin permissions and try again.

+- Find the name of the user-assigned managed identity, which you need in the following steps.

+- Find the name of the user-assigned managed identity, which you need in the following steps.

+Run the [az identity federated-credential create](/cli/azure/identity/federated-credential#az-identity-federated-credential-create) command to create a new federated identity credential on your user-assigned managed identity (specified by the name). Specify the *name*, *issuer*, *subject*, and other parameters.

+- Find the name of the user-assigned managed identity, which you need in the following steps.

+Run the [New-AzFederatedIdentityCredentials](/powershell/module/az.managedserviceidentity/new-azfederatedidentitycredentials) command to create a new federated identity credential on your user-assigned managed identity (specified by the name). Specify the *name*, *issuer*, *subject*, and other parameters.

+Run the [Get-AzFederatedIdentityCredentials](/powershell/module/az.managedserviceidentity/get-azfederatedidentitycredentials) command to read all the federated identity credentials configured on a user-assigned managed identity:

+Run the [Get-AzFederatedIdentityCredentials](/powershell/module/az.managedserviceidentity/get-azfederatedidentitycredentials) command to show a federated identity credential (by name):

+Run the [Remove-AzFederatedIdentityCredentials](/powershell/module/az.managedserviceidentity/remove-azfederatedidentitycredentials) command to delete a federated identity credential under an existing user assigned identity.

+- Find the name of the user-assigned managed identity, which you need in the following steps.

+- Find the name of the user-assigned managed identity, which you need in the following steps.

+[Create or update a federated identity credential](/rest/api/managedidentity/2022-01-31-preview/federated-identity-credentials/create-or-update) on the specified user-assigned managed identity.

+[List all the federated identity credentials](/rest/api/managedidentity/2022-01-31-preview/federated-identity-credentials/list) on the specified user-assigned managed identity.

+[Get a federated identity credential](/rest/api/managedidentity/2022-01-31-preview/federated-identity-credentials/get) on the specified user-assigned managed identity.

+[Delete a federated identity credential](/rest/api/managedidentity/2022-01-31-preview/federated-identity-credentials/delete) on the specified user-assigned managed identity.

+1. To get recommendations for a specific category, click one of the tabs: **Reliability**, **Security**, **Performance**, **Operational Excellence**, or **Cost**.

+ annotations:

+ pv.kubernetes.io/provisioned-by: blob.csi.azure.com

+ annotations:

+ pv.kubernetes.io/provisioned-by: blob.csi.azure.com

+[sas-tokens]: ../storage/common/storage-sas-overview.md

+ annotations:

+ pv.kubernetes.io/provisioned-by: disk.csi.azure.com

+ annotations:

+ pv.kubernetes.io/provisioned-by: file.csi.azure.com

+ - `PremiumV2_LRS` only supports `None` caching mode

+|skuName | Azure Disks storage account type (alias: `storageAccountType`)| `Standard_LRS`, `Premium_LRS`, `StandardSSD_LRS`, `UltraSSD_LRS`, `Premium_ZRS`, `StandardSSD_ZRS`, `PremiumV2_LRS` (`PremiumV2_LRS` only supports `None` caching mode) | No | `StandardSSD_LRS`|

+ annotations:

+ pv.kubernetes.io/provisioned-by: file.csi.azure.com

+[aks-storage-backups-best-practices]: operator-best-practices-storage.md

+ :::image type="content" source="media/api-management-howto-aad/api-management-with-aad008.png" alt-text="Screenshot showing Add Azure AD group button in the portal.":::

+> Learn more about the difference between **Delegated** and **Application** permissions types in [Permissions and consent in the Microsoft identity platform](../active-directory/develop/v2-permissions-and-consent.md#permission-types) article.

+In addition to these system groups, administrators can create custom groups or [use external groups in associated Azure Active Directory tenants][leverage external groups in associated Azure Active Directory tenants]. Custom and external groups can be used alongside system groups in giving developers visibility and access to API products. For example, you could create one custom group for developers affiliated with a specific partner organization and allow them access to the APIs from a product containing relevant APIs only. A user can be a member of more than one group.

+1. Click **+Add**.

+1. Enter a unique name for the group and an optional description.

+1. Press **Create**.

+ :::image type="content" source="media/api-management-howto-create-groups/groups001.png" alt-text="Screenshot of creating a group in the portal.":::

+Once the group is created, it's added to the **Groups** list.

+ * To edit the **Name** or **Description** of the group, click the name of the group and select **Settings**

+ * To delete the group, click the name of the group and press **Delete**.

+1. Click the name of the desired product.

+1. Press **Access control** > **+ Add group**.

+1. Select the group you want to add.

+ :::image type="content" source="media/api-management-howto-create-groups/groups002.png" alt-text="Screenshot of adding a group to a product in the portal.":::

+To remove a group from the product, click **Delete**.

+1. Select the **Groups** tab to the left of the screen, and then select a group.

+1. Select **Members** > **+ Add**.

+1. Select a member.

+ :::image type="content" source="media/api-management-howto-create-groups/groups006.png" alt-text="Screenshot of adding a member to a group in the portal.":::

+1. Press **Select**.

+Connection draining helps you gracefully remove backend pool members during planned service updates. It applies to backend instances that are

+- explicitly removed from the backend pool,

+- removed during scale-in operations, or

+- reported as unhealthy by the health probes.

+You can apply this setting to all backend pool members by enabling Connection Draining in the Backend Setting. It ensures that all deregistering instances in a backend pool don't receive any new requests/connections while maintaining the existing connections until the configured timeout value. This is also true for WebSocket connections.

+Connection draining helps you achieve graceful removal of backend pool members during planned service updates or problems with backend health. This setting is enabled via the [Backend Setting](configuration-http-settings.md) and is applied to all backend pool members during rule creation. Once enabled, the aplication gateway ensures all deregistering instances of a backend pool don't receive any new requests while allowing existing requests to complete within a configured time limit. It applies to cases where backend instances are

+- explicitly removed from the backend pool after a configuration change by a user,

+- reported as unhealthy by the health probes, or

+- removed during a scale-in operation.

+The only exception is when requests continue to be proxied to the deregistering instances because of gateway-managed session affinity.

+The connection draining is honored for WebSocket connections as well. For information on time limits, see [Backend Settings configuration](configuration-http-settings.md#connection-draining).

+sudo su omsagent -c 'python /opt/microsoft/omsconfig/Scripts/PerformRequiredConfigurationChecks.py'

+sudo su omsagent -c 'python /opt/microsoft/omsconfig/Scripts/PerformRequiredConfigurationChecks.py'

+ azcmagent config get incomingconnections.ports

+ azcmagent config set incomingconnections.ports 22

+ azcmagent config set incomingconnections.ports 22,6516

+This screenshot shows a zoom control loaded on a map.

+This screenshot shows a pitch control loaded on a map.

+This screenshot shows a rotation control loaded on a map.

+This screenshot shows a traffic control loaded on a map.

+Multiple controls can be added to an array and the map then positioned in the same area of the map to simplify development. The following code adds the standard navigation controls to the map using this approach.

+This screenshot shows all controls loaded on a map, appearing in the order they were added.

+The following example demonstrates a heat map using a liner interpolation expression to create a smooth color gradient. The `mag` property defined in the data is used with an exponential interpolation to set the weight or relevance of each data point.

+Alternatively, a URL to an image hosted on the online can be specified. However, if your scenario allows, add the image to your project's `Assets` folder, that loads faster since the image is locally available with no need to be downloaded.

+The following code creates two line features and adds a speed limit value as a property to each line. A line layer uses a data-drive style expression color the lines based on the speed limit value. Since the line data overlays along roads, the following code adds the line layer below the label layer so that road labels remain visible.

+The following screenshot shows the above code that renders two lines in a line layer with their color retrieved from a data driven style expression based on a property in the line features.

+This sample shows how to add arrow icons along a line on the map. When using a symbol layer, set the `symbolPlacement` option to `.line`. This option renders the symbols along the line and rotates the icons (0 degrees = right).

+The following screenshot shows the above code displaying a line with arrow icons displayed along it.

+The following code demonstrates what should be added to the map after it has loaded. This sample renders a single point on the map using a symbol layer.

+Initially the map has the built-in default marker icon, which is already loaded into the image sprite of the map. It's used by default if nothing is set to the `iconImage` option. In case you need to do it manually, set `"marker-default"` to the `iconImage` option.

+The code below lists the built-in icon images available as static variables of `UIImage` class.

+A Tile layer loads in tiles from a server. These images can be prerendered and stored like any other image on a server, using a naming convention that the tile layer understands. Or, these images can be rendered with a dynamic service that generates the images near real time. There are three different tile service naming conventions supported by Azure Maps TileLayer class:

+This sample shows how to create a tile layer that points to a set of tiles. This sample uses the "x, y, zoom" tiling system. The source of this tile layer is the [OpenSeaMap project](https://openseamap.org/index.php), which contains crowd sourced nautical charts. Often when viewing tile layers it's desirable to be able to clearly see the labels of cities on the map. This behavior can be achieved by inserting the tile layer below the map label layers.

+A web-mapping service (WMS) is an Open Geospatial Consortium (OGC) standard for serving images of map data. There are many open data sets available in this format that you can use with Azure Maps. This type of service can be used with a tile layer if the service supports the `EPSG:3857` coordinate reference system (CRS). When using a WMS service, set the width and height parameters to the same value supported by the service, be sure to set this same value in the `tileSize` option. In the formatted URL, set the `BBOX` parameter of the service with the `{bbox-epsg-3857}` placeholder.

+A web-mapping tile service (WMTS) is an Open Geospatial Consortium (OGC) standard for serving tiled based overlays for maps. There are many open data sets available in this format that you can use with Azure Maps. This type of service can be used with a tile layer if the service supports the `EPSG:3857` or `GoogleMapsCompatible` coordinate reference system (CRS). When using a WMTS service, set the width and height parameters to the same value supported by the service, be sure to set this same value in the `tileSize` option. In the formatted URL, replace the following placeholders accordingly:

+The following code creates two line features and adds a speed limit value as a property to each line. A line layer uses a data-drive style expression color the lines based on the speed limit value. Since the line data overlays along roads, the following code adds the line layer below the label layer so that road labels can still clearly be read.

+The following screenshot shows the above code rendering two lines in a line layer, the color retrieved from a data driven style expression based on a property in the line feature.

+This sample shows how to add arrow icons along a line on the map. When using a symbol layer, set the `symbolPlacement` option to `SymbolPlacement.LINE`. This renders the symbols along the line and rotates the icons (0 degrees = right).

+The following screenshot shows the above code displaying a line with arrow icons displayed along it.

+The map manages all events through its `events` property. The following table lists the supported map events.

+| `OnCameraIdle` | `()` | <p>Fires after the last frame rendered before the map enters an "idle" state:<ul><li>No camera transitions are in progress.</li><li>All currently requested tiles have loaded.</li><li>All fade/transition animations have completed.</li></ul></p> |

+| `OnCameraMove` | `()` | Fires repeatedly during an animated transition from one view to another, as the result of either user interaction or methods. |

+| `OnCameraMoveCanceled` | `()` | Fires when a movement request to the camera has been canceled. |

+| `OnCameraMoveStarted` | `(int reason)` | Fires just before the map begins a transition from one view to another, as the result of either user interaction or methods. The `reason` argument of the event listener returns an integer value that provides details of how the camera movement was initiated. The following list outlines the possible reasons:<ul><li>1: Gesture</li><li>2: Developer animation</li><li>3: API Animation</li></ul> |

+| `OnClick` | `(double lat, double lon): boolean` | Fires when the map is pressed and released at the same point on the map. This event handler returns a boolean value indicating if the event should be consumed or passed further to other event listeners. |

+| `OnFeatureClick` | `(List<Feature>): boolean` | Fires when the map is pressed and released at the same point on a feature. This event handler returns a boolean value indicating if the event should be consumed or passed further to other event listeners. |

+| `OnLayerAdded` | `(Layer layer)` | Fires when a layer is added to the map. |

+| `OnLayerRemoved` | `(Layer layer)` | Fires when a layer is removed from the map. |

+| `OnLoaded` | `()` | Fires immediately after all necessary resources have been downloaded and the first visually complete rendering of the map has occurred. |

+| `OnLongClick` | `(double lat, double lon): boolean` | Fires when the map is pressed, held for a moment, and then released at the same point on the map. This event handler returns a boolean value indicating if the event should be consumed or passed further to other event listeners. |

+| `OnLongFeatureClick ` | `(List<Feature>): boolean` | Fires when the map is pressed, held for a moment, and then released at the same point on a feature. This event handler returns a boolean value indicating if the event should be consumed or passed further to other event listeners. |

+| `OnReady`              | `(AzureMap map)`     | Fires when the map initially loads, the orientation changes, the minimum required map resources load and the map is ready to be interacted with programmatically. |

+| `OnSourceAdded` | `(Source source)` | Fires when a `DataSource` or `VectorTileSource` is added to the map. |

+| `OnSourceRemoved` | `(Source source)` | Fires when a `DataSource` or `VectorTileSource` is removed from the map. |

+| `OnStyleChange` | `()` | Fires when the map's style loads or changes. |

+When the `OnFeatureClick` or `OnLongFeatureClick` events are added to the map, a layer instance or layer ID can be passed in as a second parameter. When a layer is passed in, an event fires if it occurs on that layer. Events scoped to layers are supported by the symbol, bubble, line, and polygon layers.

+Style options can be set during web control initialization. Or, you can update style options by calling the map control's `setStyle` function. To see all available style options, see [style options](/javascript/api/azure-maps-control/atlas.styleoptions).

+| **Gen 2** | Maps/Location Insights | Gen 2 pricing is for new and current Azure Maps customers. Gen 2 comes with a free monthly tier of transactions to be used to test and build on Azure maps. Maps and Location Insights SKUΓÇÖs contain all Azure Maps capabilities. It allows you to achieve cost savings as Azure Maps transactions increases. Additionally, it has higher QPS limits than Gen 1. The Gen 2 pricing tier is required when using [Creator for indoor maps](creator-indoor-maps.md).

+Enable clustering in the `DataSource` class by setting the `cluster` option to `true`. Set `clusterRadius` to select nearby points and combines them into a cluster. The value of `clusterRadius` is in pixels. Use `clusterMaxZoom` to specify a zoom level at which to disable the clustering logic. Here's an example of how to enable clustering in a data source.

+| `getClusterChildren(Feature clusterFeature)` | `FeatureCollection` | Retrieves the children of the given cluster on the next zoom level. These children may be a combination of shapes and subclusters. The subclusters become features with properties matching ClusteredProperties. |

+| `getClusterExpansionZoom(Feature clusterFeature)` | `int` | Calculates a zoom level at which the cluster starts expanding or break apart. |

+The following code displays clustered points using a bubble layer, and the number of points in each cluster using a symbol layer. A second symbol layer is used to display individual points that aren't within a cluster.

+Use clustering to show the data points density while keeping a clean user interface. The following sample shows you how to add custom symbols and represent clusters and individual data points using the symbol layer.

+Heat maps are a great way to display the density of data on the map. This visualization method can handle a large number of data points on its own. If the data points are clustered and the cluster size is used as the weight of the heat map, then the heat map can handle even more data. To achieve this option, set the `heatmapWeight` option of the heat map layer to `get("point_count")`. When the cluster radius is small, the heat map looks nearly identical to a heat map using the unclustered data points, but it performs better. However, a smaller cluster radius results in a more accurate heat map, but with fewer performance benefits.

+The following image shows the above code displaying a heat map that is optimized by using clustered point features and the cluster count as the weight in the heat map.

+When mouse events occur on a layer that contains clustered data points, the clustered data point return to the event as a GeoJSON point feature object. This point feature has the following properties:

+The following image shows the above code displaying clustered points on a map that when selected, zoom into the next zoom level that a cluster starts to break apart and expand.

+The point data that a cluster represents is spread over an area. In this sample when the mouse is hovered over a cluster, two main behaviors occur. First, the individual data points contained in the cluster will be used to calculate a convex hull. Then, the convex hull displays on the map to show an area. A convex hull is a polygon that wraps a set of points like an elastic band and can be calculated using the `atlas.math.getConvexHull` method. All points contained in a cluster can be retrieved from the data source using the `getClusterLeaves` method.

+The following image shows the above code displays the area of all points within a clicked clustered.

+Often clusters are represented using a symbol with the number of points that are within the cluster. But, sometimes it's desirable to customize the style of clusters with more metrics. With cluster properties, custom properties can be created and equal to a calculation based on the properties within each point with a cluster. Cluster properties can be defined in `clusterProperties` option of the `DataSource`.

+The following code calculates a count based on the entity type property of each data point in a cluster. When a user selects on a cluster, a popup shows with additional information about the cluster.

+The following image shows the above code displays a popup with aggregated counts of each entity value type for all points in the clicked clustered point.

+When displaying many data points on the map, data points may overlap over each other. The overlap may cause the map may become unreadable and difficult to use. Clustering point data is the process of combining point data that are near each other and representing them on the map as a single clustered data point. As the user zooms into the map, the clusters break apart into their individual data points. When you work with large number of data points, use the clustering processes to improve your user experience.

+Enable clustering in the `DataSource` class by setting the `cluster` option to `true`. Set `clusterRadius` to select nearby data points and combines them into a cluster. The value of `clusterRadius` is in points. Use `clusterMaxZoom` to specify a zoom level at which to disable the clustering logic. Here's an example of how to enable clustering in a data source.

+| `children(of cluster: Feature)` | `[Feature]` | Retrieves the children of the given cluster on the next zoom level. These children may be a combination of features and subclusters. The subclusters become features with properties matching ClusteredProperties. |

+| `zoomLevel(forExpanding cluster: Feature)` | `Double` | Calculates a zoom level at which the cluster starts expanding or break apart. |

+The following code displays clustered points using a bubble layer, and the number of points in each cluster using a symbol layer. A second symbol layer is used to display individual points that aren't within a cluster.

+When displaying data points, the symbol layer automatically hides symbols that overlap each other to ensure a cleaner user interface. This default behavior might be undesirable if you want to show the data points density on the map. However, these settings can be changed. To display all symbols, set the `iconAllowOverlap` option of the Symbol layer to `true`.

+Use clustering to show the data points density while keeping a clean user interface. The following sample shows you how to add custom symbols and represent clusters and individual data points using the symbol layer.

+Heat maps are a great way to display the density of data on the map. This visualization method can handle a large number of data points on its own. If the data points are clustered and the cluster size is used as the weight of the heat map, then the heat map can handle even more data. To achieve this option, set the `heatmapWeight` option of the heat map layer to `NSExpression(forKeyPath: "point_count")`. When the cluster radius is small, the heat map looks nearly identical to a heat map using the unclustered data points, but it performs better. However, the smaller the cluster radius, the more accurate the heat map is, but with fewer performance benefits.

+The following image shows the above code displaying a heat map optimized by using clustered point features and the cluster count as the weight in the heat map.

+When tap events occur on a layer that contains clustered data points, the clustered data point return to the event as a GeoJSON point feature object. This point feature has the following properties:

+The following image shows the above code displaying clustered points on a map that when tapped, zoom into the next zoom level that a cluster starts to break apart and expand.

+The point data that a cluster represents is spread over an area. In this sample when a cluster is tapped, two main behaviors occur. First, the individual data points contained in the cluster used to calculate a convex hull. Then, the convex hull is displayed on the map to show an area. A convex hull is a polygon that wraps a set of points like an elastic band and can be calculated using the `convexHull(from:)` method. All points contained in a cluster can be retrieved from the data source using the `leaves(of:offset:limit:)` method.

+The following image shows the above code displaying the area of all points within a tapped cluster.

+The following image shows the above code displaying a popup with aggregated counts of each entity value type for all points in the tapped clustered point.

+Alternatively the properties can be loaded into a JsonObject first then passed into the feature when creating it, as shown in the following sample code.

+The feature collection, feature, and geometry classes all have `fromJson()` and `toJson()` static methods, which help with serialization. The formatted valid JSON String passed through the `fromJson()` method creates the geometry object. This `fromJson()` method also means you can use Gson or other serialization/deserialization strategies. The following code shows how to take a stringified GeoJSON feature and deserialize it into the Feature class, then serialize it back into a GeoJSON string.

+The `DataSource` class has a built-in method called `importDataFromUrl` that can load in GeoJSON files using a URL to a file on the web or in the asset folder. This method **must** be called before the data source is added to the map.

+The `importDataFromUrl` method provides an easy way to load a GeoJSON feed into a data source but provides limited control on how the data is loaded and what happens after it's been loaded. The following code is a reusable class for importing data from the web or assets folder and returning it to the UI thread via a callback function. Next, add additional post load logic in the callback to process the data, add it to the map, calculate its bounding box, and update the maps camera.

+The following code demonstrates how to use this utility to import GeoJSON data as a string and return it to the UI thread via a callback. In the callback, the string data can be serialized into a GeoJSON Feature collection and added to the data source. Optionally, update the maps camera to focus in on the data.

+The `DataSource` class makes it easy to add and remove features. Updating the geometry or properties of a feature requires replacing the feature in the data source. There are two methods that can be used to update a feature(s):

+There are more rendering layers that don't connect to these data sources, but they directly load the data for rendering.

+With Azure Maps, all you need is a single polygon in a data source as shown in the following code.

+The following Web SDK style expressions aren't supported in the Android SDK:

+The above example works fine, if all the point features have the `zoneColor` property. If they don't, the color will likely fall back to "black". To modify the fallback color, use a `switchCase` expression in combination with the `has` expression to check if the property exists. If the property doesn't exist, return a fallback color.

+Bubble and symbol layers render the coordinates of all shapes in a data source, by default. This behavior can highlight the vertices of a polygon or a line. The `filter` option of the layer can be used to limit the geometry type of the features it renders, by using a `geometryType` expression within a boolean expression. The following example limits a bubble layer so that only `Point` features are rendered.

+Similarly, the outline of Polygons render in line layers. To disable this behavior in a line layer, add a filter that only allows `LineString` and `MultiLineString` features.

+Here are more examples of how to use data expressions:

+When comparing values, the comparison is strictly typed. Values of different types are always considered unequal. Cases where the types are known to be different at parse time are considered invalid and produces a parse error.

+| `neq(Expression compareOne, Expression | boolean | number | string compareTwo)` \| `neq(Expression compareOne, Expression | string compareTwo, Expression collator)` | boolean | Returns `true` if the input values aren't equal, `false` otherwise. |

+The following example steps through different boolean conditions until it finds one that evaluates to `true`, and then returns that associated value. If no boolean condition evaluates to `true`, a fallback value is returned.

+A `match` expression is a type of conditional expression that provides switch-statement like logic. The input can be any expression such as `get( "entityType")` that returns a string or a number. Each stop must have a label that is either a single literal value or an array of literal values, whose values must be all strings or all numbers. The input matches if any of the values in the array match. Each stop label must be unique. If the input type doesn't match the type of the labels, the result is the default fallback value.

+The following example uses an array to list a set of labels that should all return the same value. This approach is much more efficient than listing each label individually. In this case, if the `entityType` property is "restaurant" or "grocery_store", the color "red" is returned.

+The following example uses a `coalesce` expression to set the `textField` option of a symbol layer. If the `title` property is missing from the feature or set to `null`, the expression tries looking for the `subTitle` property, if it's missing or `null`, it will then fall back to an empty string.

+| `collator(boolean caseSensitive, boolean diacriticSensitive)` \| `collator(boolean caseSensitive, boolean diacriticSensitive, java.util.Locale locale)` \| `collator(Expression caseSensitive, Expression diacriticSensitive)` \| `collator(Expression caseSensitive, Expression diacriticSensitive, Expression locale)` | collator | Returns a collator for use in locale-dependent comparison operations. The case-sensitive and diacritic-sensitive options default to false. The locale argument specifies the IETF language tag of the locale to use. If none is provided, the default locale is used. If the requested locale isn't available, the collator uses a system-defined fallback locale. Use resolved-locale to test the results of locale fallback behavior. |

+The following example creates an RGB color value that has a *red* value of `255`, and *green* and *blue* values that are calculated by multiplying `2.5` by the value of the `temperature` property. As the temperature changes, the color changes to different shades of *red*.

+If all the color parameters are numbers, there's no need to wrap them with the `literal` expression. For example:

+The above expression renders a pin on the map with the text "64┬░F" overlaid on top of it as shown in the following image.

+Here's an example of what these different types of interpolations look like.

+The following example uses a `linear interpolate` expression to set the `bubbleColor` property of a bubble layer based on the `temperature` property of the point feature. If the `temperature` value is less than 60, "blue" is returned. If it's between 60 and less than 70, yellow is returned. If it's between 70 and less than 80, "orange" (`#FFA500`) is returned. If it's 80 or greater, "red" is returned.

+The following example uses a `step` expression to set the `bubbleColor` property of a bubble layer based on the `temperature` property of the point feature. If the `temperature` value is less than 60, "blue" is returned. If it's between 60 and less than 70, "yellow" is returned. If it's between 70 and less than 80, "orange" is returned. If it's 80 or greater, "red" is returned.

+| `formatFontScale(number)` \| `formatFontScale(Expression)` | Specifies the scaling factor for the font size. If specified, this value overrides the `textSize` property for the individual string. |

+This layer renders the point feature as shown in the following image:

+By default, the radii of data points rendered in the heat map layer have a fixed pixel radius for all zoom levels. As the map is zoomed, the data aggregates together and the heat map layer looks different. A `zoom` expression can be used to scale the radius for each zoom level such that each data point covers the same physical area of the map. It makes the heat map layer look more static and consistent. Each zoom level of the map has twice as many pixels vertically and horizontally as the previous zoom level. Scaling the radius, such that it doubles with each zoom level, creates a heat map that looks consistent on all zoom levels. It can be accomplished using the `zoom` expression with a `base 2 exponential interpolation` expression, with the pixel radius set for the minimum zoom level and a scaled radius for the maximum zoom level calculated as `2 * Math.pow(2, minZoom - maxZoom)` as shown below.

+Variable binding expressions store the results of a calculation in a variable. So, that the calculation results can be referenced elsewhere in an expression multiple times. It's a useful optimization for expressions that involve many calculations.

+operators and custom operators aren't supported.

+locale-sensitive as long as it's case- or diacritic-insensitive. Comparison

+predicate options aren't supported with comparison modifiers

+Automatic type casting isn't performed. Therefore, a feature only matches a

+Bubble and symbol layers render the coordinates of all geometries in a data source, by default. This behavior can highlight the vertices of a polygon or a line. The `filter` option of the layer can be used to limit the geometry type of the features it renders, by using `NSExpression.geometryTypeAZMVariable` within a predicate. The following example limits a bubble layer so that only `Point` features are rendered.

+The following example steps through different predicates until it finds one that evaluates to `true`, and then returns its true expression. If no predicates evaluate to `true`, the last false expression is returned.

+Aggregate expressions can contain arrays of expressions. In some cases, it's possible to use the array itself instead of wrapping the array in an aggregate expression.

+Th iOS SDK defines the following variables for use with layer options.

+By default, the radii of data points rendered in the heat map layer have a fixed point radius for all zoom levels. As the map is zoomed, the data aggregates together and the heat map layer looks different. A `zoom` expression can be used to scale the radius for each zoom level such that each data point covers the same physical area of the map. It makes the heat map layer look more static and consistent. Each zoom level of the map has twice as many points vertically and horizontally as the previous zoom level. Scaling the radius, such that it doubles with each zoom level, creates a heat map that looks consistent on all zoom levels. It can be accomplished using the `zoom` expression with a `base 2 exponential interpolation` expression, with the point radius set for the minimum zoom level and a scaled radius for the maximum zoom level calculated as `pow(2, maxZoom - minZoom) * radius` as shown below.

+A match expression is a type of conditional expression that provides switch-statement like logic. The input can be any expression such as `NSExpression(forKeyPath: "entityType")` that returns a string or a number. The matched expression is a dictionary, which should have keys as expressions that evaluate either to single string or number or to an array of all strings or all numbers and values as any expressions. If the input expression type doesn't match the type of the keys, the result is the default fallback value.

+The following example uses an expression evaluating to string array to specify a set of labels that should all return the same value. This approach is much more efficient than listing each label individually. In this case, if the `entityType` property is `"restaurant"` or `"grocery_store"`, red color is returned.

+The following example uses a coalesce expression to set the `textField` option of a symbol layer. If the `title` property is missing from the feature or set to `nil`, the expression looks for the `subTitle` property, if it's missing or `nil`, it returns an empty string.

+Joins multiple strings together. Each value must be a string or a number.

+The above expression renders a pin on the map with the text `"64┬░F"` overlaid on top of it as shown in the following image.

+Here's an example of what these different types of interpolations look like.

+The following example uses a linear interpolation expression to set the `bubbleColor` property of a bubble layer based on the `temperature` property of the point feature. If the `temperature` value is less than 60, blue color is returned. If it's between 60 and less than 70, yellow is returned. If it's between 70 and less than 80, orange is returned. If it's 80 or greater, red is returned.

+The following example uses a step expression to set the `bubbleColor` property of a bubble layer based on the `temperature` property of the point feature. If the `temperature` value is less than 60, blue is returned. If it's between 60 and less than 70, yellow is returned. If it's between 70 and less than 80, orange is returned. If it's 80 or greater, red is returned.

+The Azure Maps Android SDK provides a `Popup` class that makes it easy to create UI annotation elements that are anchored to a position on the map. For popups, you have to pass in a view with a relative layout into the `content` option of the popup. Here's a simple layout example that displays dark text on top of a while background.

+When a user interacts with a feature on the map, events can be used to react to those actions. A common scenario is to display a message made of the metadata properties of a feature the user interacted with. The `azureMap(_:didTapOn:)` event is the main event used to detect when the user tapped a feature on the map. There's also an `azureMap(_:didLongPressOn:)` event. When adding a delegate to the map, it can be limited to a single layer by passing in the ID of a layer to limit it to. If no layer ID is passed in, tapping any feature on the map, regardless of which layer it is in, would fire this event. The following code creates a symbol layer to render point data on the map, then adds a delegate, limited to this symbol layer, which handles the `azureMap(_:didTapOn:)` event.

+The Azure Maps iOS SDK provides a `Popup` class that makes it easy to create UI annotation elements that are anchored to a position on the map. For popups, you have to pass in a self-sizing view into the `content` option of the popup. Here's a simple view example that displays dark text on top of a white background.

+When using drawing tools on a map, it's useful to react to certain events as the user draws on the map. This table lists all events supported by the `DrawingManager` class.

+The following image is a screenshot of the above code rendering a polygon with a fill pattern on the map.

+The following code demonstrates what should be added to the map after it has loaded. This sample renders a single point on the map using a symbol layer.

+The table below lists all of the built-in icon image names available. These markers pull their colors from color resources that can be overridden. However, overriding the color of one of these markers would apply to all layers that use that icon image.

+A Tile layer loads in tiles from a server. These images can be prerendered and stored like any other image on a server, using a naming convention that the tile layer understands. Or, these images can be rendered with a dynamic service that generates the images near real time. There are three different tile service naming conventions supported by Azure Maps TileLayer class:

+This sample shows how to create a tile layer that points to a set of tiles. This sample uses the "x, y, zoom" tiling system. The source of this tile layer is the [OpenSeaMap project](https://openseamap.org/index.php), which contains crowd sourced nautical charts. Often when viewing tile layers it's desirable to be able to clearly see the labels of cities on the map. This behavior can be achieved by inserting the tile layer below the map label layers.

+A web-mapping service (WMTS) is an Open Geospatial Consortium (OGC) standard for serving images of map data. There are many open data sets available in this format that you can use with Azure Maps. This type of service can be used with a tile layer if the service supports the `EPSG:3857` coordinate reference system (CRS). When using a WMS service, set the width and height parameters to the value supported by the service, be sure to set this same value in the `tileSize` option. In the formatted URL, set the `BBOX` parameter of the service with the `{bbox-epsg-3857}` placeholder.

+A web-mapping tile service (WMTS) is an Open Geospatial Consortium (OGC) standard for serving tiled based overlays for maps. There are many open data sets available in this format that you can use with Azure Maps. This type of service can be used with a tile layer if the service supports the `EPSG:3857` or `GoogleMapsCompatible` coordinate reference system (CRS). When using a WMTS service, set the width and height parameters to the value supported by the service, be sure to set this same value in the `tileSize` option. In the formatted URL, replace the following placeholders accordingly:

+Once you have made the desired changes to your styles, save the changes to your Creator resource. You can overwrite your style with the changes or create a new style.

+Before you can register data in Azure Maps, you need to create an environment containing all required components. You need a storage account with one or more containers that hold the files you wish to register and managed identities for authentication. This section explains how to prepare your Azure environment to register data in Azure Maps.

+- Each [level] contains [units], [structures], [verticalPenetrations] and [openings]. All items defined in the level must be fully contained within the Level geometry.

+> We recommend using the same key in all your applications. If you use the primary key in some places and the secondary key in others, you won't be able to rotate your keys without some applications losing access.

+description: This article demonstrates how to display traffic data on a map using the Microsoft Azure Maps Android SDK.

+| `IncidentCategory.CLUSTER` | `"cluster"` | A cluster of traffic incidents of different categories. Zooming in the map results in the cluster breaking apart into its individual incidents. |

+1. Pass the language and regional view information into the `AzureMaps` class using the static `setLanguage` and `setView` properties. This sets the default language and regional view properties in your app.

+Here's an example of Azure Maps with the language set to "fr-FR" and regional view set to "Auto".

+For a complete list of supported languages and regional views, see [Localization support in Azure Maps](supported-languages.md).

+The Azure Maps Android SDK supports the Azure Government cloud. The Azure Maps Android SDK is accessed from the same Maven repository. The following tasks need to be done to connect to the Azure Government cloud version of the Azure Maps platform.

+* The maven identifier changed from `"com.microsoft.azure.maps:mapcontrol:0.7"` to `"com.azure.android:azure-maps-control:1.0.0"`. The namespace and major version number changed.

+The Route Directions APIs return instructions including the travel time and the coordinates for a route path. The Route Matrix API lets you calculate the travel time and distances for a set of routes that are defined by origin and destination locations. For every given origin, the Matrix API calculates the cost (travel time and distance) of routing from that origin to every given destination. These API allow you to specify parameters such as the desired departure time, arrival times, and the vehicle type, like car or truck. They all use real-time or predictive traffic data accordingly to return the most optimal routes.

+1. Get a `tilesetId` by completing the [tutorial for creating Indoor maps](tutorial-creator-indoor-maps.md). You'll use this identifier to render indoor maps with the Azure Maps iOS SDK.

+The map manages all events through its `events` property accepting delegates, which conform to the `AzureMapDelegate` protocol. The following table lists all supported map events represented as methods of the `AzureMapDelegate` protocol.

+When adding a delegate to the map, layer IDs can be passed in as a second parameter. When layers are passed in, the event only fires if it occurs on that layer. Events scoped to layers are supported by the symbol, bubble, line, and polygon layers.

+The following screenshot shows a zoom control loaded on a map.

+The following screenshot shows a pitch control loaded on a map.

+The following screenshot shows a compass control loaded on a map.

+The following screenshot shows a traffic control loaded on a map.

+To simplify development, add multiple controls to an array and map simultaneously then position in the same area. The following code adds the standard navigation controls to the map using this approach.

+The following screenshot shows all controls loaded on a map. They appear in the order they're added to the map.

+Alternatively, a URL to an image hosted on the online can be specified. However, if your scenario allows, add the image to your projects `drawable` folder, it loads faster since the image is locally available and doesn't need to be downloaded.

+The following table lists all supported map class events.

+The Azure Maps Android SDK has an API interface that is similar to the Web SDK. If you've developed with one of these SDKs, many of the same concepts, best practices, and architectures apply. This tutorial demonstrates how to:

+5. In the **MainActivity.java** file, import the Google Maps SDK. Forward all the life-cycle methods from the activity containing the map view to the corresponding ones in map class. Retrieve a `MapView` instance from the map fragment using the `getMapAsync(OnMapReadyCallback)` method. The `MapView` automatically initializes the maps system and the view. Edit the **MainActivity.java** file as follows:

+5. In the **MainActivity.kt** file, import the Google Maps SDK. Forward all the life-cycle methods from the activity containing the map view to the corresponding ones in map class. Retrieve a `MapView` instance from the map fragment using the `getMapAsync(OnMapReadyCallback)` method. The `MapView` automatically initializes the maps system and the view. Edit the **MainActivity.kt** file as follows:

+ 4. Go to **File** in the toolbar and then select **Sync Project with Gradle Files**.

+4. In the **MainActivity.java** file:

+4. In the **MainActivity.kt** file:

+If you run your application, the map control loads as in the following image.

+Here's an example of Google Maps with the language set to "fr".

+Here's an example of Azure Maps with the language set to "fr-FR".

+Dynamic maps in both Azure Maps and Google Maps can be programmatically moved to new geographic locations by calling the appropriate methods. Let's make the map display satellite aerial imagery, center the map over a location with coordinates, and change the zoom level. For this example, use latitude: 35.0272, longitude: -111.0225, and zoom level of 15.

+With Google Maps, custom images can be used for markers. Load custom images using the marker's `icon` option. To align the point of the image to the coordinate, use the `anchor` option. The anchor is relative to the dimensions of the image. In this case, the anchor is 0.2 units wide, and one unit high.

+> In Azure Maps, it's convenient to render layers below other layers, including base map layers. Also, it's often desirable to render tile layers below the map labels so that they are easy to read. The `map.layers.add` method takes a second parameter which is the id of the layer in which to insert the new layer below. Use the following code to insert a tile layer below the map labels:

+The table provides a high-level list of Azure Maps features, which correspond to Google Maps features. This list doesn't show all Azure Maps features. Additional Azure Maps features include: accessibility, geofencing, isochrones, spatial operations, direct map tile access, batch services, and data coverage comparisons (that is, imagery coverage).

+The following statements apply across all Azure Maps open-source projects and samples:

+ * Once you've ensured that everything is correct in the **Review + create** page, select the **Create** button.

+ * **Minimum SDK**. Select `API 21: Android 5.0.0 (Lollipop)` as the minimum SDK. It's the earliest version supported by the Azure Maps Android SDK.

+1. The **Android Virtual Device Manager** appears. Select **Create Virtual Device**.

+ If the **gradle.properties** file doesn't include `android.useAndroidX` and `android.enableJetifier`, add the next two lines to the end of the file:

+ The map control contains its own lifecycle methods for managing Android's OpenGL lifecycle. These lifecycle methods must be called directly from the containing Activity. To correctly call the map control's lifecycle methods, override the following lifecycle methods in the Activity that contains the map control, then call the respective map control method.

+ The map control contains its own lifecycle methods for managing Android's OpenGL lifecycle. These lifecycle methods must be called directly from the containing Activity. To correctly call the map control's lifecycle methods, override the following lifecycle methods in the Activity that contains the map control. And, you must call the respective map control method.

+Android Studio takes a few seconds to build the application. After the build is complete, you can test your application in the emulated Android device. You should see a map like this one:

+1. With the desired Xcode iOS project selected in the **Project navigator**, select the **+** button to **Add package dependency**.

+1. In the **AppDelegate.swift** file:

+By setting the authentication information on the AzureMaps class globally using the `AzureMaps.configure(subscriptionKey:)` or `AzureMaps.configure(aadClient:aadAppId:aadTenant:)` you won't need to add your authentication information on every view.

+Xcode takes a few seconds to build the application. After the build is complete, you can test your application in the simulated iOS device. You should see a map like this one:

+See the following articles for more code examples:

+### [3.0.0-preview.5](https://www.npmjs.com/package/azure-maps-control/v/3.0.0-preview.5) (March 15, 2023)

+#### Installation (3.0.0-preview.5)

+The preview is available on [npm][3.0.0-preview.5] and CDN.

+- **NPM:** Refer to the instructions at [azure-maps-control@3.0.0-preview.5][3.0.0-preview.5]

+- **CDN:** Reference the following CSS and JavaScript in the `<head>` element of an HTML file:

+ ```html

+ <link href="https://atlas.microsoft.com/sdk/javascript/mapcontrol/3.0.0-preview.5/atlas.min.css" rel="stylesheet" />

+ <script src="https://atlas.microsoft.com/sdk/javascript/mapcontrol/3.0.0-preview.5/atlas.min.js"></script>

+ ```

+#### New features (3.0.0-preview.5)

+- Support dynamically updating mapConfiguration via `map.setServiceOptions({ mapConfiguration: 'MAP_CONFIG' })`

+### [3.0.0-preview.4] (March 10, 2023)

+### [2.2.5](https://www.npmjs.com/package/azure-maps-control/v/2.2.5)

+#### New features (2.2.5)

+- Support dynamically updating mapConfiguration via `map.setServiceOptions({ mapConfiguration: 'MAP_CONFIG' })`

+[Azure Maps Blog]: https://techcommunity.microsoft.com/t5/azure-maps-blog/bg-p/AzureMapsBlog

+Often it's desirable to focus the map over a set of data. A bounding box can be calculated from features using the `MapMath.fromData` method and can be passed into the `bounds` option of the map camera. When setting a map view based on a bounding box, it's often useful to specify a `padding` value to account for the pixel size of points being rendered as bubbles or symbols. The following code shows how to set all optional camera options when using a bounding box to set the position of the camera.

+| `animationDuration(Integer durationMs)` | Specifies how long the camera animates between the views in milliseconds (ms). |

+| `IncidentCategory.cluster` | A cluster of traffic incidents of different categories. Zooming in the map results in the cluster breaking apart into its individual incidents. |

+Azure Maps and GitHub style properties are the two main sets of supported property names. Most property names of the different Azure maps layer options are supported as style properties of features in the simple data layer. Expressions have been added to some layer options to support style property names that are commonly used by GitHub. These property names are defined by [GitHub's GeoJSON map support](https://help.github.com/en/github/managing-files-in-a-repository/mapping-geojson-files-on-github), and they're used to style GeoJSON files that are stored and rendered within the platform. All GitHub's styling properties are supported in the simple data layer, except the `marker-symbol` styling properties.

+To see a live sample of what you're creating in this tutorial, see [Simple Store Locator] on the **Azure Maps Code Samples** site.

+To more easily follow and engage this tutorial, download the following resources:

+* [Simple Store Locator] source code.

+* [Store location data] used to import into the store locator dataset.

+After you finish, *https://docsupdatetracker.net/index.html* should look like _[Simple Store Locator.html]_ in the tutorial sample code.

+* For the completed code, see the [Simple Store Locator tutorial on GitHub].

+[Simple Store Locator tutorial on GitHub]: https://github.com/Azure-Samples/AzureMapsCodeSamples/tree/master/Samples/Tutorials/Simple%20Store%20Locator

+[Simple Store Locator.html]: https://github.com/Azure-Samples/AzureMapsCodeSamples/blob/master/Samples/Tutorials/Simple%20Store%20Locator/Simple%20Store%20Locator.html

+[suggestions as you type]: https://samples.azuremaps.com/?sample=search-autosuggest-and-jquery-ui

+[support for multiple languages]: https://samples.azuremaps.com/?sample=map-localization

+[filter locations along a route]: https://samples.azuremaps.com/?sample=filter-data-along-route

+[set filters]: https://samples.azuremaps.com/?sample=filter-symbols-by-property

+[Store location data]: https://github.com/Azure-Samples/AzureMapsCodeSamples/tree/master/Samples/Tutorials/Simple%20Store%20Locator/data

+1. Complete the [Quickstart: Create an Android app](quick-android-map.md). This tutorial extends the code used in that quickstart.

+Most GeoJSON files wrap all data within a `FeatureCollection`. With this scenario in mind, if the GeoJSON files are loaded into the application as a string, they can be passed into the feature collection's static `fromJson` method, which deserializes the string into a GeoJSON `FeatureCollection` object that can be added to the map.

+10. Run the application. A map is displayed with bubbles overlaid for each location in the GeoJSON file. Tapping on any bubble displays a popup with the name and entity type of the feature touched.

+This tutorial demonstrates how to use the Azure Maps [Route service] and [Map control] to display route directions for both private vehicles and commercial vehicles (trucks) with `USHazmatClass2` cargo type.

+ * The HTML header includes CSS and JavaScript resource files hosted by the Azure Map Control library.

+ * The `GetMap` function contains the inline JavaScript code used to access the Azure Maps API.

+ * [atlas] is the namespace that contains the Azure Maps API and related visual components.

+ * [atlas.Map] provides the control for a visual and interactive web map.

+4. Save the file and open it in your browser. The browser displays a basic map by calling `atlas.Map` using your Azure Maps subscription key.

+ * This code implements the Map control's `ready` event handler. The rest of the code in this tutorial is placed inside the `ready` event handler.

+ * For more traffic options, see [TrafficOptions interface].

+2. Save the **MapTruckRoute.html** file and refresh the page in your browser. If you zoom into any city, like Los Angeles, the streets display with current traffic flow data.

+In this tutorial, two routes are calculated on the map. The first route is calculated for a private vehicle (car). The second route is calculated for a commercial vehicle (truck) to show the difference between the results. When rendered, the map displays a symbol icon for the start and end points of the route, and route line geometries with different colors for each route path. For more information on adding line layers, see [Add a line layer to a map]. To learn more about symbol layers, see [Add a symbol layer to a map].

+ * [Expressions] are used to retrieve the line width and color from properties on the route line feature.

+ Next, a symbol layer is created and attached to the data source. This layer specifies how the start and end points are rendered. Expressions have been added to retrieve the icon image and text label information from properties on each point object. To learn more about expressions, see [Data-driven style expressions].

+ * This code creates two [GeoJSON Point objects] to represent start and end points, which are then added to the data source.

+ * For more information, see the [setCamera] function in the Microsoft technical documentation.

+This section shows you how to use the Azure Maps Route service to get directions from one point to another, based on your mode of transport. Two modes of transport are used: truck and car.

+>The Route service provides APIs to plan *fastest*, *shortest*, *eco*, or *thrilling* routes based on distance, traffic conditions, and mode of transport used. The service also lets users plan future routes based on historical traffic conditions. Users can see the prediction of route durations for any given time. For more information, see [Get Route directions API].

+ * Use [MapControlCredential] to share authentication between a map control and the service module when creating a new [pipeline] object.

+ * The [routeURL] represents a URL to Azure Maps [Route service].

+ //Add the route line to the data source. This should render below the car route which will likely be added to the data source faster, so insert it at index 0.

+ * This code queries the Azure Maps Route service through the [Azure Maps Route Directions API].

+ * The route line is given an index of 0 to ensure that the truck route is rendered before any other lines in the data source. The reason is the truck route calculation are often slower than a car route calculation. If the truck route line is added to the data source after the car route, it will render above it.

+ > To see all possible options and values for the Azure Maps Route Directions API, see [URI Parameters for Post Route Directions].

+ * This code queries the Azure Maps routing service through the [Azure Maps Route Directions API] method.

+* For the completed code used in this tutorial, see the [Truck Route] tutorial on GitHub.

+* To view this sample live, see [Multiple routes by mode of travel] on the **Azure Maps Code Samples** site.

+* You can also use [Data-driven style expressions].

+[Route service]: /rest/api/maps/route

+[Map control]: how-to-use-map-control.md

+[Get Route directions API]: /rest/api/maps/route/getroutedirections

+[routeURL]: /javascript/api/azure-maps-rest/atlas.service.routeurl

+[pipeline]: /javascript/api/azure-maps-rest/atlas.service.pipeline

+[TrafficOptions interface]: /javascript/api/azure-maps-control/atlas.trafficoptions

+[atlas]: /javascript/api/azure-maps-control/atlas

+[atlas.Map]: /javascript/api/azure-maps-control/atlas.map

+[Add a symbol layer to a map]: map-add-pin.md

+[Add a line layer to a map]: map-add-line-layer.md

+[Expressions]: data-driven-style-expressions-web-sdk.md

+[Data-driven style expressions]: data-driven-style-expressions-web-sdk.md

+[GeoJSON Point objects]: https://en.wikipedia.org/wiki/GeoJSON

+[setCamera]: /javascript/api/azure-maps-control/atlas.map#setCamera_CameraOptions___CameraBoundsOptions___AnimationOptions_

+[MapControlCredential]: /javascript/api/azure-maps-rest/atlas.service.mapcontrolcredential

+[Azure Maps Route Directions API]: /javascript/api/azure-maps-rest/atlas.service.routeurl#calculateroutedirections-aborter--geojson-position-calculateroutedirectionsoptions-

+[Truck Route]: https://samples.azuremaps.com/?sample=car-vs-truck-route

+[Multiple routes by mode of travel]: https://samples.azuremaps.com/?sample=multiple-routes-by-mode-of-travel

+[Data-driven style expressions]: data-driven-style-expressions-web-sdk.md

+[URI Parameters for Post Route Directions]: /rest/api/maps/route/postroutedirections#uri-parameters

+ Title: 'Tutorial: How to display route directions using Azure Maps Route service and Map control'

+See the [route tutorial] in GitHub for the source code. See [Route to a destination] for a live sample.

+ * The HTML header includes CSS and JavaScript resource files hosted by the Azure Map Control library.

+ * The `GetMap` function contains the inline JavaScript code used to access the Azure Maps APIs. It's added in the next step.

+4. Save your changes to the file and open the HTML page in a browser. The map shown is the most basic map that you can make by calling `atlas.Map` using your Azure Maps account subscription key.

+ :::image type="content" source="./media/tutorial-route-location/basic-map.png" alt-text="A screenshot showing the most basic map that you can make by calling atlas.Map using your Azure Maps account key.":::

+In this tutorial, you'll render the route using a line layer. The start and end points are rendered using a symbol layer. For more information on adding line layers, see [Add a line layer to a map](map-add-line-layer.md). To learn more about symbol layers, see [Add a symbol layer to a map].

+ * This code implements the Map control's `ready` event handler. The rest of the code in this tutorial are placed inside the `ready` event handler.

+ * To define how the route line is rendered, a line layer is created and attached to the data source. To ensure that the route line doesn't cover up the road labels, we've passed a second parameter with the value of `'labels'`.

+ :::image type="content" source="./media/tutorial-route-location/map-pins.png" alt-text="A screenshot showing a map with a route containing a blue teardrop pin marking the start point at Microsoft in Redmond Washington and a blue round pin marking the end point at a gas station in Seattle.":::

+ * The [routeURL] represents a URL to Azure Maps [Route service API].

+ :::image type="content" source="./media/tutorial-route-location/map-route.png" alt-text="A screenshot showing a map that demonstrates the Azure Map control and Route service.":::

+* For the completed code used in this tutorial, see the [route tutorial] on GitHub.

+[route tutorial]: https://github.com/Azure-Samples/AzureMapsCodeSamples/tree/master/Samples/Tutorials/Route

+> * Retrieve the subscription key for your Maps account

+ * The `GetMap` function contains the inline JavaScript code used to access the Azure Maps APIs. It's added in the next step.

+3. Add the following JavaScript code to the `GetMap` function of the HTML file. Replace the string `<Your Azure Maps Subscription Key>` with the subscription key that you copied from your Azure Maps account.

+ view: 'Auto',

+ subscriptionKey: '<Your Azure Maps Subscription Key>'

+ :::image type="content" source="./media/tutorial-search-location/basic-map.png" alt-text="A screen shot showing the most basic map that you can make by calling atlas.Map using your Azure Maps account key.":::

+This section shows how to use the Maps [Search API] to find a point of interest on your map. It's a RESTful API designed for developers to search for addresses, points of interest, and other geographical information. The Search service assigns a latitude and longitude information to a specified address. The **Service Module** explained next can be used to search for a location using the Maps Search API.

+ * Use [MapControlCredential] to share authentication between a map control and the service module when creating a new [pipeline] object.

+ * The [searchURL] represents a URL to Azure Maps [MapControlCredential].

+2. Next add the following script block just below the previous code just added in the map `ready` event handler. This is the code to build the search query. It uses the [Fuzzy Search service], a basic search API of the Search Service. Fuzzy Search service handles most fuzzy inputs like addresses, places, and points of interest (POI). This code searches for nearby gas stations within the specified radius of the provided latitude and longitude. A GeoJSON feature collection from the response is then extracted using the `geojson.getFeatures()` method and added to the data source, which automatically results in the data being rendered on the maps symbol layer. The last part of this script block sets the maps camera view using the bounding box of the results using the Map's [setCamera] property.

+ // set camera to bounds to<Your Azure Maps Subscription Key> show the results

+ :::image type="content" source="./media/tutorial-search-location/pins-map.png" alt-text="A screen shot showing the map resulting from the search, which is a map showing Seattle with round-blue pins at locations of gas stations.":::

+4. You can see the raw data that the map is rendering by entering the following HTTPRequest in your browser. Replace `<Your Azure Maps Subscription Key>` with your subscription key.

+1. Add the following lines of code in the map `ready` event handler after the code to query the fuzzy search service. This code creates an instance of a Popup and add a mouseover event to the symbol layer.

+ :::image type="content" source="./media/tutorial-search-location/popup-map.png" alt-text="A screen shot of a map with information popups that appear when you hover over a search pin.":::

+* For the completed code used in this tutorial, see the [search tutorial] on GitHub.

+* To view this sample live, see [Search for points of interest] on the **Azure Maps Code Samples** site.

+[manage authentication in Azure Maps]: how-to-manage-authentication.md

+[search tutorial]: https://github.com/Azure-Samples/AzureMapsCodeSamples/tree/master/Samples/Tutorials/Search

+[Search for points of interest]: https://samples.azuremaps.com/?sample=search-for-points-of-interest

+[MapControlCredential]: /javascript/api/azure-maps-rest/atlas.service.mapcontrolcredential

+[pipeline]: /javascript/api/azure-maps-rest/atlas.service.pipeline

+[searchURL]: /javascript/api/azure-maps-rest/atlas.service.searchurl

+[Search API] /rest/api/maps/search

+[Fuzzy Search service]: /rest/api/maps/search/get-search-fuzzy

+[setCamera]: /javascript/api/azure-maps-control/atlas.map#setcamera-cameraoptionscameraboundsoptionsanimationoptions-

+ Heartbeat | where Category == "Azure Monitor Agent" and Computer == "<computer-name>" | take 10

+ # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

+ # logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

+# logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

+# logger.addHandler(AzureLogHandler(connection_string=<appinsights-connection-string>))

+The following configurations are officially supported with Container insights. If you have a different version of Kubernetes and operating system versions, please open a support ticket..

+You can analyze the amount of billable data collected from a virtual machine or a set of virtual machines. The **Usage** table doesn't have the granularity to show data volumes for specific virtual machines, so these queries use the [find operator](/azure/data-explorer/kusto/query/findoperator) to search all tables that include a computer name. The **Usage** type is omitted because this query is only for analytics of data trends.

+# Configure Virtual WAN for Azure NetApp Files (preview)

+- Lambda expression can only be specified directly as function arguments in these functions: [`filter()`](#filter), [`map()`](#map), [`reduce()`](#reduce), [`sort()`](#sort), and [`toObject()`](#toobject).

+> VMware HCX Mobility Optimized Networking is officially supported by VMware and Azure VMware Solutions from HCX version 4.1.0.

+>VMware HCX Mobility Optimized Networking (MON) is not supported with the use of a 3rd party gateway. It may only be used with the T1 gateway directly connected to the T0 gateway with no network virtual appliance (NVA). You may be able to make this configuration function, but we do not support it.

+>Special consideration for using MON in Azure VMware Solution is to give the /32 routes advertised over BGP to its peers; this includes on-premises and Azure over the ExpressRoute connection. For example, a VM in Azure learns the path to an Azure VMware Solution VM on an Azure VMware Solution MON enabled segment. Once the return traffic is sent back to the T0 gateway as expected, if the return subnet is an RFC1918 match, traffic is forced over the NE instead of the T0. Then egresses over the ExpressRoute back to Azure on the on-premises side. This can cause confusion for stateful firewalls in the middle and asymmetric routing behavior. It's also a good idea to determine how VMs on NE MON segments will need to access the internet, either via the T0 in Azure VMware Solution or only through the NE back to on-premises. In general, all of the default policy routes should be removed to avoid asymmetric traffic. Only enable policy routes if the network infrastructure as been configured in such a way to account for and prevent asymmetric traffic.

+- Supports *Multiple Backups Per Day*.

+3. Select **+Add**.

+ >[!Note]

+ >The maximum limit of instant recovery point retention range depends on the number of snapshots you take per day. If the snapshot count is more (for example, every *4 hours* frequency in *24 hours* duration - *6* scheduled snapshots), then the maximum allowed days for retention reduces.

+ >

+ >However, if you choose lower RPO of *12 hours*, the snapshot retention is increased to *30 days*.

+6. Select **Create**.

+> [!Note]

+> Azure Backup now enables you to back up your Azure VMs multiple times a day using the Enhanced policy. With this capability, you can also define the duration in which your backup jobs would trigger and align your backup schedule with the working hours when there are frequent updates to Azure Virtual Machines. [Learn more](backup-azure-vms-enhanced-policy.md).

+Do multiple backups per day | Supported through **Enhanced policy**. <br><br> For hourly backup, the minimum recovery point objective (RPO) is 4 hours and the maximum is 24 hours. You can set the backup schedule to 4, 6, 8, 12, and 24 hours, respectively. <br><br> Note that the maximum limit of instant recovery point retention range depends on the number of snapshots you take per day. If the snapshot count is more (for example, every *4 hours* frequency in *24 hours* duration - *6* scheduled snapshots), then the maximum allowed days for retention reduces. However, if you choose lower RPO of *12* hours, the snapshot retention is increased to *30 days*. <br><br> Learn about how to [back up an Azure VM using Enhanced policy](backup-azure-vms-enhanced-policy.md).

+[Restore Virtual Machine Scale Sets](../virtual-machine-scale-sets/virtual-machine-scale-sets-orchestration-modes.md#scale-sets-with-flexible-orchestration) | Supported for the flexible orchestration model to back up and restore a single Azure VM.

+- The Backup traffic from servers to the Recovery Services vault is encrypted via Advanced Encryption Standard 256.

+> [!Note]

+> With Enhanced policy, you can now back up Azure VMs multiple times a day that helps to perform hourly backups. [Learn more](backup-azure-vms-enhanced-policy.md).

+> [!Note]

+> You can also set Enhanced policy to back up Azure VMs multiple times a day. Learn about [Enhanced policy](backup-azure-vms-enhanced-policy.md). 

+ - [Multiple backups per day for Azure VMs is now generally available](#multiple-backups-per-day-for-azure-vms-is-now-generally-available)

+## Multiple backups per day for Azure VMs is now generally available

+Azure Backup now enables you to create a backup policy to take multiple backups a day. With this capability, you can also define the duration in which your backup jobs would trigger and align your backup schedule with the working hours when there are frequent updates to Azure Virtual Machines. For more information, see [Back up an Azure VM using Enhanced policy](backup-azure-vms-enhanced-policy.md).

+For the Service Bus managed connector, the maximum message size is limited to 1 MB, even when you use a premium tier Service Bus namespace.

+Each container app issues its own unique cookie or token for authentication. A client cannot use the same cookie or token provided by one container app to authenticate with another container app, even within the same container app environment.

+ Title: Choose between RU-based and vCore-based models

+description: Choose whether the RU-based or vCore-based option for Azure Cosmos DB for MongoDB is ideal for your workload.

+# What is RU-based and vCore-based Azure Cosmos DB for MongoDB?

+Azure Cosmos DB is a fully managed NoSQL and relational database for modern app development.

+Both, the Request Unit (RU) and vCore-based Azure Cosmos DB for MongoDB offering make it easy to use Azure Cosmos DB as if it were a MongoDB database. Both options work without the overhead of complex management and scaling approaches. You can use your existing MongoDB skills and continue to use your favorite MongoDB drivers, SDKs, and tools by pointing your application to the connection string for your account using the API for MongoDB. Additionally, both are cloud-native offerings that can be integrated seamlessly with other Azure services to build enterprise-grade modern applications.

+## Choosing between RU-based and vCore-based options

+Here are a few key factors to help you decide which is the right architecture for you:

+| Factor | RU-based | vCore-based |

+| -- | -- | -|

+| What do you want to do | &bull; Works well if you're trying to build new cloud-native MongoDB apps or refactor existing apps for all the benefits of a cloud-native offering | &bull; Works well if you're trying to lift and shift existing MongoDB apps and run them as-is on a fully supported managed service. |

+| What are your availability needs | &bull; Offers upto [99.999%](../high-availability.md#slas) of availability with multi-region deployments | &bull; Offers competitive SLA (once generally available) |

+| How do you want to scale | &bull; Offers limitless horizontal scalability, instantaneous scale up and granular throughput control. | &bull; Offers high-capacity vertical and horizontal scaling with familiar vCore-based cluster tier options to choose from. |

+| What are your top read & query patterns | &bull; Works well for workloads with more point reads *(fetching a single item by its ID and shard key value)* and lesser long running queries and complex aggregation pipeline operations. | &bull; Works irrespective of the operation types in your workload. Operations may include workloads with long-running queries, complex aggregation pipelines, distributed transactions, joins, etc. |

+## Resource and billing differences between the options

+There are differences between the offerings in the way the resources are assigned and billed on the platform:

+| Resource details | RU-based | vCore-based |

+| -- | -- | -|

+| How are the resources assigned | &bull; This option is a multi-tenant service that instantly assigns resources to the workload to meet its storage and throughput needs. <br/>&bull; Throughput uses the concept of [Request Units (RUs)](../request-units.md). | &bull; This option provides dedicated instances using preset CPU, memory and storage resources that scale to meet your needs. |

+| How are the resources billed | &bull; You pay variable fees for the RUs and consumed storage. <br/>&bull; RU charges are based on the choice of the model: provisioned throughput (standard or autoscale) or serverless. | &bull; You pay consistent flat fee based on the compute (CPU, memory and the number of nodes) and storage. |

+## Next steps

+- [Create a Go app](quickstart-go.md) using Azure Cosmos DB for MongoDB.

+- Deploy Azure Cosmos DB for MongoDB vCore [using a Bicep template](vcore/quickstart-bicep.md).

+ Title: Compatibility and feature support

+description: Review Azure Cosmos DB for MongoDB vCore supported features and syntax including; commands, query support, datatypes, aggregation, and operators.

+# MongoDB compatibility and feature support with Azure Cosmos DB for MongoDB vCore

+Azure Cosmos DB is Microsoft's fully managed NoSQL and relational database, offering [multiple database APIs](../../choose-api.md). You can communicate with Azure Cosmos DB for MongoDB using the MongoDB drivers, SDKs and tools you're already familiar with. Azure Cosmos DB for MongoDB enables the use of existing client drivers by adhering to the MongoDB wire protocol.

+By using the Azure Cosmos DB for MongoDB, you can enjoy the benefits of the MongoDB you're used to, with all of the enterprise capabilities that Azure Cosmos DB provides.

+## Protocol Support

+The supported operators and any limitations or exceptions are listed here. Any client driver that understands these protocols should be able to connect to Azure Cosmos DB for MongoDB. When you create Azure Cosmos DB for MongoDB vCore clusters, the endpoint is in the format `*.mongocluster.cosmos.azure.com`.

+> [!NOTE]

+> This article only lists the supported server commands, and excludes client-side wrapper functions. Client-side wrapper functions such as `deleteMany()` and `updateMany()` internally utilize the `delete()` and `update()` server commands. Functions utilizing supported server commands are compatible with the Azure Cosmos DB for MongoDB.

+## Query language support

+Azure Cosmos DB for MongoDB provides comprehensive support for MongoDB query language constructs. Below you can find the detailed list of currently supported operations, operators, stages, commands, and options.

+## Database commands

+Azure Cosmos DB for MongoDB vCore supports the following database commands:

+### Query and write operation commands

+| Command | Supported |

+|||

+| `change streams` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `delete` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `find` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `findAndModify` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `getLastError` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getMore` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Partial |

+| `insert` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `resetError` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `update` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Session commands

+| Command | Supported |

+|||

+| `abortTransaction` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `commitTransaction` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `endSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `killAllSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `killAllSessionsByPattern` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `killSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `refreshSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `startSession` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Authentication commands

+| Command | Supported |

+|||

+| `authenticate` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getnonce` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `logout` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Geospatial command

+| Command | Supported |

+|||

+| `geoSearch` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Query Plan Cache commands

+| Command | Supported |

+|||

+| `planCacheClear` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `planCacheClearFilters` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `planCacheListFilters` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `planCacheSetFilter` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Administration commands

+| Command | Supported |

+|||

+| `cloneCollectionAsCapped` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `collMod` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Partial |

+| `compact` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `connPoolSync` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `convertToCapped` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `create` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Partial |

+| `createIndexes` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `currentOp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `drop` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `dropDatabase` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `dropConnections` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dropIndexes` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `filemd5` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `fsync` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `fsyncUnlock` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getDefaultRWConcern` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getClusterParameter` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getParameter` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `killCursors` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `killOp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `listCollections` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `listDatabases` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `listIndexes` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `logRotate` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `reIndex` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `renameCollection` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `rotateCertificates` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `setFeatureCompatibilityVersion` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `setIndexCommitQuorum` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `setParameter` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `setDefaultRWConcern` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `shutdown` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### User Management commands

+| Command | Supported |

+|||

+| `createUser` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dropAllUsersFromDatabase` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dropUser` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `grantRolesToUser` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `revokeRolesFromUser` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `updateUser` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `usersInfo` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Role Management commands

+| Command | Supported |

+|||

+| `createRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dropRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dropAllRolesFromDatabase` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `grantPrivilegesToRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `grantRolesToRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `invalidateUserCache` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `revokePrivilegesFromRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `revokeRolesFromRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `rolesInfo` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `updateRole` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Replication commands

+| Command | Supported |

+|||

+| `applyOps` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `hello` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `replSetAbortPrimaryCatchUp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetFreeze` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetGetConfig` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetGetStatus` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetInitiate` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetMaintenance` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetReconfig` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetResizeOplog` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetStepDown` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `replSetSyncFrom` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Sharding commands

+| Command | Supported |

+|||

+| `abortReshardCollection` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `addShard` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `addShardToZone` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `balancerCollectionStatus` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `balancerStart` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `balancerStatus` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `balancerStop` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `checkShardingIndex` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `clearJumboFlag` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `cleanupOrphaned` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `cleanupReshardCollection` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `commitReshardCollection` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `configureCollectionBalancing` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `enableSharding` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `flushRouterConfig` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getShardMap` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getShardVersion` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `isdbgrid` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `listShards` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `medianKey` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `moveChunk` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `movePrimary` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `mergeChunks` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `refineCollectionShardKey` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `removeShard` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `removeShardFromZone` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `reshardCollection` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `setShardVersion` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `shardCollection` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `shardingState` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `split` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `splitVector` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `unsetSharding` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `updateZoneKeyRange` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Diagnostics commands

+| Command | Supported |

+|||

+| `availableQueryOptions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `buildInfo`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `collStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `connPoolStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `connectionStatus` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Partial |

+| `cursorInfo` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dataSize` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dbHash` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `dbStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `driverOIDTest` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `explain`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `features` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getCmdLineOpts` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `getLog`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `hostInfo` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Partial |

+| `_isSelf` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `listCommands` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `lockInfo` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `netstat` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `ping`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `profile` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `serverStatus` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `shardConnPoolStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `top` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `validate`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `whatsmyuri`| :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Free Monitoring Commands

+| Command | Supported |

+|||

+| `getFreeMonitoringStatus` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `setFreeMonitoring` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Auditing command

+| Command | Supported |

+|||

+| `logApplicationMessage` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+## Aggregation pipeline

+Azure Cosmos DB for MongoDB vCore supports the following aggregation pipeline features:

+### Aggregation commands

+| Command | Supported |

+|||

+| `aggregate` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `count` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `distinct` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `mapReduce` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Aggregation stages

+| Command | Supported |

+|||

+| `$addFields` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$bucket` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$bucketAuto` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$changeStream` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$count` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$currentOp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$facet` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$geoNear` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$graphLookup` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$group` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$indexStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$limit` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$listLocalSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$listSessions` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$lookup` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$match` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$merge` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$out` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$planCacheStats` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$project` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$redact` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexFind` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexFindAll` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexMatch` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$replaceRoot` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$replaceWith` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sample` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$set` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$skip` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sort` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sortByCount` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$unset` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$unwind` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+> [!NOTE]

+> The `$lookup` aggregation does not yet support using variable expressions using 'let'.

+### Boolean expressions

+| Command | Supported |

+|||

+| `and` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `not` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `or` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Type expressions

+| Command | Supported |

+|||

+| `$type` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toLong` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toString` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$convert` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toDate` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toDecimal` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toObjectId` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toDouble` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toBool` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toInt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$isNumber` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Set expressions

+| Command | Supported |

+|||

+| `$anyElementTrue` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setUnion` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$allElementsTrue` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setIntersection` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setDifference` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setEquals` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setIsSubset` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Comparison expressions

+| Command | Supported |

+|||

+| `$ne` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lte` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$gt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$gte` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$eq` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$cmp` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Custom Aggregation expressions

+| Command | Supported |

+|||

+| `$accumulator` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$function` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Data size Operators

+| Command | Supported |

+|||

+| `$binarySize` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$bsonSize` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Arithmetic expressions

+| Command | Supported |

+|||

+| `$add` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$multiply` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$subtract` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$divide` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$ceil` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$floor` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$trunc` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$abs` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$mod` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$pow` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sqrt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$exp` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$ln` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$log` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$log10` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$round` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Timestamp expressions

+| Command | Supported |

+|||

+| `$tsIncrement` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$tsSecond` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Trigonometry expressions

+| Command | Supported |

+|||

+| `$sin` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$cos` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$tan` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$asin` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$acos` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$atan` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$atan2` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$asinh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$acosh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$atanh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$sinh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$cosh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$tanh` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$degreesToRadians` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$radiansToDegrees` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### String expressions

+| Command | Supported |

+|||

+| `$concat` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateToString` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toLower` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$toString` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$substr` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$split` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$strLenCP` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$toUpper` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$indexOfCP` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$substrCP` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$ltrim` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$substrBytes` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$indexOfBytes` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$trim` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$strLenBytes` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateFromString` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexFind` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexFindAll` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$regexMatch` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$replaceOne` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$replaceAll` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$rtrim` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$strcasecmp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Text expression Operator

+| Command | Supported |

+|||

+| `$meta` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Array expressions

+| Command | Supported |

+|||

+| `$in` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$size` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$arrayElemAt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$slice` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$filter` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$map` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$objectToArray` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$arrayToObject` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$reduce` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$indexOfArray` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$concatArrays` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$isArray` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$zip` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$reverseArray` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$range` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$first` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$firstN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$last` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lastN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$maxN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$minN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$sortArray` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Variable operator

+| Command | Supported |

+|||

+| `$let` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### System variables

+| Command | Supported |

+|||

+| `$$CLUSTERTIME` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$CURRENT` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$DESCEND` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$KEEP` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$NOW` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$PRUNE` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$REMOVE` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$$ROOT` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Window operators

+| Command | Supported |

+|||

+| `$sum` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$push` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$addToSet` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$count` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$max` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$min` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$avg` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevPop` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$bottom` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$bottomN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$covariancePop` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$covarianceSamp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$denseRank` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$derivative` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$documentNumber` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$expMovingAvg` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$first` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$integral` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$last` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$linearFill` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$locf` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$minN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$rank` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$shift` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevSamp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$top` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$topN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Literal operator

+| Command | Supported |

+|||

+| `$literal` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Date expressions

+| Command | Supported |

+|||

+| `$dateToString` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$month` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$year` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$hour` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$minute` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$second` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$dayOfMonth` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$week` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$millisecond` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$toDate` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$dateToParts` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$dayOfWeek` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$dayOfYear` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$isoWeek` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$isoWeekYear` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$isoDayOfWeek` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$dateAdd` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateDiff` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateFromParts` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateFromString` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateSubtract` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$dateTrunc` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Conditional expressions

+| Command | Supported |

+|||

+| `$cond` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$ifNull` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$switch` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Accumulator expressions

+| Command | Supported |

+|||

+| `$accumulator` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$addToSet` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$avg` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$bottom` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$bottomN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$count` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$first` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$firstN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$last` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lastN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$max` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$maxN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$mergeObjects` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$min` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$push` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevPop` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevSamp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$sum` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$top` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$topN` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevPop` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$stdDevSamp` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$sum` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Miscellaneous operators

+| Command | Supported |

+|||

+| `$getField` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$rand` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sampleRate` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Object expressions

+| Command | Supported |

+|||

+| `$mergeObjects` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$objectToArray` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$setField` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+## Data types

+Azure Cosmos DB for MongoDB supports documents encoded in MongoDB BSON format.

+| Command | Supported |

+|||

+| `Double` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `String` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Object` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Array` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Binary Data` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `ObjectId` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Boolean` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Date` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Null` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `32-bit Integer (int)` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Timestamp` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `64-bit Integer (long)` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `MinKey` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `MaxKey` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Decimal128` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Regular Expression` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `JavaScript` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `JavaScript (with scope)` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Undefined` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+## Indexes and index properties

+Azure Cosmos DB for MongoDB vCore supports the following indexes and index properties:

+### Indexes

+| Command | Supported |

+|||

+| `Single Field Index` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Compound Index` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Multikey Index` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Text Index` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `Geospatial Index` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `Hashed Index` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Index properties

+| Command | Supported |

+|||

+| `TTL` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Unique` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Partial` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Case Insensitive` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `Sparse` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `Background` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+## Operators

+Azure Cosmos DB for MongoDB vCore supports the following operators:

+### Comparison Query operators

+| Command | Supported |

+|||

+| `$eq` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$gt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$gte` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$in` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lt` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$lte` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$ne` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$nin` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Logical operators

+| Command | Supported |

+|||

+| `$or` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$and` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$not` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$nor` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Element operators

+| Command | Supported |

+|||

+| `$exists` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$type` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Evaluation query operators

+| Command | Supported |

+|||

+| `$expr` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$jsonSchema` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$mod` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$regex` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$text` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$where` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Array operators

+| Command | Supported |

+|||

+| `$all` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$elemMatch` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$size` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Bitwise Query operators

+| Command | Supported |

+|||

+| `$bitsAllClear` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$bitsAllSet` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$bitsAnyClear` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$bitsAnySet` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Miscellaneous operators

+| Command | Supported |

+|||

+| `$comment` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$rand` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$natural` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+### Projection operators

+| Command | Supported |

+|||

+| `$` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$elemMatch` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$slice` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Update operators

+Azure Cosmos DB for MongoDB vCore supports the following update operators:

+#### Field update operators

+| Command | Supported |

+|||

+| `$currentDate` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$inc` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$min` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$max` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$mul` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$rename` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$set` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$setOnInsert` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$unset` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+#### Array update operators

+| Command | Supported |

+|||

+| `$` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$[]` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$[<identifier>]` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$addToSet` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$pop` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$pull` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$push` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$pullAll` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+#### Update modifiers

+| Command | Supported |

+|||

+| `$each` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$position` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$slice` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+| `$sort` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+#### Bitwise update operator

+| Command | Supported |

+|||

+| `$bit` | :::image type="icon" source="media/compatibility/yes-icon.svg"::: Yes |

+### Geospatial operators

+| Operator | Supported |

+| | |

+| `$geoIntersects` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$geoWithin` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$near` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$nearSphere` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$box` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$center` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$centerSphere` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$geometry` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$maxDistance` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$minDistance` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$polygon` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+| `$uniqueDocs` | :::image type="icon" source="media/compatibility/no-icon.svg"::: No |

+## Next steps

+> [!div class="nextstepaction"]

+> [Migration options for Azure Cosmos DB for MongoDB vCore](migration-options.md)

+ Title: High availability and replication

+description: Review replication and high availability concepts in the context of Azure Cosmos DB for MongoDB vCore.

+# High availability in Azure Cosmos DB for MongoDB vCore

+High availability (HA) avoids database downtime by maintaining standby replicas of every node in a cluster. If a node goes down, Azure Cosmos DB for MongoDB vCore switches incoming connections from the failed node to its standby replica.

+## How it works

+When HA is enabled, Azure Cosmos DB for MongoDB vCore runs one replica node for each primary node in the cluster. The primary and its replica use synchronous replication. The service detects failures on primary nodes and fails over to the replica nodes with zero data loss. The MongoDB connection string remains the same.

+When HA is enabled, HA replica nodes are provisioned in a different availability zone from their primary nodes, if the region supports multiple zones and has available capacity. HA replicas don't receive requests from clients unless their primary node fails.

+Even without HA enabled, each node has its own locally redundant storage (LRS) with three synchronous replicas maintained by Azure Storage service. If there's a single replica failure, the Azure Storage service detects the failure, and transparently re-creates the relevant data. For LRS storage durability, see metrics on [this page](../../../storage/common/storage-redundancy.md#summary-of-redundancy-options).

+## Configure high availability

+High availability (HA) can be specified when [creating a cluster](quickstart-portal.md) or in the [**Scale** section of an existing cluster](how-to-scale-cluster.md) in the Azure portal.

+## Next steps

+> [!div class="nextstepaction"]

+> [Scale a cluster in Azure Cosmos DB for MongoDB vCore](how-to-scale-cluster.md)

+ Title: Restore a cluster backup

+description: Restore an Azure Cosmos DB for MongoDB vCore cluster from a point in time encrypted backup snapshot.

+# Restore a cluster in Azure Cosmos DB for MongoDB vCore

+Azure Cosmos DB for MongoDB vCore provides automatic backups that enable point-in-time recovery (PITR) without any action required from users. Backups allow customers to restore a server to any point in time within the retention period.

+> [!IMPORTANT]

+> During the preview phase, backups are free of charge.

+> [!NOTE]

+> The backup and restore feature is designed to protect against data loss, but it doesn't provide a complete disaster recovery solution. You should ensure that alaredy have your own disaster recovery plan in place to protect against larger scale outages.

+## Prerequisites

+- An existing Azure Cosmos DB for MongoDB vCore cluster.

+ - If you don't have an Azure subscription, [create an account for free](https://azure.microsoft.com/free).

+ - If you have an existing Azure subscription, [create a new Azure Cosmos DB for MongoDB vCore cluster](quickstart-portal.md).

+## Backups

+Backups are **performed automatically** in the background. Backups are retained for 35 days for active clusters and 7 days for deleted clusters. All backups are encrypted using AES 256-bit encryption.

+> [!NOTE]

+> Backup files can't be exported. They may only be used for restore operations in Azure Cosmos DB for MongoDB vCore.

+In Azure regions that support availability zones, backup snapshots are stored in three availability zones. As long as at least one availability zone is online, the cluster is restorable.

+## Restore from a backup

+The restore process creates a new cluster with the same configuration in the same Azure region, subscription, and resource group as the original. To restore data, customers must create an Azure support request.

+1. Sign in to the [Azure portal](https://portal.azure.com).

+1. Navigate to the **Help + support** section and select **Create a support request**. For more information, see [create an Azure support request](../../../azure-portal/supportability/how-to-create-azure-support-request.md#go-to-help--support-from-the-global-header).

+1. Once the support ticket is submitted, our team guides you through the process of restoring your data from the backup.

+## Next steps

+In this guide, we've covered the backup and restore features for Azure Cosmos DB for MongoDB vCore.

+> [!div class="nextstepaction"]

+> [Review security concepts](security.md)

+ Title: Scale or configure a cluster

+description: Scale an Azure Cosmos DB for MongoDB vCore cluster by changing the tier and disk size or change the configuration by enabling high availability.

+# Scaling and configuring Your Azure Cosmos DB for MongoDB vCore cluster

+Azure Cosmos DB for MongoDB vCore provides seamless scalability and high availability. This document serves as a quick guide for developers who want to learn how to scale and configure their clusters. When changes are made, they're performed live to the cluster without downtime.

+## Prerequisites

+- An existing Azure Cosmos DB for MongoDB vCore cluster.

+ - If you don't have an Azure subscription, [create an account for free](https://azure.microsoft.com/free).

+ - If you have an existing Azure subscription, [create a new Azure Cosmos DB for MongoDB vCore cluster](quickstart-portal.md).

+## Navigate to the scale section

+To change the configuration of your cluster, use the **Scale** section of the Azure Cosmos DB for MongoDB vCore cluster page in the Azure portal. The portal includes real-time costs for these changes.

+> [!TIP]

+> For this guide, we recommend using the resource group name ``msdocs-cosmos-howto-rg``.

+1. Sign in to the [Azure portal](https://portal.azure.com).

+1. Navigate to the existing Azure Cosmos DB for MongoDB vCore cluster page.

+1. From the Azure Cosmos DB for MongoDB vCore cluster page, select the **Scale** navigation menu option.

+ :::image type="content" source="media/how-to-scale-cluster/select-scale-option.png" lightbox="media/how-to-scale-cluster/select-scale-option.png" alt-text="Screenshot of the Scale option on the page for an Azure Cosmos DB for MongoDB vCore cluster.":::

+## Change the cluster tier

+The cluster tier you select influences the amount of vCores and RAM assigned to your cluster. You can change the cluster tier to suit your needs at any time without downtime. For example, you can increase from **M50** to **M60** or decrease **M50** to **M40** using the Azure portal.

+1. To change the cluster tier, select the new tier from the drop-down menu.

+ :::image type="content" source="media/how-to-scale-cluster/configure-tier.png" alt-text="Screenshot of the cluster tier option in the Scale page of a cluster.":::

+ > [!NOTE]

+ > This change is performed live to the cluster without downtime.

+1. Select **Save** to persist your change.

+## Increase disk size

+You can increase the storage size to give your database more room to grow. For example, you can increase the storage from **128 GB** to **256 GB**.

+1. To increase the storage size, select the new size from the drop-down menu.

+ :::image type="content" source="media/how-to-scale-cluster/configure-storage.png" alt-text="Screenshot of the storage per node option in the Scale page of a cluster.":::

+ > [!NOTE]

+ > This change is performed live to the cluster without downtime. Also, storage size can only be increased, not decreased.

+1. Select **Save** to persist your change.

+## Enable or disable high availability

+You can enable or disable high availability (HA) to suit your needs. HA avoids database downtime by maintaining replica nodes of every primary node in a cluster. If a primary node goes down, incoming connections are automatically redirected to its replica node, ensuring that there's minimal downtime.

+1. To enable or disable HA, toggle the checkbox option.

+ :::image type="content" source="media/how-to-scale-cluster/configure-high-availability.png" alt-text="Screenshot of the high availability checkbox in the Scale page of a cluster.":::

+1. Select **Save** to persist your change.

+## Next steps

+In this guide, we've shown that scaling and configuring your Cosmos DB for MongoDB vCore cluster in the Azure portal is a straightforward process. The Azure portal includes the ability to adjust the cluster tier, increase storage size, and enable or disable high availability without any downtime.

+> [!div class="nextstepaction"]

+> [Restore a Azure Cosmos DB for MongoDB vCore cluster](how-to-restore-cluster.md)

+ Title: Introduction/Overview

+description: Learn about Azure Cosmos DB for MongoDB vCore, a fully managed MongoDB-compatible database for building modern applications with a familiar architecture.

+# What is Azure Cosmos DB for MongoDB vCore?

+Azure Cosmos DB for MongoDB vCore provides developers with a fully managed MongoDB-compatible database service for building modern applications with a familiar architecture. With Cosmos DB for MongoDB vCore, developers can enjoy the benefits of native Azure integrations, low total cost of ownership (TCO), and the familiar vCore architecture when migrating existing applications or building new ones.

+## Effortless integration with the Azure platform

+Azure Cosmos DB for MongoDB vCore provides a comprehensive and integrated solution for resource management, making it easy for developers to seamlessly manage their resources using familiar Azure tools. The service features deep integration into various Azure products, such as Azure Monitor and Azure CLI. This deep integration ensures that developers have everything they need to work efficiently and effectively.

+Developers can rest easy knowing that they have access to one unified support team for all their services, eliminating the need to juggle multiple support teams for different services.

+## Low total cost of ownership (TCO)

+Azure Cosmos DB for MongoDB's scalable architecture is designed to deliver the best performance and cost efficiency for your workloads. Visit the [pricing page](https://azure.microsoft.com/pricing/details/cosmos-db/) to learn more about pricing for each cluster tier or price out a cluster in the Azure portal. With optional high availability (HA), there's no need to pay for resources you don't need for workloads such as development and testing. With HA disabled, cost savings are passed on to you in the form of a reduced per-hour cost.

+Here are the current tiers for the service:

+| Cluster tier | Base storage | RAM | vCPUs |

+| | | | |

+| M30 | 128 GB | 8 GB | 2 |

+| M40 | 128 GB | 16 GB | 4 |

+| M50 | 128 GB | 32 GB | 8 |

+| M60 | 128 GB | 64 GB | 16 |

+| M80 | 128 GB | 128 GB | 32 |

+Azure Cosmos DB for MongoDB vCore is organized into easy to understand cluster tiers based on vCPUs, RAM, and attached storage. These tiers make it easy to lift and shift your existing workloads or build new applications.

+## Flexibility for developers

+Cosmos DB for MongoDB vCore is built with flexibility for developers in mind. The service offers high capacity vertical and horizontal scaling with no shard key required until the database surpasses TBs. The service also supports automatically sharding existing databases with no downtime. Developers can easily scale their clusters up or down, vertically and horizontally, all with no downtime, to meet their needs.

+## Next steps

+- Read more about [feature compatibility with MongoDB](compatibility.md).

+- Review options for [migrating from MongoDB to Azure Cosmos DB for MongoDB vCore](migration-options.md)

+- Get started by [creating an account](quickstart-portal.md).

+ Title: Migrate data from MongoDB

+description: Learn about the various options to migrate your data from other MongoDB sources to Azure Cosmos DB for MongoDB vCore.

+# Options for migrating data to Azure Cosmos DB for MongoDB vCore

+This document describes the various options to lift and shift your MongoDB workloads to Azure Cosmos DB for MongoDB vCore-based offering.

+## Native MongoDB tools (Offline)

+- You can use the native MongoDB tools such as *mongodump/mongorestore*, *mongoexport/mongoimport* to migrate datasets offline (without replicating live changes) to Azure Cosmos DB for MongoDB vCore-based offering.

+- *mongodump/mongorestore* works well for migrating your entire MongoDB database. The compact BSON format makes more efficient use of network resources as the data is inserted into Azure Cosmos DB.

+ - *mongodump* exports your existing data as a BSON file.

+ - *mongorestore* imports your BSON file dump into Azure Cosmos DB.

+- *mongoexport/mongoimport* works well for migrating a subset of your MongoDB database.

+ - *mongoexport* exports your existing data to a human-readable JSON or CSV file.

+ - *mongoexport* takes an argument specifying the subset of your existing data to export.

+ - *mongoimport* opens a JSON or CSV file and inserts the content into the target database instance (Azure Cosmos DB in this case.).

+ - Since JSON and CSV aren't compact formats, you may incur excess network charges as *mongoimport* sends data to Azure Cosmos DB.

+- Here's how you can [migrate data to Azure Cosmos DB for MongoDB vCore using the native MongoDB tools](../tutorial-mongotools-cosmos-db.md#perform-the-migration).

+## Data migration using Azure Databricks (Offline/Online)

+- This method offers full control of the migration rate and data transformation. It can also support large datasets that are in TBs in size.

+- [Azure Databricks](https://azure.microsoft.com/services/databricks/) is a platform as a service (PaaS) offering for [Apache Spark](https://spark.apache.org/). You can use Azure Databricks to do an offline/online migration of databases from MongoDB to Azure Cosmos DB for MongoDB.

+- Here's how you can [migrate data to Azure Cosmos DB for MongoDB vCore offline using Azure Databricks](../migrate-databricks.md#provision-an-azure-databricks-cluster)

+## Next steps

+- Migrate data to Azure Cosmos DB for MongoDB vCore [using native MongoDB tools](../tutorial-mongotools-cosmos-db.md).

+- Migrate data to Azure Cosmos DB for MongoDB vCore [using Azure Databricks](../migrate-databricks.md).

+ Title: |

+ Quickstart: Deploy a cluster by using a Bicep template

+description: In this quickstart, create a new Azure Cosmos DB for MongoDB vCore cluster to store databases, collections, and documents by using a Bicep template.

+# Quickstart: Create an Azure Cosmos DB for MongoDB vCore cluster by using a Bicep template

+In this quickstart, you create a new Azure Cosmos DB for MongoDB vCore cluster. This cluster contains all of your MongoDB resources: databases, collections, and documents. The cluster provides a unique endpoint for various tools and SDKs to connect to Azure Cosmos DB and perform everyday operations.

+## Prerequisites

+- An Azure account with an active subscription. [Create an account for free](https://azure.microsoft.com/free).

+## Review the Bicep file

+The Bicep file used in this quickstart is from [Azure Quickstart Templates](/samples/azure/azure-quickstart-templates/cosmosdb-free/).

+```bicep

+@description('Azure Cosmos DB MongoDB vCore cluster name')

+@maxLength(44)

+param clusterName string = 'msdocs-${uniqueString(resourceGroup().id)}'

+@description('Location for the cluster.')

+param location string = resourceGroup().location

+@description('Username for admin user')

+param adminUsername string

+@secure()

+@description('Password for admin user')

+@minLength(8)

+@maxLength(128)

+param adminPassword string

+resource cluster 'Microsoft.DocumentDB/mongoClusters@2022-10-15-preview' = {

+ name: clusterName

+ location: location

+ properties: {

+ administratorLogin: adminUsername

+ administratorLoginPassword: adminPassword

+ nodeGroupSpecs: [

+ {

+ kind: 'Shard'

+ nodeCount: 1

+ sku: 'M40'

+ diskSizeGB: 128

+ enableHa: false

+ }

+ ]

+ }

+}

+resource firewallRules 'Microsoft.DocumentDB/mongoClusters/firewallRules@2022-10-15-preview' = {

+ parent: cluster

+ name: 'AllowAllAzureServices'

+ properties: {

+ startIpAddress: '0.0.0.0'

+ endIpAddress: '0.0.0.0'

+ }

+}

+```

+Two Azure resources are defined in the Bicep file:

+- [`Microsoft.DocumentDB/databaseAccounts`](/azure/templates/microsoft.documentdb/databaseAccounts?pivots=deployment-language-bicep): Creates an Azure Cosmos DB for MongoDB vCore cluster.

+ - [`Microsoft.DocumentDB/databaseAccounts/sqlDatabases`](/azure/templates/microsoft.documentdb/databaseAccounts?pivots=deployment-language-bicep): Creates firewall rules for the Azure Cosmos DB for MongoDB vCore cluster.

+## Deploy the Bicep file

+Create an Azure Cosmos DB for MongoDB vCore cluster by using the Bicep template.

+### [Azure CLI](#tab/azure-cli)

+1. Create shell variables for *resourceGroupName*, and *location*

+ ```azurecli

+ # Variable for resource group name and location

+ resourceGroupName="msdocs-cosmos-quickstart-rg"

+ location="eastus"

+ ```

+1. If you haven't already, sign in to the Azure CLI using the [`az login`](/cli/azure/reference-index#az-login) command.

+1. Use the [`az group create`](/cli/azure/group#az-group-create) command to create a new resource group in your subscription.

+ ```azurecli

+ az group create \

+ --name $resourceGroupName \

+ --location $location

+ ```

+1. Use [`az deployment group create`](/cli/azure/deployment/group#az-deployment-group-create) to deploy the bicep template. You're then prompted to enter a value for the `adminUsername` and `adminPassword` parameters.

+ ```azurecli

+ az deployment group create \

+ --resource-group $resourceGroupName \

+ --template-file 'main.bicep'

+ ```

+ > [!TIP]

+ > Alternatively, use the ``--parameters`` option to pass in a parameters file with pre-defined values.

+ >

+ > ```azurecli

+ > az deployment group create \

+ > --resource-group $resourceGroupName \

+ > --template-file 'main.bicep' \

+ > --parameters @main.parameters.json

+ > ```

+ >

+ > This example JSON file injects `clusteradmin` and `P@ssw.rd` values for the `adminUsername` and `adminPassword` parameters respectively.

+ >

+ > ```json

+ > {

+ > "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",

+ > "contentVersion": "1.0.0.0",

+ > "parameters": {

+ > "adminUsername": {

+ > "value": "clusteradmin"

+ > },

+ > "adminPassword": {

+ > "value": "P@ssw.rd"

+ > }

+ > }

+ > }

+ > ```

+ >

+1. Wait for the deployment operation to complete before moving on.

+### [Azure PowerShell](#tab/azure-powershell)

+1. Create shell variables for *RESOURCE_GROUP_NAME*, and *LOCATION*

+ ```azurepowershell

+ # Variable for resource group name and location

+ $RESOURCE_GROUP_NAME = "msdocs-cosmos-quickstart-rg"

+ $LOCATION = "East US"

+ ```

+1. If you haven't already, sign in to Azure PowerShell using the [`Connect-AzAccount`](/powershell/module/az.accounts/connect-azaccount) cmdlet.

+1. Use the [`New-AzResourceGroup`](/powershell/module/az.resources/new-azresourcegroup) cmdlet to create a new resource group in your subscription.

+ ```azurepowershell

+ $parameters = @{

+ Name = $RESOURCE_GROUP_NAME

+ Location = $LOCATION

+ }

+ New-AzResourceGroup @parameters

+ ```

+1. Use [`New-AzResourceGroupDeployment`](/powershell/module/az.resources/new-azresourcegroupdeployment) to deploy the bicep template. You're then prompted to enter a value for the `adminUsername` and `adminPassword` parameters.

+ ```azurepowershell

+ $parameters = @{

+ ResourceGroupName = $RESOURCE_GROUP_NAME

+ TemplateFile = "main.bicep"

+ }

+ New-AzResourceGroupDeployment @parameters

+ ```

+ > [!TIP]

+ > Alternatively, use the ``-TemplateParameterFile`` option to pass in a parameters file with pre-defined values.

+ >

+ > ```azurepowershell

+ > $parameters = @{

+ > ResourceGroupName = $RESOURCE_GROUP_NAME

+ > TemplateFile = "main.bicep"

+ > TemplateParameterFile = "main.parameters.json"

+ > }

+ > New-AzResourceGroupDeployment @parameters

+ > ```

+ >

+ > This example JSON file injects `clusteradmin` and `P@ssw.rd` values for the `adminUsername` and `adminPassword` parameters respectively.

+ >

+ > ```json

+ > {

+ > "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",

+ > "contentVersion": "1.0.0.0",

+ > "parameters": {

+ > "adminUsername": {

+ > "value": "clusteradmin"

+ > },

+ > "adminPassword": {

+ > "value": "P@ssw.rd"

+ > }

+ > }

+ > }

+ > ```

+ >

+1. Wait for the deployment operation to complete before moving on.

+## Review deployed resources

+List the resources deployed by the Bicep template to your target resource group.

+### [Azure CLI](#tab/azure-cli)

+1. Use [`az resource list`](/cli/azure/resource#az-resource-list) to get a list of resources in your resource group.

+ ```azurecli

+ az resource list \

+ --resource-group $resourceGroupName \

+ --location $location \

+ --output tsv

+ ```

+1. In the example output, look for resources that have a type of `Microsoft.DocumentDB/mongoClusters`. Here's an example of the type of output to expect:

+ ```output

+ Name ResourceGroup Location Type Status

+ -- - - --

+ msdocs-sz2dac3xtwzzu msdocs-cosmos-quickstart-rg eastus Microsoft.DocumentDB/mongoClusters

+ ```

+### [Azure PowerShell](#tab/azure-powershell)

+1. Use [`Get-AzResource`](/powershell/module/az.resources/get-azresource) to get a list of resources in your resource group.

+ ```azurepowershell

+ $parameters = @{

+ ResourceGroupName = $RESOURCE_GROUP_NAME

+ }

+ Get-AzResource @parameters

+ ```

+1. In the example output, look for resources that have a type of `Microsoft.DocumentDB/mongoClusters`. Here's an example of the type of output to expect:

+ ```output

+ Name : msdocs-sz2dac3xtwzzu

+ ResourceGroupName : msdocs-cosmos-quickstart-rg

+ ResourceType : Microsoft.DocumentDB/mongoClusters

+ Location : eastus

+ ResourceId : /subscriptions/abcdef01-2345-6789-0abc-def012345678/resourceGroups/msdocs-cosmos-quickstart-rg/providers/Microsoft.DocumentDB/mongoClusters/msdocs-sz2dac3xtwzzu

+ Tags :

+ ```

+

+## Clean up resources

+When you're done with your Azure Cosmos DB for MongoDB vCore cluster, you can delete the Azure resources you created so you don't incur more charges.

+### [Azure CLI](#tab/azure-cli)

+1. Use [`az group delete`](/cli/azure/group#az-group-delete) to remove the resource group from your subscription.

+ ```azurecli

+ az group delete \

+ --name $resourceGroupName

+ ```

+### [Azure PowerShell](#tab/azure-powershell)

+1. Use [`Remove-AzResourceGroup`](/powershell/module/az.resources/remove-azresourcegroup) to remove the resource group from your subscription.

+ ```azurepowershell

+ $parameters = @{

+ Name = $RESOURCE_GROUP_NAME

+ }

+ Remove-AzResourceGroup @parameters

+ ```

+## Next steps

+In this guide, you learned how to create an Azure Cosmos DB for MongoDB vCore cluster. You can now migrate data to your cluster.

+> [!div class="nextstepaction"]

+> [Migrate data to Azure Cosmos DB for MongoDB vCore](migration-options.md)

+ Title: |

+ Quickstart: Create a new cluster

+description: In this quickstart, create a new Azure Cosmos DB for MongoDB vCore cluster to store databases, collections, and documents by using the Azure portal.

+# Quickstart: Create an Azure Cosmos DB for MongoDB vCore cluster by using the Azure portal

+In this quickstart, you create a new Azure Cosmos DB for MongoDB vCore cluster. This cluster contains all of your MongoDB resources: databases, collections, and documents. The cluster provides a unique endpoint for various tools and SDKs to connect to Azure Cosmos DB and perform everyday operations.

+## Prerequisites

+- An Azure account with an active subscription. [Create an account for free](https://azure.microsoft.com/free).

+## Create a cluster

+Create a MongoDB cluster by using Azure Cosmos DB for MongoDB vCore.

+> [!TIP]

+> For this guide, we recommend using the resource group name ``msdocs-cosmos-quickstart-rg``.

+1. Sign in to the [Azure portal](https://portal.azure.com).

+1. From the Azure portal menu or the **Home page**, select **Create a resource**.

+1. On the **New** page, search for and select **Azure Cosmos DB**.

+1. On the **Which API best suits your workload?** page, select the **Create** option within the **Azure Cosmos DB for MongoDB** section. For more information, see [API for MongoDB and it's various models](../choose-model.md).

+ :::image type="content" source="media/quickstart-portal/select-api-option.png" lightbox="media/quickstart-portal/select-api-option.png" alt-text="Screenshot of the select API option page for Azure Cosmos DB.":::

+1. On the **Which type of resource?** page, select the **Create** option within the **vCore cluster** section. For more information, see [API for MongoDB vCore overview](introduction.md).

+ :::image type="content" source="media/quickstart-portal/select-resource-type.png" alt-text="Screenshot of the select resource type option page for Azure Cosmos DB for MongoDB.":::

+1. On the **Create Azure Cosmos DB for MongoDB cluster** page, select the **Configure** option within the **Cluster tier** section.

+ :::image type="content" source="media/quickstart-portal/select-cluster-option.png" alt-text="Screenshot of the configure cluster option for a new Azure Cosmos DB for MongoDB cluster.":::

+1. On the **Scale** page, leave the options set to their default values:

+ | Setting | Value |

+ | | |

+ | **Node count** | Single node |

+ | **Cluster tier** | M30 Tier, 2 vCores, 8-GiB RAM |

+ | **Storage per node** | 128 GiB |

+1. Leave the **High availability** option unselected. In the high availability (HA) acknowledgment section, select **I understand**. Finally, select **Save** to persist your changes to the cluster tier.

+ :::image type="content" source="media/quickstart-portal/configure-scale.png" alt-text="Screenshot of cluster tier and scale options for a cluster.":::

+1. Back on the cluster page, enter the following information:

+ | Setting | Value | Description |

+ | | | |

+ | Subscription | Subscription name | Select the Azure subscription that you wish to use for this Azure Cosmos DB for MongoDB cluster. |

+ | Resource Group | Resource group name | Select a resource group, or select **Create new**, then enter a unique name for the new resource group. |

+ | cluster Name | A unique name | Enter a name to identify your Azure Cosmos DB for MongoDB cluster. The name is used as part of a fully qualified domain name (FQDN) with a suffix of *documents.azure.com*, so the name must be globally unique. The name can only contain lowercase letters, numbers, and the hyphen (-) character. The name must also be between 3-44 characters in length. |

+ | Location | The region closest to your users | Select a geographic location to host your Azure Cosmos DB for MongoDB cluster. Use the location that is closest to your users to give them the fastest access to the data. |

+ | MongoDB version | Version of MongoDB to run in your cluster | This value is set to a default of **5.0** |

+ | Admin username | Provide a username to access the cluster | This user is created on the cluster as a user administrator. |

+ | Password | Use a unique password to pair with the username | Password must be at least eight characters and at most 128 characters. |

+ :::image type="content" source="media/quickstart-portal/configure-cluster.png" alt-text="Screenshot of various configuration options for a cluster.":::

+1. Select **Next: Networking**.

+1. In the **Networking** section, select **Allow public access from Azure services**. Additionally, add a firewall rule to give your client device or applications access to the cluster.

+ :::image type="content" source="media/quickstart-portal/configure-cluster.png" alt-text="Screenshot of networking and firewall options for a cluster.":::

+ > [!NOTE]

+ > In many corporate environments, developer machine IPs are hidden due to a VPN. In these cases, it's recommended to start with allowing access to all IPs for connection testing initially before refining the allow-list.

+1. Select **Review + create**.

+1. Review the settings you provide, and then select **Create**. It takes a few minutes to create the cluster. Wait for the portal page to display **Your deployment is complete** before moving on.

+1. Select **Go to resource** to go to the Azure Cosmos DB for MongoDB cluster page.

+ :::image type="content" source="media/quickstart-portal/deployment-complete.png" alt-text="Screenshot of the deployment page for a cluster.":::

+## Get cluster credentials

+Get the connection string you need to connect to this cluster using your application code.

+1. From the Azure Cosmos DB for MongoDB vCore cluster page, select the **Connection strings** navigation menu option.

+ :::image type="content" source="media/quickstart-portal/select-connection-strings-option.png" alt-text="Screenshot of the connection strings option on the page for a cluster.":::

+1. Record the value from the **Connection string** field.

+ :::image type="content" source="media/quickstart-portal/connection-string-value.png" alt-text="Screenshot of the connection string credential for a cluster.":::

+ > [!IMPORTANT]

+ > The connection string in the portal does not include the username and password values. You must replace the `<user>` and `<password>` placeholders with the credentials you used when you originally created the cluster.

+## Clean up resources

+When you're done with Azure Cosmos DB for MongoDB vCore cluster, you can delete the Azure resources you created so you don't incur more charges.

+1. In the Azure portal search bar, search for and select **Resource groups**.

+1. In the list, select the resource group you used for this quickstart.

+ :::image type="content" source="media/quickstart-portal/locate-resource-group.png" alt-text="Screenshot of a list of resource groups filtered down to a specific prefix.":::

+1. On the resource group page, select **Delete resource group**.

+ :::image type="content" source="media/quickstart-portal/select-delete-resource-group-option.png" alt-text="Screenshot of the delete resource group option in the menu for a specific resource group.":::

+1. In the deletion confirmation dialog, enter the name of the resource group to confirm that you intend to delete it. Finally, select **Delete** to permanently delete the resource group.

+ :::image type="content" source="media/quickstart-portal/delete-resource-group-dialog.png" alt-text="Screenshot of the delete resource group confirmation dialog with the name of the group filled out.":::

+## Next steps

+In this guide, you learned how to create an Azure Cosmos DB for MongoDB vCore cluster. You can now migrate data to your cluster.

+> [!div class="nextstepaction"]

+> [Migrate data to Azure Cosmos DB for MongoDB vCore](migration-options.md)

+ Title: Security options and features

+description: Review security options and built-in security mechanisms for Azure Cosmos DB for MongoDB vCore accounts.

+# Security in Azure Cosmos DB for MongoDB vCore

+This page outlines the multiple layers of security available to protect the data in your cluster.

+## In transit

+Encryption (SSL/TLS) is always enforced, and if you attempt to connect to your cluster without encryption, that attempt fails. Only connections via a MongoDB client are accepted and encryption is always enforced.

+Whenever data is written to Azure Cosmos DB for MongoDB vCore, your data is encrypted in-transit with Transport Layer Security 1.2.

+## At rest

+Azure Cosmos DB for MongoDB vCore uses the FIPS 140-2 validated cryptographic module for storage encryption of data at-rest. Data, including all backups, are encrypted on disk, including the temporary files. The service uses the AES 256-bit cipher included in Azure storage encryption, and the keys are system-managed. Storage encryption is always on, and can't be disabled.

+## Network security options

+This section outlines various network security options you can configure for your account.

+### No access

+**No Access** is the default option for a newly created cluster if public or private access isn't enabled. In this case, no computers, whether inside or outside of Azure, can connect to the database nodes.

+### Public IP access with firewall

+In the public access option, a public IP address is assigned to the cluster, and access to the cluster is protected by a firewall.

+## Firewall overview

+Azure Cosmos DB for MongoDB vCore uses a server-level firewall to prevent all access to your cluster until you specify which computers have permission. The firewall grants access to the cluster based on the originating IP address of each request. To configure your firewall, you create firewall rules that specify ranges of acceptable IP addresses.

+Firewall rules enable clients to access your cluster and all the databases within it. Server-level firewall rules can be configured using the Azure portal or programmatically using Azure tools such as the Azure CLI.

+By default, the firewall blocks all access to your cluster. To begin using your cluster from another computer, you need to specify one or more server-level firewall rules to enable access to your cluster. Use the firewall rules to specify which IP address ranges from the Internet to allow. Firewall rules don't affect access to the Azure portal website itself. Connection attempts from the internet and Azure must first pass through the firewall before they can reach your databases.

+## Next steps

+> [!div class="nextstepaction"]

+> [Migrate MongoDB data to Azure Cosmos DB for MongoDB vCore](migration-options.md)

+ Title: |

+ Tutorial: Build a Node.js web application

+description: In this tutorial, create a Node.js web application that connects to an Azure Cosmos DB for MongoDB vCore cluster and manages documents within a collection.

+# Tutorial: Connect a Node.js web app with Azure Cosmos DB for MongoDB vCore

+The [MERN (MongoDB, Express, React.js, Node.js) stack](https://www.mongodb.com/mern-stack) is a popular collection of technologies used to build many modern web applications. With Azure Cosmos DB for MongoDB vCore, you can build a new web application or migrate an existing application using MongoDB drivers that you're already familiar with. In this tutorial, you:

+> [!div class="checklist"]

+>

+> - Set up your environment

+> - Test the MERN application with a local MongoDB container

+> - Test the MERN application with the Azure Cosmos DB for MongoDB vCore cluster

+> - Deploy the MERN application to Azure App Service

+>

+## Prerequisites

+To complete this tutorial, you need the following resources:

+- An existing Azure Cosmos DB for MongoDB vCore cluster.

+ - If you don't have an Azure subscription, [create an account for free](https://azure.microsoft.com/free).

+ - If you have an existing Azure subscription, [create a new Azure Cosmos DB for MongoDB vCore cluster](quickstart-portal.md?tabs=azure-cli).

+- A [GitHub account](https://github.com/join).

+ - GitHub comes with free Codespaces hours for all users. For more information, see [GitHub Codespaces free utilization](https://github.com/features/codespaces#pricing).

+## 1 - Set up your environment

+Let's start by setting up your dev environment. You have the choice of **GitHub Codespaces** or **Visual Studio Code** as your integrated development environment (IDE).

+### [GitHub Codespaces](#tab/github-codespaces)

+For the most straightforward dev environment, we use GitHub Codespaces so that you have the correct developer tools and dependencies preinstalled on your machine. Codespaces also preconfigures your local MongoDB database for testing.

+1. Create a new GitHub Codespace on the `main` branch of the [`azure-samples/msdocs-azure-cosmos-db-mongodb-mern-web-app`](https://github.com/azure-samples/msdocs-azure-cosmos-db-mongodb-mern-web-app) GitHub repository.

+ > [!div class="nextstepaction"]

+ > [Open this project in GitHub Codespaces](https://github.com/azure-samples/msdocs-azure-cosmos-db-mongodb-mern-web-app/codespaces)

+1. Wait for the Codespace to start. This startup process can take two to three minutes.

+1. Open a new terminal in the codespace.

+ > [!TIP]

+ > You can use the main menu to navigate to the **Terminal** menu option and then select the **New Terminal** option.

+ >

+ > :::image type="content" source="media/tutorial-nodejs-web-app/open-terminal-option.png" lightbox="media/tutorial-nodejs-web-app/open-terminal-option.png" alt-text="Screenshot of the codespaces menu option to open a new terminal.":::

+1. Check the versions of the tools you use in this tutorial.

+ ```shell

+ docker --version

+ node --version

+ npm --version

+ az --version

+ ```

+ > [!NOTE]

+ > This tutorial requires the following versions of each tool which are preinstalled in your environment:

+ >

+ > | Tool | Version |

+ > | | |

+ > | Docker | &ge; 20.10.0 |

+ > | Node.js | &ge; 18.0150 |

+ > | NPM | &ge; 9.5.0 |

+ > | Azure CLI | &ge; 2.46.0 |

+ >

+### [Visual Studio Code](#tab/visual-studio-code)

+Alternatively, you can complete this tutorial in [Visual Studio Code](https://code.visualstudio.com) with software installed on your local machine.

+1. Make sure you have the following prerequisites installed:

+ | Tool | Version |

+ | | |

+ | [Docker](https://www.docker.com/) | &ge; 20.10.0 |

+ | [Node.js](https://nodejs.org/) | &ge; 18.0150 |

+ | [Node Package Manager (npm)](https://nodejs.org/) | &ge; 9.5.0 |

+ | [Azure CLI](/cli/azure) | &ge; 2.46.0 |

+1. Make sure you have the following extensions installed:

+ | Extension | Marketplace link |

+ | | |

+ | MongoDB for VS Code | [mongodb.mongodb-vscode](https://marketplace.visualstudio.com/items?itemName=mongodb.mongodb-vscode) |

+1. Open **Visual Studio Code** with an empty workspace.

+1. Open a new terminal.

+ > [!TIP]

+ > You can use the main menu to navigate to the **Terminal** menu option and then select the **New Terminal** option.

+ >

+ > :::image type="content" source="media/tutorial-nodejs-web-app/open-terminal-option.png" lightbox="media/tutorial-nodejs-web-app/open-terminal-option.png" alt-text="Screenshot of the menu option to open a new terminal.":::

+1. Use `git clone` to clone the MERN application from GitHub.

+ ```shell

+ git clone https://github.com/azure-samples/msdocs-azure-cosmos-db-mongodb-mern-web-app.git .

+ ```

+## 2 - Test the MERN application's API with the MongoDB container

+Start by running the sample application's API with the local MongoDB container to validate that the application works.

+1. Run a MongoDB container using Docker and publish the typical MongoDB port (`27017`).

+ ```shell

+ docker pull mongo:6.0

+ docker run --detach --publish 27017:27017 mongo:6.0

+ ```

+1. In the side bar, select the MongoDB extension.

+ :::image type="content" source="media/tutorial-nodejs-web-app/select-mongodb-option.png" alt-text="Screenshot of the MongoDB extension in the side bar.":::

+1. Add a new connection to the MongoDB extension using the connection string `mongodb://localhost`.

+ :::image type="content" source="media/tutorial-nodejs-web-app/select-mongodb-add-connection.png" alt-text="Screenshot of the add connection button in the MongoDB extension.":::

+1. Once the connection is successful, open the **data/products.mongodb** playground file.

+1. Select the **Run all** icon to execute the script.

+ :::image type="content" source="media/tutorial-nodejs-web-app/select-mongodb-playground-run-all.png" alt-text="Screenshot of the run all button in a playground for the MongoDB extension.":::

+1. The playground run should result in a list of documents in the local MongoDB collection. Here's a truncated example of the output.

+ ```json

+ [

+ {

+ "_id": { "$oid": "640a146e89286b79b6628eef" },

+ "name": "Confira Watch",

+ "category": "watches",

+ "price": 105

+ },

+ {

+ "_id": { "$oid": "640a146e89286b79b6628ef0" },

+ "name": "Diannis Watch",

+ "category": "watches",

+ "price": 98,

+ "sale": true

+ },

+ ...

+ ]

+ ```

+ > [!NOTE]

+ > The object ids (`_id`) are randomnly generated and will differ from this truncated example output.

+1. In the **client/** directory, create a new **.env** file.

+1. In the **client/.env** file, add an environment variable for this value:

+ | Environment Variable | Value |

+ | | |

+ | `CONNECTION_STRING` | The connection string to the Azure Cosmos DB for MongoDB vCore cluster. For now, use `mongodb://localhost`. |

+ ```env

+ CONNECTION_STRING=mongodb://localhost:27017?directConnection=true

+ ```

+1. Change the context of the terminal to the **server/** folder.

+ ```shell

+ cd server

+ ```

+1. Install the dependencies from Node Package Manager (npm).

+ ```shell

+ npm install

+ ```

+1. Start the Node.js &amp; Express application.

+ ```shell

+ npm start

+ ```

+1. The API automatically opens a browser window to verify that it returns an array of product documents.

+1. Close the extra browser tab/window.

+1. Close the terminal.

+## 3 - Test the MERN application with the Azure Cosmos DB for MongoDB vCore cluster

+Now, let's validate that the application works seamlessly with Azure Cosmos DB for MongoDB vCore. For this task, populate the pre-existing cluster with seed data using the MongoDB shell and then update the API's connection string.

+1. Sign in to the [Azure portal](https://portal.azure.com).

+1. Navigate to the existing Azure Cosmos DB for MongoDB vCore cluster page.

+1. From the Azure Cosmos DB for MongoDB vCore cluster page, select the **Connection strings** navigation menu option.

+ :::image type="content" source="media/tutorial-nodejs-web-app/select-connection-strings-option.png" alt-text="Screenshot of the connection strings option on the page for a cluster.":::

+1. Record the value from the **Connection string** field.

+ :::image type="content" source="media/tutorial-nodejs-web-app/connection-string-value.png" alt-text="Screenshot of the connection string credential for a cluster.":::

+ > [!IMPORTANT]

+ > The connection string in the portal does not include the username and password values. You must replace the `<user>` and `<password>` placeholders with the credentials you used when you originally created the cluster.

+1. Back within your integrated development environment (IDE), open a new terminal.

+1. Start the MongoDB Shell using the `mongosh` command and the connection string you recorded earlier. Make sure you replace the `<user>` and `<password>` placeholders with the credentials you used when you originally created the cluster.

+ ```shell

+ mongosh "<mongodb-cluster-connection-string>"

+ ```

+ > [!NOTE]

+ >

+ > You may need to encode specific values for the connection string. In this example, the name of the cluster is `msdocs-cosmos-tutorial`, the username is `clusteradmin`, and the password is `P@ssw.rd`. In the password the `@` character will need to be encoded using `%40`. An example connection string is provided here with the correct encoding of the password.

+ >

+ > ```output

+ > CONNECTION_STRING=mongodb+srv://clusteradmin:P%40ssw.rd@msdocs-cosmos-tutorial.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000

+ > ```

+ >

+1. Within the shell, run the following commands to create your database, create your collection, and seed with starter data.

+ :::code language="mongosh" source="~/azure-cosmos-db-mongodb-mern-web-app/data/products.mongodb" highlight="5-16":::

+1. The commands should result in a list of documents in the local MongoDB collection. Here's a truncated example of the output.

+ ```json

+ [

+ {

+ "_id": { "$oid": "640a146e89286b79b6628eef" },

+ "name": "Confira Watch",

+ "category": "watches",

+ "price": 105

+ },

+ {

+ "_id": { "$oid": "640a146e89286b79b6628ef0" },

+ "name": "Diannis Watch",

+ "category": "watches",

+ "price": 98,

+ "sale": true

+ },

+ ...

+ ]

+ ```

+ > [!NOTE]

+ > The object ids (`_id`) are randomnly generated and will differ from this truncated example output.

+1. Exit the MongoDB shell.

+ ```shell

+ exit

+ ```

+1. Open the **client/.env** file again. Then, update the value of the `CONNECTION_STRING` environment variables with the connection string you used with the mongo shell:

+ ```output

+ CONNECTION_STRING=<your-connection-string>

+ ```

+1. Validate that the application is using the database service by changing the context of the terminal to the **server/** folder, installing dependencies from Node Package Manager (npm), and then starting the application.

+ ```shell

+ cd server

+ npm install

+ npm start

+ ```

+1. The API automatically opens a browser window to verify that it returns an array of product documents.

+1. Close the extra browser tab/window. Then, close the terminal.

+## 4 - Deploy the MERN application to Azure App Service

+Deploy the service and client to Azure App Service to prove that the application works end-to-end. Use secrets in the web apps to store environment variables with credentials and API endpoints.

+1. Within your integrated development environment (IDE), open a new terminal.

+1. Create a shell variable for the name of the pre-existing resource group named *resourceGroupName*.

+ ```azurecli

+ # Variable for resource group name

+ resourceGroupName="<existing-resource-group>"

+ ```

+1. Create shell variables for the two web app named *serverAppName* and *clientAppName*.

+ ```azurecli

+ # Variable for randomnly generated suffix

+ let suffix=$RANDOM*$RANDOM

+ # Variable for web app names with a randomnly generated suffix

+ serverAppName="server-app-$suffix"

+ clientAppName="client-app-$suffix"

+ ```

+1. If you haven't already, sign in to the Azure CLI using the [`az login --use-device-code`](/cli/azure/reference-index#az-login) command.

+1. Change the current working directory to the **server/** path.

+ ```shell

+ cd server

+ ```

+1. Create a new web app for the server component of the MERN application with [`az webapp up`](/cli/azure/webapp#az-webapp-up).

+ ```shell

+ az webapp up \

+ --resource-group $resourceGroupName \

+ --name $serverAppName \

+ --sku F1 \

+ --runtime "NODE|18-lts"

+ ```

+1. Create a new connection string setting for the server web app named `CONNECTION_STRING` with [`az webapp config connection-string set`](/cli/azure/webapp/config/connection-string#az-webapp-config-connection-string-set). Use the same value for the connection string you used with the MongoDB shell and **.env** file earlier in this tutorial.

+ ```shell

+ az webapp config connection-string set \

+ --resource-group $resourceGroupName \

+ --name $serverAppName \

+ --connection-string-type custom \

+ --settings "CONNECTION_STRING=<mongodb-connection-string>"

+ ```

+1. Get the URI for the server web app with [`az webapp show`](/cli/azure/webapp#az-webapp-show) and store it in a shell variable name d **serverUri**.

+ ```azurecli

+ serverUri=$(az webapp show \

+ --resource-group $resourceGroupName \

+ --name $serverAppName \

+ --query hostNames[0] \

+ --output tsv)

+ ```

+1. Use the [`open-cli`](https://www.npmjs.com/package/open-cli) package and command from NuGet with `npx` to open a browser window using the URI for the server web app. Validate that the server app is returning your JSON array data from the MongoDB vCore cluster.

+ ```shell

+ npx open-cli "https://$serverUri/products" --yes

+ ```

+ > [!TIP]

+ > Sometimes deployments can finish asynchronously. If you are not seeing what you expect, wait another minute and refresh your browser window.

+1. Change the working directory to the **client/** path.

+ ```shell

+ cd ../client

+ ```

+1. Create a new web app for the client component of the MERN application with [`az webapp up`](/cli/azure/webapp#az-webapp-up).

+ ```shell

+ az webapp up \

+ --resource-group $resourceGroupName \

+ --name $clientAppName \

+ --sku F1 \

+ --runtime "NODE|18-lts"

+ ```

+1. Create a new app setting for the client web app named `REACT_APP_API_ENDPOINT` with [`az webapp config appsettings set`](/cli/azure/webapp/config/appsettings#az-webapp-config-appsettings-set). Use the server API endpoint stored in the **serverUri** shell variable.

+ ```shell

+ az webapp config appsettings set \

+ --resource-group $resourceGroupName \

+ --name $clientAppName \

+ --settings "REACT_APP_API_ENDPOINT=https://$serverUri"

+ ```

+1. Get the URI for the client web app with [`az webapp show`](/cli/azure/webapp#az-webapp-show) and store it in a shell variable name d **clientUri**.

+ ```azurecli

+ clientUri=$(az webapp show \

+ --resource-group $resourceGroupName \

+ --name $clientAppName \

+ --query hostNames[0] \

+ --output tsv)

+ ```

+1. Use the [`open-cli`](https://www.npmjs.com/package/open-cli) package and command from NuGet with `npx` to open a browser window using the URI for the client web app. Validate that the client app is rendering data from the server app's API.

+ ```shell

+ npx open-cli "https://$clientUri" --yes

+ ```

+ > [!TIP]

+ > Sometimes deployments can finish asynchronously. If you are not seeing what you expect, wait another minute and refresh your browser window.

+1. Close the terminal.

+## Clean up resources

+When you're working in your own subscription, at the end of a project, it's a good idea to remove the resources that you no longer need. Resources left running can cost you money. You can delete resources individually or delete the resource group to delete the entire set of resources.

+1. To delete the entire resource group, use [`az group delete`](/cli/azure/group#az-group-delete).

+ ```azurecli

+ az group delete \

+ --name $resourceGroupName \

+ --yes

+ ```

+1. Validate that the resource group is deleted using [`az group list`](/cli/azure/group#az-group-list).

+ ```azurecli

+ az group list

+ ```

+## Next steps

+Now that you have built your first application for the MongoDB vCore cluster, learn how to migrate your data to Azure Cosmos DB.

+> [!div class="nextstepaction"]

+> [Migrate your data](migration-options.md)

+This article is specific to EA users. Microsoft Customer Agreement (MCA) users can use similar steps to calculate their reservation savings through invoices. However, the MCA amortized usage file doesn't contain UnitPrice (on-demand pricing) for reservations. Other resources in the file do. For more information, see [Download usage for your Microsoft Customer Agreement](../savings-plan/utilization-cost-reports.md).

+The recommendations account for existing reservations and savings plans. So, previously purchased reservations and savings plans are excluded when providing recommendations.

+To view and download usage data for a billing profile, you must be a billing profile Owner, Contributor, Reader, or Invoice manager.

+To download usage for billed charges:

+1. Search for **Cost Management + Billing**.

+2. Select a billing profile.

+3. Select **Invoices**.

+4. In the invoice grid, find the row of the invoice corresponding to the usage that you want to download.

+5. Select the ellipsis (**...**) at the end of the row.

+6. In the download context menu, select **Azure usage and charges**.

+You must have an owner or a contributor role on the billing profile or its billing account to update its email invoice preference. Once you have opted-in, all users with an owner, contributor, readers, and invoice manager roles on a billing profile will get its invoice in email.

+> [!NOTE]

+> The *send by email* and *invoice email preference* invoice functionality isnΓÇÖt supported for Microsoft Customer Agreements when you work with a Microsoft partner.

+| **Built-in clients/drivers/providers** | *Access Database Engine 2016 Redistributable* - RTM - X64<br/><br/>*Microsoft Analysis Management Objects* - 15.0.2000.443 - X64<br/><br/>*Microsoft Analysis Services OLEDB Provider* - 15.0.2000.443 - X64<br/><br/>*Microsoft SQL Server 2012 Native Client* - 11.4.7462.6 - X64<br/><br/>*Microsoft ODBC Driver 13 for SQL Server* - 14.0.900.902 - X64<br/><br/>*Microsoft OLEDB Driver 18 for SQL Server* - 18.6.5 - X64<br/><br/>*Microsoft OLEDB Provider for DB2* - 6.0 - X64<br/><br/>*SharePoint Online Client Components SDK* - 15.4711.1001 - X64 |

+|`-eesp`,<br/>`-EnableExecuteSsisPackage`|| Enable SSIS package execution on self-hosted IR node.|

+|`-desp`,<br/>`-DisableExecuteSsisPackage`|| Disable SSIS package execution on self-hosted IR node.|

+|`-gesp`,<br/>`-GetExecuteSsisPackage`|| Get the value if ExecuteSsisPackage option is enabled on self-hosted IR node.|

+- Enable SSIS package execution on self-hosted integration runtime node if self-hosted IR version is **5.28.0** or later.

+ **ExecuteSsisPackage** property is newly introduced from self-hosted IR version **5.28.0**. Use below self-hosted IR command line action to enable or disable SSIS package execution:

+

+ - -EnableExecuteSsisPackage Enable SSIS package execution on self-hosted IR node.

+

+ - -DisableExecuteSsisPackage Disable SSIS package execution on self-hosted IR node.

+

+ - -GetExecuteSsisPackage

+

+ Self-hosted IR command line details refer to [Set up an existing self-hosted IR via local PowerShell](create-self-hosted-integration-runtime.md?tabs=data-factory#set-up-an-existing-self-hosted-ir-via-local-powershell).

+

+ Newly installed self-hosted IR node with version 5.28.0 or later, ExecuteSsisPackage property is by default **disabled**.

+

+ Existing self-hosted IR node updated to version 5.28.0 or later, ExecuteSsisPackage property is by default **enabled**

+- Primary NIC attached to a SRIOV enabled vSwitch [Learn more](#primary-nic-attached-to-a-sriov-enabled-vswitch)

+### Primary NIC attached to a SRIOV enabled vSwitch

+**Error description:** The primary network interface attached to a single root I/O virtualization (SRIOV) interface-enabled virtual switch caused network traffic to bypass the hyper-v, so the host could not receive DHCP requests from the VM, resulting in a provisioning timeout.

+**Suggested solutions:**

+- Connect the VM primary network interface to a virtual switch without enabling accelerated networking.

+- On an Azure Stack Edge Pro 1 device, virtual switches created on Port 1 to Port 4 do not enable accelerated networking. On Port 5 or Port 6, virtual switches will enable accelerated networking by default. 

+ - On an Azure Stack Edge Pro 2 device, virtual switches created on Port 1 or Port 2 do not enable accelerated networking. On Port 3 or Port 4, virtual switches will enable accelerated networking by default. 

+

+Azure Policy extends [Gatekeeper](https://open-policy-agent.github.io/gatekeeper) v3, an _admission

+ [constraint](https://open-policy-agent.github.io/gatekeeper/website/docs/howto/#constraints) custom resources.

+| Properties | Maximum size of desired properties and reported properties sections are 32 KB each. Maximum size of tags section is 8 KB. Maximum size of each individual property in every section is 4 KB. | These values are set by the IoT Hub service. |

+> Support for property queries is now deprecated in the IoT Central REST API and will be removed from the existing API releases.

+> [!IMPORTANT]

+> Support for property queries is now deprecated in the IoT Central REST API and will be removed from the existing API releases.

+> [!IMPORTANT]

+> Support for property queries is now deprecated in the IoT Central REST API and will be removed from the existing API releases.

+ ```javascript

+A resource group is a logical container into which Azure resources are deployed and managed. The following example creates a resource group named *ContosoResourceGroup* in the *eastus2* location.

+az group create --name "ContosoResourceGroup" --location eastus2

+A resource group is a logical container into which Azure resources are deployed and managed. Use the Azure PowerShell [New-AzResourceGroup](/powershell/module/az.resources/new-azresourcegroup) cmdlet to create a resource group named *myResourceGroup* in the *eastus2* location.

+New-AzResourceGroup -Name "myResourceGroup" -Location "eastus2"

+New-AzKeyVaultManagedHsm -Name "<your-unique-managed-hsm-name>" -ResourceGroupName "myResourceGroup" -Location "eastus2" -Administrator "<your-principal-ID>"

+ Title: Network Monitoring in Azure Monitor logs

+description: Overview of network monitoring solutions, including network performance monitor, to manage networks across cloud, on-premises, and hybrid environments.

+## Network Performance Monitor

+Network Performance Monitor is a suite of capabilities that is geared towards monitoring the health of your network. Network Performance Monitor monitors network connectivity to your applications, and provides insights into the performance of your network. Network Performance Monitor is cloud-based and provides a hybrid network monitoring solution that monitors connectivity between:

+Performance Monitor, ExpressRoute Monitor, and Service Connectivity Monitor are monitoring capabilities within Network Performance Monitor and are described in the following sections.

+Performance Monitor is part of Network Performance Monitor and is network monitoring for cloud, hybrid, and on-premises environments. You can monitor network connectivity across remote branch and field offices, store locations, data centers, and clouds. You can detect network issues before your users complain. The key advantages are:

+* Troubleshoot transient and point-in-time network issues, that's difficult to replicate

+* Determine the specific segment on the network that is responsible for degraded performance

+Network Performance Monitor for ExpressRoute offers comprehensive ExpressRoute monitoring for Azure Private peering and Microsoft peering connections. You can monitor E2E connectivity and performance between your branch offices and Azure over ExpressRoute. The key capabilities are:

+* Autodetection of ER circuits associated with your subscription

+* Detection of network topology from on-premises to your cloud applications

+* Capacity planning, bandwidth utilization analysis

+* Detect degradation of connectivity to virtual networks

+* Determine hot spots on the network that may be causing poor application performance

+* Traffic flows across your networks between Azure and Internet, public cloud regions, virtual networks, and subnets

+* Sources and destinations of traffic across virtual networks, inter-relationships between critical business services and applications

+* Security – malicious traffic, ports open to the Internet, applications or VMs attempting Internet access…

+Traffic Analytics equips you with information that helps you audit your organizationΓÇÖs network activity, secure applications and data, and optimize workload performance and stay compliant.

+* [Blog post](https://aka.ms/trafficanalytics)

+* [Documentation](../network-watcher/traffic-analytics.md)

+* [FAQ](../network-watcher/traffic-analytics-faq.yml)

+DNS Analytics is built for DNS Administrators, this solution collects, analyzes, and correlates DNS logs to provide security, operations, and performance-related insights. Some of the capabilities are:

+* [Blog post](/archive/blogs/msoms/introducing-oms-dns-analytics)

+* [Documentation](/previous-versions/azure/azure-monitor/insights/dns-analytics)

+az group delete --name $resourceGroup --yes

+More networking CLI script samples can be found in the [Azure Networking Overview documentation](../cli-samples.md)

+az group delete --name $resourceGroup --yes

+ Title: Azure PowerShell Script Sample - Peer two virtual networks

+This script creates and connects two virtual networks in the same region through the Azure network. After running the script, you'll create a peering between two virtual networks.

+More networking PowerShell script samples can be found in the [Azure Networking Overview documentation](../powershell-samples.md?toc=%2fazure%2fnetworking%2ftoc.json).

+ Title: Connection libraries - Azure Database for PostgreSQL - Flexible Server

+description: This article describes several libraries and drivers that you can use when coding applications to connect and query Azure Database for PostgreSQL - Flexible Server.

+# Connection libraries for Azure Database for PostgreSQL - Flexible Server

+This article lists libraries and drivers that developers can use to develop applications to connect to and query Azure Database for PostgreSQL.

+## Client interfaces

+Most language client libraries used to connect to PostgreSQL server are external projects and are distributed independently. The libraries listed are supported on the Windows, Linux, and Mac platforms, for connecting to Azure Database for PostgreSQL. Several quickstart examples are listed in the Next steps section.

+| **Language** | **Client interface** | **Additional information** | **Download** |

+|--|-|-|--|

+| Python | [psycopg](https://www.psycopg.org/) | DB API 2.0-compliant | [Download](https://sourceforge.net/projects/adodbapi/) |

+| PHP | [php-pgsql](https://secure.php.net/manual/en/book.pgsql.php) | Database extension | [Install](https://secure.php.net/manual/en/pgsql.installation.php) |

+| Node.js | [Pg npm package](https://www.npmjs.com/package/pg) | Pure JavaScript non-blocking client | [Install](https://www.npmjs.com/package/pg) |

+| Java | [JDBC](https://jdbc.postgresql.org/) | Type 4 JDBC driver | [Download](https://jdbc.postgresql.org/download/)  |

+| Ruby | [Pg gem](https://deveiate.org/code/pg/) | Ruby Interface | [Download](https://rubygems.org/downloads/pg-0.20.0.gem) |

+| Go | [Package pq](https://godoc.org/github.com/lib/pq) | Pure Go postgres driver | [Install](https://github.com/lib/pq/blob/master/README.md) |

+| C\#/ .NET | [Npgsql](https://www.npgsql.org/) | ADO.NET Data Provider | [Download](https://dotnet.microsoft.com/download) |

+| ODBC | [psqlODBC](https://odbc.postgresql.org/) | ODBC Driver | [Download](https://www.postgresql.org/ftp/odbc/versions/) |

+| C | [libpq](https://www.postgresql.org/docs/9.6/static/libpq.html) | Primary C language interface | Included |

+| C++ | [libpqxx](http://pqxx.org/) | New-style C++ interface | [Download](https://pqxx.org/libpqxx/) |

+## Next steps

+Read these quickstarts on how to connect to and query Azure Database for PostgreSQL by using your language of choice:

+[Python](./connect-python.md) | [Java](./connect-java.md) | [Azure CLI](./connect-azure-cli.md) | [.NET (C#)](./connect-csharp.md)

+Private endpoints provide a privately accessible IP address for the Azure service, but do not necessarily restrict public network access to it. All other Azure services require additional [access controls](../event-hubs/event-hubs-ip-filtering.md), however. These controls provide an extra network security layer to your resources, providing protection that helps prevent access to the Azure service associated with the private-link resource.

+* See [other videos, blogs and documents](./how-to-policies-devops-authoring-generic.md#next-steps)

+>[!NOTE]

+> The roles below may be expanded in the future to include additional actions that become available as long as they are are consistent with the spirit of the role.

+>[!NOTE]

+> The role definition for SQL Performance Monitor will be expanded around April 2023 to include the following actions.

+- /Sqlservers/Databases/SystemViewsAndFunctions/DatabasePerformanceState/Rows/Select

+- /Sqlservers/SystemViewsAndFunctions/ServerPerformanceState/Rows/Select

+- /Sqlservers/Databases/SystemViewsAndFunctions/DatabaseGeneralMetadata/Rows/Select

+- /Sqlservers/SystemViewsAndFunctions/ServerGeneralMetadata/Rows/Select

+- /Sqlservers/Databases/DBCCs/ViewDatabasePerformanceState/Execute

+- /Sqlservers/DBCCs/ViewServerPerformanceState/Execute

+- /Sqlservers/Databases/ExtendedEventSessions/Create

+- /Sqlservers/Databases/ExtendedEventSessions/Options/Alter

+- /Sqlservers/Databases/ExtendedEventSessions/Events/Add

+- /Sqlservers/Databases/ExtendedEventSessions/Events/Drop

+- /Sqlservers/Databases/ExtendedEventSessions/State/Enable

+- /Sqlservers/Databases/ExtendedEventSessions/State/Disable

+- /Sqlservers/Databases/ExtendedEventSessions/Drop

+- /Sqlservers/Databases/ExtendedEventSessions/Target/Add

+- /Sqlservers/Databases/ExtendedEventSessions/Target/Drop

+- /Sqlservers/ExtendedEventSessions/Create

+- /Sqlservers/ExtendedEventSessions/Options/Alter

+- /Sqlservers/ExtendedEventSessions/Events/Add

+- /Sqlservers/ExtendedEventSessions/Events/Drop

+- /Sqlservers/ExtendedEventSessions/State/Enable

+- /Sqlservers/ExtendedEventSessions/State/Disable

+- /Sqlservers/ExtendedEventSessions/Drop

+- /Sqlservers/ExtendedEventSessions/Target/Add

+- /Sqlservers/ExtendedEventSessions/Target/Drop

+* Doc: [Troubleshoot Microsoft Purview policies for SQL data sources](./troubleshoot-policy-sql.md)

+* [Postman app](https://www.postman.com/downloads/)

+This example uses [Postman app](https://www.postman.com/downloads/) and the [Search REST APIs](/rest/api/searchservice/).

+Sample documents aren't included with the Projections collection, but the [AI enrichment demo data files](https://github.com/Azure-Samples/azure-search-sample-data/tree/master/ai-enrichment-mixed-media) from the [azure-search-sample-data repo](https://github.com/Azure-Samples/azure-search-sample-data) contain text and images, and will work with the projections described in this example.

+One purpose of shaping is to ensure that all enrichment nodes are expressed in well-formed JSON, which is required for projecting into knowledge store. This is especially true when an enrichment tree contains nodes that aren't well-formed JSON (for example, when an enrichment is parented to a primitive like a string).

+The example skillset introduced at the start of this article didn't include the Shaper skill, but Shaper skills belong in a skillset and are often placed towards the end.

+Drawing on the examples above, there's a known quantity of enrichments and data shapes that can be referenced in table projections. In the tables projection below, three tables are defined by setting the `tableName`, `source` and `generatedKeyName` properties.

+You now have a working projection with three tables. [Importing these tables into Power BI](knowledge-store-connect-power-bi.md) should result in Power BI discovering the relationships.

+In the example, `projectionShape` is the consolidated shape (or enrichment node). In the projection definition, `projectionShape` is sliced into additional tables, which enables you to pull out parts of the shape, `keyPhrases` and `Entities`. In Power BI, this is useful as multiple entities and keyPhrases are associated with each document, and you'll get more insights if you can see entities and keyPhrases as categorized data.

+The `generatedKeyName` and `referenceKeyName` properties are used to relate data across tables or even across projection types. Each row in the child table has a property pointing back to the parent. The name of the column or property in the child is the `referenceKeyName` from the parent. When the `referenceKeyName` isn't provided, the service defaults it to the `generatedKeyName` from the parent.

+Object projections are JSON representations of the enrichment tree that can be sourced from any node. In comparison with table projections, object projections are simpler to define and are used when projecting whole documents. Object projections are limited to a single projection in a container and can't be sliced.

+The source is the path to a node of the enrichment tree that is the root of the projection. Although it isn't required, the node path is usually the output of a Shaper skill. This is because most skills don't output valid JSON objects on their own, which means that some form of shaping is necessary. In many cases, the same Shaper skill that creates a table projection can be used to generate an object projection. Alternatively, the source can also be set to a node with [an inline shaping](knowledge-store-projection-shape.md#inline-shape) to provide the structure.

+The destination is always a blob container, with a folder prefix of the base64 encoded value of the document ID. File projections can't share the same container as object projections and need to be projected into a different container.

+Object projections require a container name for each projection. Object projections and file projections can't share a container.

+This example also highlights another feature of projections. By defining multiple types of projections within the same projection object, there's a relationship expressed within and across the different types (tables, objects, files). This allows you to start with a table row for a document and find all the OCR text for the images within that document in the object projection.

+If you don't want the data related, define the projections in different projection groups. For example, the following snippet will result in the tables being related, but without relationships between the tables and the object (OCR text) projections.

+The example in this article demonstrates common patterns on how to create projections. Now that you have a good understanding of the concepts, you're better equipped to build projections for your specific scenario.

+REST samples are usually developed and tested on Postman, but you can use any client that supports HTTP calls, including the [Postman app](https://www.postman.com/downloads/). [This quickstart](search-get-started-rest.md) explains how to formulate the HTTP request from end-to-end.

+The article uses the Postman app. You can [download and import a Postman collection](https://github.com/Azure-Samples/azure-search-postman-samples/tree/master/Quickstart) if you prefer to use predefined requests.

+1. Open the Postman app and import the collection.

+[**Create Index (REST API)**](/rest/api/searchservice/create-index) is used to create an index. The Postman app can function as a search index client to connect to your search service and send requests. See [Create a search index using REST and Postman](search-get-started-rest.md) to get started.

+The Postman app can function as an indexer client. Using the app, you can connect to your search service and send [Create Indexer (REST)](/rest/api/searchservice/create-indexer) or [Update indexer](/rest/api/searchservice/update-indexer) requests.

+The data source definition specifies the source data to index, credentials, and policies for change detection. A data source is an independent resource that can be used by multiple indexers.

+1. [Create or update a data source](/rest/api/searchservice/create-data-source) to set its definition:

+ ```http

+ POST https://[service name].search.windows.net/datasources?api-version=2020-06-30

+ "name": "my-table-storage-ds",

+ "description": null,

+ "type": "azuretable",

+ "subtype": null,

+ "credentials": {

+ "connectionString": "DefaultEndpointsProtocol=https;AccountName=<account name>"

+ },

+ "container": {

+ "name": "my-table-in-azure-storage",

+ "query": ""

+ },

+ "dataChangeDetectionPolicy": null,

+ "dataDeletionDetectionPolicy": null,

+ "encryptionKey": null,

+ "identity": null

+ ```

+1. Optionally, set "query" to a filter on PartitionKey. Setting this property is a best practice that improves performance. If "query" is null, the indexer executes a full table scan, which can result in poor performance if the tables are large.

+> If you use SAS credentials, you'll need to update the data source credentials periodically with renewed signatures to prevent their expiration. When SAS credentials expire, the indexer will fail with an error message similar to "Credentials provided in the connection string are invalid or have expired".

+ + With this approach, if you need to trigger a full reindex, reset the data source query in addition to [resetting the indexer](search-howto-run-reset-indexers.md).

+ { "name": "Key", "type": "Edm.String", "key": true, "searchable": false },

+1. Create a document key field ("key": true), but allow the indexer to populate it automatically. A table indexer populates the key field with concatenated partition and row keys from the table. For example, if a rowΓÇÖs PartitionKey is `1` and RowKey is `1_123`, then the key value is `11_123`. If the partition key is null, just the row key is used.

+ If you're using the Import data wizard to create the index, the portal infers a "Key" field for the search index and uses an implicit field mapping to connect the source and destination fields. You don't have to add the field yourself, and you don't need to set up a field mapping.

+ If you're using the REST APIs and you want implicit field mappings, create and name the document key field "Key" in the search index definition as shown in the previous step (`{ "name": "Key", "type": "Edm.String", "key": true, "searchable": false }`). The indexer populates the Key field automatically, with no field mappings required.

+ If you don't want a field named "Key" in your search index, add an explicit field mapping in the indexer definition with the field name you want, setting the source field to "Key":

+ ```json

+ "fieldMappings" : [

+ {

+ "sourceFieldName" : "Key",

+ "targetFieldName" : "MyDocumentKeyFieldName"

+ }

+ ]

+ ```

+1. Now add any other entity fields that you want in your index. For example, if an entity looks like the following example, your search index should have fields for HotelName, Description, and Category to receive those values.

+ Using the same names and compatible [data types](/rest/api/searchservice/supported-data-types) minimizes the need for [field mappings](search-indexer-field-mappings.md). When names and types are the same, the indexer can determine the data path automatically.

+Once you have an index and data source, you're ready to create the indexer. Indexer configuration specifies the inputs, parameters, and properties controlling run time behaviors.

+ "name" : "my-table-indexer",

+ "dataSourceName" : "my-table-storage-ds",

+ "disabled": null,

+ "schedule": null,

+ "parameters" : {

+ "batchSize" : null,

+ "maxFailedItems" : null,

+ "maxFailedItemsPerBatch" : null,

+ "base64EncodeKeys" : null,

+ "configuration" : { }

+ "fieldMappings" : [ ],

+ "cache": null,

+ "encryptionKey": null

+1. [Specify field mappings](search-indexer-field-mappings.md) if there are differences in field name or type, or if you need multiple versions of a source field in the search index. The Target field is the name of the field in the search index.

+ ```json

+ "fieldMappings" : [

+ {

+ "sourceFieldName" : "Description",

+ "targetFieldName" : "HotelDescription"

+ }

+ ]

+ ```

+ "startTime":"2023-02-21T00:23:24.957Z",

+ "endTime":"2023-02-21T00:36:47.752Z",

+ "startTime":"2023-02-21T00:23:24.957Z",

+ "endTime":"2023-02-21T00:36:47.752Z",

+Learn more about how to [run the indexer](search-howto-run-reset-indexers.md), [monitor status](search-howto-monitor-indexers.md), or [schedule indexer execution](search-howto-schedule-indexers.md). The following articles apply to indexers that pull content from Azure Storage:

+First, use [az-search-shared-private-link-resource list](/cli/azure/search/shared-private-link-resource) to review any existing shared private links to ensure you're not duplicating a link. There can be only one shared private link for each resource and sub-resource combination.

+1. Choose a tool that can invoke an outbound request scenario, such as an indexer connection to a private endpoint. An easy choice is using the **Import data** wizard, but you can also try the Postman app and REST APIs for more precision. Assuming that your search service isn't also configured for a private connection, the REST client connection to Search can be over the public internet.

+For early development and proof-of-concept testing, we recommend starting with an interactive tool like Azure portal, or the Postman app for making REST API calls. With these approaches, you can test a query request in isolation and assess the effects of different properties without having to write any code.

+The [Postman app](https://www.postman.com/downloads/) can function as a query client. Using the app, you can connect to your search service and send [Search Documents (REST)](/rest/api/searchservice/search-documents) requests. Numerous tutorials and examples demonstrate REST clients for querying indexing.

+| [**ChatGPT + Enterprise data with Azure OpenAI and Cognitive Search (GitHub)**](https://github.com/Azure-Samples/azure-search-openai-demo/blob/main/README.md) | Sample | Python code and a template for combining Cognitive Search with the large language models in OpenAI. For background, see this Tech Community blog post: [Revolutionize your Enterprise Data with ChatGPT](https://techcommunity.microsoft.com/t5/ai-applied-ai-blog/revolutionize-your-enterprise-data-with-chatgpt-next-gen-apps-w/ba-p/3762087). <br><br>Key points: <br><br>Use Cognitive Search to consolidate and index searchable content.</br> <br>Query the index for initial search results.</br> <br>Assemble prompts from those results and send to the gpt-35-turbo (preview) model in Azure OpenAI.</br> <br>Return a cross-document answer and provide citations and transparency in your customer-facing app so that users can assess the response.</br>|

+| Azure Blob Storage | microsoft.storage/storageaccounts | properties.primaryEndpoints.blob | `abc.blob.core.windows.net` |

+This tutorial shows how to deploy a data-driven Python [Django](https://www.djangoproject.com/) web app to [Azure App Service](overview.md) and connect it to an Azure Database for a Postgres database. You can also try the PostgreSQL Flexible Server by selecting the option above. Flexible Server provides a simpler deployment mechanism and lower ongoing costs.

+| Replication | `*.hypervrecoverymanager.windowsazure.com` | `*.hypervrecoverymanager.windowsazure.us` | Allows the VM to communicate with the Site Recovery service. |

+ Title: Enterprise tier in Azure Marketplace

+description: Learn about the Azure Spring Apps Enterprise tier offering available in Azure Marketplace.

+# Enterprise tier in Azure Marketplace

+This article describes the Azure Marketplace offer and license requirements for the VMware Taznu components in the Enterprise tier in Azure Spring Apps.

+## Enterprise tier and VMware Tanzu components

+The Azure Spring Apps Enterprise tier is optimized for the needs of enterprise Spring developers and provides advanced configurability, flexibility, and portability. Azure Spring Apps also provides the enterprise-ready VMware Spring Runtime with 24/7 support in a strong partnership with VMware. You can learn more about the tier's value propositions in the [Enterprise plan](./overview.md#enterprise-plan) section of [What is Azure Spring Apps?](/azure/spring-apps/overview)

+Because the Enterprise tier provides feature parity with the Standard tier, it provides a rich set of features that include app lifecycle management, monitoring, and troubleshooting.

+The Enterprise tier provides the following managed VMware Tanzu components that empower enterprises to ship faster:

+- Tanzu Build Service

+- Application Configuration Service for Tanzu

+- Tanzu Service Registry

+- Spring Cloud Gateway for Tanzu

+- API portal for VMware Tanzu

+- Application Live View for VMware Tanzu

+- Application Accelerator for VMware Tanzu

+The pricing for Azure Spring Apps Enterprise tier is composed of the following two parts:

+- Infrastructure pricing, set by Microsoft, based on vCPU and memory usage of apps and managed Tanzu components.

+- Tanzu component licensing pricing, set by VMware, based on vCPU usage of apps.

+For more information about pricing, see [Azure Spring Apps pricing](https://azure.microsoft.com/pricing/details/spring-apps/).

+To provide the best customer experience to manage the Tanzu component license purchasing and metering, VMware creates an [Azure Spring Apps Enterprise](https://aka.ms/ascmpoffer) offer in Azure Marketplace. This offer represents a Tanzu component license that is automatically purchased on behalf of customers during the creation of an Azure Spring Apps Enterprise tier instance.

+Under this implicit Azure Marketplace third-party offer purchase from VMware, your personal data and application vCPU usage data is shared with VMware. You agree to this data sharing when you agree to the marketplace terms upon creating the service instance.

+To purchase the Tanzu component license successfully, the billing account of your subscription must be included in one of the locations listed in the [Supported geographic locations of billing account](#supported-geographic-locations-of-billing-account) section. Because of tax management restrictions from VMware in some countries, not all countries are supported.

+The extra license fees apply only to the Enterprise tier. In the Azure Spring Apps Standard tier, there are no extra license fees because the managed Spring components use the OSS config server and Eureka server. No other third-party license fees are required.

+On the [Azure Spring Apps Enterprise](https://aka.ms/ascmpoffer) offer page in Azure Marketplace, you can review the Tanzu component license pricing as shown in the following image.

+You can use the Azure portal or the Azure CLI to provision an Azure Spring Apps Enterprise tier service instance. You can also select **Subscribe** on the Azure Marketplace offer page to create the service instance. Azure Marketplace redirects you to the Azure Spring Apps creation page.

+## Requirements

+You must understand and fulfill the following requirements to successfully create an instance of Azure Spring Apps Enterprise tier when purchasing the Azure Marketplace offer.

+- Your Azure subscription must be registered to the `Microsoft.SaaS` resource provider. For more information, see the [Register resource provider](../azure-resource-manager/management/resource-providers-and-types.md#register-resource-provider) section of [Azure resource providers and types](../azure-resource-manager/management/resource-providers-and-types.md).

+- Your Azure subscription must have an associated payment method. Azure credits or free MSDN subscriptions aren't supported. For more information, see the [Purchasing requirements](/marketplace/azure-marketplace-overview#purchasing-requirements) section of [What is Azure Marketplace?](/marketplace/azure-marketplace-overview)

+- Your Azure subscription must belong to a billing account in a supported geographic location defined in the [Azure Spring Apps Enterprise](https://aka.ms/ascmpoffer) offer in Azure Marketplace. For more information, see the [Supported geographic locations of billing account](#supported-geographic-locations-of-billing-account) section.

+- Your region must be available. Choose an Azure region currently available. For more information, see [In which regions is Azure Spring Apps Enterprise tier available?](./faq.md#in-which-regions-is-azure-spring-apps-enterprise-tier-available) in the [Azure Spring Apps FAQ](faq.md).

+- Your organization must allow Azure Marketplace purchases. For more information, see the [Enabling Azure Marketplace purchases](../cost-management-billing/manage/ea-azure-marketplace.md#enabling-azure-marketplace-purchases) section of [Azure Marketplace](../cost-management-billing/manage/ea-azure-marketplace.md).

+- Your organization must allow acquisition of any Azure Marketplace software application as described in the [Purchase policy management](/marketplace/azure-purchasing-invoicing#purchase-policy-management) section of [Azure Marketplace purchasing](/marketplace/azure-purchasing-invoicing).

+- You must accept the marketplace legal terms and privacy statements while provisioning the tier on the Azure portal, or you can use the following commands to do so in advance.

+ ```azurecli

+ az term accept \

+ --publisher vmware-inc \

+ --product azure-spring-cloud-vmware-tanzu-2 \

+ --plan asa-ent-hr-mtr

+ ```

+## Supported geographic locations of billing account

+To successfully purchase the [Azure Spring Apps Enterprise](https://aka.ms/ascmpoffer) offer on Azure Marketplace, your Azure subscription must belong to a billing account in a supported geographic location defined in the offer.

+The following table lists each supported geographic location and its [ISO 3166 two-digit alpha code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes).

+- [Launch your first app](./quickstart.md)

+- Understand and fulfill the requirements listed in the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+* [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md)

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+* If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+* If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+* If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+* If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- Understand and fulfill the [Requirements](how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](how-to-enterprise-marketplace-offer.md).

+- If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [Enterprise Tier in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+- If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [View Azure Spring Apps Enterprise tier offering in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+- If you're deploying Azure Spring Apps Enterprise tier for the first time in the target subscription, see the [Requirements](./how-to-enterprise-marketplace-offer.md#requirements) section of [View Azure Spring Apps Enterprise tier offering in Azure Marketplace](./how-to-enterprise-marketplace-offer.md).

+Asia | East Asia </br> South East Asia

+Brazil | Brazil South

+United States | Central US </br> East US </br> East US 2</br> North Central US </br> South Central US </br> West Central US </br> West US </br> West US 2 </br> West US 3

+This tutorial uses the CLI within the [Azure Cloud Shell](../../cloud-shell/overview.md), which is constantly updated to the latest version.

+An Azure resource group is a logical container into which Azure resources are deployed and managed. A resource group must be created before a virtual machine. In this example, a resource group named *myResourceGroupVM* is created in the *eastus2* region.

+az group create --name myResourceGroupVM --location eastus2

+When you create a virtual machine, several options are available such as operating system image, disk sizing, and administrative credentials. The following example creates a VM named *myVM* that runs SUSE Linux Enterprise Server (SLES). A user account named *azureuser* is created on the VM, and SSH keys are generated if they do not exist in the default key location (*~/.ssh*):

+ --image SLES \

+ --public-ip-sku Standard \

+It may take a few minutes to create the VM. Once the VM has been created, the Azure CLI outputs information about the VM. Take note of the `publicIpAddress`, this address can be used to access the virtual machine.

+ "location": "eastus2",

+A full list can be seen by adding the `--all` parameter. The image list can also be filtered by `--publisher` or `ΓÇô-offer`. In this example, the list is filtered for all images, published by OpenLogic, with an offer that matches *CentOS*.

+az vm image list --offer CentOS --publisher OpenLogic --all --output table

+Example partial output:

+Architecture Offer Publisher Sku Urn Version

+-- - -- --

+x64 CentOS OpenLogic 8_2 OpenLogic:CentOS:8_2:8.2.2020111800 8.2.2020111800

+x64 CentOS OpenLogic 8_2-gen2 OpenLogic:CentOS:8_2-gen2:8.2.2020062401 8.2.2020062401

+x64 CentOS OpenLogic 8_2-gen2 OpenLogic:CentOS:8_2-gen2:8.2.2020100601 8.2.2020100601

+x64 CentOS OpenLogic 8_2-gen2 OpenLogic:CentOS:8_2-gen2:8.2.2020111801 8.2.2020111801

+x64 CentOS OpenLogic 8_3 OpenLogic:CentOS:8_3:8.3.2020120900 8.3.2020120900

+x64 CentOS OpenLogic 8_3 OpenLogic:CentOS:8_3:8.3.2021020400 8.3.2021020400

+x64 CentOS OpenLogic 8_3-gen2 OpenLogic:CentOS:8_3-gen2:8.3.2020120901 8.3.2020120901

+x64 CentOS OpenLogic 8_3-gen2 OpenLogic:CentOS:8_3-gen2:8.3.2021020401 8.3.2021020401

+x64 CentOS OpenLogic 8_4 OpenLogic:CentOS:8_4:8.4.2021071900 8.4.2021071900

+x64 CentOS OpenLogic 8_4-gen2 OpenLogic:CentOS:8_4-gen2:8.4.2021071901 8.4.2021071901

+x64 CentOS OpenLogic 8_5 OpenLogic:CentOS:8_5:8.5.2022012100 8.5.2022012100

+x64 CentOS OpenLogic 8_5 OpenLogic:CentOS:8_5:8.5.2022101800 8.5.2022101800

+x64 CentOS OpenLogic 8_5-gen2 OpenLogic:CentOS:8_5-gen2:8.5.2022012101 8.5.2022012101

+To deploy a VM using a specific image, take note of the value in the *Urn* column, which consists of the publisher, offer, SKU, and optionally a version number to [identify](cli-ps-findimage.md#terminology) the image. When specifying the image, the image version number can be replaced with `latest`, which selects the latest version of the distribution. In this example, the `--image` parameter is used to specify the latest version of a CentOS 8.5.

+az vm create --resource-group myResourceGroupVM --name myVM2 --image OpenLogic:CentOS:8_5:latest --generate-ssh-keys

+| Type | Description |

+|--||

+| [General purpose](../sizes-general.md) | Balanced CPU-to-memory. Ideal for dev / test and small to medium applications and data solutions. |

+| [Compute optimized](../sizes-compute.md) | High CPU-to-memory. Good for medium traffic applications, network appliances, and batch processes. |

+| [Memory optimized](../sizes-memory.md) | High memory-to-core. Great for relational databases, medium to large caches, and in-memory analytics. |

+| [Storage optimized](../sizes-storage.md) | High disk throughput and IO. Ideal for Big Data, SQL, and NoSQL databases. |

+| [GPU](../sizes-gpu.md) | Specialized VMs targeted for heavy graphic rendering and video editing. |

+| [High performance](../sizes-hpc.md) | Our most powerful CPU VMs with optional high-throughput network interfaces (RDMA). |

+az vm list-sizes --location eastus2 --output table

+Example partial output:

+4 8192 Standard_D2ds_v4 2 1047552 76800

+8 16384 Standard_D4ds_v4 4 1047552 153600

+16 32768 Standard_D8ds_v4 8 1047552 307200

+32 65536 Standard_D16ds_v4 16 1047552 614400

+32 131072 Standard_D32ds_v4 32 1047552 1228800

+32 196608 Standard_D48ds_v4 48 1047552 1843200

+32 262144 Standard_D64ds_v4 64 1047552 2457600

+4 8192 Standard_D2ds_v5 2 1047552 76800

+8 16384 Standard_D4ds_v5 4 1047552 153600

+16 32768 Standard_D8ds_v5 8 1047552 307200

+32 65536 Standard_D16ds_v5 16 1047552 614400

+32 131072 Standard_D32ds_v5 32 1047552 1228800

+32 196608 Standard_D48ds_v5 48 1047552 1843200

+32 262144 Standard_D64ds_v5 64 1047552 2457600

+32 393216 Standard_D96ds_v5 96 1047552 3686400

+ --image SLES \

+ --size Standard_D2ds_v4 \

+az vm resize --resource-group myResourceGroupVM --name myVM --size Standard_D4s_v3

+Code Level DisplayStatus

+ -

+PowerState/running Info VM running

+Depending on how you delete a VM, it may only delete the VM resource, not the networking and disk resources. You can change the default behavior to delete other resources when you delete the VM. For more information, see [Delete a VM and attached resources](../delete.md).

+Deleting a resource group also deletes all resources in the resource group, like the VM, virtual network, and disk. The `--no-wait` parameter returns control to the prompt without waiting for the operation to complete. The `--yes` parameter confirms that you wish to delete the resources without an additional prompt to do so.

+This scope is integrated with [update management center](../update-center/overview.md), which allows you to save recurring deployment schedules to install updates for your Windows Server and Linux machines in Azure, in on-premises environments, and in other cloud environments connected using Azure Arc-enabled servers. Some features and limitations unique to this scope include:

+## Shut Down Machines

+We are unable to apply maintenance updates to any shut down machines. You need to ensure that your machine is turned on at least 15 minutes before a scheduled update or your update may not be applied. If your machine is in a shutdown state at the time of your scheduled update, it may appear that the maintenance configuration has been disassociated on the Azure portal, and this is only a display issue that the team is currently working to fix it. The maintenance configuration has not been completely disassociated and you can check it via CLI using [check configuration](maintenance-configurations-cli.md#check-configuration).

+This script sample creates a virtual network with front-end and back-end subnets. Inbound network traffic to the front-end subnet is limited to HTTP, and HTTPS, while outbound traffic to the internet from the back-end subnet isn't permitted. After running the script, you have one virtual machine with two NICs. Each NIC is connected to a different subnet.

+You can execute the script from the Azure [Cloud Shell](https://shell.azure.com/powershell), or from a local PowerShell installation. If you use PowerShell locally, this script requires the Azure PowerShell module version 1.0.0 or later. To find the installed version, run `Get-InstalledModule -Name Az`. If you need to upgrade, see [Install Azure PowerShell module](/powershell/azure/install-az-ps). If you're running PowerShell locally, you also need to run `Connect-AzAccount` to create a connection with Azure.

+More virtual network PowerShell script samples can be found in [Virtual network PowerShell samples](../powershell-samples.md).

+This script sample creates and connects two virtual networks in the same region through the Azure network. After running the script, you'll create a peering between two virtual networks.

+You can execute the script from the Azure [Cloud Shell](https://shell.azure.com/powershell), or from a local PowerShell installation. If you use PowerShell locally, this script requires the Az PowerShell module version 5.4.1 or later. To find the installed version, run `Get-Module -ListAvailable Az`. If you need to upgrade, see [Install Azure PowerShell module](/powershell/azure/install-Az-ps). If you're running PowerShell locally, you also need to run `Connect-AzAccount` to create a connection with Azure.

+More virtual network PowerShell script samples can be found in [Virtual network PowerShell samples](../powershell-samples.md).

+You can execute the script from the Azure [Cloud Shell](https://shell.azure.com/powershell), or from a local PowerShell installation. If you use PowerShell locally, this script requires the Az PowerShell module version 5.4.1 or later. To find the installed version, run `Get-Module -ListAvailable Az`. If you need to upgrade, see [Install Azure PowerShell module](/powershell/azure/install-Az-ps). If you're running PowerShell locally, you also need to run `Connect-AzAccount` to create a connection with Azure.

+More virtual network PowerShell script samples can be found in [Virtual network PowerShell samples](../powershell-samples.md).