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

项目
2024/12/18

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

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

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

先决条件

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

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 帐户。

创建 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

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

下一步

创建表

AI 技能盛会

通过

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

先决条件

配置 CLI 参数

配置参数

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

ARM 模板

使用 ARM 模板

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

下一步

其他资源