Creación de un clúster y de la base de datos de Azure Data Explorer

Artículo
07/07/2024

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 utilizando C#, Python, Go, la CLI de Azure, PowerShell 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:

Suscripción a Azure. Cree una cuenta de Azure gratuita.
Visual Studio 2022 Community Edition. Active el Desarrollador de Azure durante la configuración de Visual Studio.
Instale el paquete Microsoft.Azure.Management.Kusto NuGet.
Un principal de aplicación y servicio de Microsoft Entra que puede acceder a recursos. Guarde el id. de directorio (inquilino), el id. de aplicación, y el secreto de cliente.

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.

Configuración de los parámetros de la CLI

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.

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	Nombre que quiere para el clúster.
skuName	Standard_E8ads_v5	La SKU que se usará para el clúster.
nivel	Estándar	Nivel de SKU.
capacidad	number	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 creación exitosa del clúster verificando 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	Nombre que quiere para el clúster.
sku_name	Standard_E8ads_v5	La SKU que se usará para el clúster.
nivel	Estándar	Nivel de SKU.
capacidad	number	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 exitosa del clúster verificando 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)>"

Sugerencia

Utilice auth.NewAuthorizerFromCLIWithResource si tiene Azure CLI instalado y configurado para la autenticación. En esa situación, no es preciso crear ninguna entidad de servicio.

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)

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	Nombre que quiere para el clúster.
sku	Standard_E8ads_v5	La SKU que se usará para el clúster. Parámetros: name: el nombre de SKU. tier: el nivel de SKU.
resource-group	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 creación exitosa del clúster verificando el resultado contiene provisioningState como Succeeded.

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	Nombre que quiere para el clúster.
SKU	Standard_E8ads_v5	La SKU que se usará para el 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 creación exitosa del clúster verificando el resultado contiene provisioningState como Succeeded.

Para saber cómo implementar la siguiente plantilla ARM mediante PowerShell, consulte Uso de la plantilla ARM. También puede implementar la plantilla en Azure Portal seleccionando Implementar en Azure.

Plantilla ARM

Puede usar esta plantilla para sus propias implementaciones o personalizarla para satisfacer sus necesidades. Para la sintaxis y las propiedades de JSON que se usan en una plantilla, consulte Tipos de recursos de 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
            }
        }
    ]
}

Uso de la plantilla de ARM

Los siguientes pasos explican cómo implementar la plantilla ARM utilizando PowerShell.

Abra Azure Cloud Shell y siga las instrucciones para iniciar sesión.

Seleccione Copiar para copiar el script de 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 ..."

Haga clic con el botón derecho en la consola del shell y seleccione Pegar.

Nota

La creación de un clúster y una base de datos de Azure Data Explorer tarda unos minutos.

Para comprobar la implementación, use el siguiente script de Azure PowerShell. Si Cloud Shell sigue abierto, no es necesario copiar ni ejecutar la primera línea (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 ..."

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.

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.
soft_delete_period	3650 days, 0:00:00	Cantidad de tiempo que los datos estarán disponibles para consulta.
hot_cache_period	3650 days, 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)

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.
database-name	clidatabase	El nombre de la base de datos.
resource-group	testrg	Nombre del grupo de recursos en el que se creará el clúster.
read-write-database	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

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

Paso siguiente

Crear una tabla

Compartir a través de

Creación de un clúster y de la base de datos de Azure Data Explorer

Requisitos previos

Configuración de los parámetros de la CLI

Configurar parámetros

Creación de un clúster de Azure Data Explorer

Plantilla ARM

Uso de la plantilla de ARM

Cree una base de datos Azure Data Explorer

Paso siguiente

Comentarios

Recursos adicionales