Azure Data Explorer es un servicio de análisis de datos rápido y totalmente administrado para analizar en tiempo real grandes volúmenes de datos de que se transmiten desde aplicaciones, sitios web, dispositivos IoT, etc. Para usar Azure Data Explorer, cree primero un clúster y una o varias bases de datos en ese clúster. A continuación, puede ingerir (cargar) datos en una base de datos y ejecutar consultas con ellos.
En este artículo, aprenderá a crear un clúster y una base de datos mediante C#, Python, Go, el CLI de Azure, PowerShell, Bicep o una plantilla de Azure Resource Manager (ARM). Para aprender a crear un clúster y una base de datos mediante el portal de Azure, consulte Inicio rápido: crear un clúster y una base de datos de Azure Data Explorer.
Para ver ejemplos de código basados en versiones anteriores del SDK, consulte el artículo archivado.
Requisitos previos
Requisitos previos según el método de creación de clústeres y bases de datos:
Importante
La extensión kusto para CLI de Azure está obsoleta y no se mantiene. Se recomienda usar plantillas de PowerShell o ARM/Bicep para la creación de clústeres y bases de datos. Si decide usar CLI de Azure, asegúrese de instalar la extensión Kusto para asegurarse de que tiene los comandos de la CLI más recientes para Azure Data Explorer.
- Suscripción a Azure. Cree una cuenta de Azure gratuita.
- Puede utilizar Azure Cloud Shell para ejecutar el código de este artículo sin tener que instalar nada en su entorno local.
- Si decide instalar y utilizar la CLI de Azure localmente, siga los pasos indicados en Configurar parámetros. En este artículo se requiere la CLI de Azure versión 2.0.4 o versiones posteriores. Ejecute
az --version para comprobar la versión. Si necesita instalarla o actualizarla, consulte Instalación de la CLI de Azure.
Los siguientes pasos no son necesarios si ejecuta comandos en Azure Cloud Shell. Si está ejecutando la CLI localmente, siga estos pasos para configurar el entorno:
Instale la extensión para usar la versión más reciente de la CLI de Kusto:
az extension add -n kusto
Ejecute el siguiente comandos para iniciar sesión en Azure:
az login
Establezca la suscripción donde quiere que se cree el clúster. Reemplace MyAzureSub por el nombre de la suscripción de Azure que quiere usar:
az account set --subscription MyAzureSub
Establezca el grupo de recursos en el que desea que se cree el clúster. Sustituya testrg por el nombre del grupo de recursos que quiere utilizar:
az group create --name testrg --location westus
Creación de un clúster de Azure Data Explorer
Esta sección le guía a través del proceso de creación de un clúster Azure Data Explorer. Seleccione la pestaña correspondiente al método que prefiera para crear el clúster.
Plantilla ARM
A continuación se muestra un ejemplo de una plantilla de ARM que crea un clúster de Azure Data Explorer y una base de datos dentro de ese clúster con una configuración mínima. Para obtener detalles completos y propiedades admitidas, consulte Referencia de clústeres de plantillas de ARM y referencia de base de datos de plantilla de 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"
}
}
]
}
A continuación se muestra un ejemplo de una plantilla de Bicep que crea un clúster de Azure Data Explorer y una base de datos dentro de ese clúster con una configuración mínima. Para conocer todos los detalles y las propiedades admitidas, consulte referencia de clústeres de Bicep y referencia de bases de datos de 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'
}
}
Cree el clúster mediante el siguiente comando:
New-AzKustoCluster -ResourceGroupName testrg -Name mykustocluster -Location westus2 -SkuTier Standard -SkuCapacity 2 -SkuName 'Standard_E8ads_v5'
|
Configuración |
Valor sugerido |
Descripción del campo |
| Nombre |
mykustocluster |
El nombre deseado de su clúster. |
| SKU |
Standard_E8ads_v5 |
El SKU que se utilizará en su clúster. |
| ResourceGroupName |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
Puede usar otros parámetros opcionales, como la capacidad del clúster.
Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
Confirme la correcta creación del clúster verificando que el resultado contiene provisioningState como Succeeded.
Cree el clúster mediante el siguiente 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);
|
Configuración |
Valor sugerido |
Descripción del campo |
| clusterName |
mykustocluster |
El nombre deseado del clúster. |
| skuName |
Standard_E8ads_v5 |
El SKU que se utilizará para su clúster. |
| nivel |
Estándar |
Nivel de SKU. |
| capacidad |
número |
Número de instancias del clúster. |
| resourceGroupName |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
Nota:
La creación de un clúster es una operación de larga duración, por lo que se recomienda encarecidamente utilizar CreateOrUpdateAsync en lugar de CreateOrUpdate.
Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
Confirme la correcta creación del clúster verificando que el resultado contiene provisioningState como Succeeded.
Cree el clúster mediante el siguiente 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()
|
Configuración |
Valor sugerido |
Descripción del campo |
| cluster_name |
mykustocluster |
El nombre deseado para el clúster. |
| sku_name |
Standard_E8ads_v5 |
El SKU que se utilizará para su clúster. |
| nivel |
Estándar |
Nivel del SKU. |
| capacidad |
número |
Número de instancias del clúster. |
| resource_group_name |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
Nota:
La creación de un clúster es una operación de larga duración. El método begin_create_or_update devuelve una instancia de LROPoller. Consulte la clase LROPoller para más información.
Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:
cluster_operations.get(resource_group_name = resource_group_name, cluster_name= cluster_name, custom_headers=None, raw=False)
Confirme la creación correcta del clúster verificando que el resultado contiene provisioningState como Succeeded.
El siguiente código muestra cómo crear un clúster.
Establezca las variables de entorno necesarias, incluida la información principal de servicio de los requisitos previos. Escriba el identificador de la suscripción, el grupo de recursos y la región en que desea crear el clúster.
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)>"
Ejecute el siguiente código para crear el clúster:
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)
Enumere los clústeres para garantizar el éxito de la creación:
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
La extensión kusto para CLI de Azure está obsoleta y no se mantiene. Se recomienda usar plantillas de PowerShell o ARM/Bicep para la creación de clústeres y bases de datos. Si decide usar CLI de Azure, asegúrese de instalar la extensión Kusto para asegurarse de que tiene los comandos de la CLI más recientes para Azure Data Explorer.
Cree el clúster mediante el siguiente comando:
az kusto cluster create --cluster-name azureclitest --sku name="Standard_E8ads_v5" tier="Standard" --resource-group testrg --location westus
|
Configuración |
Valor sugerido |
Descripción del campo |
| nombre |
azureclitest |
El nombre deseado de su clúster. |
| sku |
Standard_E8ads_v5 |
El SKU que se utilizará para el clúster. Parámetros: name: el nombre de SKU.
tier: el nivel de SKU. |
| grupo-de-recursos |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
| ubicación |
westus |
La ubicación en la que se creará el clúster. |
Puede usar otros parámetros opcionales, como la capacidad del clúster.
Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:
az kusto cluster show --cluster-name azureclitest --resource-group testrg
Confirme la correcta creación del clúster verificando que el resultado contiene provisioningState como Succeeded.
Cree una base de datos Azure Data Explorer
En esta sección, creará una base de datos dentro del clúster creado en la sección anterior.
El clúster y la base de datos se crean junto con la plantilla ARM de la sección anterior.
El clúster y la base de datos se crean junto con la plantilla Bicep de la sección anterior.
Cree la base de datos con el siguiente comando:
New-AzKustoDatabase -ResourceGroupName testrg -ClusterName mykustocluster -Name mykustodatabase -SoftDeletePeriod 3650:00:00:00 -HotCachePeriod 3650:00:00:00
|
Configuración |
Valor sugerido |
Descripción del campo |
| ClusterName |
mykustocluster |
Nombre del clúster donde se creará la base de datos. |
| Nombre |
mykustodatabase |
El nombre de la base de datos. |
| ResourceGroupName |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
| SoftDeletePeriod |
3650:00:00:00 |
Cantidad de tiempo que los datos estarán disponibles para consulta. |
| HotCachePeriod |
3650:00:00:00 |
Cantidad de tiempo que los datos se conservarán en la caché. |
Ejecute el siguiente comando para ver la base de datos que ha creado:
Get-AzKustoDatabase -ClusterName mykustocluster -ResourceGroupName testrg -Name mykustodatabase
Cree la base de datos mediante el siguiente 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);
Nota:
Si usa la versión 2.0.0 de C#, o cualquier versión inferior, use Database en lugar de ReadWriteDatabase.
|
Configuración |
Valor sugerido |
Descripción del campo |
| clusterName |
mykustocluster |
Nombre del clúster donde se creará la base de datos. |
| databaseName |
mykustodatabase |
El nombre de la base de datos. |
| resourceGroupName |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
| softDeletePeriod |
3650:00:00:00 |
Cantidad de tiempo que los datos estarán disponibles para consulta. |
| hotCachePeriod |
3650:00:00:00 |
Cantidad de tiempo que los datos se conservarán en la caché. |
Ejecute el siguiente comando para ver la base de datos que ha creado:
databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;
Cree la base de datos con el siguiente 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()
Nota:
Si utiliza la versión 0.4.0 de Python, o cualquier versión inferior, use Database en lugar de ReadWriteDatabase.
|
Configuración |
Valor sugerido |
Descripción del campo |
| cluster_name |
mykustocluster |
Nombre del clúster donde se creará la base de datos. |
| database_name |
mykustodatabase |
El nombre de la base de datos. |
| resource_group_name |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
| periodo_de_eliminacion_logica |
3650 días, 0:00:00 |
Cantidad de tiempo que los datos estarán disponibles para consulta. |
| periodo_de_caché_activa |
3650 días, 0:00:00 |
Cantidad de tiempo que los datos se conservarán en la caché. |
Ejecute el siguiente comando para ver la base de datos que ha creado:
database_operations.get(resource_group_name = resource_group_name, cluster_name = cluster_name, database_name = database_name)
El siguiente código muestra cómo crear una base de datos. La importación de paquetes y la iniciación de variables de entorno es la misma que en la sección anterior.
Ejecute el siguiente código para crear la base de datos:
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)
Enumere las bases de datos para garantizar el éxito de la creación:
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
La extensión kusto para CLI de Azure está obsoleta y no se mantiene. Se recomienda usar plantillas de PowerShell o ARM/Bicep para la creación de clústeres y bases de datos. Si decide usar CLI de Azure, asegúrese de instalar la extensión Kusto para asegurarse de que tiene los comandos de la CLI más recientes para Azure Data Explorer.
Cree la base de datos con el siguiente 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
|
Configuración |
Valor sugerido |
Descripción del campo |
| cluster-name |
azureclitest |
Nombre del clúster donde se creará la base de datos. |
| nombre de la base de datos |
clidatabase |
El nombre de la base de datos. |
| grupo-de-recursos |
testrg |
Nombre del grupo de recursos en el que se creará el clúster. |
| base de datos de lectura y escritura |
P365DP31Dwestus |
El tipo de base de datos. Parámetros: soft-delete-period, indica la cantidad de tiempo que los datos estarán disponibles para consulta. Para más información, consulte Directiva de retención.
hot-cache-period: cantidad de tiempo que los datos se conservarán en la caché. Para más información, consulte Directiva de caché.
location: esta es la ubicación en la que se creará la base de datos. |
Ejecute el siguiente comando para ver la base de datos que ha creado:
az kusto database show --database-name clidatabase --resource-group testrg --cluster-name azureclitest
Paso siguiente