Vytvoření clusteru a databáze Azure Data Explorer

Článek
05/08/2023

Azure Data Explorer je rychlá, plně spravovaná služba analýzy dat pro analýzy velkých objemů dat v reálném čase, která se streamují z aplikací, webů, zařízení IoT a dalších. Pokud chcete použít Azure Data Explorer, musíte nejdříve vytvořit cluster a v něm vytvořit jednu nebo více databází. Pak můžete ingestovat (načíst) data do databáze a spouštět na ni dotazy.

V tomto článku se dozvíte, jak vytvořit cluster a databázi pomocí C#, Pythonu, Go, Azure CLI, PowerShellu nebo šablony Azure Resource Manager (ARM). Informace o vytvoření clusteru a databáze pomocí Azure Portal najdete v tématu Rychlý start: Vytvoření clusteru a databáze Azure Data Explorer.

Požadavky

Požadavky podle metody vytváření clusteru a databáze:

Předplatné Azure. Vytvořte si bezplatný účet Azure.
Visual Studio 2022 Community Edition. Během instalace sady Visual Studio zapněte vývoj pro Azure .
Nainstalujte balíček NuGet Microsoft.Azure.Management.Kusto.
Azure AD aplikace a instančního objektu, který má přístup k prostředkům. Uložte ID adresáře (tenanta),ID aplikace a tajný klíč klienta.

Předplatné Azure. Vytvořte si bezplatný účet Azure.
Ke spuštění kódu v tomto článku můžete použít Azure Cloud Shell, aniž byste museli cokoli instalovat do místního prostředí.
Pokud se rozhodnete nainstalovat a používat Azure CLI místně, postupujte podle kroků v tématu Konfigurace parametrů. Tento článek vyžaduje Azure CLI verze 2.0.4 nebo novější. Spuštěním příkazu az --version zkontrolujte svou verzi. Pokud potřebujete instalaci nebo upgrade, přečtěte si téma Instalace rozhraní příkazového řádku Azure CLI.

Konfigurace parametrů rozhraní příkazového řádku

Následující kroky se nevyžadují, pokud spouštíte příkazy v Azure Cloud Shell. Pokud rozhraní příkazového řádku spouštíte místně, nastavte prostředí takto:

Nainstalujte rozšíření, abyste mohli používat nejnovější verzi rozhraní příkazového řádku Kusto:
```
az extension add -n kusto
```
Spuštěním následujícího příkazu se přihlaste k Azure:
```
az login
```
Nastavte předplatné, ve kterém chcete cluster vytvořit. Nahraďte MyAzureSub názvem předplatného Azure, které chcete použít:
```
az account set --subscription MyAzureSub
```
Nastavte skupinu prostředků, ve které chcete cluster vytvořit. Nahraďte testrg názvem skupiny prostředků, kterou chcete použít:
```
az group create --name testrg --location westus
```

Předplatné Azure. Vytvořte si bezplatný účet Azure.
Ke spuštění kódu v tomto článku můžete použít Azure Cloud Shell, aniž byste museli cokoli instalovat do místního prostředí.
Pokud se rozhodnete nainstalovat a používat PowerShell místně, postupujte podle kroků v tématu Konfigurace parametrů.

Konfigurace parametrů

Následující kroky se nevyžadují, pokud spouštíte příkazy v Azure Cloud Shell. Pokud rozhraní příkazového řádku spouštíte místně, nastavte prostředí takto:

Spuštěním následujícího příkazu se přihlaste k Azure:
```
Connect-AzAccount
```

Nastavte předplatné, ve kterém chcete cluster vytvořit:

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

Pokud azure CLI spouštíte místně nebo v Azure Cloud Shell, musíte na zařízení nainstalovat Az.Kusto modul:
```
 Install-Module -Name Az.Kusto
```

Vytvoření clusteru Azure Data Explorer

Tato část vás provede procesem vytvoření clusteru Azure Data Explorer. Zvolte příslušnou kartu pro upřednostňovanou metodu pro vytvoření clusteru.

Vytvořte cluster pomocí následujícího kódu:

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 authClient = ConfidentialClientApplicationBuilder.Create(clientId)
    .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
    .WithClientSecret(clientSecret)
    .Build();
var result = authClient.AcquireTokenForClient(new[] { "https://management.core.windows.net/" }).ExecuteAsync().Result;
var credentials = new TokenCredentials(result.AccessToken, result.TokenType);
var kustoManagementClient = new KustoManagementClient(credentials) { SubscriptionId = subscriptionId };
var resourceGroupName = "testrg";
var clusterName = "mykustocluster";
var skuName = KustoSkuName.StandardE8adsV5;
var skuTier = KustoSkuTier.Standard;
var capacity = 5;
var clusterData = new Cluster(
    location: "Central US",
    sku: new AzureSku(skuName, skuTier, capacity)
);
await kustoManagementClient.Clusters.CreateOrUpdateAsync(resourceGroupName, clusterName, clusterData);

