Criar um cluster do Azure Data Explorer e o banco de dados

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 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, você aprenderá a criar um cluster e um banco de dados usando C#, Python, Go, o CLI do Azure, o PowerShell, Bicep ou um modelo do ARM (Azure Resource Manager). Para saber como criar um cluster e um banco de dados usando o portal do Azure, consulte Início Rápido: Criar um cluster e um banco de dados do Azure Data Explorer.

Para obter amostras de código baseadas 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:

Modelo de ARM

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.

Bicep

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.

PowerShell

• Configure seu ambiente usando as instruções em Usar cmdlets Kusto no Azure PowerShell.

C#

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.
• Visual Studio Community Edition 2022. Ativar o Desenvolvimento do Azure durante a configuração do Visual Studio.
• Instale o pacote NuGet Microsoft.Azure.Management.Kusto.
• Um aplicativo e uma entidade de serviço do Microsoft Entra com acesso a recursos. Salve o ID do Diretório (locatário), o ID do Aplicativo e o Segredo do Cliente.

Python

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.
• Python 3.4+.
• Instale os pacotes azure-common e azure-mgmt-kusto.
• Um aplicativo e uma entidade de serviço do Microsoft Entra que podem acessar recursos. Salve o ID do Diretório (locatário), o ID do Aplicativo e o Segredo do Cliente.

Go

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.
• Instale o Git.
• Instale uma versão apropriada do Go. Para conhecer as versões compatíveis, consulte Módulo do Azure Kusto para Go.
• Um aplicativo e uma entidade de serviço do Microsoft Entra que podem acessar recursos. Salve o ID do Diretório (locatário), o ID do Aplicativo e o Segredo do Cliente.

CLI do Azure

Importante

A extensão kusto para CLI do Azure está desatualizada e não mantida. É recomendável usar modelos do PowerShell ou arm/Bicep para criação de cluster e banco de dados. Se você optar por usar CLI do Azure, instale a extensão Kusto para garantir que você tenha os comandos mais recentes da CLI para Azure Data Explorer.

• Uma assinatura do Azure. Criar uma conta gratuita do Azure.
• Você pode usar o Azure Cloud Shell para executar o código deste 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 tutorial 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, confira Instalar a CLI do Azure.

Configurar os parâmetros da CLI

As etapas a seguir não serã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:

1. Instale a extensão para usar a versão mais recente da CLI do Kusto:

   az extension add -n kusto
   

2. Execute o comando a seguir para entrar no Azure:

   az login
   

3. Defina a assinatura em que deseja criar o cluster. Substitua MyAzureSub pelo nome da assinatura do Azure que deseja usar:

   az account set --subscription MyAzureSub
   

4. Configure o grupo de recursos onde você deseja que seu 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ê no processo de criação de um cluster do Azure Data Explorer. Escolha a guia relevante para seu método preferido de criar o cluster.

Modelo de ARM

modelo do ARM

Veja abaixo um exemplo de um modelo do ARM que cria um cluster Azure Data Explorer e um banco de dados dentro desse cluster com configuração mínima. Para obter detalhes completos e propriedades com suporte, consulte a referência de cluster de modelo do ARM e a referência de banco de dados de modelo do 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"
            }
        }
    ]
}

Bicep

Veja abaixo um exemplo de um modelo de Bicep que cria um cluster Azure Data Explorer e um banco de dados dentro desse cluster com configuração mínima. Para obter detalhes completos e propriedades com suporte, consulte referência de cluster do Bicep e referência de banco 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'
      }
    }

PowerShell

1. Crie o 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 cluster.
   Sku	Standard_E8ads_v5	O SKU que será usado no seu cluster.
   ResourceGroupName	testrg	O nome do grupo de recursos em que o cluster será criado.

   Há outros parâmetros opcionais que podem ser usados, como a capacidade do cluster.

2. Execute o comando a seguir para verificar se o cluster foi criado com êxito:

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

3. Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

C#

1. Crie o cluster usando o código a seguir:

   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
   clusterName	mykustocluster	O nome desejado para o cluster.
   skuName	Standard_E8ads_v5	O SKU que será utilizado no seu cluster.
   nível	Standard	O nível de SKU.
   capacidade	número	O número de instâncias do cluster.
   resourceGroupName	testrg	O nome do grupo de recursos em que o cluster será criado.

   Observação

   Criar um cluster é uma operação de execução prolongada, portanto, é altamente recomendável usar CreateOrUpdateAsync, em vez de CreateOrUpdate.

2. Execute o comando a seguir para verificar se o cluster foi criado com êxito:

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

3. Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

Python

1. Crie o 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	O SKU que será usado no seu cluster.
   nível	Standard	O nível de SKU.
   capacidade	número	O número de instâncias do cluster.
   resource_group_name	testrg	O nome do grupo de recursos em que o cluster será criado.

   Observação

   Criar um cluster é uma operação de execução prolongada. O método begin_create_or_update retorna uma instância de LROPoller. Para saber mais, confira Classe LROPoller.

2. Execute o comando a seguir 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)
   

3. Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

Go

O código a seguir mostra como criar um cluster.

1. Defina as variáveis de ambiente necessárias, incluindo as informações sobre a entidade de serviço dos pré-requisitos. Insira a ID da assinatura, o grupo de recursos e a região em que você deseja 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)>"
   

   Dica

   Use auth.NewAuthorizerFromCLIWithResource se você tiver a CLI do Azure instalada e configurada para autenticação. Nessa situação, não é necessário criar uma entidade de serviço.

2. Execute o código a seguir 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)
   

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

CLI do Azure

Importante

A extensão kusto para CLI do Azure está desatualizada e não mantida. É recomendável usar modelos do PowerShell ou arm/Bicep para criação de cluster e banco de dados. Se você optar por usar CLI do Azure, instale a extensão Kusto para garantir que você tenha os comandos mais recentes da CLI para Azure Data Explorer.

1. Crie o 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	O SKU que será usado no seu cluster. Parâmetros: name – O nome do SKU. tier – A camada da SKU.
   grupo-de-recursos	testrg	O nome do grupo de recursos em que o cluster será criado.
   local	westus	O local em que o cluster será criado.

   Há outros parâmetros opcionais que podem ser usados, como a capacidade do cluster.

2. Execute o comando a seguir para verificar se o cluster foi criado com êxito:

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

3. Confirme a criação bem-sucedida do cluster 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.

Modelo de ARM

O cluster e o banco de dados são criados junto com o modelo do ARM na seção anterior.

Bicep

O cluster e o banco de dados são criados junto com o modelo de Bicep na seção anterior.

PowerShell

1. Crie o 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
   ClusterName	mykustocluster	O nome do cluster em que o banco de dados será criado.
   Nome	mykustodatabase	O nome do banco de dados.
   ResourceGroupName	testrg	O nome do grupo de recursos em que o cluster será criado.
   SoftDeletePeriod	3650:00:00:00	O tempo durante o qual os dados serão mantidos disponíveis para consulta.
   HotCachePeriod	3650:00:00:00	O tempo durante o qual os dados serão mantidos no cache.

2. Execute o seguinte comando para ver o banco de dados criado:

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

C#

1. Crie o banco de dados usando o código a seguir:

   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

   Caso você esteja usando o C# versão 2.0.0 ou inferior, use o banco de dados em vez de ReadWriteDatabase.

   Configuração	Valor sugerido	Descrição do campo
   clusterName	mykustocluster	O nome do cluster em que o banco de dados será criado.
   databaseName	mykustodatabase	O nome do banco de dados.
   resourceGroupName	testrg	O nome do grupo de recursos em que o cluster será criado.
   softDeletePeriod	3650:00:00:00	O tempo durante o qual os dados serão mantidos disponíveis para consulta.
   hotCachePeriod	3650:00:00:00	O tempo durante o qual os dados serão mantidos no cache.

2. Execute o seguinte comando para ver o banco de dados criado:

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

Python

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

   Caso você esteja usando o Python versão 0.4.0 ou inferior, use o banco de dados em vez de ReadWriteDatabase.

   Configuração	Valor sugerido	Descrição do campo
   cluster_name	mykustocluster	O nome do cluster em que o banco de dados será criado.
   database_name	mykustodatabase	O nome do banco de dados.
   resource_group_name	testrg	O nome do grupo de recursos em que o cluster será criado.
   período de exclusão reversível	3650 dias, 0:00:00	O tempo durante o qual os dados serão mantidos disponíveis para consulta.
   hot_cache_period	3650 dias, 0:00:00	O tempo durante o qual os dados serão mantidos no cache.

2. Execute o seguinte comando para ver o banco de dados criado:

   database_operations.get(resource_group_name = resource_group_name, cluster_name = cluster_name, database_name = database_name)
   

Go

O código a seguir mostra como criar um banco de dados. As importações de pacotes e a iniciação de variáveis de ambiente são as mesmas da seção anterior.

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

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

CLI do Azure

Importante

A extensão kusto para CLI do Azure está desatualizada e não mantida. É recomendável usar modelos do PowerShell ou arm/Bicep para criação de cluster e banco de dados. Se você optar por usar CLI do Azure, instale a extensão Kusto para garantir que você tenha os comandos mais recentes da CLI para Azure Data Explorer.

1. Crie o 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 em que o banco de dados será criado.
   database-name	clidatabase	O nome do banco de dados.
   grupo de recursos	testrg	O nome do grupo de recursos em que o cluster será criado.
   banco de dados de leitura e escrita	P365DP31Dwestus	O tipo de banco de dados. Parâmetros: soft-delete-period – Indica o tempo durante o qual os dados serão mantidos disponíveis para consulta. Consulte política de retenção para obter mais informações. hot-cache-period – Indica o tempo durante o qual os dados serão mantidos no cache. Consulte política de cache para obter mais informações. location – O local em que o banco de dados será criado.

2. Execute o seguinte comando para ver o banco de dados criado:

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

Próxima etapa

Criar uma tabela