Een Azure Data Explorer-cluster en -database maken

Artikel
03/27/2024

Azure Data Explorer is een snelle, volledig beheerde service voor gegevensanalyses waarmee grote hoeveelheden gegevens van toepassingen, websites, IoT-apparaten en dergelijke in real-time kunnen worden geanalyseerd. Als u Azure Data Explorer wilt gebruiken, maakt u eerst een cluster. Daarna maakt u een of meer databases in het cluster. Vervolgens kunt u gegevens opnemen (laden) in een database en er query's op uitvoeren.

In dit artikel leert u hoe u een cluster en een database maakt met behulp van C#, Python, Go, de Azure CLI, PowerShell of een ARM-sjabloon (Azure Resource Manager). Zie Quickstart: Een Azure Data Explorer-cluster en -database maken voor meer informatie over het maken van een cluster en database met behulp van de Azure Portal.

Zie het gearchiveerde artikel voor codevoorbeelden op basis van eerdere SDK-versies.

Vereisten

Vereisten per methode voor het maken van clusters en databases:

Een Azure-abonnement. Maak een gratis Azure-account.
Visual Studio 2022 Community Edition. Schakel Azure-ontwikkeling in tijdens de installatie van Visual Studio.
Installeer het NuGet-pakket Microsoft.Azure.Management.Kusto.
Een Microsoft Entra toepassing en service-principal die toegang hebben tot resources. Sla de map-id (tenant),toepassings-id en clientgeheim op.

Een Azure-abonnement. Maak een gratis Azure-account.
U kunt Azure Cloud Shell gebruiken om de code in dit artikel uit te voeren zonder dat u iets in uw lokale omgeving hoeft te installeren.
Als u ervoor kiest om de Azure CLI lokaal te installeren en te gebruiken, volgt u de stappen in Parameters configureren. Voor dit artikel is Azure CLI versie 2.0.4 of hoger vereist. Voer az --version uit om uw versie te controleren. Als u uw CLI wilt installeren of upgraden, raadpleegt u De Azure CLI installeren.

De CLI-parameters configureren

De volgende stappen zijn niet vereist als u opdrachten uitvoert in Azure Cloud Shell. Als u de CLI lokaal uitvoert, volgt u deze stappen om de omgeving in te stellen:

Installeer de extensie om de nieuwste Kusto CLI-versie te gebruiken:
```
az extension add -n kusto
```
Voer de volgende opdracht uit om u aan te melden bij Azure:
```
az login
```
Stel het abonnement in waarin u uw cluster wilt maken. Vervang MyAzureSub door de naam van het Azure-abonnement dat u wilt gebruiken:
```
az account set --subscription MyAzureSub
```
Stel de resourcegroep in waar u het cluster wilt maken. Vervang door testrg de naam van de resourcegroep die u wilt gebruiken:
```
az group create --name testrg --location westus
```

Een Azure Data Explorer-cluster maken

In deze sectie wordt u begeleid bij het maken van een Azure Data Explorer-cluster. Kies het relevante tabblad voor de methode van uw voorkeur om het cluster te maken.

Maak uw cluster met behulp van de volgende 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);

Instelling	Voorgestelde waarde	Beschrijving van veld
clusterName	mykustocluster	De gewenste naam van uw cluster.
skuName	Standard_E8ads_v5	De SKU die wordt gebruikt voor uw cluster.
laag	Standard	De SKU-laag.
capacity	Nummer	Het aantal exemplaren van het cluster.
resourceGroupName	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.

Notitie

Een cluster maken is een langdurige bewerking, dus het wordt ten zeerste aanbevolen om CreateOrUpdateAsync te gebruiken in plaats van CreateOrUpdate.

Voer de volgende opdracht uit om te controleren of het cluster is gemaakt:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Bevestig dat het cluster is gemaakt door te controleren of het resultaat bevat provisioningState als Succeeded.

Maak uw cluster met behulp van de volgende opdracht:

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

