Esplora dati di Azure: servizio di analisi dei dati veloce e completamente gestito per l'analisi in tempo reale di volumi elevati di flussi di dati provenienti da applicazioni, siti Web, dispositivi IoT e altro ancora. Per usare Esplora dati di Azure, è necessario prima creare un cluster e quindi uno o più database al suo interno. È quindi possibile inserire (caricare) dati in un database ed eseguire query su di esso.
Questo articolo illustra come creare un cluster e un database usando C#, Python, Go, il interfaccia della riga di comando di Azure, PowerShell, Bicep o un modello di Azure Resource Manager (ARM). Per informazioni su come creare un cluster e un database usando il portale di Azure, vedere Avvio rapido: Creare un cluster e un database di Azure Esplora dati.
Per esempi di codice basati sulle versioni precedenti dell'SDK, vedere l'articolo archiviato.
Prerequisiti
Prerequisiti per metodo di creazione di cluster e database:
Importante
L'estensione Kusto per interfaccia della riga di comando di Azure non è aggiornata e non viene mantenuta. È consigliabile usare i modelli di PowerShell o ARM/Bicep per la creazione di cluster e database. Se si sceglie di usare interfaccia della riga di comando di Azure, assicurarsi di installare l'estensione Kusto per assicurarsi di disporre dei comandi dell'interfaccia della riga di comando più recenti per Esplora dati di Azure.
- 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. Esegui
az --version per verificare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.
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:
Installare l'estensione per usare la versione più recente dell'interfaccia della riga di comando Kusto:
az extension add -n kusto
Eseguire questo comando per accedere ad Azure:
az login
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
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
Creare un cluster di Esplora dati di Azure
Questa sezione illustra il processo di creazione di un cluster Esplora dati di Azure. Scegliere la scheda pertinente per il metodo preferito per creare il cluster.
Modello ARM
Di seguito è riportato un esempio di modello ARM che crea un cluster Esplora dati di Azure e un database all'interno di tale cluster con una configurazione minima. Per tutti i dettagli e le proprietà supportate, vedere il riferimento al cluster del modello ARM e il riferimento al database del modello ARM.
{
"$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"
}
}
]
}
Di seguito è riportato un esempio di modello di Bicep che crea un cluster Esplora dati di Azure e un database all'interno di tale cluster con una configurazione minima. Per informazioni complete e sulle proprietà supportate, vedere informazioni di riferimento sul cluster Bicep e informazioni di riferimento sul database Bicep.
@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'
}
}
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 |
Il nome desiderato del cluster. |
| Sku |
Standard_E8ads_v5 |
Lo SKU che verrà utilizzato per il tuo 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.
Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.
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 |
Il nome desiderato del cluster. |
| skuName |
Standard_E8ads_v5 |
Lo SKU che verrà usato per il cluster. |
| livello |
Standard |
Livello di SKU. |
| capacità |
numero |
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.
Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.
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 |
Il nome desiderato del cluster. |
| sku_name |
Standard_E8ads_v5 |
Lo SKU che verrà utilizzato per il tuo cluster. |
| livello |
Standard |
Il livello SKU. |
| capacità |
numero |
Numero di istanze del cluster. |
| nome_gruppo_risorse |
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.
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)
Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.
Il codice seguente illustra come creare un cluster.
Imposta le variabili di ambiente necessarie, incluse le informazioni relative all'entità servizio indicate nei 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
Usa auth.NewAuthorizerFromCLIWithResource se hai installato e configurato interfaccia della riga di comando di Azure per l'autenticazione. In tale situazione, non è necessario creare un service principal.
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)
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)
Importante
L'estensione Kusto per interfaccia della riga di comando di Azure non è aggiornata e non viene mantenuta. È consigliabile usare i modelli di PowerShell o ARM/Bicep per la creazione di cluster e database. Se si sceglie di usare interfaccia della riga di comando di Azure, assicurarsi di installare l'estensione Kusto per assicurarsi di disporre dei comandi dell'interfaccia della riga di comando più recenti per Esplora dati di Azure.
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 |
| nome |
azureclitest |
Il nome desiderato del cluster. |
| sku |
Standard_E8ads_v5 |
Lo SKU che verrà usato per il tuo cluster. Parametri: name : nome dello SKU.
tier : il livello SKU. |
| gruppo di risorse |
testrg |
Il nome del gruppo di risorse in cui verrà creato il cluster. |
| posizione |
westus |
La posizione in cui verrà creato il cluster. |
Esistono altri parametri facoltativi che è possibile usare, ad esempio la capacità del cluster.
Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:
az kusto cluster show --cluster-name azureclitest --resource-group testrg
Verificare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.
Creare un database di Esplora dati di Azure
In questa sezione verrà creato un database all'interno del cluster creato nella sezione precedente.
Il cluster e il database vengono creati insieme al modello ARM nella sezione precedente.
Il cluster e il database vengono creati insieme al modello di Bicep nella sezione precedente.
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 |
| Nome cluster |
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. |
Eseguire il comando seguente per vedere il database creato:
Get-AzKustoDatabase -ClusterName mykustocluster -ResourceGroupName testrg -Name mykustodatabase
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 tuo 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. |
Eseguire il comando seguente per vedere il database creato:
databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;
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 tuo database. |
| nome_gruppo_risorse |
testrg |
Il nome del gruppo di risorse in cui verrà creato il cluster. |
| periodo di eliminazione temporanea |
3650 giorni, 0:00:00 |
Periodo di tempo in cui i dati verranno mantenuti disponibili in modo che sia possibile eseguire una query. |
| periodo_cache_attiva |
3650 giorni, 0:00:00 |
Periodo di tempo in cui i dati verranno conservati nella cache. |
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.
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)
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)
Importante
L'estensione Kusto per interfaccia della riga di comando di Azure non è aggiornata e non viene mantenuta. È consigliabile usare i modelli di PowerShell o ARM/Bicep per la creazione di cluster e database. Se si sceglie di usare interfaccia della riga di comando di Azure, assicurarsi di installare l'estensione Kusto per assicurarsi di disporre dei comandi dell'interfaccia della riga di comando più recenti per Esplora dati di Azure.
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 tuo database. |
| gruppo di risorse |
testrg |
Il nome del gruppo di risorse in cui verrà creato il cluster. |
| database di lettura e scrittura |
P365DP31Dwestus |
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. |
Eseguire il comando seguente per vedere il database creato:
az kusto database show --database-name clidatabase --resource-group testrg --cluster-name azureclitest
Passaggio successivo