Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

• Ein Azure-Abonnement. Erstellen Sie ein kostenloses Azure-Konto.

• Ein Azure-Abonnement. Erstellen Sie ein kostenloses Azure-Konto.

• Richten Sie Ihre Umgebung mithilfe der Anweisungen in Verwenden von Kusto-Cmdlets in Azure PowerShell ein.

• 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.
• Python 3.4 oder höher
• Installieren Sie die azure-common- und azure-mgmt-kusto-Pakete.
• 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.
• Installieren Sie Git.
• Installieren Sie eine geeignete Version von Go. Unterstützte Versionen finden Sie unter Azure Kusto Module for Go.
• 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:

1. Installieren Sie die Erweiterung, um die aktuelle Version der Kusto-Befehlszeilenschnittstelle zu verwenden:

   az extension add -n kusto
   

2. Führen Sie den folgenden Befehl aus, um sich bei Azure anzumelden:

   az login
   

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

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

ARM-Vorlage

Nachfolgend finden Sie ein Beispiel für eine ARM-Vorlage, die einen Azure Data Explorer Cluster und eine Datenbank innerhalb dieses Clusters mit minimaler Konfiguration erstellt. Ausführliche Informationen und unterstützte Eigenschaften finden Sie unter ARM-Vorlagenclusterreferenz und ARM-Vorlagendatenbankreferenz.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "clusters_kustocluster_name": {
            "type": "string",
            "defaultValue": "[concat('kusto', uniqueString(resourceGroup().id))]",
            "metadata": {
                "description": "Name of the cluster to create"
            }
        },
        "databases_kustodb_name": {
            "type": "string",
            "defaultValue": "kustodb",
            "metadata": {
                "description": "Name of the database to create"
            }
        },
        "location": {
            "type": "string",
            "defaultValue": "[resourceGroup().location]",
            "metadata": {
                "description": "Location for all resources."
            }
        }
    },
    "variables": {},
    "resources": [
        {
            "name": "[parameters('clusters_kustocluster_name')]",
            "type": "Microsoft.Kusto/clusters",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "sku": {
                "name": "Standard_E8ads_v5",
                "tier": "Standard",
                "capacity": 2
            }
        },
        {
            "name": "[concat(parameters('clusters_kustocluster_name'), '/', parameters('databases_kustodb_name'))]",
            "type": "Microsoft.Kusto/clusters/databases",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[resourceId('Microsoft.Kusto/clusters', parameters('clusters_kustocluster_name'))]"
            ],
            "kind": "ReadWrite",
            "properties": {
                "softDeletePeriod": "P365D",
                "hotCachePeriod": "P31D"
            }
        }
    ]
}

Im Folgenden finden Sie ein Beispiel für eine Bicep-Vorlage, die einen Azure Data Explorer Cluster und eine Datenbank innerhalb dieses Clusters mit minimaler Konfiguration erstellt. Ausführliche Informationen und unterstützte Eigenschaften finden Sie unter Bicep Clusterreferenz und Bicep Datenbankreferenz.

    @description('Name of the cluster to create')
    param clusterName string = 'kusto${uniqueString(resourceGroup().id)}'
    
    @description('Name of the database to create')
    param databaseName string = 'kustodb'
    
    @description('Location for all resources.')
    param location string = resourceGroup().location
    
    resource cluster 'Microsoft.Kusto/clusters@2025-02-14' = {
      name: clusterName
      location: location
      sku: {
        name: 'Standard_E8ads_v5'
        tier: 'Standard'
        capacity: 2
      }
    }
    
    
    resource database 'Microsoft.Kusto/clusters/databases@2025-02-14' = {
      parent: cluster
      name: databaseName
      location: location
      kind: 'ReadWrite'
      properties: {
        softDeletePeriod: 'P365D'
        hotCachePeriod: 'P31D'
      }
    }

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

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

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

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

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

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

   clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
   

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

1. 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.
   Ebene	Standard	Die SKU-Ebene.
   Kapazität	Zahl	Die Anzahl der Instanzen des Clusters.
   Name der Ressourcengruppe	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.

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

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

1. 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 auth.NewAuthorizerFromCLIWithResource, wenn Sie Azure CLI installiert und für die Authentifizierung konfiguriert haben. In diesem Fall müssen Sie keinen Dienstprinzipal erstellen.

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

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

1. 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
   Ressourcengruppe	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
   Standort	westus	Der Standort, an dem der Cluster erstellt wird.

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

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

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

Das Cluster und die Datenbank werden zusammen mit der ARM-Vorlage im vorherigen Abschnitt erstellt.

Der Cluster und die Datenbank werden im vorherigen Abschnitt zusammen mit der Bicep-Vorlage erstellt.

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

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

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

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

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

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

1. 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 Tage, 0:00:00 Uhr	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
   hot_cache_period	3650 Tage, 0:00:00 Uhr	Der Zeitraum, für den Daten im Cache verfügbar sein sollen.

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

1. Führen Sie den folgenden Code aus, um die 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)
   

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

1. 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.
   Ressourcengruppe	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
   Lese-/Schreibdatenbank	P365DP31Dwestus	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.

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