Instelling	Voorgestelde waarde	Beschrijving van veld
cluster_name	mykustocluster	De gewenste naam van uw cluster.
sku_name	Standard_E8ads_v5	De SKU die wordt gebruikt voor uw cluster.
laag	Standard	De SKU-laag.
capacity	Nummer	Het aantal exemplaren van het cluster.
resource_group_name	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.

Notitie

Een cluster maken is een langdurige bewerking. Methode begin_create_or_update een exemplaar van LROPoller retourneert, raadpleegt u LROPoller-klasse voor meer informatie.

Voer de volgende opdracht uit om te controleren of het cluster is gemaakt:

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

Bevestig dat het cluster is gemaakt door te controleren of het resultaat bevat provisioningState als Succeeded.

De volgende code laat zien hoe u een cluster maakt. Zie Een Azure Data Explorer-cluster beheren met azure Go SDK om de codeopslagplaats te klonen.

Stel de vereiste omgevingsvariabelen in, inclusief informatie over de service-principal van de vereisten. Voer uw abonnements-id, resourcegroep en regio in waar u het cluster wilt maken.

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

Tip

Gebruik verificatie. NewAuthorizerFromCLIWithResource als u Azure CLI hebt geïnstalleerd en geconfigureerd voor verificatie. In dat geval hoeft u geen service-principal te maken.

Voer de volgende code uit om het cluster te maken:

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)

Maak een lijst van de clusters om het maken ervan te garanderen:

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)

Maak uw cluster met behulp van de volgende opdracht:

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

Instelling	Voorgestelde waarde	Beschrijving van veld
naam	azureclitest	De gewenste naam van uw cluster.
sku	Standard_E8ads_v5	De SKU die wordt gebruikt voor uw cluster. Parameters: name : de naam van de SKU. laag : de SKU-laag.
resource-group	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.
location	westus	De locatie waar het cluster wordt gemaakt.

Er zijn andere optionele parameters die u kunt gebruiken, zoals de capaciteit van het cluster.

Voer de volgende opdracht uit om te controleren of het cluster is gemaakt:

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

Bevestig dat het cluster is gemaakt door te controleren of het resultaat bevat provisioningState als Succeeded.

Maak uw cluster met behulp van de volgende opdracht:

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

Instelling	Voorgestelde waarde	Beschrijving van veld
Naam	mykustocluster	De gewenste naam van uw cluster.
Sku	Standard_E8ads_v5	De SKU die wordt gebruikt voor uw cluster.
ResourceGroupName	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.

Er zijn andere optionele parameters die u kunt gebruiken, zoals de capaciteit van het cluster.

Voer de volgende opdracht uit om te controleren of het cluster is gemaakt:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Bevestig dat het cluster is gemaakt door te controleren of het resultaat bevat provisioningState als Succeeded.

Zie De ARM-sjabloon gebruiken voor meer informatie over het implementeren van de volgende ARM-sjabloon met behulp van PowerShell. U kunt de sjabloon ook implementeren in de Azure Portal door Implementeren in Azure te selecteren.

ARM-sjabloon

U kunt deze sjabloon gebruiken voor uw eigen implementaties of de sjabloon aanpassen aan uw eisen. Zie Microsoft.Kusto-resourcetypen voor de JSON-syntaxis en eigenschappen die u in een sjabloon kunt gebruiken.

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

De ARM-sjabloon gebruiken

In de volgende stappen wordt uitgelegd hoe u de ARM-sjabloon implementeert met behulp van PowerShell.

Open Azure Cloud Shell en volg de instructies om u aan te melden.

Selecteer Kopiëren om het PowerShell-script te kopiëren.

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

Klik met de rechtermuisknop op de shell-console en selecteer Plakken.

Notitie

Het duurt enkele minuten om een Azure Data Explorer-cluster en -database te maken.

Gebruik het volgende Azure PowerShell script om de implementatie te controleren. Als de Cloud Shell nog steeds is geopend, hoeft u de eerste regel niet te kopiëren/uit te voeren (Read-Host).

$projectName = Read-Host -Prompt "Enter the same project name that you used in the last procedure"

Install-Module -Name Az.Kusto
$resourceGroupName = "${projectName}rg"
$clusterName = "${projectName}cluster"

