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

Článek
07/03/2024

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 dotazy na ni.

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

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

Požadavky

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

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, 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 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:

Nainstalujte rozšíření pro použití nejnovější verze 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 Exploreru

Tato část vás provede procesem vytvoření clusteru Azure Data Exploreru. Vyberte příslušnou kartu pro preferovanou 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 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.
úroveň	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, takže místo CreateOrUpdateUpdate se důrazně doporučuje 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 tak, ž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.
úroveň	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 LROPoller třída získat 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 tak, ž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 Exploreru 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, 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 ověřování. Pokud máte azure CLI nainstalované a nakonfigurované pro ověřování, newAuthorizerFromCLIWithResource 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)

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)

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. úroveň – úroveň skladové položky.
resource-group	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
location	westus	Umístění, kam se cluster vytvoří.

Existují další volitelné parametry, které můžete použít, například kapacitu 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 tak, ž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
Název	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 kapacitu 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 tak, ž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. Případně můžete šablonu nasadit na webu 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. Syntaxe a vlastnosti JSON, 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í kroky vysvětlují, jak nasadit šablonu ARM pomocí PowerShellu.

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

Výběrem možnosti Kopírovat 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 myši na konzolu prostředí a pak vyberte Vložit.

Poznámka:

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

K ověření nasazení použijte následující skript Azure PowerShellu. 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 Exploreru

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

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 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.
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. Inicializace importu balíčku a 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 Exploreru 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 clusteru, ve kterém se databáze vytvoří.
název databáze	clidatabase	Název databáze.
resource-group	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
read-write-database	P365D P31D westus	Typ databáze. Parametry: obnovitelné odstranění období – označuje dobu, po kterou budou data k dispozici pro dotazování. 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.

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

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

Sdílet prostřednictvím

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 Exploreru

Šablona ARM

Použití šablony ARM

Vytvoření databáze Azure Data Exploreru

Další krok

Váš názor

Další materiály