# Cosmos DB

Source: /azure/services/cosmos-db/

## Introduction

Azure Cosmos DB is a globally distributed, multi-model NoSQL database service designed for high availability and low latency.
It supports multiple APIs including SQL (NoSQL), MongoDB, Cassandra, Gremlin, and Table, enabling teams to choose the data model that best fits their application.
Cosmos DB is commonly used for real-time applications, globally replicated datasets, and multi-tenant SaaS platforms that require predictable performance at any scale. For more information, see [Introduction to Azure Cosmos DB](https://learn.microsoft.com/en-us/azure/cosmos-db/introduction).

LocalStack for Azure provides a local environment for building and testing applications that make use of Azure Cosmos DB.
The supported APIs are available on our [API Coverage section](#api-coverage), which provides information on the extent of Cosmos DB's integration with LocalStack.

## Getting started

This guide walks you through creating Cosmos DB accounts, databases, and containers using the SQL and MongoDB APIs.

Launch LocalStack using your preferred method. For more information, see [Introduction to LocalStack for Azure](/azure/getting-started/). Once the container is running, enable Azure CLI interception by running:

```bash
lstk az start-interception
```

This command points the `az` CLI away from the public Azure management REST API and toward the LocalStack for Azure emulator API.
To revert this configuration, run:

```bash
lstk az stop-interception
```

This reconfigures the `az` CLI to send commands to the official Azure management REST API.

### SQL (NoSQL) API

This section walks through creating a Cosmos DB account with the SQL API, creating a database and a container, and listing resources.

#### Create a resource group

Create a resource group to hold all resources created in this guide:

```bash
az group create --name rg-cosmos-demo --location eastus
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo",
  "location": "eastus",
  "name": "rg-cosmos-demo",
  "properties": { "provisioningState": "Succeeded" },
  "type": "Microsoft.Resources/resourceGroups"
}
```

#### Create a Cosmos DB account

Create a Cosmos DB account configured for the SQL API. Tags and capabilities are stored and returned, so tools that compare the response with their configuration, such as Terraform and Bicep, do not report drift:

```bash
az cosmosdb create \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --locations regionName=eastus \
  --tags env=dev
```

```bash title="Output"
{
  "databaseAccountOfferType": "Standard",
  "documentEndpoint": "https://mycosmosaccount.cosmos.documents.localhost.localstack.cloud:4511/",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount",
  "instanceId": "7f34833d-901c-429f-ae09-da2e48417e21",
  "kind": "GlobalDocumentDB",
  "location": "East US",
  "name": "mycosmosaccount",
  "provisioningState": "Succeeded",
  "resourceGroup": "rg-cosmos-demo",
  "tags": {
    "env": "dev"
  },
  "type": "Microsoft.DocumentDB/databaseAccounts",
  ...
}
```

The `documentEndpoint` points at the emulated account. Applications use it exactly as they would use the Azure endpoint; see [Connect with an SDK](#connect-with-an-sdk) for the certificate setup.

The account uses provisioned throughput, because later sections set throughput on its database. Azure does not allow that on a serverless account (`--capabilities EnableServerless`).

Running the same `az cosmosdb create` again updates the existing account in place: it keeps its `instanceId`, its keys and its databases, and only the properties you pass change. Real Azure rejects an account name that is already taken elsewhere, and so does LocalStack.

#### Update an account

Change properties of an existing account with `az cosmosdb update`, which sends a PATCH request. Only the properties you pass change:

```bash
az cosmosdb update \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --tags env=test \
  --query "{name:name, tags:tags, instanceId:instanceId}"
```

```bash title="Output"
{
  "instanceId": "7f34833d-901c-429f-ae09-da2e48417e21",
  "name": "mycosmosaccount",
  "tags": {
    "env": "test"
  }
}
```

#### List account keys

Retrieve the primary and secondary access keys for the account:

```bash
az cosmosdb keys list \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo
```

```bash title="Output"
{
  "primaryMasterKey": "C2y6yDjf5/R+ob0N8A7C...",
  "primaryReadonlyMasterKey": "C2y6yDjf5/R+ob0N8A7C...",
  "secondaryMasterKey": "C2y6yDjf5/R+ob0N8A7C...",
  "secondaryReadonlyMasterKey": "C2y6yDjf5/R+ob0N8A7C..."
}
```

Retrieve the connection string for the account:

```bash
az cosmosdb keys list \
  --type connection-strings \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --query "connectionStrings[0].connectionString"
```

```bash title="Output"
"AccountEndpoint=https://mycosmosaccount.cosmos.documents.localhost.localstack.cloud:4511/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;"
```

#### Create a SQL database

Create a SQL API database within the Cosmos DB account, with dedicated throughput:

```bash
az cosmosdb sql database create \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --name mydb \
  --throughput 400
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount/sqlDatabases/mydb",
  "name": "mydb",
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts/sqlDatabases"
...
}
```

#### Create a SQL container

Create a SQL container with a partition key path of `/id` and a default time to live. The partition key, the indexing policy, the default TTL and unique key policies you pass are applied to the container and returned:

```bash
az cosmosdb sql container create \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --database-name mydb \
  --name mycontainer \
  --partition-key-path /id \
  --ttl 3600
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount/sqlDatabases/mydb/containers/mycontainer",
  "name": "mycontainer",
  "resource": {
    "defaultTtl": 3600,
    "id": "mycontainer",
    "partitionKey": {
      "kind": "Hash",
      "paths": [
        "/id"
      ]
    },
    ...
  },
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers"
}
```

Running `az cosmosdb sql database create` or `az cosmosdb sql container create` again for an existing resource updates it in place, which is what a Bicep or Terraform re-deployment does. Mutable properties such as the TTL and the indexing policy are replaced; a changed partition key is rejected, as on Azure:

```bash
az cosmosdb sql container create \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --database-name mydb \
  --name mycontainer \
  --partition-key-path /id \
  --ttl 7200 \
  --query "{name:name, defaultTtl:resource.defaultTtl}"
```

```bash title="Output"
{
  "defaultTtl": 7200,
  "name": "mycontainer"
}
```

#### Manage throughput

Read and change the throughput of a database or container. A resource created without dedicated throughput has no throughput settings, and reading them returns `NotFound`, as on Azure:

```bash
az cosmosdb sql database throughput show \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --name mydb
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount/sqlDatabases/mydb/throughputSettings/default",
  "resource": {
    "instantMaximumThroughput": "10000",
    "minimumThroughput": "400",
    "softAllowedMaximumThroughput": "1000000",
    "throughput": 400,
    ...
  },
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/throughputSettings"
}
```

```bash
az cosmosdb sql database throughput update \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --name mydb \
  --throughput 1000 \
  --query "resource.throughput"
```

```bash title="Output"
1000
```

The same commands exist for containers (`az cosmosdb sql container throughput show|update`) and for MongoDB databases and collections (`az cosmosdb mongodb database|collection throughput show|update`). Autoscale settings (`--max-throughput`) are stored and reported too. Throughput is recorded and returned, but request units are not metered or enforced.

#### List databases and containers

List all SQL databases in the account and all containers within the database:

```bash
az cosmosdb sql database list \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo
```

```bash title="Output"
[
  {
    "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount/sqlDatabases/mydb",
    "name": "mydb",
    "resourceGroup": "rg-cosmos-demo",
    "type": "Microsoft.DocumentDB/databaseAccounts/sqlDatabases"
  }
]
```


Then list all containers in the database:

```bash
az cosmosdb sql container list \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --database-name mydb
```

```bash title="Output"
[
  {
    "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mycosmosaccount/sqlDatabases/mydb/containers/mycontainer",
    "name": "mycontainer",
    "resourceGroup": "rg-cosmos-demo",
    "type": "Microsoft.DocumentDB/databaseAccounts/sqlDatabases/containers"
  }
]
```

Reading a resource that does not exist returns the same `NotFound` error as Azure, and deleting one that does not exist succeeds, so tools that read before they create, or retry a delete, behave as they do against Azure:

```bash
az cosmosdb sql container show \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --database-name mydb \
  --name missing
```

```bash title="Output"
ERROR: (NotFound) Message: {"code":"NotFound","message":"Message: {\"Errors\":[\"Resource Not Found. Learn more: https://aka.ms/cosmosdb-tsg-not-found\"]}..."}
Code: NotFound
```

#### Connect with an SDK

The emulated account speaks the Cosmos DB REST protocol, so the official SDKs work against it unchanged. The endpoint uses a certificate issued by the LocalStack root CA. Download it from the running emulator and make it trusted by your SDK, for example through `REQUESTS_CA_BUNDLE` for the Python SDK or `NODE_EXTRA_CA_CERTS` for the Node.js SDK:

```bash
curl -s -o ls-root-ca.crt http://localhost:4566/_localstack/certs/ca/LocalStack_LOCAL_Root_CA.crt
export REQUESTS_CA_BUNDLE=$PWD/ls-root-ca.crt
```

Export the account endpoint and primary key for the SDK to read:

```bash
COSMOS_ENDPOINT=$(az cosmosdb show \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --query "documentEndpoint" \
  --output tsv)

COSMOS_KEY=$(az cosmosdb keys list \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --query "primaryMasterKey" \
  --output tsv)

export COSMOS_ENDPOINT COSMOS_KEY
```

Create a database, a container and an item with the Python SDK, reading the endpoint and key from those variables:

```python
import os

from azure.cosmos import CosmosClient, PartitionKey

client = CosmosClient(os.environ["COSMOS_ENDPOINT"], os.environ["COSMOS_KEY"])
database = client.create_database_if_not_exists("appdb")
container = database.create_container_if_not_exists("orders", partition_key=PartitionKey(path="/customerId"))
container.upsert_item({"id": "order-1", "customerId": "c-42", "total": 19.99})
```

Resources created through the data plane are visible to the management plane, so an application can create its own databases and containers and `az`, Bicep or Terraform still see them:

```bash
az cosmosdb sql database list \
  --account-name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --query "[].name"
```

```bash title="Output"
[
  "mydb",
  "appdb"
]
```

### MongoDB API

This section walks through creating a Cosmos DB account with the MongoDB API, creating a database, and connecting with a MongoDB client.

#### Create a MongoDB Cosmos DB account

Create a second Cosmos DB account configured for the MongoDB API. The requested server version is stored and returned, but it does not change the version of the backing MongoDB server. Use a driver compatible with the backing server.

```bash
az cosmosdb create \
  --name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --locations regionName=eastus \
  --kind MongoDB \
  --server-version 7.0
```

```bash title="Output"
{
  "apiProperties": {
    "serverVersion": "7.0"
  },
  "capabilities": [
    {
      "name": "EnableMongo"
    }
  ],
  "databaseAccountOfferType": "Standard",
  "documentEndpoint": "https://mymongoaccount.documents.azure.com:443/",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mymongoaccount",
  "kind": "MongoDB",
  "location": "East US",
  "name": "mymongoaccount",
  "provisioningState": "Succeeded",
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts",
  ...
}
```

#### Retrieve connection string

Retrieve the MongoDB-compatible connection string for the account:

```bash
az cosmosdb keys list \
  --name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --type connection-strings \
  --query "connectionStrings[0].connectionString" \
  --output tsv
```

```bash title="Output"
mongodb://primary:<key>@mymongoaccount.mongo.cosmos.localhost.localstack.cloud:4512/
```

The host name resolves to the emulator and the port is assigned per account, so use the connection string exactly as returned.

#### Create a MongoDB database

Create a MongoDB database within the account:

```bash
az cosmosdb mongodb database create \
  --account-name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --name mymongodb
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mymongoaccount/mongodbDatabases/mymongodb",
  "name": "mymongodb",
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts/mongodbDatabases"
...
}
```

#### Create a MongoDB collection

Create a MongoDB collection inside the database with a shard key, a unique index and dedicated throughput. The shard key and the index options are applied to the collection and returned:

```bash
az cosmosdb mongodb collection create \
  --account-name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --database-name mymongodb \
  --name mycollection \
  --shard userId \
  --idx '[{"key":{"keys":["_id"]}},{"key":{"keys":["userId"]},"options":{"unique":true}}]' \
  --throughput 400
```

```bash title="Output"
{
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mymongoaccount/mongodbDatabases/mymongodb/collections/mycollection",
  "name": "mycollection",
  "resource": {
    "id": "mycollection",
    "indexes": [
      {
        "key": {
          "keys": [
            "_id"
          ]
        },
        "options": null
      },
      {
        "key": {
          "keys": [
            "userId"
          ]
        },
        "options": {
          "expireAfterSeconds": null,
          "unique": true
        }
      }
    ],
    "shardKey": {
      "userId": "Hash"
    },
    ...
  },
  "resourceGroup": "rg-cosmos-demo",
  "type": "Microsoft.DocumentDB/databaseAccounts/mongodbDatabases/collections"
}
```

Collections that an application creates through the MongoDB driver are listed by `az cosmosdb mongodb collection list` as well.

#### Connect with the MongoDB client

Extract the connection string and connect to the MongoDB database using `mongosh`:

```bash
CONN_STR=$(az cosmosdb keys list \
  --name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --type connection-strings \
  --query "connectionStrings[0].connectionString" \
  --output tsv)

mongosh "$CONN_STR"
```

### Delete and verify

Delete the Cosmos DB account and confirm it no longer appears in the list:

```bash
az cosmosdb delete \
  --name mycosmosaccount \
  --resource-group rg-cosmos-demo \
  --yes

az cosmosdb list --resource-group rg-cosmos-demo
```

```bash title="Output"
[
  {
    "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg-cosmos-demo/providers/Microsoft.DocumentDB/databaseAccounts/mymongoaccount",
    "kind": "MongoDB",
    "name": "mymongoaccount",
    "provisioningState": "Succeeded",
    "resourceGroup": "rg-cosmos-demo",
    "type": "Microsoft.DocumentDB/databaseAccounts"
  }
]
```

Delete the second Cosmos DB account configured for the MongoDB API:

```bash
az cosmosdb delete \
  --name mymongoaccount \
  --resource-group rg-cosmos-demo \
  --yes
```

Then list all Cosmos DB accounts to confirm the resource group is now empty:

```bash
az cosmosdb list --resource-group rg-cosmos-demo
```

```bash title="Output"
[]
```

## Features

- **Account lifecycle:** Create, read, update (PUT and PATCH), list, and delete Cosmos DB accounts for both SQL and MongoDB API kinds. Re-deploying an existing account updates it in place and keeps its keys and data.
- **Account properties:** Tags, capabilities, the MongoDB server version, consistency policy, failover priorities and properties such as `enableFreeTier`, `publicNetworkAccess` and `minimalTlsVersion` are stored and returned.
- **Account key management:** Retrieve primary and secondary master keys and read-only keys.
- **Connection strings:** Retrieve connection strings for the API for NoSQL (SQL) and for MongoDB via `az cosmosdb keys list --type connection-strings`.
- **Name availability check:** Validate account name uniqueness; a taken name cannot be claimed from another resource group or subscription.
- **SQL databases:** Create, read, update, list, and delete SQL (NoSQL) databases within an account.
- **SQL containers:** Create, read, update, list, and delete SQL containers with partition key (including hierarchical keys), indexing policy, default TTL, unique key policy and conflict resolution policy.
- **Throughput settings:** Read and update manual or autoscale throughput of SQL databases and containers and of MongoDB databases and collections.
- **MongoDB databases:** Create, read, list, and delete MongoDB databases within an account; re-deploying an existing database keeps it and its collections.
- **MongoDB collections:** Create, read, update, list, and delete MongoDB collections with shard key, indexes (including `unique` and `expireAfterSeconds` options) and throughput settings.
- **Data plane integration:** Databases, containers and collections created through the Cosmos DB SDKs or a MongoDB driver are visible to the management plane, and vice versa.
- **Native MongoDB access:** Connect directly to the local MongoDB backend using a standard MongoDB client.
- **Cosmos DB for PostgreSQL:** Create, start, stop, restart and delete clusters (`Microsoft.DBforPostgreSQL/serverGroupsv2`) with firewall rules, backed by a local PostgreSQL server.

## Limitations

- **Table API not supported:** The Cosmos DB Table API is not emulated.
- **Cassandra API not supported:** The Cosmos DB Cassandra API is not emulated.
- **Gremlin API not supported:** The Cosmos DB Gremlin (graph) API is not emulated.
- **Cosmos DB for PostgreSQL:** The backing server is a plain PostgreSQL instance without the Citus extension, so distributed tables are not available. Worker nodes exist as metadata only. Azure has retired this service for new clusters.
- **Global distribution not emulated:** Multi-region replication and conflict resolution are accepted at the model level but not executed.
- **Change feed and triggers:** Change feed processing and Cosmos DB triggers for Azure Functions are not emulated.
- **Throughput and RU metering:** Throughput settings are stored and returned, but request unit (RU) consumption is not tracked or enforced. Migrating between manual and autoscale throughput is not supported. A serverless account (`EnableServerless`) accepts throughput settings, which Azure rejects.
- **RBAC for data plane:** Cosmos DB SQL role definitions and role assignments are not implemented, and data plane requests are not authorized: any key or Microsoft Entra token is accepted, and `disableLocalAuth` is not enforced.
- **Key regeneration and failover:** Regenerating account keys and changing failover priorities of an existing account are not supported.
- **Stored procedures, triggers and user-defined functions:** Not supported through the management plane.

## Samples

The following samples demonstrate how to use Azure Cosmos DB with LocalStack for Azure. Each comes in a Python and a .NET version:

- Web App and Cosmos DB for NoSQL API ([Python](https://github.com/localstack/localstack-azure-samples/tree/main/samples/web-app-cosmosdb-nosql-api/python), [.NET](https://github.com/localstack/localstack-azure-samples/tree/main/samples/web-app-cosmosdb-nosql-api/dotnet))
- Web App and Cosmos DB for MongoDB API ([Python](https://github.com/localstack/localstack-azure-samples/tree/main/samples/web-app-cosmosdb-mongodb-api/python), [.NET](https://github.com/localstack/localstack-azure-samples/tree/main/samples/web-app-cosmosdb-mongodb-api/dotnet))
- AKS workload and Cosmos DB for NoSQL API ([Python](https://github.com/localstack-samples/aks-samples/tree/main/samples/web-app-cosmosdb-nosql-api/python), [.NET](https://github.com/localstack-samples/aks-samples/tree/main/samples/web-app-cosmosdb-nosql-api/dotnet))
- AKS workload and Cosmos DB for MongoDB API ([Python](https://github.com/localstack-samples/aks-samples/tree/main/samples/web-app-cosmosdb-mongodb-api/python), [.NET](https://github.com/localstack-samples/aks-samples/tree/main/samples/web-app-cosmosdb-mongodb-api/dotnet))

## API Coverage


### Cosmos DB API coverage

Source service: `cosmos-db`. 50 of 310 tracked operations are implemented.

Service documentation: /azure/services/cosmos-db/

| Operation | Status |
| --- | --- |
| CassandraResources.CreateUpdateCassandraKeyspace | Not implemented |
| CassandraResources.CreateUpdateCassandraRoleAssignment | Not implemented |
| CassandraResources.CreateUpdateCassandraRoleDefinition | Not implemented |
| CassandraResources.CreateUpdateCassandraTable | Not implemented |
| CassandraResources.DeleteCassandraKeyspace | Not implemented |
| CassandraResources.DeleteCassandraRoleAssignment | Not implemented |
| CassandraResources.DeleteCassandraRoleDefinition | Not implemented |
| CassandraResources.DeleteCassandraTable | Not implemented |
| CassandraResources.GetCassandraKeyspace | Not implemented |
| CassandraResources.GetCassandraKeyspaceThroughput | Not implemented |
| CassandraResources.GetCassandraRoleAssignment | Not implemented |
| CassandraResources.GetCassandraRoleDefinition | Not implemented |
| CassandraResources.GetCassandraTable | Not implemented |
| CassandraResources.GetCassandraTableThroughput | Not implemented |
| CassandraResources.ListCassandraKeyspaces | Not implemented |
| CassandraResources.ListCassandraRoleAssignments | Not implemented |
| CassandraResources.ListCassandraRoleDefinitions | Not implemented |
| CassandraResources.ListCassandraTables | Not implemented |
| CassandraResources.MigrateCassandraKeyspaceToAutoscale | Not implemented |
| CassandraResources.MigrateCassandraKeyspaceToManualThroughput | Not implemented |
| CassandraResources.MigrateCassandraTableToAutoscale | Not implemented |
| CassandraResources.MigrateCassandraTableToManualThroughput | Not implemented |
| CassandraResources.UpdateCassandraKeyspaceThroughput | Not implemented |
| CassandraResources.UpdateCassandraTableThroughput | Not implemented |
| Clusters.CheckNameAvailability | Implemented |
| Collection.ListMetricDefinitions | Not implemented |
| Collection.ListMetrics | Not implemented |
| Collection.ListUsages | Not implemented |
| CollectionPartition.ListMetrics | Not implemented |
| CollectionPartition.ListUsages | Not implemented |
| CollectionPartitionRegion.ListMetrics | Not implemented |
| CollectionRegion.ListMetrics | Not implemented |
| Database.ListMetricDefinitions | Not implemented |
| Database.ListMetrics | Not implemented |
| Database.ListUsages | Not implemented |
| DatabaseAccountRegion.ListMetrics | Not implemented |
| DatabaseAccounts.CheckNameExists | Implemented |
| DatabaseAccounts.CreateOrUpdate | Implemented |
| DatabaseAccounts.CreateUpdateCassandraKeyspace | Not implemented |
| DatabaseAccounts.CreateUpdateCassandraTable | Not implemented |
| DatabaseAccounts.CreateUpdateGremlinDatabase | Not implemented |
| DatabaseAccounts.CreateUpdateGremlinGraph | Not implemented |
| DatabaseAccounts.CreateUpdateMongoDbCollection | Not implemented |
| DatabaseAccounts.CreateUpdateMongoDbDatabase | Not implemented |
| DatabaseAccounts.CreateUpdateSqlContainer | Not implemented |
| DatabaseAccounts.CreateUpdateSqlDatabase | Not implemented |
| DatabaseAccounts.CreateUpdateTable | Not implemented |
| DatabaseAccounts.Delete | Implemented |
| DatabaseAccounts.DeleteCassandraKeyspace | Not implemented |
| DatabaseAccounts.DeleteCassandraTable | Not implemented |
| DatabaseAccounts.DeleteGremlinDatabase | Not implemented |
| DatabaseAccounts.DeleteGremlinGraph | Not implemented |
| DatabaseAccounts.DeleteMongoDbCollection | Not implemented |
| DatabaseAccounts.DeleteMongoDbDatabase | Not implemented |
| DatabaseAccounts.DeleteSqlContainer | Not implemented |
| DatabaseAccounts.DeleteSqlDatabase | Not implemented |
| DatabaseAccounts.DeleteTable | Not implemented |
| DatabaseAccounts.FailoverPriorityChange | Not implemented |
| DatabaseAccounts.Get | Implemented |
| DatabaseAccounts.GetCassandraKeyspace | Not implemented |
| DatabaseAccounts.GetCassandraKeyspaceThroughput | Not implemented |
| DatabaseAccounts.GetCassandraTable | Not implemented |
| DatabaseAccounts.GetCassandraTableThroughput | Not implemented |
| DatabaseAccounts.GetGremlinDatabase | Not implemented |
| DatabaseAccounts.GetGremlinDatabaseThroughput | Not implemented |
| DatabaseAccounts.GetGremlinGraph | Not implemented |
| DatabaseAccounts.GetGremlinGraphThroughput | Not implemented |
| DatabaseAccounts.GetMongoDbCollection | Not implemented |
| DatabaseAccounts.GetMongoDbCollectionThroughput | Not implemented |
| DatabaseAccounts.GetMongoDbDatabase | Not implemented |
| DatabaseAccounts.GetMongoDbDatabaseThroughput | Not implemented |
| DatabaseAccounts.GetReadOnlyKeys | Implemented |
| DatabaseAccounts.GetSqlContainer | Not implemented |
| DatabaseAccounts.GetSqlContainerThroughput | Not implemented |
| DatabaseAccounts.GetSqlDatabase | Not implemented |
| DatabaseAccounts.GetSqlDatabaseThroughput | Not implemented |
| DatabaseAccounts.GetTable | Not implemented |
| DatabaseAccounts.GetTableThroughput | Not implemented |
| DatabaseAccounts.List | Implemented |
| DatabaseAccounts.ListByResourceGroup | Implemented |
| DatabaseAccounts.ListCassandraKeyspaces | Not implemented |
| DatabaseAccounts.ListCassandraTables | Not implemented |
| DatabaseAccounts.ListConnectionStrings | Implemented |
| DatabaseAccounts.ListGremlinDatabases | Not implemented |
| DatabaseAccounts.ListGremlinGraphs | Not implemented |
| DatabaseAccounts.ListKeys | Implemented |
| DatabaseAccounts.ListMetricDefinitions | Not implemented |
| DatabaseAccounts.ListMetrics | Not implemented |
| DatabaseAccounts.ListMongoDbCollections | Not implemented |
| DatabaseAccounts.ListMongoDbDatabases | Not implemented |
| DatabaseAccounts.ListReadOnlyKeys | Implemented |
| DatabaseAccounts.ListSqlContainers | Not implemented |
| DatabaseAccounts.ListSqlDatabases | Not implemented |
| DatabaseAccounts.ListTables | Not implemented |
| DatabaseAccounts.ListUsages | Not implemented |
| DatabaseAccounts.OfflineRegion | Not implemented |
| DatabaseAccounts.OnlineRegion | Not implemented |
| DatabaseAccounts.RegenerateKey | Not implemented |
| DatabaseAccounts.Update | Implemented |
| DatabaseAccounts.UpdateCassandraKeyspaceThroughput | Not implemented |
| DatabaseAccounts.UpdateCassandraTableThroughput | Not implemented |
| DatabaseAccounts.UpdateGremlinDatabaseThroughput | Not implemented |
| DatabaseAccounts.UpdateGremlinGraphThroughput | Not implemented |
| DatabaseAccounts.UpdateMongoDbCollectionThroughput | Not implemented |
| DatabaseAccounts.UpdateMongoDbDatabaseThroughput | Not implemented |
| DatabaseAccounts.UpdateSqlContainerThroughput | Not implemented |
| DatabaseAccounts.UpdateSqlDatabaseThroughput | Not implemented |
| DatabaseAccounts.UpdateTableThroughput | Not implemented |
| Fleet.Create | Not implemented |
| Fleet.Delete | Not implemented |
| Fleet.Get | Not implemented |
| Fleet.List | Not implemented |
| Fleet.ListByResourceGroup | Not implemented |
| Fleet.Update | Not implemented |
| Fleetspace.Create | Not implemented |
| Fleetspace.Delete | Not implemented |
| Fleetspace.Get | Not implemented |
| Fleetspace.List | Not implemented |
| Fleetspace.Update | Not implemented |
| FleetspaceAccount.Create | Not implemented |
| FleetspaceAccount.Delete | Not implemented |
| FleetspaceAccount.Get | Not implemented |
| FleetspaceAccount.List | Not implemented |
| GremlinResources.CreateUpdateGremlinDatabase | Not implemented |
| GremlinResources.CreateUpdateGremlinGraph | Not implemented |
| GremlinResources.CreateUpdateGremlinRoleAssignment | Not implemented |
| GremlinResources.CreateUpdateGremlinRoleDefinition | Not implemented |
| GremlinResources.DeleteGremlinDatabase | Not implemented |
| GremlinResources.DeleteGremlinGraph | Not implemented |
| GremlinResources.DeleteGremlinRoleAssignment | Not implemented |
| GremlinResources.DeleteGremlinRoleDefinition | Not implemented |
| GremlinResources.GetGremlinDatabase | Not implemented |
| GremlinResources.GetGremlinDatabaseThroughput | Not implemented |
| GremlinResources.GetGremlinGraph | Not implemented |
| GremlinResources.GetGremlinGraphThroughput | Not implemented |
| GremlinResources.GetGremlinRoleAssignment | Not implemented |
| GremlinResources.GetGremlinRoleDefinition | Not implemented |
| GremlinResources.ListGremlinDatabases | Not implemented |
| GremlinResources.ListGremlinGraphs | Not implemented |
| GremlinResources.ListGremlinRoleAssignments | Not implemented |
| GremlinResources.ListGremlinRoleDefinitions | Not implemented |
| GremlinResources.MigrateGremlinDatabaseToAutoscale | Not implemented |
| GremlinResources.MigrateGremlinDatabaseToManualThroughput | Not implemented |
| GremlinResources.MigrateGremlinGraphToAutoscale | Not implemented |
| GremlinResources.MigrateGremlinGraphToManualThroughput | Not implemented |
| GremlinResources.RetrieveContinuousBackupInformation | Not implemented |
| GremlinResources.UpdateGremlinDatabaseThroughput | Not implemented |
| GremlinResources.UpdateGremlinGraphThroughput | Not implemented |
| Locations.Get | Not implemented |
| Locations.List | Not implemented |
| MongoDbResources.CreateUpdateMongoDbCollection | Implemented |
| MongoDbResources.CreateUpdateMongoDbDatabase | Implemented |
| MongoDbResources.CreateUpdateMongoRoleDefinition | Not implemented |
| MongoDbResources.CreateUpdateMongoUserDefinition | Not implemented |
| MongoDbResources.DeleteMongoDbCollection | Implemented |
| MongoDbResources.DeleteMongoDbDatabase | Implemented |
| MongoDbResources.DeleteMongoRoleDefinition | Not implemented |
| MongoDbResources.DeleteMongoUserDefinition | Not implemented |
| MongoDbResources.GetMongoDbCollection | Implemented |
| MongoDbResources.GetMongoDbCollectionThroughput | Implemented |
| MongoDbResources.GetMongoDbDatabase | Implemented |
| MongoDbResources.GetMongoDbDatabaseThroughput | Implemented |
| MongoDbResources.GetMongoRoleDefinition | Not implemented |
| MongoDbResources.GetMongoUserDefinition | Not implemented |
| MongoDbResources.ListMongoDbCollections | Implemented |
| MongoDbResources.ListMongoDbDatabases | Implemented |
| MongoDbResources.ListMongoRoleDefinitions | Not implemented |
| MongoDbResources.ListMongoUserDefinitions | Not implemented |
| MongoDbResources.MigrateMongoDbCollectionToAutoscale | Not implemented |
| MongoDbResources.MigrateMongoDbCollectionToManualThroughput | Not implemented |
| MongoDbResources.MigrateMongoDbDatabaseToAutoscale | Not implemented |
| MongoDbResources.MigrateMongoDbDatabaseToManualThroughput | Not implemented |
| MongoDbResources.RetrieveContinuousBackupInformation | Not implemented |
| MongoDbResources.UpdateMongoDbCollectionThroughput | Implemented |
| MongoDbResources.UpdateMongoDbDatabaseThroughput | Implemented |
| MongoMIResources.CreateUpdateMongoMIRoleAssignment | Not implemented |
| MongoMIResources.CreateUpdateMongoMIRoleDefinition | Not implemented |
| MongoMIResources.DeleteMongoMIRoleAssignment | Not implemented |
| MongoMIResources.DeleteMongoMIRoleDefinition | Not implemented |
| MongoMIResources.GetMongoMIRoleAssignment | Not implemented |
| MongoMIResources.GetMongoMIRoleDefinition | Not implemented |
| MongoMIResources.ListMongoMIRoleAssignments | Not implemented |
| MongoMIResources.ListMongoMIRoleDefinitions | Not implemented |
| NotebookWorkspaces.CreateOrUpdate | Not implemented |
| NotebookWorkspaces.Delete | Not implemented |
| NotebookWorkspaces.Get | Not implemented |
| NotebookWorkspaces.ListByDatabaseAccount | Not implemented |
| NotebookWorkspaces.ListConnectionInfo | Not implemented |
| NotebookWorkspaces.RegenerateAuthToken | Not implemented |
| NotebookWorkspaces.Start | Not implemented |
| Operations.List | Not implemented |
| PartitionKeyRangeId.ListMetrics | Not implemented |
| PartitionKeyRangeIdRegion.ListMetrics | Not implemented |
| Percentile.ListMetrics | Not implemented |
| PercentileSourceTarget.ListMetrics | Not implemented |
| PercentileTarget.ListMetrics | Not implemented |
| PrivateEndpointConnections.CreateOrUpdate | Not implemented |
| PrivateEndpointConnections.Delete | Not implemented |
| PrivateEndpointConnections.Get | Not implemented |
| PrivateEndpointConnections.ListByDatabaseAccount | Not implemented |
| PrivateLinkResources.Get | Not implemented |
| PrivateLinkResources.ListByDatabaseAccount | Not implemented |
| RestorableDatabaseAccounts.GetByLocation | Not implemented |
| RestorableDatabaseAccounts.List | Not implemented |
| RestorableDatabaseAccounts.ListByLocation | Not implemented |
| RestorableGremlinDatabases.List | Not implemented |
| RestorableGremlinGraphs.List | Not implemented |
| RestorableGremlinResources.List | Not implemented |
| RestorableMongodbCollections.List | Not implemented |
| RestorableMongodbDatabases.List | Not implemented |
| RestorableMongodbResources.List | Not implemented |
| RestorableSqlContainers.List | Not implemented |
| RestorableSqlDatabases.List | Not implemented |
| RestorableSqlResources.List | Not implemented |
| RestorableTableResources.List | Not implemented |
| RestorableTables.List | Not implemented |
| ServerGroupsv2.Clusters_Create | Implemented |
| ServerGroupsv2.Clusters_Delete | Implemented |
| ServerGroupsv2.Clusters_Get | Implemented |
| ServerGroupsv2.Clusters_List | Implemented |
| ServerGroupsv2.Clusters_ListByResourceGroup | Implemented |
| ServerGroupsv2.Clusters_PromoteReadReplica | Not implemented |
| ServerGroupsv2.Clusters_Restart | Implemented |
| ServerGroupsv2.Clusters_Start | Implemented |
| ServerGroupsv2.Clusters_Stop | Implemented |
| ServerGroupsv2.Clusters_Update | Not implemented |
| ServerGroupsv2.Configurations_Get | Not implemented |
| ServerGroupsv2.Configurations_GetCoordinator | Not implemented |
| ServerGroupsv2.Configurations_GetNode | Not implemented |
| ServerGroupsv2.Configurations_ListByCluster | Not implemented |
| ServerGroupsv2.Configurations_ListByServer | Not implemented |
| ServerGroupsv2.Configurations_UpdateOnCoordinator | Not implemented |
| ServerGroupsv2.Configurations_UpdateOnNode | Not implemented |
| ServerGroupsv2.FirewallRules_CreateOrUpdate | Implemented |
| ServerGroupsv2.FirewallRules_Delete | Implemented |
| ServerGroupsv2.FirewallRules_Get | Implemented |
| ServerGroupsv2.FirewallRules_ListByCluster | Implemented |
| ServerGroupsv2.PrivateEndpointConnections_CreateOrUpdate | Not implemented |
| ServerGroupsv2.PrivateEndpointConnections_Delete | Not implemented |
| ServerGroupsv2.PrivateEndpointConnections_Get | Not implemented |
| ServerGroupsv2.PrivateEndpointConnections_ListByCluster | Not implemented |
| ServerGroupsv2.PrivateLinkResources_Get | Not implemented |
| ServerGroupsv2.PrivateLinkResources_ListByCluster | Not implemented |
| ServerGroupsv2.Roles_Create | Not implemented |
| ServerGroupsv2.Roles_Delete | Not implemented |
| ServerGroupsv2.Roles_Get | Not implemented |
| ServerGroupsv2.Roles_ListByCluster | Not implemented |
| ServerGroupsv2.Servers_Get | Implemented |
| ServerGroupsv2.Servers_ListByCluster | Implemented |
| Service.Create | Not implemented |
| Service.Delete | Not implemented |
| Service.Get | Not implemented |
| Service.List | Not implemented |
| SqlResources.CreateUpdateClientEncryptionKey | Not implemented |
| SqlResources.CreateUpdateSqlContainer | Implemented |
| SqlResources.CreateUpdateSqlDatabase | Implemented |
| SqlResources.CreateUpdateSqlRoleAssignment | Not implemented |
| SqlResources.CreateUpdateSqlRoleDefinition | Not implemented |
| SqlResources.CreateUpdateSqlStoredProcedure | Not implemented |
| SqlResources.CreateUpdateSqlTrigger | Not implemented |
| SqlResources.CreateUpdateSqlUserDefinedFunction | Not implemented |
| SqlResources.DeleteSqlContainer | Implemented |
| SqlResources.DeleteSqlDatabase | Implemented |
| SqlResources.DeleteSqlRoleAssignment | Not implemented |
| SqlResources.DeleteSqlRoleDefinition | Not implemented |
| SqlResources.DeleteSqlStoredProcedure | Not implemented |
| SqlResources.DeleteSqlTrigger | Not implemented |
| SqlResources.DeleteSqlUserDefinedFunction | Not implemented |
| SqlResources.GetClientEncryptionKey | Not implemented |
| SqlResources.GetSqlContainer | Implemented |
| SqlResources.GetSqlContainerThroughput | Implemented |
| SqlResources.GetSqlDatabase | Implemented |
| SqlResources.GetSqlDatabaseThroughput | Implemented |
| SqlResources.GetSqlRoleAssignment | Not implemented |
| SqlResources.GetSqlRoleDefinition | Not implemented |
| SqlResources.GetSqlStoredProcedure | Not implemented |
| SqlResources.GetSqlTrigger | Not implemented |
| SqlResources.GetSqlUserDefinedFunction | Not implemented |
| SqlResources.ListClientEncryptionKeys | Not implemented |
| SqlResources.ListSqlContainers | Implemented |
| SqlResources.ListSqlDatabases | Implemented |
| SqlResources.ListSqlRoleAssignments | Not implemented |
| SqlResources.ListSqlRoleDefinitions | Not implemented |
| SqlResources.ListSqlStoredProcedures | Not implemented |
| SqlResources.ListSqlTriggers | Not implemented |
| SqlResources.ListSqlUserDefinedFunctions | Not implemented |
| SqlResources.MigrateSqlContainerToAutoscale | Not implemented |
| SqlResources.MigrateSqlContainerToManualThroughput | Not implemented |
| SqlResources.MigrateSqlDatabaseToAutoscale | Not implemented |
| SqlResources.MigrateSqlDatabaseToManualThroughput | Not implemented |
| SqlResources.RetrieveContinuousBackupInformation | Not implemented |
| SqlResources.UpdateSqlContainerThroughput | Implemented |
| SqlResources.UpdateSqlDatabaseThroughput | Implemented |
| TableResources.CreateUpdateTable | Not implemented |
| TableResources.CreateUpdateTableRoleAssignment | Not implemented |
| TableResources.CreateUpdateTableRoleDefinition | Not implemented |
| TableResources.DeleteTable | Not implemented |
| TableResources.DeleteTableRoleAssignment | Not implemented |
| TableResources.DeleteTableRoleDefinition | Not implemented |
| TableResources.GetTable | Not implemented |
| TableResources.GetTableRoleAssignment | Not implemented |
| TableResources.GetTableRoleDefinition | Not implemented |
| TableResources.GetTableThroughput | Not implemented |
| TableResources.ListTableRoleAssignments | Not implemented |
| TableResources.ListTableRoleDefinitions | Not implemented |
| TableResources.ListTables | Not implemented |
| TableResources.MigrateTableToAutoscale | Not implemented |
| TableResources.MigrateTableToManualThroughput | Not implemented |
| TableResources.RetrieveContinuousBackupInformation | Not implemented |
| TableResources.UpdateTableThroughput | Not implemented |