你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

免责声明

对 Python 2.7 的 Azure SDK Python 包支持已于 2022 年 1 月 1 日结束。 有关详细信息和问题，请参阅 https://github.com/Azure/azure-sdk-for-python/issues/20691

适用于 Python 的 Azure Cosmos DB SQL API 客户端库 - 版本 4.5.1

Azure Cosmos DB 是一种全球分布式多模型数据库服务，支持文档、键值、宽列和图形数据库。

使用适用于 Python 的 Azure Cosmos DB SQL API SDK 管理数据库及其包含在此 NoSQL 数据库服务中的 JSON 文档。 高级功能包括：

• 创建 Cosmos DB 数据库 并修改其设置
• 创建和修改 容器 以存储 JSON 文档集合
• 创建、读取、更新和删除容器中) JSON 文档 (项
• 使用类似于 SQL 的语法查询数据库中的文档

SDK 源代码 | 包 (PyPI) | 包 (Conda) | API 参考文档 | 产品文档 | 样品

此 SDK 用于 SQL API。 对于所有其他 API，请检查 Azure Cosmos DB 文档来评估项目的最佳 SDK。

入门

Python 2.x 支持的重要更新

从 2022 年 1 月 1 日开始，此 SDK 的新版本不支持 Python 2.x。 有关详细信息，请查看 CHANGELOG。

先决条件

• Azure 订阅 - 创建免费帐户
• Azure Cosmos DB 帐户 - SQL API
• Python 3.6+

如果需要 Cosmos DB SQL API 帐户，可以使用以下 Azure CLI 命令创建一个帐户：

az cosmosdb create --resource-group <resource-group-name> --name <cosmos-account-name>

安装包

pip install azure-cosmos

配置虚拟环境（可选）

尽管并不要求使用虚拟环境，但使用这种环境可让基础系统与 Azure SDK 环境相互保持隔离。 执行以下命令配置，然后使用 venv 进入虚拟环境：

python3 -m venv azure-cosmosdb-sdk-environment
source azure-cosmosdb-sdk-environment/bin/activate

验证客户端

与 Cosmos DB 的交互从 CosmosClient 类的实例开始。 需要一个 帐户、其 URI 和其中一个 帐户密钥 来实例化客户端对象。

使用以下 Azure CLI 代码片段使用数据库帐户 URI 及其主密钥填充两个环境变量 (也可以在Azure 门户) 中找到这些值。 此代码片段已针对 Bash shell 格式化。

RES_GROUP=<resource-group-name>
ACCT_NAME=<cosmos-db-account-name>

export ACCOUNT_URI=$(az cosmosdb show --resource-group $RES_GROUP --name $ACCT_NAME --query documentEndpoint --output tsv)
export ACCOUNT_KEY=$(az cosmosdb list-keys --resource-group $RES_GROUP --name $ACCT_NAME --query primaryMasterKey --output tsv)

创建客户端

填充 ACCOUNT_URI 和 ACCOUNT_KEY 环境变量后，可以创建 CosmosClient。

from azure.cosmos import CosmosClient

import os
URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)

AAD 身份验证

还可以使用服务主体的 AAD 凭据和 Azure 标识包对客户端进行身份验证。 可以直接将凭据信息传递到 ClientSecretCredential，或使用 DefaultAzureCredential：

from azure.cosmos import CosmosClient
from azure.identity import ClientSecretCredential, DefaultAzureCredential

import os
url = os.environ['ACCOUNT_URI']
tenant_id = os.environ['TENANT_ID']
client_id = os.environ['CLIENT_ID']
client_secret = os.environ['CLIENT_SECRET']

# Using ClientSecretCredential
aad_credentials = ClientSecretCredential(
    tenant_id=tenant_id,
    client_id=client_id,
    client_secret=client_secret)

# Using DefaultAzureCredential (recommended)
aad_credentials = DefaultAzureCredential()