Nastavení	Navrhovaná hodnota	Popis pole
clusterName	mykustocluster	Požadovaný název clusteru.
skuName	Standard_E8ads_v5	Skladová položka, která se použije pro váš cluster.
tier	Standard	Úroveň skladové položky.
capacity	Číslo	Počet instancí clusteru.
resourceGroupName	testrg	Název skupiny prostředků, ve které se cluster vytvoří.

Poznámka

Vytvoření clusteru je dlouhotrvající operace, proto se důrazně doporučuje místo CreateOrUpdateAsync použít CreateOrUpdateAsync.

Spuštěním následujícího příkazu zkontrolujte, jestli se cluster úspěšně vytvořil:

clusterData = await kustoManagementClient.Clusters.GetAsync(resourceGroupName, clusterName);

Ověřte úspěšné vytvoření clusteru ověřením, že výsledek obsahuje provisioningState hodnotu Succeeded.

Vytvořte cluster pomocí následujícího příkazu:

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()

Nastavení	Navrhovaná hodnota	Popis pole
cluster_name	mykustocluster	Požadovaný název clusteru.
sku_name	Standard_E8ads_v5	Skladová položka, která se použije pro váš cluster.
tier	Standard	Úroveň skladové položky.
capacity	Číslo	Počet instancí clusteru.
resource_group_name	testrg	Název skupiny prostředků, ve které se cluster vytvoří.

Poznámka

Vytvoření clusteru je dlouhotrvající operace. Metoda begin_create_or_update vrátí instanci LROPoller, viz třída LROPoller , kde najdete další informace.

Spuštěním následujícího příkazu zkontrolujte, jestli se cluster úspěšně vytvořil:

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

Ověřte úspěšné vytvoření clusteru tím, že ověříte, že výsledek obsahuje provisioningState hodnotu Succeeded.

Následující kód ukazuje, jak vytvořit cluster. Pokud chcete naklonovat úložiště kódu, přečtěte si téma Správa clusteru Azure Data Explorer pomocí sady Azure Go SDK.

Nastavte požadované proměnné prostředí včetně informací o instančním objektu z požadavků. Zadejte ID předplatného, skupinu prostředků a oblast, ve které chcete cluster vytvořit.

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)>"

Tip

Použijte ověřování. NewAuthorizerFromCLIWithResource , pokud máte nainstalované a nakonfigurované Azure CLI pro ověřování. V takovém případě nemusíte vytvářet instanční objekt.

Spuštěním následujícího kódu vytvořte cluster:

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)

Vypište clustery, aby se zajistilo úspěšné vytvoření:

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)

Vytvořte cluster pomocí následujícího příkazu:

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

Nastavení	Navrhovaná hodnota	Popis pole
name	azureclitest	Požadovaný název clusteru.
Sku	Standard_E8ads_v5	Skladová položka, která se použije pro váš cluster. Parametry: name – název skladové položky. tier – úroveň skladové položky.
resource-group	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
location	westus	Umístění, kde se cluster vytvoří.

Existují další volitelné parametry, které můžete použít, například kapacita clusteru.

Spuštěním následujícího příkazu zkontrolujte, jestli se cluster úspěšně vytvořil:
```
az kusto cluster show --cluster-name azureclitest --resource-group testrg
```
Ověřte úspěšné vytvoření clusteru tím, že ověříte, že výsledek obsahuje provisioningState hodnotu Succeeded.

Vytvořte cluster pomocí následujícího příkazu:

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

Nastavení	Navrhovaná hodnota	Popis pole
Name	mykustocluster	Požadovaný název clusteru.
Skladová jednotka (SKU)	Standard_E8ads_v5	Skladová položka, která se použije pro váš cluster.
ResourceGroupName	testrg	Název skupiny prostředků, ve které se cluster vytvoří.

Existují další volitelné parametry, které můžete použít, například kapacita clusteru.

Spuštěním následujícího příkazu zkontrolujte, jestli se cluster úspěšně vytvořil:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Ověřte úspěšné vytvoření clusteru tím, že ověříte, že výsledek obsahuje provisioningState hodnotu Succeeded.

Informace o nasazení následující šablony ARM pomocí PowerShellu najdete v tématu Použití šablony ARM. Alternativně můžete šablonu nasadit v Azure Portal výběrem možnosti Nasadit do Azure.

Šablona ARM

Tuto šablonu můžete použít pro vlastní nasazení nebo ji upravit, aby splňovala vaše požadavky. Syntaxi JSON a vlastnosti, které se mají použít v šabloně, najdete v tématu Typy prostředků 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_E8ads_v5",
                "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
            }
        }
    ]
}

Použití šablony ARM

Následující postup vysvětluje, jak nasadit šablonu ARM pomocí PowerShellu.

Otevřete Azure Cloud Shell a podle pokynů se přihlaste.

Vyberte Kopírovat a zkopírujte skript PowerShellu.

