Creare un database e un cluster di Esplora dati di Azure

Articolo
05/17/2023

Esplora dati di Azure è un servizio di analisi dei dati veloce e completamente gestito per l'analisi in tempo reale di volumi elevati di dati in streaming 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 dati (caricare) in un database ed eseguire query su di esso.

In questo articolo si apprenderà come creare un cluster e un database usando C#, Python, Go, l'interfaccia della riga di comando di Azure, PowerShell o un modello di Azure Resource Manager (ARM). Per informazioni su come creare un cluster e un database usando la portale di Azure, vedere Avvio rapido: Creare un cluster e un database di Azure Esplora dati.

Per esempi di codice basati sulle versioni precedenti di SDK, vedere l'articolo archiviato.

Prerequisiti

Prerequisiti per metodo di creazione del cluster e del database:

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 NuGet Microsoft.Azure.Management.Kusto.
Un'Microsoft Entra'applicazione e un'entità servizio che può 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

La procedura seguente non è necessaria 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 di 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 Azure Esplora dati

Questa sezione illustra il processo di creazione di un cluster di Azure Esplora dati. Scegliere la scheda pertinente per il metodo preferito per creare il cluster.

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.

Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Confermare 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	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, vedere Classe LROPoller per ottenere altre informazioni.

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)

Confermare 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 di Azure Esplora dati tramite Azure Go SDK.

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 l'interfaccia della riga di comando di Azure è installata e configurata per l'autenticazione. In tale situazione, non è necessario creare un'entità servizio.

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)

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: nome : nome SKU. livello : livello SKU.
resource-group	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
posizione	westus	Percorso 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
```
Confermare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

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.

Per verificare se il cluster è stato creato correttamente, eseguire il comando seguente:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Confermare la corretta creazione del cluster verificando che il risultato contenga provisioningState come Succeeded.

Per informazioni su come distribuire il modello di Resource Manager seguente con 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

La procedura seguente illustra come distribuire il modello di Resource Manager con PowerShell.

Aprire Azure Cloud Shell e seguire le istruzioni per accedere.

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

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

Nota

Sono necessari alcuni minuti per creare un cluster e un database di Azure Esplora dati.

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

Creare un database di Esplora dati di Azure

In questa sezione verrà creato un database all'interno del cluster creato nella sezione precedente.

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

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

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 di Azure Esplora dati usando Azure Go SDK.

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)

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	Nome del database.
resource-group	testrg	Il nome del gruppo di risorse in cui verrà creato il cluster.
read-write-database	P365DP31Dwestus	Tipo di database. Parametri: periodo di eliminazione temporanea : indica la quantità di tempo per 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

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
ClusterName	mykustocluster	Nome del cluster in cui verrà creato il database.
Nome	mykustodatabase	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

Passaggio successivo

Creare una tabella

Creare un database e un cluster di Esplora dati di Azure

Prerequisiti

Configurare i parametri dell'interfaccia della riga di comando

Configurare i parametri

Creare un cluster di Azure Esplora dati

Modello ARM

Usare il modello di Resource Manager

Creare un database di Esplora dati di Azure

Passaggio successivo

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive