Creare un database e un cluster di Esplora dati di Azure

• Una sottoscrizione di Azure. Creare un account Azure gratuito.
• Visual Studio 2022 Community Edition. Attivare lo sviluppo di Azure durante la configurazione di Visual Studio.
• Installare il pacchetto Microsoft.Azure.Management.Kusto NuGet.
• Un'applicazione Microsoft Entra e un'entità servizio che possono accedere alle risorse. Salvare l'ID directory (tenant), l'ID applicazione e il segreto client.

• Una sottoscrizione di Azure. Creare un account Azure gratuito.
• Python 3.4+.
• Installare i pacchetti azure-common e azure-mgmt-kusto .
• Un'applicazione Microsoft Entra e un'entità servizio che possono accedere alle risorse. Salvare l'ID directory (tenant), l'ID applicazione e il segreto client.

• Una sottoscrizione di Azure. Creare un account Azure gratuito.
• Installare Git.
• Installare una versione appropriata di Go. Per le versioni supportate, vedere Modulo Kusto di Azure per Go.
• Un'applicazione Microsoft Entra e un'entità servizio che possono accedere alle risorse. Salvare l'ID directory (tenant), l'ID applicazione e il segreto client.

• Una sottoscrizione di Azure. Creare un account Azure gratuito.
• È possibile usare Azure Cloud Shell per eseguire il codice in questo articolo senza dover installare alcun elemento nell'ambiente locale.
• Se si sceglie di installare e usare l'interfaccia della riga di comando di Azure in locale, seguire la procedura descritta in Configurare i parametri. Questo articolo richiede l'interfaccia della riga di comando di Azure 2.0.4 o versioni successive. Eseguire az --version per controllare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Configurare i parametri dell'interfaccia della riga di comando

I passaggi seguenti non sono necessari se si eseguono comandi in Azure Cloud Shell. Se si esegue l'interfaccia della riga di comando in locale, seguire questa procedura per configurare l'ambiente:

1. Installare l'estensione per usare la versione più recente dell'interfaccia della riga di comando Kusto:

   az extension add -n kusto
   

2. Eseguire questo comando per accedere ad Azure:

   az login
   

3. Impostare la sottoscrizione in cui si vuole creare il cluster. Sostituire MyAzureSub con il nome della sottoscrizione di Azure che si vuole usare:

   az account set --subscription MyAzureSub
   

4. Impostare il gruppo di risorse in cui si vuole creare il cluster. Sostituire testrg con il nome del gruppo di risorse che si vuole usare:

   az group create --name testrg --location westus
   

• Configurare l'ambiente usando le istruzioni riportate in Usare i cmdlet Kusto in Azure PowerShell.

Configurare i parametri

I passaggi seguenti non sono necessari se si eseguono comandi in Azure Cloud Shell. Se si esegue l'interfaccia della riga di comando in locale, seguire questa procedura per configurare l'ambiente:

• Una sottoscrizione di Azure. Creare un account Azure gratuito.

1. Creare il cluster usando il codice seguente:

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

   Impostazione	Valore consigliato	Descrizione campo
   clusterName	mykustocluster	Nome del cluster.
   skuName	Standard_E8ads_v5	SKU usato per il cluster.
   livello	Standard	Livello SKU.
   capacità	number	Numero di istanze del cluster.
   resourceGroupName	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.

   Nota

   Creare un cluster è un'operazione a esecuzione prolungata, pertanto è consigliabile usare CreateOrUpdateAsync anziché CreateOrUpdate.

2. Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:

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

3. Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

1. Creare il cluster tramite il comando seguente:

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

   Impostazione	Valore consigliato	Descrizione campo
   cluster_name	mykustocluster	Nome del cluster.
   sku_name	Standard_E8ads_v5	SKU usato per il cluster.
   livello	Standard	Livello SKU.
   capacità	number	Numero di istanze del cluster.
   resource_group_name	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.

   Nota

   Creare un cluster è un'operazione a esecuzione prolungata. Il metodo begin_create_or_update restituisce un'istanza di LROPoller. Per altre informazioni, vedere Classe LROPoller.

2. Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:

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

3. Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

Il codice seguente illustra come creare un cluster. Per clonare il repository di codice, vedere Gestire un cluster Esplora dati di Azure con Azure Go SDK.

1. Impostare le variabili di ambiente necessarie, incluse le informazioni sull'entità servizio dai prerequisiti. Immettere l'ID sottoscrizione, il gruppo di risorse e l'area in cui si vuole creare il cluster.

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

   Suggerimento

   Usare l'autenticazione. NewAuthorizerFromCLIWithResource se è installata e configurata l'interfaccia della riga di comando di Azure per l'autenticazione. In questo caso, non è necessario creare un'entità servizio.

2. Eseguire il codice seguente per creare il cluster:

   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. Elencare i cluster per garantire la corretta creazione:

   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)
   

