Tworzenie klastra i bazy danych usługi Azure Data Explorer

Artykuł
07/03/2024

Usługa Azure Data Explorer to szybka, w pełni zarządzana usługa do analizy danych, która pozwala w czasie rzeczywistym analizować duże woluminy danych przesyłanych strumieniowo z aplikacji, witryn internetowych, urządzeń IoT i nie tylko. Aby używać usługi Azure Data Explorer, najpierw utwórz klaster, a następnie utwórz w tym klastrze co najmniej jedną bazę danych. Następnie można pozyskiwać (ładować) dane do bazy danych i uruchamiać względem niej zapytania.

W tym artykule dowiesz się, jak utworzyć klaster i bazę danych przy użyciu języka C#, Python, Go, interfejsu wiersza polecenia platformy Azure, programu PowerShell lub szablonu usługi Azure Resource Manager (ARM). Aby dowiedzieć się, jak utworzyć klaster i bazę danych przy użyciu witryny Azure Portal, zobacz Szybki start: tworzenie klastra i bazy danych usługi Azure Data Explorer.

Przykłady kodu oparte na poprzednich wersjach zestawu SDK można znaleźć w zarchiwizowanym artykule.

Wymagania wstępne

Wymagania wstępne według metody tworzenia klastra i bazy danych:

Subskrypcja Azure. Utwórz bezpłatne konto platformy Azure.
Visual Studio 2022 Community Edition. Włącz programowanie na platformie Azure podczas konfigurowania programu Visual Studio.
Zainstaluj pakiet NuGet Microsoft.Azure.Management.Kusto.
Aplikacja Firmy Microsoft Entra i jednostka usługi, która może uzyskiwać dostęp do zasobów. Zapisz identyfikator katalogu (dzierżawy), identyfikator aplikacji i klucz tajny klienta.

Subskrypcja Azure. Utwórz bezpłatne konto platformy Azure.
Za pomocą usługi Azure Cloud Shell możesz uruchomić kod w tym artykule bez konieczności instalowania niczego w środowisku lokalnym.
Jeśli zdecydujesz się zainstalować interfejs wiersza polecenia platformy Azure i korzystać z niego lokalnie, wykonaj kroki opisane w temacie Konfigurowanie parametrów. Ten artykuł wymaga interfejsu wiersza polecenia platformy Azure w wersji 2.0.4 lub nowszej. Uruchom polecenie az --version, aby sprawdzić wersję. Jeśli konieczna będzie instalacja lub uaktualnienie interfejsu, zobacz Instalowanie interfejsu wiersza polecenia platformy Azure.

Konfigurowanie parametrów interfejsu wiersza polecenia

Poniższe kroki nie są wymagane, jeśli uruchamiasz polecenia w usłudze Azure Cloud Shell. Jeśli używasz interfejsu wiersza polecenia lokalnie, wykonaj następujące kroki, aby skonfigurować środowisko:

Zainstaluj rozszerzenie, aby korzystać z najnowszej wersji interfejsu wiersza polecenia kusto:
```
az extension add -n kusto
```
Uruchom następujące polecenia, aby zalogować się na platformie Azure:
```
az login
```
Ustaw subskrypcję, w której chcesz utworzyć klaster. Zastąp wartość MyAzureSub nazwą subskrypcji platformy Azure, której chcesz użyć:
```
az account set --subscription MyAzureSub
```
Ustaw grupę zasobów, w której chcesz utworzyć klaster. Zastąp testrg ciąg nazwą grupy zasobów, której chcesz użyć:
```
az group create --name testrg --location westus
```

Tworzenie klastra usługi Azure Data Explorer

Ta sekcja przeprowadzi Cię przez proces tworzenia klastra usługi Azure Data Explorer. Wybierz odpowiednią kartę preferowanej metody, aby utworzyć klaster.

Utwórz klaster przy użyciu następującego kodu:

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

Ustawienie	Sugerowana wartość	Opis pola
clusterName	mykustocluster	Wybrana nazwa klastra.
skuName	Standard_E8ads_v5	Jednostka SKU, która będzie używana na potrzeby klastra.
warstwa	Standardowa	Warstwa jednostki SKU.
capacity	numer	Liczba wystąpień klastra.
resourceGroupName	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.

Uwaga

Tworzenie klastra jest długotrwałą operacją, dlatego zdecydowanie zaleca się użycie metody CreateOrUpdateAsync zamiast createOrUpdateUpdate.

