Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

Artikel
07/05/2024

Azure Data Explorer ist ein schneller, vollständig verwalteter Datenanalysedienst für die Echtzeitanalyse großer Datenmengen, die von Anwendungen, Websites, IoT-Geräten usw. gestreamt werden. Um den Azure Data Explorer zu verwenden, erstellen Sie zuerst einen Cluster und anschließend eine oder mehrere Datenbanken in diesem Cluster. Anschließend können Sie Daten in eine Datenbank erfassen (laden) und Abfragen dafür ausführen.

In diesem Artikel erfahren Sie, wie Sie ein Cluster und eine Datenbank mit C#, Python, Go, Azure CLI, PowerShell oder einer ARM-Vorlage (Azure Resource Manager) erstellen. Informationen zum Erstellen eines Clusters und einer Datenbank mithilfe des Azure-Portals finden Sie in der Schnellstartanleitung: Erstellen eines Azure Data Explorer-Clusters und einer Datenbank.

Codebeispiele, die auf früheren SDK-Versionen basieren, finden Sie im archivierten Artikel.

Voraussetzungen

Voraussetzungen nach Methode der Cluster- und Datenbankerstellung:

Ein Azure-Abonnement. Erstellen Sie ein kostenloses Azure-Konto.
Visual Studio 2022 Community Edition. Aktivieren Sie beim Setup von Visual Studio die Option Azure-Entwicklung.
Installieren Sie das NuGet-Paket Microsoft.Azure.Management.Kusto.
Eine Microsoft Entra-Anwendung und ein Dienstprinzipal mit Zugriff auf Ressourcen. Speichern Sie die Verzeichnis-ID (Mandanten)-ID, Anwendungs-ID und den geheimen Clientschlüssel.

Ein Azure-Abonnement. Erstellen Sie ein kostenloses Azure-Konto.
Sie können Azure Cloud Shell verwenden, um den Code in diesem Artikel auszuführen, ohne etwas in Ihrer lokalen Umgebung installieren zu müssen.
Wenn Sie die Azure CLI lokal installieren und verwenden möchten, führen Sie die Schritte in Konfigurieren von Parametern aus. Für diesen Artikel ist mindestens Version 2.0.4 der Azure CLI erforderlich. Führen Sie az --version aus, um Ihre Version zu überprüfen. Installations- und Upgradeinformationen finden Sie bei Bedarf unter Installieren von Azure CLI.

Konfigurieren der CLI-Parameter

Die folgenden Schritte sind nicht erforderlich, wenn Sie Befehle in Azure Cloud Shell ausführen. Wenn Sie die CLI lokal ausführen, führen Sie die folgenden Schritte aus, um die Umgebung einzurichten:

Installieren Sie die Erweiterung, um die aktuelle Version der Kusto-Befehlszeilenschnittstelle zu verwenden:
```
az extension add -n kusto
```
Führen Sie den folgenden Befehl aus, um sich bei Azure anzumelden:
```
az login
```
Legen Sie das Abonnement fest, in dem der Cluster erstellt werden soll. Ersetzen Sie MyAzureSub durch den Namen des gewünschten Azure-Abonnements:
```
az account set --subscription MyAzureSub
```
Legen Sie die Ressourcengruppe fest, in der der Cluster erstellt werden soll. Ersetzen Sie testrg durch den Namen der Ressourcengruppe, die Sie verwenden möchten:
```
az group create --name testrg --location westus
```

Erstellen eines Azure Data Explorer-Clusters

Dieser Abschnitt führt Sie durch den Prozess der Erstellung eines Azure Data Explorer-Clusters. Wählen Sie die relevante Registerkarte für Ihre bevorzugte Methode aus, um das Cluster zu erstellen.

Erstellen Sie Ihren Cluster mit dem folgenden Code:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
clusterName	mykustocluster	Der gewünschte Name Ihres Clusters.
skuName	Standard_E8ads_v5	Die SKU, die für Ihren Cluster verwendet wird.
Schicht	Standard	Die SKU-Ebene.
Kapazität	Zahl	Die Anzahl der Instanzen des Clusters.
resourceGroupName	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll

Hinweis

Das Erstellen eines Clusters ist ein zeitintensiver Vorgang. Daher wird dringend empfohlen, anstelle von CreateOrUpdate die Option CreateOrUpdateAsync zu verwenden.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihr Cluster erfolgreich erstellt wurde:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Bestätigen Sie die erfolgreiche Erstellung des Clusters, indem Sie überprüfen, ob das Ergebnis provisioningState als Succeeded enthält.

