Skapa ett Azure Data Explorer-kluster och en databas

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, Bicep 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:

ARM-template

• Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.

Bicep

• Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.

PowerShell

• Konfigurera din miljö med hjälp av anvisningarna i Använda Kusto-cmdletar i Azure PowerShell.

C#

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

Python

• Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.
• Python 3.4+.
• Installera azure-common - och azure-mgmt-kusto-paketen .
• Ett Microsoft Entra-program och tjänstens huvudnamn som kan komma åt resurser. Spara katalog-ID (tenant-ID), applikations-ID och klientsekretess.

Gå!

• Ett Azure-abonnemang. Skapa ett kostnadsfritt Azure-konto.
• Installera Git.
• Installera en lämplig version av Go. För versioner som stöds, se Azure Kusto Module for Go.
• Ett Microsoft Entra-program och tjänstens huvudnamn som kan komma åt resurser. Spara katalog-ID (tenant-ID), applikations-ID och klientsekretess.

Azure CLI

Important

Kusto-tillägget för Azure CLI är inaktuellt och underhålls inte. Vi rekommenderar att du använder PowerShell- eller ARM/Bicep-mallar för att skapa kluster och databaser. Om du väljer att använda Azure CLI måste du installera tillägget Kusto så att du har de senaste CLI-kommandona för Azure Data Explorer.

• 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:

1. Installera tillägget för att använda den senaste Kusto CLI-versionen:

   az extension add -n kusto
   

2. Kör följande kommando för att logga in på Azure:

   az login
   

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

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

ARM-template

ARM-mall

Nedan visas ett exempel på en ARM-mall som skapar ett Azure Data Explorer kluster och en databas i klustret med minimal konfiguration. Fullständig information och egenskaper som stöds finns i REFERENS för ARM-mallkluster och REFERENS för ARM-malldatabas.

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

Bicep

Nedan visas ett exempel på en Bicep mall som skapar ett Azure Data Explorer kluster och en databas i klustret med minimal konfiguration. Fullständig information och egenskaper som stöds finns i Bicep klusterreferens och Bicep databasreferens.

    @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'
      }
    }

PowerShell

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

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

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

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

C#

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

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

   clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
   

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

Python

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

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

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

Gå!

Följande kod visar hur du skapar ett kluster.

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

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

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

Azure CLI

Important

Kusto-tillägget för Azure CLI är inaktuellt och underhålls inte. Vi rekommenderar att du använder PowerShell- eller ARM/Bicep-mallar för att skapa kluster och databaser. Om du väljer att använda Azure CLI måste du installera tillägget Kusto så att du har de senaste CLI-kommandona för Azure Data Explorer.

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

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

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

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

Skapa en Azure Data Explorer-databas

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

ARM-template

Klustret och databasen skapas tillsammans med ARM-mallen i föregående avsnitt.

Bicep

Klustret och databasen skapas tillsammans med mallen Bicep i föregående avsnitt.

PowerShell

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

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

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

C#

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

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

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

Python

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

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

Gå!

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

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

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

Azure CLI

Important

Kusto-tillägget för Azure CLI är inaktuellt och underhålls inte. Vi rekommenderar att du använder PowerShell- eller ARM/Bicep-mallar för att skapa kluster och databaser. Om du väljer att använda Azure CLI måste du installera tillägget Kusto så att du har de senaste CLI-kommandona för Azure Data Explorer.

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

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

Nästa steg

Skapa en tabell