1. Creare il cluster tramite il comando seguente:

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

   Impostazione	Valore consigliato	Descrizione campo
   name	azureclitest	Nome del cluster.
   sku	Standard_E8ads_v5	SKU usato per il cluster. Parametri: name : nome dello SKU. tier : il livello SKU.
   resource-group	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
   location	westus	Percorso in cui verrà creato il cluster.

   Esistono altri parametri facoltativi che è possibile usare, ad esempio la capacità del cluster.

2. Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:

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

3. Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

1. Creare il cluster tramite il comando seguente:

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

   Impostazione	Valore consigliato	Descrizione campo
   Nome	mykustocluster	Nome del cluster.
   Sku	Standard_E8ads_v5	SKU usato per il cluster.
   ResourceGroupName	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.

   Esistono altri parametri facoltativi che è possibile usare, ad esempio la capacità del cluster.

2. Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

3. Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

Per informazioni su come distribuire il modello di Resource Manager seguente usando PowerShell, vedere Usare il modello di Resource Manager. In alternativa, è possibile distribuire il modello nel portale di Azure selezionando Distribuisci in Azure.

Modello ARM

È possibile usare questo modello per le proprie distribuzioni o personalizzarlo in base alle esigenze. Per la sintassi e le proprietà JSON da usare in un modello, vedere Tipi di risorse Microsoft.Kusto.

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

Usare il modello di Resource Manager

I passaggi seguenti illustrano come distribuire il modello di Resource Manager usando PowerShell.

1. Aprire Azure Cloud Shell e seguire le istruzioni per accedere.

2. Selezionare Copia per copiare lo script di PowerShell.

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

3. Fare clic con il pulsante destro del mouse sulla console della shell e quindi scegliere Incolla.

   Nota

   La creazione di un cluster e di un database di Azure Esplora dati richiede alcuni minuti.

4. Per verificare la distribuzione, usare lo script di Azure PowerShell seguente. Se Cloud Shell è ancora aperto, non è necessario copiare/eseguire la prima riga (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 ..."
   

1. Creare il database usando il codice seguente:

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

   Nota

   Se si usa C# versione 2.0.0 o successiva, usare Database anziché ReadWriteDatabase.

   Impostazione	Valore consigliato	Descrizione campo
   clusterName	mykustocluster	Nome del cluster in cui verrà creato il database.
   databaseName	mykustodatabase	Il nome del database.
   resourceGroupName	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
   softDeletePeriod	3650:00:00:00	Periodo di tempo in cui i dati verranno mantenuti disponibili in modo che sia possibile eseguire una query.
   hotCachePeriod	3650:00:00:00	Periodo di tempo in cui i dati verranno conservati nella cache.

2. Eseguire il comando seguente per vedere il database creato:

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

1. Creare il database tramite il comando seguente:

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

   Nota

   Se si usa Python versione 0.4.0 o successiva, usare Database anziché ReadWriteDatabase.

   Impostazione	Valore consigliato	Descrizione campo
   cluster_name	mykustocluster	Nome del cluster in cui verrà creato il database.
   database_name	mykustodatabase	Il nome del database.
   resource_group_name	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
   soft_delete_period	3650 giorni, 0:00:00	Periodo di tempo in cui i dati verranno mantenuti disponibili in modo che sia possibile eseguire una query.
   hot_cache_period	3650 giorni, 0:00:00	Periodo di tempo in cui i dati verranno conservati nella cache.

2. Eseguire il comando seguente per vedere il database creato:

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

Nel codice seguente viene illustrato come creare un database. L'avvio delle importazioni del pacchetto e della variabile di ambiente è uguale a quello della sezione precedente. Per clonare il repository di codice, vedere Gestire un cluster Esplora dati di Azure con Azure Go SDK.

1. Eseguire il codice seguente per creare il database:

   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. Elencare i database per garantire la corretta creazione:

   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)
   

1. Creare il database tramite il comando seguente:

   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
   

   Impostazione	Valore consigliato	Descrizione campo
   cluster-name	azureclitest	Nome del cluster in cui verrà creato il database.
   database_name	clidatabase	Il nome del database.
   resource-group	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
   read-write-database	P365D P31D westus	Tipo di database. Parametri: periodo di eliminazione temporanea: indica la quantità di tempo in cui i dati verranno mantenuti disponibili per la query. Per altre informazioni, vedere Criteri di conservazione. hot-cache-period : indica la quantità di tempo in cui i dati verranno mantenuti nella cache. Per altre informazioni, vedere Criteri della cache. location : percorso in cui verrà creato il database.

2. Eseguire il comando seguente per vedere il database creato:

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

1. Creare il database tramite il comando seguente:

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

   Impostazione	Valore consigliato	Descrizione campo
   NomeCluster	mykustocluster	Nome del cluster in cui verrà creato il database.
   Nome	mykustodatabase	Il nome del database.
   ResourceGroupName	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
   SoftDeletePeriod	3650:00:00:00	Periodo di tempo in cui i dati verranno mantenuti disponibili in modo che sia possibile eseguire una query.
   HotCachePeriod	3650:00:00:00	Periodo di tempo in cui i dati verranno conservati nella cache.

2. Eseguire il comando seguente per vedere il database creato:

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

Il cluster e il database vengono creati insieme al modello di Resource Manager nella sezione precedente.