创建 Azure 数据资源管理器群集和数据库

Azure 数据资源管理器是一项快速、完全托管的数据分析服务，用于实时分析从应用程序、网站和 IoT 设备等资源流式传输的海量数据。 若要使用 Azure 数据资源管理器，请先创建群集，再在该群集中创建一个或多个数据库。 然后，可将数据引入（加载）到数据库，并对其运行查询。

本文介绍如何使用 C#、Python、Go、Azure CLI、PowerShell、Bicep 或 Azure 资源管理器 （ARM） 模板创建群集和数据库。 若要了解如何使用 Azure 门户创建群集和数据库，请参阅快速入门：创建 Azure 数据资源管理器群集和数据库。

有关基于以前的 SDK 版本的代码示例，请参阅存档的文章。

先决条件

群集和数据库创建方法的先决条件：

ARM 模板

• Azure 订阅。 创建免费 Azure 帐户。

Bicep

• Azure 订阅。 创建免费 Azure 帐户。

PowerShell

• 使用在 Azure PowerShell 中使用 Kusto cmdlet 中的说明设置环境。

C#

• Azure 订阅。 创建免费 Azure 帐户。
• Visual Studio 2022 Community Edition。 在安装 Visual Studio 的过程中，请确保启用“Azure 开发”。
• 安装 Microsoft.Azure.Management.Kusto NuGet 包。
• 可访问资源的 Microsoft Entra 应用程序和服务主体。 保存 目录（租户）ID、应用程序 ID 和 客户端密码。

Python

• Azure 订阅。 创建免费 Azure 帐户。
• Python 3.4+。
• 安装 azure-common 和 azure-mgmt-kusto 包。
• 可访问资源的 Microsoft Entra 应用程序和服务主体。 保存 目录（租户）ID、应用程序 ID 和 客户端密码。

Go

• Azure 订阅。 创建免费 Azure 帐户。
• 安装 Git。
• 安装合适版本的 Go。 有关支持的版本，请参阅适用于 Go 的 Azure Kusto 模块。
• 可访问资源的 Microsoft Entra 应用程序和服务主体。 保存 目录（租户）ID、应用程序 ID 和 客户端密码。

Azure CLI

重要

Azure CLI的 Kusto 扩展已过时，且未维护。 建议使用 PowerShell 或 ARM/Bicep 模板来创建群集和数据库。 如果选择使用 Azure CLI，请确保安装 Kusto 扩展以确保具有适用于Azure 数据资源管理器的最新 CLI 命令。

• Azure 订阅。 创建免费 Azure 帐户。
• 可以使用 Azure Cloud Shell 运行本文中的代码，而不必在本地环境中安装任何内容。
• 如果你选择在本地安装和使用 Azure CLI，请按照配置参数中的步骤操作。 本文需要 Azure CLI 2.0.4 或更高版本。 请运行 az --version 以查看版本。 如需进行安装或升级，请参阅安装 Azure CLI。

配置 CLI 参数

如果在 Azure Cloud Shell 中运行命令，则不需要执行以下步骤。 如果在本地运行 CLI，请按照以下步骤设置环境：

1. 安装扩展以使用最新的 Kusto CLI 版本：

   az extension add -n kusto
   

2. 运行以下命令来登录到 Azure：

   az login
   

3. 设置要在其中创建群集的订阅。 将 MyAzureSub 替换为要使用的 Azure 订阅的名称：

   az account set --subscription MyAzureSub
   

4. 设置要在其中创建群集的资源组。 将 testrg 替换为要使用的资源组的名称：

   az group create --name testrg --location westus
   

创建 Azure 数据资源管理器群集

本部分指导你完成创建 Azure 数据资源管理器群集的过程。 选择与你的首选方法相关的选项卡来创建群集。

ARM 模板

ARM 模板