client = CosmosClient(url, aad_credentials)

始终确保用于 AAD 身份验证的托管标识具有 readMetadata 权限。
有关如何设置 AAD 身份验证的详细信息： 为 AAD 身份验证设置 RBAC
有关 AAD 身份验证客户端允许的操作的详细信息： RBAC 权限模型

关键概念

初始化 CosmosClient 后，可以与 Cosmos DB 中的主要资源类型进行交互：

• 数据库：一个 Cosmos DB 帐户可包含多个数据库。 创建数据库时，指定与文档交互时要使用的 API：SQL、MongoDB、Gremlin、Cassandra 或 Azure 表。 使用 DatabaseProxy 对象管理其容器。

• 容器：容器是 JSON 文档的集合。 使用 ContainerProxy 对象上的方法创建 (插入) 、读取、更新和删除容器中的项。

• Item：Item 是存储在容器中的 JSON 文档的字典式表示形式。 添加到容器的每个项都必须包含一个 id 键，其中包含用于唯一标识容器中的项的值。

有关这些资源的详细信息，请参阅使用 Azure Cosmos 数据库、容器和项。

如何使用 enable_cross_partition_query

关键字 (keyword) 参数enable_cross_partition_query接受 2 个选项： None (默认) 或 True。

有关按 ID 使用查询的注意事项

使用尝试基于 ID 值查找项的查询时，请始终确保传入字符串类型变量。 Azure Cosmos DB 仅允许字符串 ID 值，如果使用任何其他数据类型，此 SDK 将不返回任何结果和错误消息。

有关客户端一致性级别的说明

从版本 4.3.0b3 开始，如果用户未向其客户端初始化传入显式一致性级别，则其客户端将使用其数据库帐户的默认级别。 以前，默认设置为 Session 一致性。 如果出于某种原因想要继续执行此操作，可以更改客户端初始化，以包含此的显式参数，如下所示：

from azure.cosmos import CosmosClient

import os
URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY, consistency_level='Session')

限制

目前不支持以下功能。 有关替代选项，检查下面的“解决方法”部分。

数据平面限制：

• 分组依据查询
• 来自 DISTINCT 子查询的 COUNT 查询：SELECT COUNT (1) FROM (SELECT DISTINCT C.ID FROM C)
• 批量/事务批处理
• 直接 TCP 模式访问
• 对聚合跨分区查询（如排序、计数和 distinct）的延续标记支持。 可流式处理查询（如 ） SELECT * FROM WHERE支持 继续标记。
• 更改源：处理器
• 更改源：读取多个分区键值
• 更改源：读取特定时间
• 更改源：从头开始读取
• 更改源：拉取模型
• 混合类型的跨分区 ORDER BY
• 为异步查询类型方法启用诊断

控制平面限制：

• 获取 CollectionSizeUsage、DatabaseUsage 和 DocumentUsage 指标
• 创建地理空间索引
• 获取连接字符串
• 获取容器的最小 RU/秒

解决方法

批量处理限制解决方法

如果要使用 Python SDK 对 Cosmos DB 执行批量插入，最佳替代方法是使用 存储过程 以使用相同的分区键写入多个项。

控制平面限制解决方法

通常，可以将 Azure 门户、 Azure Cosmos DB 资源提供程序 REST API、 Azure CLI 或 PowerShell 用于控制平面不支持的限制。

布尔数据类型

虽然 Python 语言对布尔类型 使用 “True”和“False”，但 Cosmos DB 仅 接受 “true”和“false”。 换句话说，Python 语言使用带有第一个大写字母和所有其他小写字母的布尔值，而 Cosmos DB 及其 SQL 语言仅对相同的布尔值使用小写字母。 如何处理此挑战？

