Skapa ett Azure Data Explorer-kluster och en databas

2025-10-10

Azure Data Explorer är en snabb, fullständigt hanterad dataanalystjänst för realtidsanalys på stora mängder dataströmning från program, webbplatser, IoT-enheter med mera. Om du vill använda Azure Data Explorer skapar du först ett kluster och skapar en eller flera databaser i klustret. Sedan kan du mata in (läsa in) data i en databas och köra frågor mot den.

I den här artikeln får du lära dig hur du skapar ett kluster och en databas med hjälp av antingen C#, Python, Go, Azure CLI, PowerShell eller en ARM-mall (Azure Resource Manager). Information om hur du skapar ett kluster och en databas med hjälp av Azure-portalen finns i Snabbstart: Skapa ett Azure Data Explorer-kluster och en databas.

Kodexempel baserade på tidigare SDK-versioner finns i den arkiverade artikeln.

Förutsättningar

Förutsättningar efter metod för att skapa kluster och databaser:

Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.
Visual Studio 2022 Community Edition. Aktivera Azure-utveckling under Visual Studio-installationen.
Installera NuGet-paketet Microsoft.Azure.Management.Kusto.
Ett Microsoft Entra-program och tjänstens huvudnamn som kan komma åt resurser. Spara katalog-ID (tenant-ID), applikations-ID och klientsekretess.

Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.
Du kan använda Azure Cloud Shell för att köra koden i den här artikeln utan att behöva installera något i din lokala miljö.
Om du väljer att installera och använda Azure CLI lokalt följer du stegen i Konfigurera parametrar. Den här artikeln kräver Azure CLI version 2.0.4 eller senare. Kör az --version för att kontrollera din version. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

Konfigurera CLI-parametrarna

Följande steg krävs inte om du kör kommandon i Azure Cloud Shell. Om du kör CLI lokalt följer du de här stegen för att konfigurera miljön:

Installera tillägget för att använda den senaste Kusto CLI-versionen:
```
az extension add -n kusto
```
Kör följande kommando för att logga in på Azure:
```
az login
```
Ange den prenumeration där du vill att klustret ska skapas. Ersätt MyAzureSub med namnet på den Azure-prenumeration som du vill använda:
```
az account set --subscription MyAzureSub
```
Ange den resursgrupp där du vill att klustret ska skapas. Ersätt testrg med namnet på den resursgrupp som du vill använda:
```
az group create --name testrg --location westus
```

Skapa ett Azure Data Explorer-kluster

Det här avsnittet vägleder dig genom processen att skapa ett Azure Data Explorer-kluster. Välj relevant flik för den metod du föredrar för att skapa klustret.

Skapa klustret med hjälp av följande kod:

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	Föreslaget värde	Fältbeskrivning
klusternamn	mykustocluster	Det önskade namnet på klustret.
skuName	Standard_E8ads_v5	Den SKU som ska användas för klustret.
tier	Standard	SKU-nivån.
capacity	number	Antalet instanser av klustret.
resourceGroupName	testrg	Resursgruppens namn där klustret ska skapas.

Anmärkning

Att skapa ett kluster är en tidskrävande åtgärd, så vi rekommenderar starkt att du använder CreateOrUpdateAsync i stället för CreateOrUpdate.

Kör följande kommando för att kontrollera om klustret har skapats:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Bekräfta att klustret har skapats genom att verifiera att resultatet innehåller provisioningState som Succeeded.

Skapa klustret med hjälp av följande kommando:

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	Föreslaget värde	Fältbeskrivning
klusternamn	mykustocluster	Det önskade namnet på klustret.
sku_namn	Standard_E8ads_v5	Den SKU som ska användas för klustret.
tier	Standard	SKU-nivån.
capacity	number	Antalet instanser av klustret.
resursgrupp_namn	testrg	Resursgruppens namn där klustret ska skapas.

Anmärkning

Att skapa ett kluster är en tidskrävande åtgärd. Metod begin_create_or_update returnerar en instans av LROPoller, se LROPoller-klassen för att få mer information.

Kör följande kommando för att kontrollera om klustret har skapats:

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

Bekräfta att klustret har skapats genom att verifiera att resultatet innehåller provisioningState som Succeeded.

Följande kod visar hur du skapar ett kluster.

Ange nödvändiga miljövariabler, inklusive information om tjänstens huvudnamn från kraven. Ange ditt prenumerations-ID, resursgrupp och region där du vill skapa klustret.

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

Tips/Råd

Använd auth.NewAuthorizerFromCLIWithResource om du har Azure CLI installerat och konfigurerat för autentisering. I så fall behöver du inte skapa ett huvudnamn för tjänsten.

Kör följande kod för att skapa klustret:

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)

Lista klustren för att säkerställa att de skapats framgångsrikt.

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)

Skapa klustret med hjälp av följande kommando:

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

Setting	Föreslaget värde	Fältbeskrivning
name	azureclitest	Det önskade namnet på klustret.
sku	Standard_E8ads_v5	Den SKU som ska användas för klustret. Parametrar: namn – SKU-namnet. tier – SKU-nivån.
resursgrupp	testrg	Resursgruppens namn där klustret ska skapas.
location	westus	Platsen där klustret ska skapas.

Det finns andra valfria parametrar som du kan använda, till exempel klustrets kapacitet.

