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

• Předplatné Azure. Vytvořte bezplatný účet Azure.

• Předplatné Azure. Vytvořte bezplatný účet Azure.

• Nakonfigurujte své prostředí podle pokynů v Použití rutin Kusto v Azure PowerShellu.

• Předplatné Azure. Vytvořte bezplatný účet Azure.
• Visual Studio 2022 Community Edition. Zapněte vývoj pro Azure během instalace sady Visual Studio.
• Nainstalujte balíček NuGet Microsoft.Azure.Management.Kusto.
• Aplikace Microsoft Entra a instanční objekt služby s přístupem k prostředkům. Uložte ID adresáře (tenanta), ID aplikace a tajný klíč klienta.

• Předplatné Azure. Vytvořte bezplatný účet Azure.
• Python 3.4+.
• Nainstalujte balíčky azure-common a azure-mgmt-kusto.
• Aplikace Microsoft Entra a instanční objekt služby, které mohou přistupovat k prostředkům. Uložte ID adresáře (tenanta), ID aplikace a tajný klíč klienta.

• Předplatné Azure. Vytvořte bezplatný účet Azure.
• Nainstalujte Git.
• Nainstalujte odpovídající verzi Jazyka Go. Podporované verze najdete v modulu Azure Kusto pro Go.
• Aplikace Microsoft Entra a instanční objekt služby, které mohou přistupovat k prostředkům. Uložte ID adresáře (tenanta), ID aplikace a tajný klíč klienta.

• Předplatné Azure. Vytvořte bezplatný účet Azure.
• Azure Cloud Shell můžete použít ke spuštění kódu v tomto článku, aniž byste museli instalovat cokoli do místního prostředí.
• Pokud se rozhodnete nainstalovat a používat Azure CLI místně, postupujte podle kroků v části 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

Pokud spouštíte příkazy ve službě Azure Cloud Shell, následující kroky se nevyžadují. Pokud používáte rozhraní příkazového řádku místně, nastavte prostředí pomocí následujícího postupu:

1. Nainstalujte rozšíření pro použití nejnovější verze rozhraní příkazového řádku Kusto:

   az extension add -n kusto
   

2. Spuštěním následujícího příkazu se přihlaste k Azure:

   az login
   

3. 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
   

4. 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
   

šablona ARM

Níže je příklad šablony ARM, která vytvoří cluster Azure Data Explorer a databázi v rámci tohoto clusteru s minimální konfigurací. Úplné podrobnosti a podporované vlastnosti najdete v referenčních informacích k clusteru šablon ARM a referenční informace k databázi šablon 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"
            }
        }
    ]
}

Níže je příklad šablony Bicep, která vytvoří cluster Azure Data Explorer a databázi v tomto clusteru s minimální konfigurací. Podrobné informace a podporované vlastnosti najdete v referenčních informacích ke clusteru Bicep a v referenčních informacích k databázi 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'
      }
    }

1. 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
   Název	mykustocluster	Požadovaný název clusteru.
   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 kapacitu clusteru.

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

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

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

1. 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.
   přesunout do jiné vrstvy	Standard	Úroveň skladové položky.
   kapacita	čí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, takže místo CreateOrUpdateUpdate se důrazně doporučuje použít CreateOrUpdateAsync.

2. 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;
   

3. Potvrďte úspěšné vytvoření klastru ověřením, že výsledek obsahuje provisioningState jako Succeeded.

1. 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.
   přesunout do jiné vrstvy	Standard	Úroveň skladové položky.
   kapacita	čí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 vrací instanci LROPoller; další informace naleznete v tématu třída LROPoller.

2. 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)
   

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

Následující kód ukazuje, jak vytvořit cluster.

1. Nastavte požadované proměnné prostředí včetně informací o instančním objektu služby z prerequisites. Zadejte ID předplatného, skupinu prostředků a oblast, do 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 auth.NewAuthorizerFromCLIWithResource, pokud máte Azure CLI nainstalované a nakonfigurované pro ověřování. V takovém případě nemusíte vytvářet instanční objekt služby.

2. 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)
   

3. Vytvořte seznam clusterů, abyste zajistili ú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)
   

1. 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
   název	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. úroveň – úroveň skladové položky.
   skupina-prostředků	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
   poloha	westus	Umístění, ve kterém bude cluster vytvořen.

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

2. 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
   

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

Cluster a databáze se vytvoří společně s šablonou ARM v předchozí části.

Cluster a databáze se vytvoří společně se šablonou Bicep v předchozí části.

1. 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 clusteru, ve kterém se databáze vytvoří.
   Název	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.

2. 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
   

1. 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 jazyk C# verze 2.0.0 nebo novější, použijte místo ReadWriteDatabase databázi.

   Nastavení	Navrhovaná hodnota	Popis pole
   clusterName	mykustocluster	Název clusteru, ve kterém se databáze vytvoří.
   databaseName	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.

2. 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;
   

1. 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 novější, použijte místo ReadWriteDatabase databázi.

   Nastavení	Navrhovaná hodnota	Popis pole
   cluster_name	mykustocluster	Název clusteru, ve kterém se databáze vytvoří.
   database_name	mykustodatabase	Název databáze.
   název_skupiny_prostředků	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.

2. 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. Importy balíčku a nastavení proměnné prostředí jsou stejné jako v předchozí části.

1. 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)
   

2. 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)
   

1. 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 clusteru, ve kterém se databáze vytvoří.
   název databáze	clidatabase	Název databáze.
   skupina-prostředků	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
   databáze pro čtení i zápis	P365DP31Dwestus	Typ databáze. Parametry: soft-delete-period – určuje dobu, po kterou budou data k dispozici pro dotazy. Další informace najdete v zásadách uchovávání informací. období horké mezipaměti – označuje dobu, po kterou se budou data uchovávat v mezipaměti. Další informace najdete v zásadách mezipaměti. location -Umístění, kam bude databáze vytvořena.

2. 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