Uruchom następujące polecenie, aby sprawdzić, czy klaster został utworzony pomyślnie:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Potwierdź pomyślne utworzenie klastra, sprawdzając, czy wynik zawiera provisioningState wartość Succeeded.

Utwórz klaster przy użyciu następującego polecenia:

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

Ustawienie	Sugerowana wartość	Opis pola
cluster_name	mykustocluster	Wybrana nazwa klastra.
sku_name	Standard_E8ads_v5	Jednostka SKU, która będzie używana na potrzeby klastra.
warstwa	Standardowa	Warstwa jednostki SKU.
capacity	numer	Liczba wystąpień klastra.
resource_group_name	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.

Uwaga

Tworzenie klastra to długotrwała operacja. Metoda begin_create_or_update zwraca wystąpienie LROPoller, zobacz klasa LROPoller, aby uzyskać więcej informacji.

Uruchom następujące polecenie, aby sprawdzić, czy klaster został utworzony pomyślnie:

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

Potwierdź pomyślne utworzenie klastra, sprawdzając, czy wynik zawiera provisioningState wartość Succeeded.

Poniższy kod pokazuje, jak utworzyć klaster. Aby sklonować repozytorium kodu, zobacz Zarządzanie klastrem usługi Azure Data Explorer przy użyciu zestawu Azure Go SDK.

Ustaw wymagane zmienne środowiskowe, w tym informacje o jednostce usługi z wymagań wstępnych. Wprowadź identyfikator subskrypcji, grupę zasobów i region, w którym chcesz utworzyć klaster.

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

Napiwek

Użyj uwierzytelniania. NewAuthorizerFromCLIWithResource , jeśli masz zainstalowany i skonfigurowany do uwierzytelniania interfejs wiersza polecenia platformy Azure. W takiej sytuacji nie trzeba tworzyć jednostki usługi.

Uruchom następujący kod, aby utworzyć klaster:

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)

Wyświetl listę klastrów, aby zapewnić pomyślne utworzenie:

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)

Utwórz klaster przy użyciu następującego polecenia:

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

Ustawienie	Sugerowana wartość	Opis pola
name	azureclitest	Wybrana nazwa klastra.
sku	Standard_E8ads_v5	Jednostka SKU, która będzie używana na potrzeby klastra. Parametry: name — nazwa jednostki SKU. warstwa — warstwa jednostki SKU.
resource-group	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.
lokalizacja	westus	Lokalizacja, w której zostanie utworzony klaster.

Istnieją inne parametry opcjonalne, których można użyć, takie jak pojemność klastra.

Uruchom następujące polecenie, aby sprawdzić, czy klaster został utworzony pomyślnie:
```
az kusto cluster show --cluster-name azureclitest --resource-group testrg
```
Potwierdź pomyślne utworzenie klastra, sprawdzając, czy wynik zawiera provisioningState wartość Succeeded.

Utwórz klaster przy użyciu następującego polecenia:

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

Ustawienie	Sugerowana wartość	Opis pola
Nazwisko	mykustocluster	Wybrana nazwa klastra.
SKU	Standard_E8ads_v5	Jednostka SKU, która będzie używana na potrzeby klastra.
ResourceGroupName	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.

Istnieją inne parametry opcjonalne, których można użyć, takie jak pojemność klastra.

Uruchom następujące polecenie, aby sprawdzić, czy klaster został utworzony pomyślnie:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Potwierdź pomyślne utworzenie klastra, sprawdzając, czy wynik zawiera provisioningState wartość Succeeded.

Aby dowiedzieć się, jak wdrożyć następujący szablon usługi ARM przy użyciu programu PowerShell, zobacz Korzystanie z szablonu usługi ARM. Alternatywnie możesz wdrożyć szablon w witrynie Azure Portal , wybierając pozycję Wdróż na platformie Azure.

Szablon ARM

Można użyć tego szablonu na potrzeby własnych wdrożeń lub dostosować go do konkretnych potrzeb. Aby uzyskać informacje o składni i właściwościach JSON do użycia w szablonie, zobacz Typy zasobów 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
            }
        }
    ]
}

Korzystanie z szablonu usługi ARM

W poniższych krokach opisano sposób wdrażania szablonu usługi ARM przy użyciu programu PowerShell.

Otwórz usługę Azure Cloud Shell i postępuj zgodnie z instrukcjami, aby się zalogować.

Wybierz przycisk Kopiuj, aby skopiować skrypt programu PowerShell.

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

Kliknij prawym przyciskiem myszy konsolę powłoki, a następnie wybierz polecenie Wklej.

Uwaga

Utworzenie klastra i bazy danych usługi Azure Data Explorer potrwa kilka minut.