Kör följande kommando för att kontrollera om klustret har skapats:

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

Bekräfta att klustret har skapats genom att verifiera att resultatet innehåller provisioningState som Succeeded.

Skapa klustret med hjälp av följande kommando:

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

Setting	Föreslaget värde	Fältbeskrivning
Namn	mykustocluster	Det önskade namnet på klustret.
Sku	Standard_E8ads_v5	Den SKU som ska användas för klustret.
ResourceGroupName	testrg	Resursgruppens namn där klustret ska skapas.

Det finns andra valfria parametrar som du kan använda, till exempel klustrets kapacitet.

Kör följande kommando för att kontrollera om klustret har skapats:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Bekräfta att klustret har skapats genom att verifiera att resultatet innehåller provisioningState som Succeeded.

Information om hur du distribuerar följande ARM-mall med Hjälp av PowerShell finns i Använda ARM-mallen. Du kan också distribuera mallen i Azure-portalen genom att välja Distribuera till Azure.

ARM-mall

Du kan använda den här mallen för dina egna distributioner eller anpassa den så att den uppfyller dina krav. JSON-syntaxen och egenskaperna som ska användas i en mall finns i Microsoft.Kusto-resurstyper.

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

Använda ARM-mallen

Följande steg beskriver hur du distribuerar ARM-mallen med Hjälp av PowerShell.

Öppna Azure Cloud Shell och följ anvisningarna för att logga in.

Välj Kopiera för att kopiera PowerShell-skriptet.

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

Högerklicka på gränssnittskonsolen och välj sedan Klistra in.

Anmärkning

Det tar några minuter att skapa ett Azure Data Explorer-kluster och en databas.

Kontrollera distributionen genom att använda följande Azure PowerShell-skript. Om Cloud Shell fortfarande är öppet behöver du inte kopiera/köra den första raden (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 ..."

Skapa en Azure Data Explorer-databas

I det här avsnittet skapar du en databas i klustret som skapades i föregående avsnitt.

Skapa databasen med hjälp av följande kod:

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

Anmärkning

Om du använder C# version 2.0.0 eller senare använder du Database i stället för ReadWriteDatabase.

Setting	Föreslaget värde	Fältbeskrivning
klusternamn	mykustocluster	Namnet på klustret där databasen ska skapas.
databaseName	mykustodatabase	Namnet på databasen.
resourceGroupName	testrg	Resursgruppens namn där klustret ska skapas.
softDeletePeriod	3650:00:00:00	Hur lång tid data ska hållas tillgängliga för frågor.
hotCachePeriod	3650:00:00:00	Hur lång tid data ska lagras i cacheminnet.

Kör följande kommando för att se databasen som du skapade:

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

Skapa databasen med hjälp av följande kommando:

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

Anmärkning

Om du använder Python version 0.4.0 eller senare använder du Databasen i stället för ReadWriteDatabase.

Setting	Föreslaget värde	Fältbeskrivning
klusternamn	mykustocluster	Namnet på klustret där databasen ska skapas.
databasnamn	mykustodatabase	Namnet på databasen.
resursgrupp_namn	testrg	Resursgruppens namn där klustret ska skapas.
soft_borttagningsperiod	3650 dagar, 0:00:00	Hur lång tid data ska hållas tillgängliga för frågor.
period för varm cache	3650 dagar, 0:00:00	Hur lång tid data ska lagras i cacheminnet.

Kör följande kommando för att se databasen som du skapade:

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

Följande kod visar hur du skapar en databas. Initieringen av paketimporter och miljövariabler är samma som i föregående avsnitt.

Kör följande kod för att skapa databasen:

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)

Visa en lista över databaserna för att säkerställa att de har skapats:

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)

Skapa databasen med hjälp av följande kommando:

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	Föreslaget värde	Fältbeskrivning
cluster-name	azureclitest	Namnet på klustret där databasen ska skapas.
database-name	clidatabase	Namnet på databasen.
resursgrupp	testrg	Resursgruppens namn där klustret ska skapas.
läs-skriv-databas	P365DP31Dwestus	Databastypen. Parametrar: mjuk borttagningsperiod – Anger hur lång tid data ska hållas tillgängliga för frågor. Mer information finns i kvarhållningsprincipen . hot-cache-period – anger hur lång tid data ska sparas i cacheminnet. Mer information finns i cachepolicy. plats -The plats där databasen ska skapas.

Kör följande kommando för att se databasen som du skapade:

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

Skapa databasen med hjälp av följande kommando:

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

Setting	Föreslaget värde	Fältbeskrivning
Klusternamn	mykustocluster	Namnet på klustret där databasen ska skapas.
Namn	mykustodatabase	Namnet på databasen.
ResourceGroupName	testrg	Resursgruppens namn där klustret ska skapas.
SoftDeletePeriod	3650:00:00:00	Hur lång tid data ska hållas tillgängliga för frågor.
HetCachePeriod	3650:00:00:00	Hur lång tid data ska lagras i cacheminnet.

Kör följande kommando för att se databasen som du skapade:

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

Nästa steg

Skapa en tabell

Feedback

Var den här sidan till hjälp?

Dela via

Skapa ett Azure Data Explorer-kluster och en databas

Förutsättningar

Skapa ett Azure Data Explorer-kluster

Skapa en Azure Data Explorer-databas

Nästa steg

Feedback

Ytterligare resurser