Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

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.

Voraussetzungen

Voraussetzungen nach Methode der Cluster- und Datenbankerstellung:

Ein Azure-Abonnement. Erstellen Sie ein kostenloses Azure-Konto.
Visual Studio 2022 Community Edition. Aktivieren Sie die Azure-Entwicklung während des Visual Studio-Setups.
Installieren Sie das Microsoft.Azure.Management.Kusto NuGet-Paket.
Eine Azure AD-Anwendung und ein Dienstprinzipal, die auf Ressourcen zugreifen können. 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 unter "Parameter konfigurieren" 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. Wenn Sie die Azure CLI installieren oder aktualisieren müssen, lesen Sie die Anleitung unter Installieren der 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
```

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 PowerShell lokal installieren und verwenden möchten, führen Sie die Schritte unter "Parameter konfigurieren" aus.

Parameter konfigurieren

Führen Sie den folgenden Befehl aus, um sich bei Azure anzumelden:
```
Connect-AzAccount
```

Legen Sie das Abonnement fest, in dem der Cluster erstellt werden soll:

 Set-AzContext -SubscriptionId "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

Wenn Sie Azure CLI lokal oder in der Azure Cloud Shell ausführen, müssen Sie das Az.Kusto Modul auf Ihrem Gerät installieren:
```
 Install-Module -Name Az.Kusto
```

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 authClient = ConfidentialClientApplicationBuilder.Create(clientId)
    .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
    .WithClientSecret(clientSecret)
    .Build();
var result = authClient.AcquireTokenForClient(new[] { "https://management.core.windows.net/" }).ExecuteAsync().Result;
var credentials = new TokenCredentials(result.AccessToken, result.TokenType);
var kustoManagementClient = new KustoManagementClient(credentials) { SubscriptionId = subscriptionId };
var resourceGroupName = "testrg";
var clusterName = "mykustocluster";
var skuName = KustoSkuName.StandardE8adsV5;
var skuTier = KustoSkuTier.Standard;
var capacity = 5;
var clusterData = new Cluster(
    location: "Central US",
    sku: new AzureSku(skuName, skuTier, capacity)
);
await kustoManagementClient.Clusters.CreateOrUpdateAsync(resourceGroupName, clusterName, clusterData);

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

Hinweis

Erstellen eines Clusters ist ein lange ausgeführter Vorgang, daher wird dringend empfohlen, CreateOrUpdateAsync anstelle von CreateOrUpdate zu verwenden.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihr Cluster erfolgreich erstellt wurde:
```
clusterData = await kustoManagementClient.Clusters.GetAsync(resourceGroupName, clusterName);
```
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	Vorgeschlagener 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	Norm	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 vorgang mit langer Ausführung. Methode begin_create_or_update gibt eine Instanz von LROPoller zurück, siehe LROPoller-Klasse , um weitere Informationen zu erhalten.

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 mit 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 auth.NewAuthorizerFromCLIWithResource, wenn Sie Azure CLI installiert und für die Authentifizierung konfiguriert haben. 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	Vorgeschlagener 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. Stufe – 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.

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	Vorgeschlagener Wert	Feldbeschreibung
Name	mykustocluster	Der gewünschte Name Ihres Clusters.
Sku	Standard_E8ads_v5	Die SKU, die für Ihren Cluster verwendet wird.
ResourceGroupName (Ressourcengruppenname)	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" auswählen.

ARM-Vorlage

Sie können diese Vorlage für Ihre eigenen Bereitstellungen verwenden oder an Ihre Anforderungen anpassen. Die JSON-Syntax und -Eigenschaften, die in einer Vorlage verwendet werden sollen, 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" aus, 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 dann "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 databaseName = "mykustodatabase";
var softDeletePeriod = TimeSpan.FromDays(3650);
var hotCachePeriod = TimeSpan.FromDays(3650);
var databaseData = new ReadWriteDatabase(
    location: clusterData.Location, softDeletePeriod: softDeletePeriod, hotCachePeriod: hotCachePeriod
);
await kustoManagementClient.Databases.CreateOrUpdateAsync(resourceGroupName, clusterName, databaseName, databaseData);

Hinweis

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

Einstellung	Vorgeschlagener Wert	Feldbeschreibung
clusterName	mykustocluster	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
Datenbankname	mykustodatabase	Der Name Ihrer Datenbank.
Ressourcengruppenname	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
Zeitraum für weiche Löschung	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 kustoManagementClient.Databases.GetAsync(resourceGroupName, clusterName, databaseName) as ReadWriteDatabase;

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	Vorgeschlagener Wert	Feldbeschreibung
cluster_name	mykustocluster	Der Name Ihres Clusters, in dem die Datenbank erstellt werden soll.
Datenbankname	mykustodatabase	Der Name Ihrer Datenbank.
resource_group_name	testrg	Der Name der Ressourcengruppe, in der der Cluster erstellt werden soll
Weichlöschzeitraum	3650 Tage, 0:00:00 Uhr	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
Hot-Cache-Zeitraum	3650 Tage, 0:00:00 Uhr	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 mit Azure Go SDK".

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)

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	Vorgeschlagener 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-Schreib-Datenbank	P365DP31DWestus	Der Datenbanktyp. Parameter: soft-delete-period – Gibt an, wie lange die Daten für die Abfrage verfügbar bleiben. Weitere Informationen finden Sie unter "Aufbewahrungsrichtlinie ". hot-cache-period – Gibt an, wie lange die Daten im Cache aufbewahrt werden. Weitere Informationen finden Sie unter "Cacherichtlinie ". Speicherort -The Speicherort, 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	Vorgeschlagener 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
Zeitraum für sanftes Löschen	3650:00:00:00	Der Zeitraum, für den Daten für Abfragen verfügbar sein sollen.
Heißcacheperiode	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ächste Schritte

Last updated on 2023-05-08

Freigeben über

Erstellen eines Azure Data Explorer-Clusters und einer Datenbank

Voraussetzungen

Erstellen eines Azure Data Explorer-Clusters

Azure Data Explorer-Datenbank erstellen

Nächste Schritte

Zusätzliche Ressourcen