• 使用 Python 创建的 JSON 文档必须使用“True”和“False”才能通过语言验证。 SDK 会将其转换为“true”和“false”。 这意味着“true”和“false”将存储在 Cosmos DB 中。
• 如果使用 Cosmos DB 门户的数据资源管理器检索这些文档，将看到“true”和“false”。
• 如果使用此 Python SDK 检索这些文档，“true”和“false”值将自动转换为“True”和“False”。

SQL 查询 x FROM 子句子项

此 SDK 使用 query_items 方法将 SQL 查询提交到 Azure Cosmos DB。

Cosmos DB SQL 语言允许 使用 FROM 子句获取子项，以将源减少到较小的子集。 例如，可以使用 select * from Families.children 而不是 select * from Families。 但请注意：

• 对于使用 方法的 query_items SQL 查询，此 SDK 要求指定 partition_key 或使用 enable_cross_partition_query 标志。
• 如果要获取子项并指定 partition_key，请确保子项中包含分区键，这在大多数情况下都不是如此。

最大项计数

这是 query_items 方法的参数，指示每页返回的最大项数的整数。 None可以指定 值，让服务确定最佳项计数。 这是建议的配置值，也是未设置此 SDK 时的默认行为。

示例

以下部分提供了多个代码片段，其中涵盖了一些最常见的 Cosmos DB 任务，包括：

• 创建数据库
• 创建容器
• 创建启用了分析存储的容器
• 获取现有容器
• 插入数据
• 删除数据
• 查询数据库
• 获取数据库属性
• 获取数据库和容器吞吐量
• 修改容器属性
• 使用异步客户端

创建数据库

向 CosmosClient 进行身份验证后，可以使用帐户中的任何资源。 以下代码片段创建一个 SQL API 数据库，在调用 create_database 时未指定 API 时，该数据库是默认的。

from azure.cosmos import CosmosClient, exceptions
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
try:
    database = client.create_database(DATABASE_NAME)
except exceptions.CosmosResourceExistsError:
    database = client.get_database_client(DATABASE_NAME)

创建容器

此示例使用默认设置创建一个容器。 如果数据库中已存在同名容器， (409 Conflict 生成错误) ，则会改为获取现有容器。

from azure.cosmos import CosmosClient, PartitionKey, exceptions
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'

try:
    container = database.create_container(id=CONTAINER_NAME, partition_key=PartitionKey(path="/productName"))
except exceptions.CosmosResourceExistsError:
    container = database.get_container_client(CONTAINER_NAME)
except exceptions.CosmosHttpResponseError:
    raise

创建启用了分析存储的容器

此示例使用 Azure Synapse Link 创建启用了分析存储的容器，用于报告、BI、AI 和高级分析。

analytical_storage_ttl选项包括：

• 0 或 Null 或未通知：未启用。
• -1：数据将无限存储。
• 任何其他数字：实际 ttl（以秒为单位）。

CONTAINER_NAME = 'products'
try:
    container = database.create_container(id=CONTAINER_NAME, partition_key=PartitionKey(path="/productName"),analytical_storage_ttl=-1)
except exceptions.CosmosResourceExistsError:
    container = database.get_container_client(CONTAINER_NAME)
except exceptions.CosmosHttpResponseError:
    raise

如果容器创建失败，上述代码片段还会处理 CosmosHttpResponseError 异常。 有关错误处理和故障排除的详细信息，请参阅部分。

获取现有容器

从数据库中检索现有容器：

from azure.cosmos import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

插入数据

若要将项插入容器中，请将包含数据的字典传递给 ContainerProxy.upsert_item。 添加到容器的每个项都必须包含一个 id 键，其中包含用于唯一标识容器中的项的值。

此示例将多个项插入到容器中，每个项都有唯 id一的 ：

from azure.cosmos import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

for i in range(1, 10):
    container.upsert_item({
            'id': 'item{0}'.format(i),
            'productName': 'Widget',
            'productModel': 'Model {0}'.format(i)
        }
    )

删除数据