下面是一个 ARM 模板示例，该模板创建Azure 数据资源管理器群集，并在该群集中创建配置最少的数据库。 有关完整详细信息和支持的属性，请参阅 ARM 模板群集参考 和 ARM 模板数据库参考。

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "clusters_kustocluster_name": {
            "type": "string",
            "defaultValue": "[concat('kusto', uniqueString(resourceGroup().id))]",
            "metadata": {
                "description": "Name of the cluster to create"
            }
        },
        "databases_kustodb_name": {
            "type": "string",
            "defaultValue": "kustodb",
            "metadata": {
                "description": "Name of the database to create"
            }
        },
        "location": {
            "type": "string",
            "defaultValue": "[resourceGroup().location]",
            "metadata": {
                "description": "Location for all resources."
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "name": "[parameters('clusters_kustocluster_name')]",
            "type": "Microsoft.Kusto/clusters",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "sku": {
                "name": "Standard_E8ads_v5",
                "tier": "Standard",
                "capacity": 2
            }
        },
        {
            "name": "[concat(parameters('clusters_kustocluster_name'), '/', parameters('databases_kustodb_name'))]",
            "type": "Microsoft.Kusto/clusters/databases",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[resourceId('Microsoft.Kusto/clusters', parameters('clusters_kustocluster_name'))]"
            ],
            "kind": "ReadWrite",
            "properties": {
                "softDeletePeriod": "P365D",
                "hotCachePeriod": "P31D"
            }
        }
    ]
}

Bicep

下面是一个Bicep模板的示例，该模板创建Azure 数据资源管理器群集和该群集中的数据库，且配置最少。 有关完整详细信息和支持的属性，请参阅 Bicep 群集参考和Bicep数据库参考。

    @description('Name of the cluster to create')
    param clusterName string = 'kusto${uniqueString(resourceGroup().id)}'
    
    @description('Name of the database to create')
    param databaseName string = 'kustodb'
    
    @description('Location for all resources.')
    param location string = resourceGroup().location
    
    resource cluster 'Microsoft.Kusto/clusters@2025-02-14' = {
      name: clusterName
      location: location
      sku: {
        name: 'Standard_E8ads_v5'
        tier: 'Standard'
        capacity: 2
      }
    }
    
    
    resource database 'Microsoft.Kusto/clusters/databases@2025-02-14' = {
      parent: cluster
      name: databaseName
      location: location
      kind: 'ReadWrite'
      properties: {
        softDeletePeriod: 'P365D'
        hotCachePeriod: 'P31D'
      }
    }

PowerShell

1. 请使用以下命令创建群集：

    New-AzKustoCluster -ResourceGroupName testrg -Name mykustocluster -Location westus2 -SkuTier Standard -SkuCapacity 2 -SkuName 'Standard_E8ads_v5'
   

   设置	建议的值	字段说明
   名称	mykustocluster	所需的群集名称。
   SKU	Standard_E8ads_v5	将用于群集的 SKU。
   ResourceGroupName	testrg	将在其中创建群集的资源组名称。

   可以使用其他可选参数，例如群集的容量。

2. 运行以下命令，检查群集是否已成功创建：

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

3. 确认是否成功创建了群集，只需检查结果中的 provisioningState 是否为 Succeeded 即可。

C#

1. 使用以下代码创建群集：

   var tenantId = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"; //Directory (tenant) ID
   var clientId = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"; //Application ID
   var clientSecret = "PlaceholderClientSecret"; //Client Secret
   var subscriptionId = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx";
   var credentials = new ClientSecretCredential(tenantId, clientId, clientSecret);
   var resourceManagementClient = new ArmClient(credentials, subscriptionId);
   var resourceGroupName = "testrg";
   var subscription = await resourceManagementClient.GetDefaultSubscriptionAsync();
   var resourceGroup = (await subscription.GetResourceGroupAsync(resourceGroupName)).Value;
   var clusters = resourceGroup.GetKustoClusters();    
   var clusterName = "mykustocluster";
   var skuName = KustoSkuName.StandardE8adsV5;
   var skuTier = KustoSkuTier.Standard;
   var capacity = 5;
   var clusterData = new KustoClusterData(
       location: AzureLocation.CentralUS,
       sku: new KustoSku(skuName, skuTier) { Capacity = capacity }
   );
   await clusters.CreateOrUpdateAsync(WaitUntil.Completed, clusterName, clusterData);
   

   设置	建议的值	字段说明
   clusterName	mykustocluster	所需的群集名称。
   skuName	Standard_E8ads_v5	将用于您的群集的 SKU。
   分层	Standard	SKU 层级。
   产能	数字	群集实例的数目。
   resourceGroupName	testrg	将在其中创建群集的资源组名称。

   注意

   创建群集是一个长时间运行的操作，因此强烈建议使用 CreateOrUpdateAsync，而不是 CreateOrUpdate。