Erstellen Sie Ihren Cluster mit dem folgenden Befehl:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
cluster_name	mykustocluster	Der gewünschte Name Ihres Clusters.
sku_name	Standard_E8ads_v5	Die SKU, die für Ihren Cluster verwendet wird.
Schicht	Standard	Die SKU-Ebene.
Kapazität	Zahl	Die Anzahl der Instanzen des Clusters.
resource_group_name	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll

Hinweis

Das Erstellen eines Clusters ist ein zeitintensiver Vorgang. Die Methode begin_create_or_update gibt eine Instanz von LROPoller zurück. Weitere Informationen finden Sie unter LROPoller-Klasse.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihr Cluster erfolgreich erstellt wurde:

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

Bestätigen Sie die erfolgreiche Erstellung des Clusters, indem Sie überprüfen, ob das Ergebnis provisioningState als Succeeded enthält.

Der folgende Code zeigt, wie ein Cluster erstellt wird. Informationen zum Klonen des Code-Repositorys finden Sie unter Verwalten eines Azure Data Explorer-Clusters mithilfe von Azure Go SDK.

Legen Sie die erforderlichen Umgebungsvariablen einschließlich Dienstprinzipalinformationen aus den Voraussetzungen fest. Geben Sie die Abonnement-ID, die Ressourcengruppe und die Region ein, in der Sie den Cluster erstellen möchten.

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

Tipp

Verwenden Sie Authentifizierung auth.NewAuthorizerFromCLIWithResource, wenn Azure CLI für die Authentifizierung installiert und konfiguriert ist. In diesem Fall müssen Sie keinen Dienstprinzipal erstellen.

Führen Sie den folgenden Code aus, um das Cluster zu erstellen:

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)

Listet die Cluster auf, um eine erfolgreiche Erstellung sicherzustellen:

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)

Erstellen Sie Ihren Cluster mit dem folgenden Befehl:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
name	azureclitest	Der gewünschte Name Ihres Clusters.
sku	Standard_E8ads_v5	Die SKU, die für Ihren Cluster verwendet wird. Parameter: name: Der SKU-Name tier: Die SKU-Ebene
resource-group	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
location	westus	Der Standort, an dem der Cluster erstellt wird.

Sie können auch noch weitere optionale Parameter verwenden, etwa die Kapazität des Clusters.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihr Cluster erfolgreich erstellt wurde:
```
az kusto cluster show --cluster-name azureclitest --resource-group testrg
```
Bestätigen Sie die erfolgreiche Erstellung des Clusters, indem Sie überprüfen, ob das Ergebnis provisioningState als Succeeded enthält.

Erstellen Sie Ihren Cluster mit dem folgenden Befehl:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
Name	mykustocluster	Der gewünschte Name Ihres Clusters.
Sku	Standard_E8ads_v5	Die SKU, die für Ihren Cluster verwendet wird.
ResourceGroupName	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll

Sie können auch noch weitere optionale Parameter verwenden, etwa die Kapazität des Clusters.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihr Cluster erfolgreich erstellt wurde:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Bestätigen Sie die erfolgreiche Erstellung des Clusters, indem Sie überprüfen, ob das Ergebnis provisioningState als Succeeded enthält.

Informationen zum Bereitstellen der folgenden ARM-Vorlage mithilfe von PowerShell finden Sie unter Verwenden der ARM-Vorlage. Alternativ können Sie die Vorlage im Azure-Portal bereitstellen, indem Sie In Azure bereitstellen.

ARM-Vorlage

Sie können diese Vorlage für Ihre eigenen Bereitstellungen verwenden oder an Ihre Anforderungen anpassen. Informationen zur JSON-Syntax und zu den Eigenschaften, die in einer Vorlage verwendet werden sollten, finden Sie unter Microsoft.Kusto-Ressourcentypen.

{
    "$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
            }
        }
    ]
}

Verwenden der ARM-Vorlage

In den folgenden Schritten wird erläutert, wie die ARM-Vorlage mithilfe von PowerShell bereitgestellt wird.

Öffnen Sie Azure Cloud Shell und folgen Sie den Anweisungen zum Anmelden.

Wählen Sie Kopieren, um das PowerShell-Skript zu kopieren.

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