若要从容器中删除项，请使用 ContainerProxy.delete_item。 Cosmos DB 中的 SQL API 不支持 SQL DELETE 语句。

from azure.cosmos import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

for item in container.query_items(
        query='SELECT * FROM products p WHERE p.productModel = "Model 2"',
        enable_cross_partition_query=True):
    container.delete_item(item, partition_key='Widget')

注意：如果使用分区集合，则应将上面的示例代码中的 的值 partitionKey 设置为此特定项的分区键值，而不是集合中分区键列的名称。 这适用于点读取和删除。

查询数据库

Cosmos DB SQL API 数据库支持使用类似于 SQL 的语法查询 具有ContainerProxy.query_items 的容器中的项。

此示例在容器中查询具有特定 id的项：

from azure.cosmos import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

# Enumerate the returned items
import json
for item in container.query_items(
        query='SELECT * FROM mycontainer r WHERE r.id="item3"',
        enable_cross_partition_query=True):
    print(json.dumps(item, indent=True))

注意：尽管可以在 子句中 FROM 指定容器名称的任何值，但建议使用容器名称实现一致性。

通过将包含参数及其值的字典传递给 ContainerProxy.query_items来执行参数化查询：

discontinued_items = container.query_items(
    query='SELECT * FROM products p WHERE p.productModel = @model',
    parameters=[
        dict(name='@model', value='Model 7')
    ],
    enable_cross_partition_query=True
)
for item in discontinued_items:
    print(json.dumps(item, indent=True))

有关使用 SQL API 查询 Cosmos DB 数据库的详细信息，请参阅使用 SQL 查询来查询 Azure Cosmos DB 数据。

获取数据库属性

获取并显示数据库的属性：

from azure.cosmos import CosmosClient
import os
import json

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
properties = database.read()
print(json.dumps(properties))

获取数据库和容器吞吐量

获取并显示具有专用吞吐量的数据库和容器的吞吐量值：

from azure.cosmos import CosmosClient
import os
import json

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)

# Database
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
db_offer = database.read_offer()
print('Found Offer \'{0}\' for Database \'{1}\' and its throughput is \'{2}\''.format(db_offer.properties['id'], database.id, db_offer.properties['content']['offerThroughput']))

# Container with dedicated throughput only. Will return error "offer not found" for containers without dedicated throughput
CONTAINER_NAME = 'testContainer'
container = database.get_container_client(CONTAINER_NAME)
container_offer = container.read_offer()
print('Found Offer \'{0}\' for Container \'{1}\' and its throughput is \'{2}\''.format(container_offer.properties['id'], container.id, container_offer.properties['content']['offerThroughput']))

修改容器属性

可以修改现有容器的某些属性。 以下示例将容器中项 (TTL) 的默认生存时间设置为 10 秒：

from azure.cosmos import CosmosClient, PartitionKey
import os
import json

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

database.replace_container(
    container,
    partition_key=PartitionKey(path="/productName"),
    default_ttl=10,
)
# Display the new TTL setting for the container
container_props = container.read()
print(json.dumps(container_props['defaultTtl']))

有关 TTL 的详细信息，请参阅 Azure Cosmos DB 数据的生存时间。

使用异步客户端

异步 cosmos 客户端是一个单独的客户端，其外观和工作方式与现有同步客户端类似。 但是，异步客户端需要单独导入，并且其方法需要与 async/await 关键字一起使用。 异步客户端需要在使用后进行初始化和关闭，这可以手动完成，也可以使用上下文管理器来完成。 下面的示例演示如何手动执行此操作。

from azure.cosmos.aio import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
DATABASE_NAME = 'testDatabase'
CONTAINER_NAME = 'products'    

async def create_products():
    client = CosmosClient(URL, credential=KEY)
    database = client.get_database_client(DATABASE_NAME)
    container = database.get_container_client(CONTAINER_NAME)
    for i in range(10):
        await container.upsert_item({
                'id': 'item{0}'.format(i),
                'productName': 'Widget',
                'productModel': 'Model {0}'.format(i)
            }
        )
    await client.close() # the async client must be closed manually if it's not initialized in a with statement

