Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

• 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
   

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

Parameter konfigurieren

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:

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

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

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

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. Informationen zum Klonen des Code-Repositorys finden Sie unter Verwalten eines Azure Data Explorer-Clusters mithilfe von Azure Go SDK.

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 Authentifizierung auth.NewAuthorizerFromCLIWithResource, wenn Azure CLI für die Authentifizierung installiert und konfiguriert ist. 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
   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.

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.

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.

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.

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

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

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

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

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

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. Informationen zum Klonen des Code-Repositorys finden Sie unter Verwalten eines Azure Data Explorer-Clusters mithilfe von Azure Go SDK.

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

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

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
   

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
   

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