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

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.

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 Azure AD a služba principal, 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
```

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 PowerShell místně, postupujte podle kroků v části Konfigurace parametrů.

Konfigurace parametrů

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 používáte Azure CLI místně nebo v Azure Cloud Shellu, musíte modul Az.Kusto nainstalovat do zařízení:
```
 Install-Module -Name Az.Kusto
```

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 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.
úroveň	Standard	Úroveň SKU.
kapacita	číslo	Počet instancí clusteru.
názevSkupinyZdroje	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 kustoManagementClient.Clusters.GetAsync(resourceGroupName, clusterName);

Ověřte úspěšné vytvoření clusteru tím, že zjistíte, zda výsledek obsahuje provisioningState jako 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	Kategorie SKU.
kapacita	číslo	Počet instancí clusteru.
název_skupiny_zdrojů	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, abyste získali 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)

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. 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 auth.NewAuthorizerFromCLIWithResource, pokud máte Azure CLI nainstalované a nakonfigurované pro ověřování. V takovém případě nemusíte vytvářet principál služby.

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
jméno	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ří.
umístění	westus	Umístění, kde bude cluster vytvořen.

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
```
Potvrďte úspěšné vytvoření clusteru tím, že ověříte, že výsledek obsahuje provisioningState jako 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.
NázevSkupinyZdroje	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 a ověřte, že výsledek obsahuje provisioningState jako 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 ve šabloně, naleznete v oddíle 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 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 jazyk C# verze 2.0.0 nebo novější, použijte místo ReadWriteDatabase databázi.

Nastavení	Navrhovaná hodnota	Popis pole
název klastru	mykustocluster	Název clusteru, ve kterém se databáze vytvoří.
název databáze	mykustodatabase	Název databáze.
názevSkupinyZdroje	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
období měkkého odstranění	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;

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ří.
název_databáze	mykustodatabase	Název databáze.
název_skupiny_zdrojů	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
období měkkého smazání	3650 dní, 0:00:00	Doba, po kterou budou data k dispozici pro dotazování.
období aktivní mezipaměti	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 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 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.
skupina zdrojů	testrg	Název skupiny prostředků, ve které se cluster vytvoří.
databáze s oprávněním čtení a zápisu	P365DP31Dwestus	Typ databáze. Parametry: doba pro měkké smazání – označuje časové období, po které budou data dostupná 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.

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ří.
Doba pro měkké odstranění	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ší kroky

Last updated on 2023-05-08

Sdílet prostřednictvím

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

Požadavky

Vytvoření clusteru Azure Data Exploreru

Vytvoření databáze Azure Data Exploreru

Další kroky

Další materiály