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

Článek
11/19/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.

Ukázky kódu založené na předchozích verzích sady SDK najdete v archivovaného článku.

Požadavky

Požadavky metodou 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.
Microsoft Entra aplikaci a instanční objekt, které mají 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.
Pomocí Azure Cloud Shell můžete spustit kód v tomto článku, 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 používáte rozhraní příkazového řádku místně, nastavte prostředí takto:

Nainstalujte rozšíření, aby používalo 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
```

Vytvoření clusteru Azure Data Explorer

Tato část vás provede procesem vytvoření clusteru Azure Data Explorer. Zvolte příslušnou kartu pro preferovanou metodu 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 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);

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 clusters.GetAsync(clusterName)).Value.Data;
```
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:

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

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 databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;

Vytvořte databázi 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 nižší, použijte databázi místo ReadWriteDatabase.

Nastavení	Navrhovaná hodnota	Popis pole
cluster_name	mykustocluster	Název vašeho clusteru, ve kterém se databáze vytvoří.
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íčků a inicializace proměnné prostředí jsou 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)

Vytvořte databázi 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 vašeho clusteru, ve kterém se databáze vytvoří.
název databáze	databáze clidatabase	Název databáze.
resource-group	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
čtení a zápis do databáze	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 se budou data uchovávat v mezipaměti. Další informace najdete v tématu Zásady mezipaměti . location – umístění, ve kterém se databáze vytvoří.

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

Vytvořte databázi 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 vašeho clusteru, ve kterém se databáze vytvoří.
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

Další krok

Vytvoření tabulky

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

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ší krok

Váš názor

Váš názor

Další materiály