2. 运行以下命令，检查群集是否已成功创建：

   clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
   

3. 确认是否成功创建了群集，只需检查结果中的 provisioningState 是否为 Succeeded 即可。

Python

1. 请使用以下命令创建群集：

   from azure.mgmt.kusto import KustoManagementClient
   from azure.mgmt.kusto.models import Cluster, AzureSku
   from azure.common.credentials import ServicePrincipalCredentials
   
   #Directory (tenant) ID
   tenant_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   #Application ID
   client_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   #Client Secret
   client_secret = "xxxxxxxxxxxxxx"
   subscription_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   credentials = ServicePrincipalCredentials(
       client_id=client_id,
       secret=client_secret,
       tenant=tenant_id
   )
   
   location = 'Central US'
   sku_name = 'Standard_E8ads_v5'
   capacity = 5
   tier = "Standard"
   resource_group_name = 'testrg'
   cluster_name = 'mykustocluster'
   cluster = Cluster(location=location, sku=AzureSku(name=sku_name, capacity=capacity, tier=tier))
   
   kusto_management_client = KustoManagementClient(credentials, subscription_id)
   
   cluster_operations = kusto_management_client.clusters
   
   poller = cluster_operations.begin_create_or_update(resource_group_name, cluster_name, cluster)
   poller.wait()
   

   设置	建议的值	字段说明
   集群名称	mykustocluster	所需的群集名称。
   sku_name	Standard_E8ads_v5	将用于您的群集的 SKU。
   分层	Standard	SKU 层级。
   产能	数字	群集实例的数目。
   resource_group_name	testrg	将在其中创建群集的资源组名称。

   注意

   创建群集是一个长时间运行的操作。 begin_create_or_update 方法返回 LROPoller 的实例，请参阅 LROPoller 类获取详细信息。

2. 运行以下命令，检查群集是否已成功创建：

   cluster_operations.get(resource_group_name = resource_group_name, cluster_name= cluster_name, custom_headers=None, raw=False)
   

3. 确认是否成功创建了群集，只需检查结果中的 provisioningState 是否为 Succeeded 即可。

Go

以下代码演示如何创建群集。

1. 设置所需的环境变量，包括先决条件中所述的服务主体信息。 输入要在其中创建群集的订阅 ID、资源组和区域。

   export AZURE_CLIENT_ID="<enter service principal client ID>"
   export AZURE_CLIENT_SECRET="<enter service principal client secret>"
   export AZURE_TENANT_ID="<enter tenant ID>"
   
   export SUBSCRIPTION="<enter subscription ID>"
   export RESOURCE_GROUP="<enter resource group name>"
   export LOCATION="<enter azure location e.g. Southeast Asia>"
   
   export CLUSTER_NAME_PREFIX="<enter prefix (cluster name will be [prefix]-ADXTestCluster)>"
   export DATABASE_NAME_PREFIX="<enter prefix (database name will be [prefix]-ADXTestDB)>"
   

   提示

   如果已安装 Azure CLI 并配置了身份验证，请使用 auth.NewAuthorizerFromCLIWithResource。 在这种情况下，不需要创建服务主体。

