Azure Data Explorer is een snelle, volledig beheerde gegevensanalyseservice voor realtime analyse van grote hoeveelheden gegevensstreaming vanuit toepassingen, websites, IoT-apparaten en meer. Als u Azure Data Explorer wilt gebruiken, maakt u eerst een cluster en maakt u een of meer databases in dat 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 C#, Python, Go, de Azure CLI, PowerShell, Bicep of een ARM-sjabloon (Azure Resource Manager). Raadpleeg Quickstart: Een Azure Data Explorer-cluster en -database maken voor instructies over het maken van een cluster en database met behulp van de Azure-portal.
Zie het gearchiveerde artikelvoor codevoorbeelden op basis van eerdere SDK-versies.
Vereiste voorwaarden
Vereisten op basis van de methode voor het maken van clusters en databases:
Important
De Kusto-extensie voor Azure CLI is verouderd en wordt niet onderhouden. U wordt aangeraden PowerShell- of ARM/Bicep-sjablonen te gebruiken voor het maken van clusters en databases. Als u ervoor kiest om Azure CLI te gebruiken, moet u de Kusto-extensie installeren om ervoor te zorgen dat u over de nieuwste CLI-opdrachten voor Azure Data Explorer beschikt.
- 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 hoeft te installeren in uw lokale omgeving.
- Als u ervoor kiest om 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 deze opdracht uit
az --version om uw versie te controleren. Raadpleeg Azure CLI installeren als u de Azure CLI moet installeren of upgraden.
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 waar u het cluster wilt laten 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 testrg door 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 gewenste methode om het cluster te maken.
ARM template
Hieronder ziet u een voorbeeld van een ARM-sjabloon waarmee een Azure Data Explorer cluster en een database in dat cluster worden gemaakt met minimale configuratie. Zie referentiemateriaal voor ARM-sjabloonclusters en naslaginformatie over arm-sjabloondatabases voor volledige details en ondersteunde eigenschappen.
{
"$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"
}
}
]
}
Hieronder ziet u een voorbeeld van een Bicep sjabloon waarmee een Azure Data Explorer cluster en een database in dat cluster worden gemaakt met minimale configuratie. Zie Bicep clusterreferentie en Bicep databasereferentie voor volledige details en ondersteunde eigenschappen.
@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'
}
}
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'
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| Naam |
mykustocluster |
De gewenste naam van uw cluster. |
| Sku |
Standard_E8ads_v5 |
De SKU die wordt gebruikt voor uw cluster. |
| ResourceGroupName |
testrg |
De 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 uw cluster is gemaakt:
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
Bevestig de succesvolle creatie van het cluster door te controleren of het resultaat provisioningState als Succeeded bevat.
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);
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| clusternaam |
mykustocluster |
De gewenste naam van uw cluster. |
| skuName |
Standard_E8ads_v5 |
De SKU die wordt gebruikt voor uw cluster. |
| tier |
Standard |
Het SKU-niveau. |
| capacity |
number |
Het aantal instanties van het cluster. |
| resourceGroupName |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
Opmerking
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 uw cluster is gemaakt:
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
Bevestig de succesvolle creatie van het cluster door te controleren of het resultaat provisioningState als Succeeded bevat.
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()
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| clusternaam |
mykustocluster |
De gewenste naam van uw cluster. |
| sku_name |
Standard_E8ads_v5 |
De SKU die wordt gebruikt voor uw cluster. |
| tier |
Standard |
Het SKU-niveau. |
| capacity |
number |
Het aantal instanties van het cluster. |
| resource_groep_naam |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
Opmerking
Een cluster maken is een langdurige bewerking. Methode begin_create_or_update retourneert een exemplaar van LROPoller. Zie LROPoller-klasse voor meer informatie.
Voer de volgende opdracht uit om te controleren of uw cluster is gemaakt:
cluster_operations.get(resource_group_name = resource_group_name, cluster_name= cluster_name, custom_headers=None, raw=False)
Bevestig de succesvolle creatie van het cluster door te controleren of het resultaat provisioningState als Succeeded bevat.
De volgende code laat zien hoe u een cluster maakt.
Stel de vereiste omgevingsvariabelen in, inclusief de informatie over de service principal uit de voorwaarden. 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)>"
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)
Geeft de clusters weer om ervoor te zorgen dat het aanmaken succesvol is.
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)
Important
De Kusto-extensie voor Azure CLI is verouderd en wordt niet onderhouden. U wordt aangeraden PowerShell- of ARM/Bicep-sjablonen te gebruiken voor het maken van clusters en databases. Als u ervoor kiest om Azure CLI te gebruiken, moet u de Kusto-extensie installeren om ervoor te zorgen dat u over de nieuwste CLI-opdrachten voor Azure Data Explorer beschikt.
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
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| naam |
azureclitest |
De gewenste naam van uw cluster. |
| sku |
Standard_E8ads_v5 |
De SKU die wordt gebruikt voor uw cluster. Parameters: name - De SKU-naam.
laag : de SKU-laag. |
| resourcegroep |
testrg |
De 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 uw cluster is gemaakt:
az kusto cluster show --cluster-name azureclitest --resource-group testrg
Bevestig de succesvolle creatie van het cluster door te controleren of het resultaat provisioningState als Succeeded bevat.
Een Azure Data Explorer-database maken
In deze sectie maakt u een database in het cluster dat in de vorige sectie is gemaakt.
Het cluster en de database worden samen met de ARM-sjabloon in de vorige sectie gemaakt.
Het cluster en de database worden samen gemaakt met het Bicep-sjabloon in de vorige paragraaf.
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
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| Clusternaam |
mykustocluster |
De naam van uw cluster waarin de database wordt gemaakt. |
| Naam |
mykustodatabase |
De naam van uw database. |
| ResourceGroupName |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
| SoftDeletePeriod |
3650:00:00:00 |
De hoeveelheid tijd die gegevens beschikbaar blijven om query's uit te voeren. |
| HotCachePeriod |
3650:00:00:00 |
De hoeveelheid tijd die gegevens in de cache worden bewaard. |
Voer de volgende opdracht uit om de database te zien die u hebt gemaakt:
Get-AzKustoDatabase -ClusterName mykustocluster -ResourceGroupName testrg -Name mykustodatabase
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);
Opmerking
Als u C#-versie 2.0.0 of lager gebruikt, gebruikt u Database in plaats van ReadWriteDatabase.
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| clusternaam |
mykustocluster |
De naam van uw cluster waarin de database wordt gemaakt. |
| databaseName |
mykustodatabase |
De naam van uw database. |
| resourceGroupName |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
| periode voor zachte verwijdering |
3650:00:00:00 |
De hoeveelheid tijd die gegevens beschikbaar blijven om query's uit te voeren. |
| hotCachePeriod |
3650:00:00:00 |
De hoeveelheid tijd die gegevens in de cache worden bewaard. |
Voer de volgende opdracht uit om de database te zien 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()
Opmerking
Als u Python versie 0.4.0 of lager gebruikt, gebruikt u Database in plaats van ReadWriteDatabase.
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| clusternaam |
mykustocluster |
De naam van uw cluster waarin de database wordt gemaakt. |
| databasenaam |
mykustodatabase |
De naam van uw database. |
| resource_groep_naam |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
| periode voor zacht verwijderen |
3650 dagen, 0:00:00 |
De hoeveelheid tijd die gegevens beschikbaar blijven om query's uit te voeren. |
| hot_cache_period |
3650 dagen, 0:00:00 |
De hoeveelheid tijd die gegevens in de cache worden bewaard. |
Voer de volgende opdracht uit om de database te zien 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 omgevingsvariabelen is hetzelfde als in de vorige sectie.
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)
Lijst de databases om ervoor te zorgen dat ze succesvol zijn aangemaakt.
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)
Important
De Kusto-extensie voor Azure CLI is verouderd en wordt niet onderhouden. U wordt aangeraden PowerShell- of ARM/Bicep-sjablonen te gebruiken voor het maken van clusters en databases. Als u ervoor kiest om Azure CLI te gebruiken, moet u de Kusto-extensie installeren om ervoor te zorgen dat u over de nieuwste CLI-opdrachten voor Azure Data Explorer beschikt.
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
|
Setting |
Voorgestelde waarde |
veldbeschrijving |
| clusternaam |
azureclitest |
De naam van uw cluster waarin de database wordt gemaakt. |
| databasenaam |
clidatabase |
De naam van uw database. |
| resourcegroep |
testrg |
De naam van de resourcegroep waar het cluster wordt gemaakt. |
| lees-schrijf-database |
P365DP31Dwestus |
Het databasetype. Parameters: periode voor voorlopig verwijderen : geeft aan hoe lang de gegevens beschikbaar worden gehouden om query's uit te voeren. Zie bewaarbeleid voor meer informatie.
hot-cache-periode : geeft de hoeveelheid tijd aan die de gegevens in de cache moeten worden bewaard. Zie cachebeleid voor meer informatie.
locatie -The locatie waar de database wordt gemaakt. |
Voer de volgende opdracht uit om de database te zien die u hebt gemaakt:
az kusto database show --database-name clidatabase --resource-group testrg --cluster-name azureclitest
Volgende stap