Klicken Sie mit der rechten Maustaste auf die Shellkonsole, und wählen Sie Einfügen aus.

Hinweis

Die Erstellung eines Azure Data Explorer-Clusters und einer Datenbank kann einige Minuten dauern.

Verwenden Sie das folgende Azure PowerShell-Skript, um die Bereitstellung zu überprüfen. Wenn die Cloud Shell noch geöffnet ist, muss die erste Zeile (Read-Host) nicht kopiert/ausgeführt werden.

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

Azure Data Explorer-Datenbank erstellen

In diesem Abschnitt erstellen Sie eine Datenbank innerhalb des im vorherigen Abschnitt erstellten Clusters.

Erstellen Sie Ihre Datenbank mit dem folgenden Code:

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

Hinweis

Wenn Sie C#-Version 2.0.0 oder eine niedrigere Version nutzen, verwenden Sie „Database“ anstelle von „ReadWriteDatabase“.

Einstellung	Empfohlener Wert	Feldbeschreibung
clusterName	mykustocluster	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
databaseName	mykustodatabase	Der Name Ihrer Datenbank.
resourceGroupName	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
softDeletePeriod	3650:00:00:00	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
hotCachePeriod	3650:00:00:00	Der Zeitraum, für den Daten im Cache verfügbar sein sollen.

Führen Sie den folgenden Befehl aus, um die erstellte Datenbank anzuzeigen:

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

Erstellen Sie Ihre Datenbank mit dem folgenden Befehl:

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

Hinweis

Wenn Sie Python-Version 0.4.0 oder eine niedrigere Version nutzen, verwenden Sie „Database“ anstelle von „ReadWriteDatabase“.

Einstellung	Empfohlener Wert	Feldbeschreibung
cluster_name	mykustocluster	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
database_name	mykustodatabase	Der Name Ihrer Datenbank.
resource_group_name	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
soft_delete_period	3650 days, 0:00:00	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
hot_cache_period	3650 days, 0:00:00	Der Zeitraum, für den Daten im Cache verfügbar sein sollen.

Führen Sie den folgenden Befehl aus, um die erstellte Datenbank anzuzeigen:

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

Das folgende Code zeigt, wie eine Datenbank erstellt wird. Die Initiierung von Paketimporten und Umgebungsvariablen entspricht dem im vorherigen Abschnitt. Informationen zum Klonen des Code-Repositorys finden Sie unter Verwalten eines Azure Data Explorer-Clusters mithilfe von Azure Go SDK.

Führen Sie den folgenden Code aus, um den Datenbank zu erstellen:

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)

Listen Sie die Datenbanken auf, um eine erfolgreiche Erstellung sicherzustellen:

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)

Erstellen Sie Ihre Datenbank mit dem folgenden Befehl:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
cluster-name	azureclitest	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
Datenbankname	clidatabase	Der Name Ihrer Datenbank.
resource-group	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
read-write-database	P365D P31D westus	Der Datenbanktyp. Parameter: soft-delete-period: Gibt den Zeitraum an, wie lange Daten für Abfragen verfügbar sein sollen. Weitere Informationen finden Sie unter Aufbewahrungsrichtlinie. hot-cache-period: Gibt den Zeitraum an, wie lange Daten im Cache verfügbar sein sollen. Weitere Informationen finden Sie unter Cacherichtlinie. location: Der Standort, an dem die Datenbank erstellt wird.

Führen Sie den folgenden Befehl aus, um die erstellte Datenbank anzuzeigen:

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

Erstellen Sie Ihre Datenbank mit dem folgenden Befehl:

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

Einstellung	Empfohlener Wert	Feldbeschreibung
ClusterName	mykustocluster	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
Name	mykustodatabase	Der Name Ihrer Datenbank.
ResourceGroupName	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
SoftDeletePeriod	3650:00:00:00	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
HotCachePeriod	3650:00:00:00	Der Zeitraum, für den Daten im Cache verfügbar sein sollen.

Führen Sie den folgenden Befehl aus, um die erstellte Datenbank anzuzeigen:

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

Nächster Schritt

Eine Tabelle erstellen

Freigeben über

Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

Voraussetzungen

Konfigurieren der CLI-Parameter

Parameter konfigurieren

Erstellen eines Azure Data Explorer-Clusters

ARM-Vorlage

Verwenden der ARM-Vorlage

Azure Data Explorer-Datenbank erstellen

Nächster Schritt

Feedback

Zusätzliche Ressourcen