强烈建议使用 async with 关键字，而不是手动打开和关闭客户端。 这将创建一个上下文管理器，该管理器将在你退出 语句后初始化并随后关闭客户端。 下面的示例演示如何执行此操作。

from azure.cosmos.aio import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
DATABASE_NAME = 'testDatabase'
CONTAINER_NAME = 'products'

async def create_products():
    async with CosmosClient(URL, credential=KEY) as client: # the with statement will automatically initialize and close the async client
        database = client.get_database_client(DATABASE_NAME)
        container = database.get_container_client(CONTAINER_NAME)
        for i in range(10):
            await container.upsert_item({
                    'id': 'item{0}'.format(i),
                    'productName': 'Widget',
                    'productModel': 'Model {0}'.format(i)
                }
            )

使用异步客户端进行查询

与同步客户端不同，异步客户端在请求中没有 enable_cross_partition 标志。 默认情况下，没有指定分区键值的查询将尝试执行跨分区查询。

查询结果可以循环访问，但查询的原始输出将返回异步迭代器。 这意味着迭代器中的每个对象都是可等待的对象，并且尚未包含真正的查询结果。 若要获取查询结果，可以使用 async for 循环，该循环在循环访问对象时等待每个结果，或者在循环访问异步迭代器时手动等待每个查询结果。

由于查询结果是异步迭代器，因此不能直接转换为列表;如果需要从结果创建列表，请使用 async for 循环或 Python 的列表理解来填充列表：

from azure.cosmos.aio import CosmosClient
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'products'
container = database.get_container_client(CONTAINER_NAME)

async def create_lists():
    results = container.query_items(
            query='SELECT * FROM products p WHERE p.productModel = "Model 2"')

    # iterates on "results" iterator to asynchronously create a complete list of the actual query results

    item_list = []
    async for item in results:
        item_list.append(item)

    # Asynchronously creates a complete list of the actual query results. This code performs the same action as the for-loop example above.
    item_list = [item async for item in results]
    await client.close()

使用集成缓存

集成缓存是一种内存中缓存，可帮助确保随着请求量的增长，成本可管理并降低延迟。 集成缓存有两个部分：用于点读取的项缓存和用于查询的查询缓存。 下面的代码片段演示如何将此功能与点读取和查询缓存方法一起使用。

使用此方法的好处是点读取，命中集成缓存的查询不使用任何 RU。 这意味着每个操作的成本比从后端读取的成本要低得多。

如何配置 Azure Cosmos DB 集成缓存（预览版）

import azure.cosmos.cosmos_client as cosmos_client
import os

URL = os.environ['ACCOUNT_URI']
KEY = os.environ['ACCOUNT_KEY']
client = cosmos_client.CosmosClient(URL, credential=KEY)
DATABASE_NAME = 'testDatabase'
database = client.get_database_client(DATABASE_NAME)
CONTAINER_NAME = 'testContainer'
container = database.get_container_client(CONTAINER_NAME)

def integrated_cache_snippet():
    item_id = body['id'] 
    query = 'SELECT * FROM c'

    #item cache
    container.read_item(item=item_id, partition_key=item_id, max_integrated_cache_staleness_in_ms=30000)

    #query cache   
    container.query_items(query=query,
         partition_key=item_id, max_integrated_cache_staleness_in_ms=30000)

有关集成缓存的详细信息，请参阅 Azure Cosmos DB 集成缓存 - 概述。

疑难解答

常规

使用 Python SDK 与 Cosmos DB 交互时，服务返回的异常对应于为 REST API 请求返回的相同 HTTP 状态代码：

Azure Cosmos DB 的 HTTP 状态代码