Get-AzKustoCluster -ResourceGroupName $resourceGroupName -Name $clusterName
Write-Host "Press [ENTER] to continue ..."

Een Azure Data Explorer-database maken

In deze sectie maakt u een database in het cluster dat u in de vorige sectie hebt gemaakt.

Maak uw database met behulp van de volgende 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);

Notitie

Als u C#-versie 2.0.0 of lager gebruikt, gebruikt u Database in plaats van ReadWriteDatabase.

Instelling	Voorgestelde waarde	Beschrijving van veld
clusterName	mykustocluster	De naam van het cluster waar de database wordt gemaakt.
databaseName	mykustodatabase	De naam van uw database.
resourceGroupName	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.
softDeletePeriod	3650:00:00:00	Hoe lang gegevens worden opgeslagen om query's erop te kunnen uitvoeren.
hotCachePeriod	3650:00:00:00	Hoe lang gegevens worden opgeslagen in de cache.

Voer de volgende opdracht uit om de database te bekijken die u hebt gemaakt:

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

Maak uw database met behulp van de volgende opdracht:

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

Notitie

Als u Python versie 0.4.0 of lager gebruikt, gebruikt u Database in plaats van ReadWriteDatabase.

Instelling	Voorgestelde waarde	Beschrijving van veld
cluster_name	mykustocluster	De naam van het cluster waar de database wordt gemaakt.
Database_name	mykustodatabase	De naam van uw database.
resource_group_name	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.
soft_delete_period	3650 dagen, 0:00:00	Hoe lang gegevens worden opgeslagen om query's erop te kunnen uitvoeren.
hot_cache_period	3650 dagen, 0:00:00	Hoe lang gegevens worden opgeslagen in de cache.

Voer de volgende opdracht uit om de database te bekijken die u hebt gemaakt:

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

De volgende code laat zien hoe u een database maakt. Het importeren van pakketten en het starten van de omgevingsvariabele is hetzelfde als in de vorige sectie. Zie Een Azure Data Explorer-cluster beheren met azure Go SDK om de codeopslagplaats te klonen.

Voer de volgende code uit om de database te maken:

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)

Geef een lijst weer van de databases om ervoor te zorgen dat het maken van de database is geslaagd:

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)

Maak uw database met behulp van de volgende opdracht:

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

Instelling	Voorgestelde waarde	Beschrijving van veld
cluster-name	azureclitest	De naam van het cluster waar de database wordt gemaakt.
databasenaam	clidatabase	De naam van uw database.
resource-group	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.
read-write-database	P365DP31Dwestus	Het databasetype. Parameters: periode voor voorlopig verwijderen : geeft aan hoelang de gegevens beschikbaar blijven voor query's. Zie Bewaarbeleid voor meer informatie. hot-cache-period : geeft aan hoelang de gegevens in de cache worden bewaard. Zie cachebeleid voor meer informatie. location : de locatie waar de database wordt gemaakt.

Voer de volgende opdracht uit om de database te bekijken die u hebt gemaakt:

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

Maak uw database met behulp van de volgende opdracht:

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

Instelling	Voorgestelde waarde	Beschrijving van veld
Clusternaam	mykustocluster	De naam van het cluster waar de database wordt gemaakt.
Name	mykustodatabase	De naam van uw database.
ResourceGroupName	testrg	Naam van de resourcegroep waar het cluster wordt gemaakt.
SoftDeletePeriod	3650:00:00:00	Hoe lang gegevens worden opgeslagen om query's erop te kunnen uitvoeren.
HotCachePeriod	3650:00:00:00	Hoe lang gegevens worden opgeslagen in de cache.

Voer de volgende opdracht uit om de database te bekijken die u hebt gemaakt:

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

Volgende stap

Een tabel maken

Een Azure Data Explorer-cluster en -database maken

Vereisten

De CLI-parameters configureren

Parameters configureren

Een Azure Data Explorer-cluster maken

ARM-sjabloon

De ARM-sjabloon gebruiken

Een Azure Data Explorer-database maken

Volgende stap

Feedback

Feedback

Aanvullende resources