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

Artigo
05/08/2023

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

Pré-requisitos

Pré-requisitos por método de criação de cluster e banco de dados:

Uma assinatura do Azure. Criar uma conta gratuita do Azure.
Visual Studio 2022 Community Edition. Ative o desenvolvimento do Azure durante a instalação do Visual Studio.
Instale o pacote NuGet Microsoft.Azure.Management.Kusto.
Um aplicativo Azure AD e uma entidade de serviço que podem acessar recursos. Salve a ID do diretório (locatário),a ID do aplicativo e o segredo do cliente.

Uma assinatura do Azure. Criar uma conta gratuita do Azure.
Você pode usar o Azure Cloud Shell para executar o código neste artigo sem precisar instalar nada em seu ambiente local.
Se você optar por instalar e usar a CLI do Azure localmente, siga as etapas em Configurar parâmetros. Este 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:

Instale a extensão para usar a versão mais recente da CLI do Kusto:
```
az extension add -n kusto
```
Execute o comando a seguir para entrar no Azure:
```
az login
```
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
```
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
```

Uma assinatura do Azure. Criar uma conta gratuita do Azure.
Você pode usar o Azure Cloud Shell para executar o código neste artigo sem precisar instalar nada em seu ambiente local.
Se você optar por instalar e usar o PowerShell localmente, siga as etapas em Configurar parâmetros.

Configurar parâmetros

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:

Execute o comando a seguir para entrar no Azure:
```
Connect-AzAccount
```

Defina a assinatura em que deseja criar o cluster:

 Set-AzContext -SubscriptionId "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

Ao executar a CLI do Azure localmente ou no Cloud Shell do Azure, você precisa instalar o Az.Kusto módulo em seu dispositivo:
```
 Install-Module -Name Az.Kusto
```

Criar um cluster do Azure Data Explorer

Esta seção orienta você pelo processo de criação de um cluster de Data Explorer do Azure. Escolha a guia relevante para o método preferido para criar o cluster.

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 authClient = ConfidentialClientApplicationBuilder.Create(clientId)
    .WithAuthority($"https://login.microsoftonline.com/{tenantId}")
    .WithClientSecret(clientSecret)
    .Build();
var result = authClient.AcquireTokenForClient(new[] { "https://management.core.windows.net/" }).ExecuteAsync().Result;
var credentials = new TokenCredentials(result.AccessToken, result.TokenType);
var kustoManagementClient = new KustoManagementClient(credentials) { SubscriptionId = subscriptionId };
var resourceGroupName = "testrg";
var clusterName = "mykustocluster";
var skuName = KustoSkuName.StandardE8adsV5;
var skuTier = KustoSkuTier.Standard;
var capacity = 5;
var clusterData = new Cluster(
    location: "Central US",
    sku: new AzureSku(skuName, skuTier, capacity)
);
await kustoManagementClient.Clusters.CreateOrUpdateAsync(resourceGroupName, clusterName, clusterData);

Configuração	Valor sugerido	Descrição do campo
clusterName	mykustocluster	O nome desejado do cluster.
skuName	Standard_E8ads_v5	O SKU que será usado para o cluster.
Camada	Standard	A camada da SKU.
ALOCADA	number	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.

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

clusterData = await kustoManagementClient.Clusters.GetAsync(resourceGroupName, clusterName);

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

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 do cluster.
sku_name	Standard_E8ads_v5	O SKU que será usado para o cluster.
Camada	Standard	A camada da SKU.
ALOCADA	number	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.

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)

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

O código a seguir mostra como criar um cluster. Para clonar o repositório de código, consulte Gerenciar um cluster do Azure Data Explorer usando o SDK do Go do Azure.

Defina as variáveis de ambiente necessárias, incluindo informações da 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 autenticação. 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.

Execute o seguinte código para criar o cluster:

import (
 "context"
 "log"
 "os"
 "strconv"

 "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
 "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
 "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kusto/armkusto"
 "github.com/olekukonko/tablewriter"
)