例如，如果尝试使用已在 Cosmos DB 数据库中使用的 ID (名称) 创建容器，则会返回错误 409 ，指示冲突。 以下代码片段通过捕获异常并显示有关错误的其他信息来妥善处理该错误。

try:
    database.create_container(id=CONTAINER_NAME, partition_key=PartitionKey(path="/productName"))
except exceptions.CosmosResourceExistsError:
    print("""Error creating container
HTTP status code 409: The ID (name) provided for the container is already in use.
The container name must be unique within the database.""")

日志记录

此库使用标准 日志记录 库进行日志记录。 有关 HTTP 会话 (URL、标头等的基本信息，) 在 INFO 级别记录。

可以使用 参数在客户端 logging_enable 上启用详细的调试级别日志记录，包括请求/响应正文和未处理标头：

import sys
import logging
from azure.cosmos import CosmosClient

# Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a console output
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)

# This client will log detailed information about its HTTP sessions, at DEBUG level
client = CosmosClient(URL, credential=KEY, logging_enable=True)

同样，即使没有为客户端启用详细日志记录，logging_enable 也可以为单个操作启用：

database = client.create_database(DATABASE_NAME, logging_enable=True)

或者，可以通过将记录器 logger 传递到 参数，使用 CosmosHttpLoggingPolicy（从 Azure 核心 HttpLoggingPolicy 扩展）进行记录。 默认情况下，它将使用 HttpLoggingPolicy 的行为。 传入 enable_diagnostics_logging 参数将启用 CosmosHttpLoggingPolicy，并在响应中提供与调试 Cosmos 问题相关的其他信息。

import logging
from azure.cosmos import CosmosClient

#Create a logger for the 'azure' SDK
logger = logging.getLogger('azure')
logger.setLevel(logging.DEBUG)

# Configure a file output
handler = logging.FileHandler(filename="azure")
logger.addHandler(handler)

# This client will log diagnostic information from the HTTP session by using the CosmosHttpLoggingPolicy.
# Since we passed in the logger to the client, it will log information on every request.
client = CosmosClient(URL, credential=KEY, logger=logger, enable_diagnostics_logging=True)

同样，可以通过将记录器传递给单一请求来为单个操作启用日志记录。 但是，如果要使用 CosmosHttpLoggingPolicy 获取其他信息， enable_diagnostics_logging 则需要在客户端构造函数中传入参数。

# This example enables the CosmosHttpLoggingPolicy and uses it with the `logger` passed in to the `create_database` request.
client = CosmosClient(URL, credential=KEY, enable_diagnostics_logging=True)
database = client.create_database(DATABASE_NAME, logger=logger)

遥测

Azure Core 为 Python SDK 提供了使用 OpenTelemetry 的功能。 若要使用此功能，唯一需要安装的包如下：

pip install azure-core-tracing-opentelemetry
pip install opentelemetry-sdk

有关此内容的详细信息，建议查看 Azure Core 中的此 文档 ，描述如何设置它。 我们还添加了一个 示例文件 ，演示如何将其与 SDK 配合使用。 无论使用哪种 Cosmos 客户端，其工作方式都相同。

后续步骤

有关 Cosmos DB 服务的更详细文档，请参阅 docs.microsoft.com 上的 Azure Cosmos DB 文档。

贡献

本项目欢迎贡献和建议。 大多数贡献要求你同意贡献者许可协议 (CLA)，并声明你有权（并且确实有权）授予我们使用你的贡献的权利。 有关详细信息，请访问 https://cla.microsoft.com 。

提交拉取请求时，CLA 机器人将自动确定你是否需要提供 CLA，并相应地修饰 PR（例如标签、注释）。 直接按机器人提供的说明操作。 只需使用 CLA 对所有存储库执行一次这样的操作。

此项目采用了 Microsoft 开放源代码行为准则。 有关详细信息，请参阅行为准则常见问题解答，或如果有任何其他问题或意见，请与 联系。