Creare un database e un cluster di Esplora dati di Azure

Articolo
05/17/2023

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

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

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

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

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. Per clonare il repository di codice, vedere Gestire un cluster Esplora dati di Azure con 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 è installata e configurata l'interfaccia della riga di comando di Azure per l'autenticazione. In questo caso, 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: 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.

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

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

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

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

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 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 Esplora dati di Azure con 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	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.

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

Eseguire il comando seguente per vedere il database creato:

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

Passaggio successivo

Crea una tabella

Condividi tramite

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 Esplora dati di Azure

Modello ARM

Usare il modello di Resource Manager

Creare un database Esplora dati di Azure

Passaggio successivo

Commenti e suggerimenti

Risorse aggiuntive