const (
 subscriptionEnvVar      = "AZURE_SUBSCRIPTION_ID"
 resourceGroupEnvVar     = "AZURE_RESOURCE_GROUP"
 locationEnvVar          = "AZURE_LOCATION"
 clusterNamePrefixEnvVar = "CLUSTER_NAME_PREFIX"
 dbNamePrefixEnvVar      = "DATABASE_NAME_PREFIX"

 clusterName  = "ADXTestCluster"
 databaseName = "ADXTestDB"
)

func init() {
 subscription = os.Getenv(subscriptionEnvVar)
 if subscription == "" {
  log.Fatalf("missing environment variable %s", subscriptionEnvVar)
 }

 rgName = os.Getenv(resourceGroupEnvVar)
 if rgName == "" {
  log.Fatalf("missing environment variable %s", resourceGroupEnvVar)
 }

 location = os.Getenv(locationEnvVar)
 if location == "" {
  log.Fatalf("missing environment variable %s", locationEnvVar)
 }

 clusterNamePrefix = os.Getenv(clusterNamePrefixEnvVar)
 if clusterNamePrefix == "" {
  log.Fatalf("missing environment variable %s", clusterNamePrefixEnvVar)
 }

 dbNamePrefix = os.Getenv(dbNamePrefixEnvVar)
 if dbNamePrefix == "" {
  log.Fatalf("missing environment variable %s", dbNamePrefixEnvVar)
 }
}

func getClustersClient(subscription string) *armkusto.ClustersClient {
 cred, err := azidentity.NewDefaultAzureCredential(nil)
 if err != nil {
  log.Fatal(err)
 }

 client, err := armkusto.NewClustersClient(subscription, cred, nil)
 if err != nil {
  log.Fatal(err)
 }

 return client
}

// 1 instance, Basic tier with compute type Dev(No SLA)_Standard_D11_v2
func createCluster(sub, name, location, rgName string) {
 ctx := context.Background()

 numInstances := int32(1)
 client := getClustersClient(sub)
 result, err := client.BeginCreateOrUpdate(
  ctx,
  rgName,
  name,
  armkusto.Cluster{
   Location: &location,
   SKU: &armkusto.AzureSKU{
    Name:     to.Ptr(armkusto.AzureSKUNameDevNoSLAStandardD11V2),
    Capacity: &numInstances,
    Tier:     to.Ptr(armkusto.AzureSKUTierBasic),
   },
  },
  nil,
 )
 if err != nil {
  log.Fatal("failed to start cluster creation ", err)
 }

 log.Printf("waiting for cluster creation to complete - %s\n", name)
 r, err := result.PollUntilDone(ctx, nil)
 if err != nil {
  log.Fatal(err)
 }

 log.Printf("created cluster %s\n", *r.Name)
}

createCluster(subscription, clusterNamePrefix+clusterName, location, rgName)

Liste os clusters para garantir a criação bem-sucedida:

func listClusters(sub, rgName string) {
 log.Printf("listing clusters in resource group %s\n", rgName)
 ctx := context.Background()

 result := getClustersClient(sub).NewListByResourceGroupPager(rgName, nil)

 data := [][]string{}

 for result.More() {
  temp, err := result.NextPage(ctx)
  if err != nil {
   log.Fatal(err)
  }
  for _, c := range temp.Value {
   data = append(data, []string{*c.Name, string(*c.Properties.State), *c.Location, strconv.Itoa(int(*c.SKU.Capacity)), *c.Properties.URI})
  }
 }

 table := tablewriter.NewWriter(os.Stdout)
 table.SetHeader([]string{"Name", "State", "Location", "Instances", "URI"})

 for _, v := range data {
  table.Append(v)
 }
 table.Render()
}

listClusters(subscription, rgName)

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
name	azureclitest	O nome desejado do cluster.
sku	Standard_E8ads_v5	O SKU que será usado para o cluster. Parâmetros: name – O nome do SKU. tier – A camada da SKU.
resource-group	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.

Execute o comando a seguir para verificar se o cluster foi criado com êxito:
```
az kusto cluster show --cluster-name azureclitest --resource-group testrg
```
Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

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 do cluster.
Sku	Standard_E8ads_v5	O SKU que será usado para o 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.

Execute o comando a seguir para verificar se o cluster foi criado com êxito:
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

Para saber como implantar o modelo do ARM a seguir usando o PowerShell, confira Usar o modelo do ARM. Como alternativa, você pode implantar o modelo no portal do Azure selecionando Implantar no Azure.