$projectName = Read-Host -Prompt "Enter a project name that is used for generating resource names"
$location = Read-Host -Prompt "Enter the location (i.e. centralus)"
$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 ..."

Klikněte pravým tlačítkem na konzolu prostředí a pak vyberte Vložit.

Poznámka

Vytvoření clusteru a databáze Azure Data Explorer trvá několik minut.

K ověření nasazení použijte následující skript Azure PowerShell. Pokud je Cloud Shell stále otevřená, nemusíte kopírovat ani spouštět první řádek (Read-Host).

$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 ..."

Vytvoření databáze Azure Data Explorer

V této části vytvoříte databázi v clusteru vytvořeném v předchozí části.

Vytvořte databázi pomocí následujícího kódu:

var databaseName = "mykustodatabase";
var softDeletePeriod = TimeSpan.FromDays(3650);
var hotCachePeriod = TimeSpan.FromDays(3650);
var databaseData = new ReadWriteDatabase(
    location: clusterData.Location, softDeletePeriod: softDeletePeriod, hotCachePeriod: hotCachePeriod
);
await kustoManagementClient.Databases.CreateOrUpdateAsync(resourceGroupName, clusterName, databaseName, databaseData);

Poznámka

Pokud používáte C# verze 2.0.0 nebo nižší, použijte databázi místo ReadWriteDatabase.

Nastavení	Navrhovaná hodnota	Popis pole
clusterName	mykustocluster	Název vašeho clusteru, ve kterém se databáze vytvoří.
databaseName	databáze mykustodatabase	Název databáze.
resourceGroupName	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
softDeletePeriod	3650:00:00:00	Doba, po kterou budou data k dispozici pro dotazování.
hotCachePeriod	3650:00:00:00	Doba, po kterou se budou data uchovávat v mezipaměti.

Spuštěním následujícího příkazu zobrazte databázi, kterou jste vytvořili:

databaseData = await kustoManagementClient.Databases.GetAsync(resourceGroupName, clusterName, databaseName) as ReadWriteDatabase;

Databázi vytvořte pomocí následujícího příkazu:

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()

Poznámka

Pokud používáte Python verze 0.4.0 nebo novější, použijte databázi místo ReadWriteDatabase.

Nastavení	Navrhovaná hodnota	Popis pole
cluster_name	mykustocluster	Název clusteru, ve kterém se vytvoří databáze.
Název_databáze	databáze mykustodatabase	Název databáze.
resource_group_name	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
soft_delete_period	3650 dní, 0:00:00	Doba, po kterou budou data k dispozici pro dotazování.
hot_cache_period	3650 dní, 0:00:00	Doba, po kterou se budou data uchovávat v mezipaměti.

Spuštěním následujícího příkazu zobrazte databázi, kterou jste vytvořili:

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

Následující kód ukazuje, jak vytvořit databázi. Import balíčku a inicializace proměnné prostředí je stejná jako v předchozí části. Pokud chcete naklonovat úložiště kódu, přečtěte si téma Správa clusteru Azure Data Explorer pomocí sady Azure Go SDK.

Spuštěním následujícího kódu vytvořte databázi:

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)

Vytvořte seznam databází, abyste zajistili úspěšné vytvoření:

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)

Databázi vytvořte pomocí následujícího příkazu:

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

Nastavení	Navrhovaná hodnota	Popis pole
název clusteru	azureclitest	Název clusteru, ve kterém se vytvoří databáze.
název databáze	databáze clidatabase	Název databáze.
resource-group	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
databáze pro čtení i zápis	P365DP31Dwestus	Typ databáze. Parametry: obnovitelné odstranění – Označuje dobu, po kterou budou data k dispozici pro dotazování. Další informace najdete v tématu Zásady uchovávání informací . hot-cache-period – označuje dobu, po kterou budou data uložena v mezipaměti. Další informace najdete v tématu Zásady mezipaměti . location – umístění, ve kterém bude databáze vytvořena.

Spuštěním následujícího příkazu zobrazte databázi, kterou jste vytvořili:

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

Databázi vytvořte pomocí následujícího příkazu:

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

Nastavení	Navrhovaná hodnota	Popis pole
Název clusteru	mykustocluster	Název clusteru, ve kterém se vytvoří databáze.
Name	databáze mykustodatabase	Název databáze.
ResourceGroupName	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
SoftDeletePeriod	3650:00:00:00	Doba, po kterou budou data k dispozici pro dotazování.
HotCachePeriod	3650:00:00:00	Doba, po kterou se budou data uchovávat v mezipaměti.

Spuštěním následujícího příkazu zobrazte databázi, kterou jste vytvořili:

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

Sdílet prostřednictvím

Vytvoření clusteru a databáze Azure Data Explorer

Požadavky

Konfigurace parametrů rozhraní příkazového řádku

Konfigurace parametrů

Vytvoření clusteru Azure Data Explorer

Šablona ARM

Použití šablony ARM

Vytvoření databáze Azure Data Explorer

Další kroky

Další materiály