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

• 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.
• Python 3.4+.
• Instale los paquetes de azure-common y azure-mgmt-kusto.
• 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.
• Instale Git.
• Instale una versión adecuada de Go. Para conocer las versiones compatibles, consulte Azure Kusto Module para Go.
• 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:

1. Instale la extensión para usar la versión más reciente de la CLI de Kusto:

   az extension add -n kusto
   

2. Ejecute el siguiente comandos para iniciar sesión en Azure:

   az login
   

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

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

• Configure su entorno siguiendo las instrucciones de Uso de Kusto cmdlets en Azure PowerShell.

Configurar parámetros

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:

• Suscripción a Azure. Cree una cuenta de Azure gratuita.

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

2. Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:

   clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
   

3. Confirme la creación exitosa del clúster verificando el resultado contiene provisioningState como Succeeded.

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

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

3. 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. Para clonar el repositorio de código, consulte Administrar un clúster de Azure Data Explorer mediante Azure Go SDK.

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

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

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

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

2. Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:

   az kusto cluster show --cluster-name azureclitest --resource-group testrg
   

3. Confirme la creación exitosa del clúster verificando el resultado contiene provisioningState como Succeeded.

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

2. Ejecute el siguiente comando para comprobar si el clúster se creó correctamente:

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

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

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

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

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

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

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

2. Ejecute el siguiente comando para ver la base de datos que ha creado:

   databaseData = (await databases.GetAsync(databaseName)).Value.Data as KustoReadWriteDatabase;
   

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

2. 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. Para clonar el repositorio de código, consulte Administrar un clúster de Azure Data Explorer mediante Azure Go SDK.

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

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

1. 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	P365D P31D westus	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.

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

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

2. Ejecute el siguiente comando para ver la base de datos que ha creado:

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

El clúster y la base de datos se crean junto con la plantilla ARM de la sección anterior.