Modelo de ARM

Você pode usar este modelo para suas próprias implantações ou personalizá-lo para atender às suas necessidades. Para que as propriedades e a sintaxe JSON sejam usadas no modelo, consulte Tipos de recursos 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
            }
        }
    ]
}

Use o modelo ARM

As etapas a seguir explicam como implantar o modelo do ARM usando o PowerShell.

Abra o Azure Cloud Shell e siga as instruções para entrar.

Selecione Copiar para copiar o script do 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 ..."

Clique com o botão direito do mouse no console do Shell e selecione Colar.

Observação

Leva alguns minutos para criar um banco de dados e um cluster do Azure Data Explorer.

Para verificar a implantação, use o seguinte script do Azure PowerShell. Se o Cloud Shell ainda estiver aberto, não será necessário copiar/executar a primeira linha (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 ..."

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.

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

var databaseName = "mykustodatabase";
var softDeletePeriod = TimeSpan.FromDays(3650);
var hotCachePeriod = TimeSpan.FromDays(3650);
var databaseData = new ReadWriteDatabase(
    location: clusterData.Location, softDeletePeriod: softDeletePeriod, hotCachePeriod: hotCachePeriod
);
await kustoManagementClient.Databases.CreateOrUpdateAsync(resourceGroupName, clusterName, 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.

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

databaseData = await kustoManagementClient.Databases.GetAsync(resourceGroupName, clusterName, databaseName) as ReadWriteDatabase;

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

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)

O código a seguir mostra como criar um banco de dados. As importações de pacote e a inicialização da variável de ambiente são as mesmas da seção anterior. Para clonar o repositório de código, consulte Gerenciar um cluster do Azure Data Explorer usando o SDK do Go do Azure.

Execute o seguinte código para criar o banco de dados:

func createDatabase(sub, rgName, clusterName, location, dbName string) {
 ctx := context.Background()

 client := getDBClient(sub)
 future, err := client.BeginCreateOrUpdate(ctx, rgName, clusterName, dbName, &armkusto.ReadWriteDatabase{Kind: to.Ptr(armkusto.KindReadWrite), Location: &location}, nil)

 if err != nil {
  log.Fatal("failed to start database creation ", err)
 }

 log.Printf("waiting for database creation to complete - %s\n", dbName)
 resp, err := future.PollUntilDone(ctx, nil)
 if err != nil {
  log.Fatal(err)
 }

 kdb := resp.GetDatabase()
 log.Printf("created DB %s with ID %s and type %s\n", *kdb.Name, *kdb.ID, *kdb.Type)
}

createDatabase(subscription, rgName, clusterNamePrefix+clusterName, location, dbNamePrefix+databaseName)

Liste os bancos de dados para garantir a criação bem-sucedida:

func listDatabases(sub, rgName, clusterName string) {
 log.Printf("listing databases in cluster %s\n", clusterName)

 ctx := context.Background()
 result := getDBClient(sub).NewListByClusterPager(rgName, clusterName, nil)

 data := [][]string{}

 for result.More() {
  temp, err := result.NextPage(ctx)
  if err != nil {
   log.Fatal(err)
  }
  for _, db := range temp.Value {
   if *db.GetDatabase().Kind == armkusto.KindReadWrite {
    data = append(data, []string{*db.GetDatabase().Name, string(*db.GetDatabase().Kind), *db.GetDatabase().Location, *db.GetDatabase().Type})
   }
  }
 }

 table := tablewriter.NewWriter(os.Stdout)
 table.SetHeader([]string{"Name", "State", "Location", "Type"})

 for _, v := range data {
  table.Append(v)
 }
 table.Render()
}

listDatabases(subscription, rgName, clusterNamePrefix+clusterName)

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.
resource-group	testrg	O nome do grupo de recursos em que o cluster será criado.
read-write-database	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.

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

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

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.

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

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

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

Pré-requisitos

Configurar os parâmetros da CLI

Configurar parâmetros

Criar um cluster do Azure Data Explorer

Modelo de ARM

Use o modelo ARM

Criar um banco de dados do Azure Data Explorer

Próximas etapas

Recursos adicionais