2. 运行以下代码以创建群集：

   import (
    "context"
    "log"
    "os"
    "strconv"
   
    "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kusto/armkusto"
    "github.com/olekukonko/tablewriter"
   )
   
   const (
    subscriptionEnvVar      = "AZURE_SUBSCRIPTION_ID"
    resourceGroupEnvVar     = "AZURE_RESOURCE_GROUP"
    locationEnvVar          = "AZURE_LOCATION"
    clusterNamePrefixEnvVar = "CLUSTER_NAME_PREFIX"
    dbNamePrefixEnvVar      = "DATABASE_NAME_PREFIX"
   
    clusterName  = "ADXTestCluster"
    databaseName = "ADXTestDB"
   )
   
   func init() {
    subscription = os.Getenv(subscriptionEnvVar)
    if subscription == "" {
     log.Fatalf("missing environment variable %s", subscriptionEnvVar)
    }
   
    rgName = os.Getenv(resourceGroupEnvVar)
    if rgName == "" {
     log.Fatalf("missing environment variable %s", resourceGroupEnvVar)
    }
   
    location = os.Getenv(locationEnvVar)
    if location == "" {
     log.Fatalf("missing environment variable %s", locationEnvVar)
    }
   
    clusterNamePrefix = os.Getenv(clusterNamePrefixEnvVar)
    if clusterNamePrefix == "" {
     log.Fatalf("missing environment variable %s", clusterNamePrefixEnvVar)
    }
   
    dbNamePrefix = os.Getenv(dbNamePrefixEnvVar)
    if dbNamePrefix == "" {
     log.Fatalf("missing environment variable %s", dbNamePrefixEnvVar)
    }
   }
   
   func getClustersClient(subscription string) *armkusto.ClustersClient {
    cred, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
     log.Fatal(err)
    }
   
    client, err := armkusto.NewClustersClient(subscription, cred, nil)
    if err != nil {
     log.Fatal(err)
    }
   
    return client
   }
   
   // 1 instance, Basic tier with compute type Dev(No SLA)_Standard_D11_v2
   func createCluster(sub, name, location, rgName string) {
    ctx := context.Background()
   
    numInstances := int32(1)
    client := getClustersClient(sub)
    result, err := client.BeginCreateOrUpdate(
     ctx,
     rgName,
     name,
     armkusto.Cluster{
      Location: &location,
      SKU: &armkusto.AzureSKU{
       Name:     to.Ptr(armkusto.AzureSKUNameDevNoSLAStandardD11V2),
       Capacity: &numInstances,
       Tier:     to.Ptr(armkusto.AzureSKUTierBasic),
      },
     },
     nil,
    )
    if err != nil {
     log.Fatal("failed to start cluster creation ", err)
    }
   
    log.Printf("waiting for cluster creation to complete - %s\n", name)
    r, err := result.PollUntilDone(ctx, nil)
    if err != nil {
     log.Fatal(err)
    }
   
    log.Printf("created cluster %s\n", *r.Name)
   }
   
   createCluster(subscription, clusterNamePrefix+clusterName, location, rgName)
   

3. 列出群集以确保成功完成创建操作：

   func listClusters(sub, rgName string) {
    log.Printf("listing clusters in resource group %s\n", rgName)
    ctx := context.Background()
   
    result := getClustersClient(sub).NewListByResourceGroupPager(rgName, nil)
   
    data := [][]string{}
   
    for result.More() {
     temp, err := result.NextPage(ctx)
     if err != nil {
      log.Fatal(err)
     }
     for _, c := range temp.Value {
      data = append(data, []string{*c.Name, string(*c.Properties.State), *c.Location, strconv.Itoa(int(*c.SKU.Capacity)), *c.Properties.URI})
     }
    }
   
    table := tablewriter.NewWriter(os.Stdout)
    table.SetHeader([]string{"Name", "State", "Location", "Instances", "URI"})
   
    for _, v := range data {
     table.Append(v)
    }
    table.Render()
   }
   
   listClusters(subscription, rgName)
   

Azure CLI

重要

Azure CLI的 Kusto 扩展已过时，且未维护。 建议使用 PowerShell 或 ARM/Bicep 模板来创建群集和数据库。 如果选择使用 Azure CLI，请确保安装 Kusto 扩展以确保具有适用于Azure 数据资源管理器的最新 CLI 命令。

1. 请使用以下命令创建群集：

   az kusto cluster create --cluster-name azureclitest --sku name="Standard_E8ads_v5" tier="Standard" --resource-group testrg --location westus
   

   设置	建议的值	字段说明
   名称	azureclitest	所需的群集名称。
   sku	Standard_E8ads_v5	将用于您的集群的 SKU。 参数：name - SKU 名称。 tier - SKU 层级。
   资源组	testrg	将在其中创建群集的资源组名称。
   位置	westus	将创建群集的位置。

   可以使用其他可选参数，例如群集的容量。

