O Azure Data Explorer é um serviço de análise de dados rápido e totalmente gerenciado para análise em tempo real de grandes volumes de streaming de dados de aplicativos, sites, dispositivos IoT e muito mais. Para usar o Azure Data Explorer, primeiro crie um cluster e crie um ou mais bancos de dados nesse cluster. Em seguida, você pode ingerir (carregar) dados em um banco de dados e executar consultas nele.
Neste artigo, vai aprender a criar um cluster e uma base de dados usando C#, Python, Go, o CLI do Azure, PowerShell, Bicep ou um modelo do Azure Resource Manager (ARM). Para saber como criar um cluster e um banco de dados usando o portal do Azure, consulte Guia de início rápido : criar um cluster e um banco de dados do Azure Data Explorer.
Para obter exemplos de código baseados em versões anteriores do SDK, consulte o artigo arquivado.
Pré-requisitos
Pré-requisitos por método de criação de cluster e banco de dados:
- Uma assinatura do Azure. Crie uma conta gratuita do Azure .
- Uma assinatura do Azure. Crie uma conta gratuita do Azure .
Importante
A extensão Kusto para CLI do Azure está desatualizada e não é mantida. Recomendamos a utilização de templates PowerShell ou ARM/Bicep para criação de clusters e bases de dados. Se optar por usar CLI do Azure, certifique-se de instalar a extensão Kusto para garantir que tem os comandos CLI mais recentes para Azure Data Explorer.
- Uma assinatura do Azure. Crie uma conta gratuita do Azure .
- Você pode usar do Azure Cloud Shell para executar o código neste artigo sem precisar instalar nada em seu ambiente local.
- Se você optar por instalar e usar a CLI do Azure localmente, siga as etapas em Configurar parâmetros. Este artigo requer a CLI do Azure versão 2.0.4 ou posterior. Execute
az --version para verificar sua versão. Se você precisar instalar ou atualizar, consulte Instalar a CLI do Azure.
As etapas a seguir não são necessárias se você estiver executando comandos no Azure Cloud Shell. Se você estiver executando a CLI localmente, siga estas etapas para configurar o ambiente:
Instale a extensão para usar a versão mais recente da CLI do Kusto:
az extension add -n kusto
Execute o seguinte comando para entrar no Azure:
az login
Defina a subscrição onde pretende que o cluster seja criado. Substitua MyAzureSub pelo nome da assinatura do Azure que você deseja usar:
az account set --subscription MyAzureSub
Defina o grupo de recursos onde você deseja que o cluster seja criado. Substitua testrg pelo nome do grupo de recursos que você deseja usar:
az group create --name testrg --location westus
Criar um cluster do Azure Data Explorer
Esta seção orienta você pelo processo de criação de um cluster do Azure Data Explorer. Escolha a guia relevante para seu método preferido para criar o cluster.
modelo do ARM
Abaixo está um exemplo de um modelo ARM que cria um cluster Azure Data Explorer e uma base de dados dentro desse cluster com configuração mínima. Para detalhes completos e propriedades suportadas, consulte referência do cluster de modelos ARM e referência da base de dados de modelos 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"
}
}
]
}
Abaixo está um exemplo de um modelo Bicep que cria um cluster do Azure Data Explorer e uma base de dados dentro desse cluster com configuração mínima. Para obter todos os detalhes e as propriedades suportadas, consulte a referência de clusters do Bicep e a referência de bases de dados do 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'
}
}
Crie seu cluster usando o seguinte comando:
New-AzKustoCluster -ResourceGroupName testrg -Name mykustocluster -Location westus2 -SkuTier Standard -SkuCapacity 2 -SkuName 'Standard_E8ads_v5'
|
Configuração |
Valor sugerido |
Descrição do campo |
| Nome |
mykustocluster |
O nome desejado para o seu cluster. |
| Código de Produto |
Standard_E8ads_v5 |
A SKU que será usada para seu cluster. |
| NomeDoGrupoDeRecursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
Há outros parâmetros opcionais que você pode usar, como a capacidade do cluster.
Execute o seguinte comando para verificar se o cluster foi criado com êxito:
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
Confirme se o cluster foi criado com sucesso, verificando se o resultado contém provisioningState como Succeeded.
Crie seu cluster usando o seguinte código:
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);
|
Configuração |
Valor sugerido |
Descrição do campo |
| nome_do_cluster |
mykustocluster |
O nome desejado para o seu cluster. |
| nome do SKU |
Standard_E8ads_v5 |
A SKU que será usada para seu cluster. |
| escalão |
Padrão |
O nível de SKU. |
| capacidade |
número |
O número de instâncias do cluster. |
| resourceGroupName |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
Observação
Criar um cluster é uma operação de longa execução, por isso é altamente recomendável usar CreateOrUpdateAsync, em vez de CreateOrUpdate.
Execute o seguinte comando para verificar se o cluster foi criado com êxito:
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
Confirme se o cluster foi criado com sucesso, verificando se o resultado contém provisioningState como Succeeded.
Crie seu cluster usando o seguinte comando:
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()
|
Configuração |
Valor sugerido |
Descrição do campo |
| cluster_name |
mykustocluster |
O nome desejado para o seu cluster. |
| sku_name |
Standard_E8ads_v5 |
A SKU que será usada para seu cluster. |
| escalão |
Padrão |
O nível de SKU. |
| capacidade |
número |
O número de instâncias do cluster. |
| nome_do_grupo_de_recursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
Observação
Criar um cluster é uma operação de longa duração. Método begin_create_or_update retorna uma instância de LROPoller. Veja a classe LROPoller para obter mais informações.
Execute o seguinte comando para verificar se o cluster foi criado com êxito:
cluster_operations.get(resource_group_name = resource_group_name, cluster_name= cluster_name, custom_headers=None, raw=False)
Confirme se o cluster foi criado com sucesso, verificando se o resultado contém provisioningState como Succeeded.
O código a seguir mostra como criar um cluster.
Defina as variáveis de ambiente necessárias, incluindo informações da entidade de serviço dos pré-requisitos. Introduza o ID da subscrição, o grupo de recursos e a região onde pretende criar o 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)>"
Execute o seguinte código para criar o 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)
Liste os clusters para garantir a criação bem-sucedida:
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
A extensão Kusto para CLI do Azure está desatualizada e não é mantida. Recomendamos a utilização de templates PowerShell ou ARM/Bicep para criação de clusters e bases de dados. Se optar por usar CLI do Azure, certifique-se de instalar a extensão Kusto para garantir que tem os comandos CLI mais recentes para Azure Data Explorer.
Crie seu cluster usando o seguinte comando:
az kusto cluster create --cluster-name azureclitest --sku name="Standard_E8ads_v5" tier="Standard" --resource-group testrg --location westus
|
Configuração |
Valor sugerido |
Descrição do campo |
| Nome |
azureclitest |
O nome desejado para o seu cluster. |
| SKU |
Standard_E8ads_v5 |
A SKU que será usada para seu cluster. Parâmetros: nome - O nome do SKU.
nível - A camada SKU. |
| grupo de recursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
| localização |
Westus |
O local onde o cluster será criado. |
Há outros parâmetros opcionais que você pode usar, como a capacidade do cluster.
Execute o seguinte comando para verificar se o cluster foi criado com êxito:
az kusto cluster show --cluster-name azureclitest --resource-group testrg
Confirme se o cluster foi criado com sucesso, verificando se o resultado contém provisioningState como Succeeded.
Criar um banco de dados do Azure Data Explorer
Nesta seção, você criará um banco de dados dentro do cluster criado na seção anterior.
O cluster e o banco de dados são criados junto com o modelo ARM na seção anterior.
O cluster e a base de dados são criados em conjunto com o modelo Bicep na secção anterior.
Crie seu banco de dados usando o seguinte comando:
New-AzKustoDatabase -ResourceGroupName testrg -ClusterName mykustocluster -Name mykustodatabase -SoftDeletePeriod 3650:00:00:00 -HotCachePeriod 3650:00:00:00
|
Configuração |
Valor sugerido |
Descrição do campo |
| Nome do Cluster |
mykustocluster |
O nome do cluster onde o banco de dados será criado. |
| Nome |
mykustodatabase |
O nome do seu banco de dados. |
| NomeDoGrupoDeRecursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
| SoftDeletePeriod |
3650:00:00:00 |
A quantidade de tempo que os dados serão mantidos disponíveis para consulta. |
| Período de Cache Rápido |
3650:00:00:00 |
A quantidade de tempo que os dados serão mantidos em cache. |
Execute o seguinte comando para ver o banco de dados que você criou:
Get-AzKustoDatabase -ClusterName mykustocluster -ResourceGroupName testrg -Name mykustodatabase
Crie seu banco de dados usando o seguinte código:
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);
Observação
Se você estiver usando C# versão 2.0.0 ou inferior, use Database em vez de ReadWriteDatabase.
|
Configuração |
Valor sugerido |
Descrição do campo |
| nome_do_cluster |
mykustocluster |
O nome do cluster onde o banco de dados será criado. |
| Nome do banco de dados |
mykustodatabase |
O nome do seu banco de dados. |
| resourceGroupName |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
| período de eliminação suave |
3650:00:00:00 |
A quantidade de tempo que os dados serão mantidos disponíveis para consulta. |
| hotCachePeriod |
3650:00:00:00 |
A quantidade de tempo que os dados serão mantidos em cache. |
Execute o seguinte comando para ver o banco de dados que você criou:
databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;
Crie seu banco de dados usando o seguinte comando:
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()
Observação
Se você estiver usando Python versão 0.4.0 ou inferior, use Database em vez de ReadWriteDatabase.
|
Configuração |
Valor sugerido |
Descrição do campo |
| cluster_name |
mykustocluster |
O nome do cluster onde o banco de dados será criado. |
| nome_da_base_de_dados |
mykustodatabase |
O nome do seu banco de dados. |
| nome_do_grupo_de_recursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
| período de eliminação suave |
3650 dias, 0:00:00 |
A quantidade de tempo que os dados serão mantidos disponíveis para consulta. |
| período_cache_quente |
3650 dias, 0:00:00 |
A quantidade de tempo que os dados serão mantidos em cache. |
Execute o seguinte comando para ver o banco de dados que você criou:
database_operations.get(resource_group_name = resource_group_name, cluster_name = cluster_name, database_name = database_name)
O código a seguir mostra como criar um banco de dados. As importações de pacotes e a inicialização da variável de ambiente são iguais à seção anterior.
Execute o seguinte código para criar o banco de dados:
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)
Liste os bancos de dados para garantir a criação bem-sucedida:
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
A extensão Kusto para CLI do Azure está desatualizada e não é mantida. Recomendamos a utilização de templates PowerShell ou ARM/Bicep para criação de clusters e bases de dados. Se optar por usar CLI do Azure, certifique-se de instalar a extensão Kusto para garantir que tem os comandos CLI mais recentes para Azure Data Explorer.
Crie seu banco de dados usando o seguinte comando:
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
|
Configuração |
Valor sugerido |
Descrição do campo |
| nome do cluster |
azureclitest |
O nome do cluster onde o banco de dados será criado. |
| nome do banco de dados |
clidatabase |
O nome do seu banco de dados. |
| grupo de recursos |
testrg |
O nome do grupo de recursos onde o cluster será criado. |
| banco de dados de leitura-gravação |
P365DP31Dwestus |
O tipo de banco de dados. Parâmetros: soft-delete-period - Significa o período de tempo durante o qual os dados estarão disponíveis para consulta. Consulte a política de retenção para obter mais informações.
período de cache quente - Significa a quantidade de tempo que os dados serão mantidos em cache. Consulte a política de cache para obter mais informações.
local -The local onde o banco de dados será criado. |
Execute o seguinte comando para ver o banco de dados que você criou:
az kusto database show --database-name clidatabase --resource-group testrg --cluster-name azureclitest
Próximo passo