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

项目
2024/12/18

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

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

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

先决条件

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

Azure 订阅。创建 Azure 帐户。
Python 3.4+。
安装 azure-common 和 azure-mgmt-kusto 包。
可以访问资源的 Microsoft Entra 应用程序和服务主体。保存“目录(租户) ID”、“应用程序 ID”和“客户端机密”值。

Azure 订阅。创建 Azure 帐户。
如果你选择在本地安装和使用 Azure CLI，请按照配置参数中的步骤操作。本文需要 Azure CLI 2.0.4 或更高版本。请运行 az --version 检查版本。如需进行安装或升级，请参阅安装 Azure CLI。

配置 CLI 参数

如果在本地运行 CLI，请按照以下步骤设置环境：

安装扩展以使用最新的 Kusto CLI 版本：
```
az extension add -n kusto
```
运行以下命令来登录到 Azure：
```
az login
```
设置将在其中创建群集的订阅。将 MyAzureSub 替换为要使用的 Azure 订阅的名称：
```
az account set --subscription MyAzureSub
```
设置要在其中创建群集的资源组。将 testrg 替换为要使用的资源组的名称：
```
az group create --name testrg --location chinaeast2
```

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

配置参数

如果在本地运行 CLI，请按照以下步骤设置环境：

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

Connect-AzAccount -Environment AzureChinaCloud

设置要在其中创建群集的订阅：

 Set-AzContext -SubscriptionId "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

在本地运行 Azure CLI 时，需要在设备上安装 Az.Kusto 模块：
```
 Install-Module -Name Az.Kusto
```

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

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

使用以下代码创建群集：

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.chinaeast2,
    sku: new KustoSku(skuName, skuTier) { Capacity = capacity }
);
await clusters.CreateOrUpdateAsync(WaitUntil.Completed, clusterName, clusterData);

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

备注

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

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

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

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

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

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 = 'China East 2'
sku_name = 'Standard_D13_v2'
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()

设置	建议的值	字段说明
cluster_name	mykustocluster	所需的群集名称。
sku_name	Standard_D13_v2	将用于群集的 SKU。
层	Standard	SKU 层。
容量	数字	群集实例的数目。
resource_group_name	testrg	将在其中创建群集的资源组名称。

备注

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

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

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

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

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

设置所需的环境变量，包括先决条件中所述的服务主体信息。输入要在其中创建群集的订阅 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. China East 2>"

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。在这种情况下，不需要创建服务主体。

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

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)

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

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)

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

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

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

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

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

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

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

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

 New-AzKustoCluster -ResourceGroupName testrg -Name mykustocluster -Location chinaeast2 -SkuTier Standard -SkuCapacity 2 -SkuName 'Standard_D13_v2'

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

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

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

Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg

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

若要了解如何使用 PowerShell 部署以下 ARM 模板，请参阅使用 ARM 模板。或者，可以通过选择“部署到 Azure”，在 Azure 门户中部署模板。

ARM 模板

可将此模板用于自己的部署，或自定义此模板以满足要求。有关要在模板中使用的 JSON 语法和属性，请参阅 Microsoft.Kusto 资源类型。

{
    "$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",
            "sku": {
                "name": "Standard_D13_v2",
                "tier": "Standard",
                "capacity": 2
            },
            "apiVersion": "2022-12-29",
            "location": "[parameters('location')]",
            "tags": {
                "Created By": "GitHub quickstart template"
            },
            "properties": {
                "trustedExternalTenants": [],
                "optimizedAutoscale": {
                    "version": 1,
                    "isEnabled": true,
                    "minimum": 2,
                    "maximum": 10
                },
                "enableDiskEncryption": false,
                "enableStreamingIngest": false,
                "virtualNetworkConfiguration": {
                    "subnetId": "<subnet resource id>",
                    "enginePublicIpId": "<Engine service's public IP address resource id>",
                    "dataManagementPublicIpId": "<Data management's service public IP address resource id>"
                },
                "keyVaultProperties": {
                    "keyName": "<Key name>",
                    "keyVaultUri": "<Key vault uri>",
                    "userIdentity": "<ResourceId of user assigned managed identity>"
                },
                "enablePurge": false,
                "enableDoubleEncryption": false,
                "engineType": "V3"
            },
            "identity": {
                "type": "SystemAssigned, UserAssigned",
                "userAssignedIdentities": {
                    "<ResourceId of managed identity>": {}
                }
            }
        },
        {
            "name": "[concat(parameters('clusters_kustocluster_name'), '/', parameters('databases_kustodb_name'))]",
            "type": "Microsoft.Kusto/clusters/databases",
            "apiVersion": "2022-12-29",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[resourceId('Microsoft.Kusto/clusters', parameters('clusters_kustocluster_name'))]"
            ],
            "properties": {
                "softDeletePeriodInDays": 365,
                "hotCachePeriodInDays": 31
            }
        }
    ]
}

使用 ARM 模板

以下步骤说明如何使用 PowerShell 部署 ARM 模板。

将以下代码复制到 PowerShell。

$projectName = Read-Host -Prompt "Enter a project name that is used for generating resource names"
$location = Read-Host -Prompt "Enter the location (i.e. chinaeast2)"
$resourceGroupName = "${projectName}rg"
$clusterName = "${projectName}cluster"
$parameters = @{}
$parameters.Add("clusters_kustocluster_name", $clusterName)
$templateUri = "https://azure.microsoft.com/resources/templates/kusto-cluster-database/"
New-AzResourceGroup -Name $resourceGroupName -Location $location
New-AzResourceGroupDeployment -ResourceGroupName $resourceGroupName -TemplateUri $templateUri -TemplateParameterObject $parameters
Write-Host "Press [ENTER] to continue ..."

右键单击 shell 控制台并选择“粘贴” 。

备注

创建 Azure 数据资源管理器群集和数据库需要数分钟的时间。

若要验证部署，请使用以下 Azure PowerShell 脚本。

$projectName = Read-Host -Prompt "Enter the same project name that you used in the last procedure"

Install-Module -Name Az.Kusto
$resourceGroupName = "${projectName}rg"
$clusterName = "${projectName}cluster"

Get-AzKustoCluster -ResourceGroupName $resourceGroupName -Name $clusterName
Write-Host "Press [ENTER] to continue ..."

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

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

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

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	将在其中创建群集的资源组名称。
softDeletePeriod	3650:00:00:00	供查询使用的数据的保留时间。
hotCachePeriod	3650:00:00:00	数据将在缓存中保留的时间。

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

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

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

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 = 'China East 2'
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。

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

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

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

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

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

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)

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

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)

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

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=chinaeast2

设置	建议的值	字段说明
cluster-name	azureclitest	将在其中创建数据库的群集的名称。
database-name	clidatabase	数据库名称。
resource-group	testrg	将在其中创建群集的资源组名称。
read-write-database	P365D P31D chinaeast2	数据库类型。参数：soft-delete-period - 表示供查询使用的数据的保留时间。有关详细信息，请参阅保留策略。 hot-cache-period - 表示数据将在缓存中保留的时间。有关详细信息，请参阅缓存策略。 location - 这是会在其中创建数据库的位置。

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

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

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

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

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

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

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

下一步

创建表

AI 技能盛会

通过

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

先决条件

配置 CLI 参数

配置参数

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

ARM 模板

使用 ARM 模板

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

下一步

其他资源