2. 运行以下命令，检查群集是否已成功创建：

   az kusto cluster show --cluster-name azureclitest --resource-group testrg
   

3. 确认是否成功创建了群集，只需检查结果中的 provisioningState 是否为 Succeeded 即可。

创建 Azure 数据资源管理器数据库

在本部分，你将在上一部分中创建的群集内创建一个数据库。

ARM 模板

群集和数据库是连同上一部分中的 ARM 模板一起创建的。

Bicep

群集和数据库是使用上一节中的 Bicep 模板一并创建的。

PowerShell

1. 请使用以下命令创建数据库：

   New-AzKustoDatabase -ResourceGroupName testrg -ClusterName mykustocluster -Name mykustodatabase -SoftDeletePeriod 3650:00:00:00 -HotCachePeriod 3650:00:00:00
   

   设置	建议的值	字段说明
   集群名称	mykustocluster	将在其中创建数据库的群集的名称。
   名称	mykustodatabase	数据库名称。
   ResourceGroupName	testrg	将在其中创建群集的资源组名称。
   软删除期限	3650:00:00:00	供查询使用的数据的保留时间。
   热缓存周期	3650:00:00:00	数据将在缓存中保留的时间。

2. 若要查看已创建的数据库，请运行以下命令：

   Get-AzKustoDatabase -ClusterName mykustocluster -ResourceGroupName testrg -Name mykustodatabase
   

C#

1. 使用以下代码创建数据库：

   var cluster = (await clusters.GetAsync(clusterName)).Value;
   var databases = cluster.GetKustoDatabases();
   var databaseName = "mykustodatabase";
   var softDeletePeriod = TimeSpan.FromDays(3650);
   var hotCachePeriod = TimeSpan.FromDays(3650);
   var databaseData = new KustoReadWriteDatabase
   {
       Location = clusterData.Location, SoftDeletePeriod = softDeletePeriod, HotCachePeriod = hotCachePeriod
   };
   await databases.CreateOrUpdateAsync(WaitUntil.Completed, databaseName, databaseData);
   

   注意

   如果使用的是 C# 版本 2.0.0 或更低版本，请使用 Database 而不是 ReadWriteDatabase。

   设置	建议的值	字段说明
   clusterName	mykustocluster	将在其中创建数据库的群集的名称。
   databaseName	mykustodatabase	数据库名称。
   resourceGroupName	testrg	将在其中创建群集的资源组名称。
   软删除保留期	3650:00:00:00	供查询使用的数据的保留时间。
   hotCachePeriod	3650:00:00:00	数据将在缓存中保留的时间。

2. 若要查看已创建的数据库，请运行以下命令：

   databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;
   

Python

1. 请使用以下命令创建数据库：

   from azure.mgmt.kusto import KustoManagementClient
   from azure.common.credentials import ServicePrincipalCredentials
   from azure.mgmt.kusto.models import ReadWriteDatabase
   from datetime import timedelta
   
   #Directory (tenant) ID
   tenant_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   #Application ID
   client_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   #Client Secret
   client_secret = "xxxxxxxxxxxxxx"
   subscription_id = "xxxxxxxx-xxxxx-xxxx-xxxx-xxxxxxxxx"
   credentials = ServicePrincipalCredentials(
       client_id=client_id,
       secret=client_secret,
       tenant=tenant_id
   )
   
   location = 'Central US'
   resource_group_name = 'testrg'
   cluster_name = 'mykustocluster'
   soft_delete_period = timedelta(days=3650)
   hot_cache_period = timedelta(days=3650)
   database_name = "mykustodatabase"
   
   kusto_management_client = KustoManagementClient(credentials, subscription_id)
   
   database_operations = kusto_management_client.databases
   database = ReadWriteDatabase(location=location,
         soft_delete_period=soft_delete_period,
         hot_cache_period=hot_cache_period)
   
   poller = database_operations.begin_create_or_update(resource_group_name = resource_group_name, cluster_name = cluster_name, database_name = database_name, parameters = database)
   poller.wait()
   

   注意

   如果使用的是 Python 版本 0.4.0 或更低版本，请使用 Database 而不是 ReadWriteDatabase。

   设置	建议的值	字段说明
   集群名称	mykustocluster	将在其中创建数据库的群集的名称。
   database_name	mykustodatabase	数据库名称。
   resource_group_name	testrg	将在其中创建群集的资源组名称。
   软删除期限	3650 天，0:00:00	供查询使用的数据的保留时间。
   hot_cache_period	3650 天，0:00:00	数据将在缓存中保留的时间。