Aby zweryfikować wdrożenie, użyj następującego skryptu programu Azure PowerShell. Jeśli usługa Cloud Shell jest nadal otwarta, nie musisz kopiować/uruchamiać pierwszego wiersza (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 ..."

Tworzenie bazy danych usługi Azure Data Explorer

W tej sekcji utworzysz bazę danych w klastrze utworzonym w poprzedniej sekcji.

Utwórz bazę danych przy użyciu następującego kodu:

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

Uwaga

Jeśli używasz języka C# w wersji 2.0.0 lub nowszej, użyj polecenia Database zamiast ReadWriteDatabase.

Ustawienie	Sugerowana wartość	Opis pola
clusterName	mykustocluster	Nazwa klastra, w którym zostanie utworzona baza danych.
databaseName	mykustodatabase	Nazwa bazy danych.
resourceGroupName	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.
softDeletePeriod	3650:00:00:00	Okres przechowywania danych na potrzeby zapytań.
hotCachePeriod	3650:00:00:00	Okres przechowywania danych w pamięci podręcznej.

Uruchom następujące polecenie, aby wyświetlić utworzoną bazę danych:

databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;

Utwórz bazę danych przy użyciu następującego polecenia:

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

Uwaga

Jeśli używasz języka Python w wersji 0.4.0 lub nowszej, użyj polecenia Database zamiast ReadWriteDatabase.

Ustawienie	Sugerowana wartość	Opis pola
cluster_name	mykustocluster	Nazwa klastra, w którym zostanie utworzona baza danych.
database_name	mykustodatabase	Nazwa bazy danych.
resource_group_name	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.
soft_delete_period	3650 dni, 0:00:00	Okres przechowywania danych na potrzeby zapytań.
hot_cache_period	3650 dni, 0:00:00	Okres przechowywania danych w pamięci podręcznej.

Uruchom następujące polecenie, aby wyświetlić utworzoną bazę danych:

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

Poniższy kod pokazuje, jak utworzyć bazę danych. Importowanie pakietu i inicjowanie zmiennej środowiskowej jest takie samo jak w poprzedniej sekcji. Aby sklonować repozytorium kodu, zobacz Zarządzanie klastrem usługi Azure Data Explorer przy użyciu zestawu Azure Go SDK.

Uruchom następujący kod, aby utworzyć bazę danych:

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)

Wyświetl listę baz danych, aby zapewnić pomyślne utworzenie:

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)

Utwórz bazę danych przy użyciu następującego polecenia:

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

Ustawienie	Sugerowana wartość	Opis pola
cluster-name	azureclitest	Nazwa klastra, w którym zostanie utworzona baza danych.
nazwa bazy danych	clidatabase	Nazwa bazy danych.
resource-group	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.
read-write-database	P365D P31D westus	Typ bazy danych. Parametry: okres usuwania nietrwałego — oznacza ilość czasu, przez który dane będą dostępne dla zapytań. Aby uzyskać więcej informacji, zobacz zasady przechowywania. hot-cache-period — oznacza czas przechowywania danych w pamięci podręcznej. Aby uzyskać więcej informacji, zobacz zasady pamięci podręcznej. location — lokalizacja, w której zostanie utworzona baza danych.

Uruchom następujące polecenie, aby wyświetlić utworzoną bazę danych:

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

Utwórz bazę danych przy użyciu następującego polecenia:

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

Ustawienie	Sugerowana wartość	Opis pola
NazwaKlastra	mykustocluster	Nazwa klastra, w którym zostanie utworzona baza danych.
Nazwisko	mykustodatabase	Nazwa bazy danych.
ResourceGroupName	testrg	Nazwa grupy zasobów, w której zostanie utworzony klaster.
SoftDeletePeriod	3650:00:00:00	Okres przechowywania danych na potrzeby zapytań.
HotCachePeriod	3650:00:00:00	Okres przechowywania danych w pamięci podręcznej.

Uruchom następujące polecenie, aby wyświetlić utworzoną bazę danych:

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

Następny krok

Utwórz tabelę

Udostępnij za pośrednictwem

Tworzenie klastra i bazy danych usługi Azure Data Explorer

Wymagania wstępne

Konfigurowanie parametrów interfejsu wiersza polecenia

Konfigurowanie parametrów

Tworzenie klastra usługi Azure Data Explorer

Szablon ARM

Korzystanie z szablonu usługi ARM

Tworzenie bazy danych usługi Azure Data Explorer

Następny krok

Opinia

Dodatkowe zasoby