2. 若要查看已创建的数据库，请运行以下命令：

   database_operations.get(resource_group_name = resource_group_name, cluster_name = cluster_name, database_name = database_name)
   

Go

以下代码演示如何创建数据库。 包导入和环境变量启动与上一部分相同。

1. 运行以下代码以创建数据库：

   func createDatabase(sub, rgName, clusterName, location, dbName string) {
    ctx := context.Background()
   
    client := getDBClient(sub)
    future, err := client.BeginCreateOrUpdate(ctx, rgName, clusterName, dbName, &armkusto.ReadWriteDatabase{Kind: to.Ptr(armkusto.KindReadWrite), Location: &location}, nil)
   
    if err != nil {
     log.Fatal("failed to start database creation ", err)
    }
   
    log.Printf("waiting for database creation to complete - %s\n", dbName)
    resp, err := future.PollUntilDone(ctx, nil)
    if err != nil {
     log.Fatal(err)
    }
   
    kdb := resp.GetDatabase()
    log.Printf("created DB %s with ID %s and type %s\n", *kdb.Name, *kdb.ID, *kdb.Type)
   }
   
   createDatabase(subscription, rgName, clusterNamePrefix+clusterName, location, dbNamePrefix+databaseName)
   

2. 列出数据库以确保成功完成创建操作：

   func listDatabases(sub, rgName, clusterName string) {
    log.Printf("listing databases in cluster %s\n", clusterName)
   
    ctx := context.Background()
    result := getDBClient(sub).NewListByClusterPager(rgName, clusterName, nil)
   
    data := [][]string{}
   
    for result.More() {
     temp, err := result.NextPage(ctx)
     if err != nil {
      log.Fatal(err)
     }
     for _, db := range temp.Value {
      if *db.GetDatabase().Kind == armkusto.KindReadWrite {
       data = append(data, []string{*db.GetDatabase().Name, string(*db.GetDatabase().Kind), *db.GetDatabase().Location, *db.GetDatabase().Type})
      }
     }
    }
   
    table := tablewriter.NewWriter(os.Stdout)
    table.SetHeader([]string{"Name", "State", "Location", "Type"})
   
    for _, v := range data {
     table.Append(v)
    }
    table.Render()
   }
   
   listDatabases(subscription, rgName, clusterNamePrefix+clusterName)
   

Azure CLI

重要

Azure CLI的 Kusto 扩展已过时，且未维护。 建议使用 PowerShell 或 ARM/Bicep 模板来创建群集和数据库。 如果选择使用 Azure CLI，请确保安装 Kusto 扩展以确保具有适用于Azure 数据资源管理器的最新 CLI 命令。

1. 请使用以下命令创建数据库：

   az kusto database create --cluster-name azureclitest --database-name clidatabase --resource-group testrg --read-write-database soft-delete-period=P365D hot-cache-period=P31D location=westus
   

   设置	建议的值	字段说明
   集群名称	azureclitest	将在其中创建数据库的群集的名称。
   数据库名称	clidatabase	数据库名称。
   资源组	testrg	将在其中创建群集的资源组名称。
   读写数据库	P365DP31Dwestus	数据库类型。 参数：soft-delete-period - 表示数据可供查询的保留时长。 有关详细信息，请参阅保留策略。 hot-cache-period - 表示数据在缓存中保留的时长。 有关详细信息，请参阅缓存策略。 location - 将创建数据库的位置。

2. 若要查看已创建的数据库，请运行以下命令：

   az kusto database show --database-name clidatabase --resource-group testrg --cluster-name azureclitest
   

下一步

创建表