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

Artigo
12/18/2024

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 crie 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, PowerShell ou um modelo do Azure Resource Manager (ARM). Para saber como criar um cluster e um banco de dados usando o portal do Azure, consulte Guia de início rápido : criar um cluster e um banco de dados do Azure Data Explorer.

Para obter exemplos de código baseados 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:

Uma assinatura do Azure. Crie uma conta gratuita do Azure .
Visual Studio 2022 Community Edition. Ative de desenvolvimento do Azure durante a configuração do Visual Studio.
Instale o pacote NuGet Microsoft.Azure.Management.Kusto.
Um aplicativo e principal de serviço Microsoft Entra que pode acessar recursos. Guarde o ID do Diretório (locatário), ID do Aplicativoe Segredo do Cliente.

Uma assinatura do Azure. Crie uma conta gratuita do Azure .
Você pode usar do 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 artigo 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, consulte Instalar a CLI do Azure.

Configurar os parâmetros da CLI

As etapas a seguir não sã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 seguinte comando para entrar no Azure:
```
az login
```
Defina a subscrição onde pretende que o cluster seja criado. Substitua MyAzureSub pelo nome da assinatura do Azure que você deseja usar:
```
az account set --subscription MyAzureSub
```
Defina o grupo de recursos onde você deseja que o 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ê pelo processo de criação de um cluster do Azure Data Explorer. Escolha a guia relevante para seu método preferido para criar o cluster.

Crie seu cluster usando o seguinte 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);

Configuração	Valor sugerido	Descrição do campo
nome_do_cluster	mykustocluster	O nome desejado para o seu cluster.
nome do SKU	Standard_E8ads_v5	A SKU que será usada para seu cluster.
nível	Padrão	O nível de SKU.
capacidade	número	O número de instâncias do cluster.
resourceGroupName	testrg	O nome do grupo de recursos onde o cluster será criado.

Observação

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

Execute o seguinte comando para verificar se o cluster foi criado com êxito:
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Confirme se o cluster foi criado com sucesso, verificando se o resultado contém provisioningState como Succeeded.

Crie seu 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 cluster.
sku_name	Standard_E8ads_v5	A SKU que será usada para seu cluster.
nível	Standard	A camada de SKU.
capacidade	número	O número de instâncias do cluster.
nome_do_grupo_de_recursos	testrg	O nome do grupo de recursos onde o cluster será criado.

Observação

Criar um cluster é uma operação de longa duração. Método begin_create_or_update retorna uma instância de LROPoller. Veja a classe LROPoller para obter mais informações.

Execute o seguinte comando 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.

Defina as variáveis de ambiente necessárias, incluindo informações da entidade de serviço dos pré-requisitos. Introduza o ID da subscrição, o grupo de recursos e a região onde pretende 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 um principal 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 seu 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	A SKU que será usada para o seu cluster. Parâmetros: nome - O nome do SKU. nível - A camada SKU.
grupo de recursos	testrg	O nome do grupo de recursos onde o cluster será criado.
Localização	Westus	O local onde o cluster será criado.

Há outros parâmetros opcionais que você pode usar, como a capacidade do cluster.

Execute o seguinte comando 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 seu 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 seu cluster.
Código de Produto	Standard_E8ads_v5	O SKU que será usado para o seu cluster.
NomeDoGrupoDeRecursos	testrg	O nome do grupo de recursos onde o cluster será criado.

Há outros parâmetros opcionais que você pode usar, como a capacidade do cluster.

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

Para saber como implantar o seguinte modelo ARM usando o PowerShell, consulte Usar o modelo ARM. Como alternativa, pode-se implantar o modelo no portal do Azure selecionando Implantar no Azure.

Modelo ARM

Você pode usar esse modelo para suas próprias implantações ou personalizá-lo para atender às suas necessidades. Para obter a sintaxe JSON e as propriedades a serem usadas em um 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
            }
        }
    ]
}

Usar o modelo ARM

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

Abra Azure Cloud Shelle 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 no console do shell e selecione Colar.

Observação

Leva alguns minutos para criar um cluster e um banco de dados 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 seu banco de dados usando o seguinte 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);

Observação

Se você estiver usando C# versão 2.0.0 ou inferior, use Database em vez de ReadWriteDatabase.

Configuração	Valor sugerido	Descrição do campo
nome_do_cluster	mykustocluster	O nome do cluster onde o banco de dados será criado.
Nome do banco de dados	mykustodatabase	O nome do seu banco de dados.
resourceGroupName	testrg	O nome do grupo de recursos onde o cluster será criado.
período de eliminação suave	3650:00:00:00	A quantidade de tempo que os dados serão mantidos disponíveis para consulta.
hotCachePeriod	3650:00:00:00	A quantidade de tempo que os dados serão mantidos em cache.

Execute o seguinte comando para ver o banco de dados que você criou:

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

Crie seu 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

Se você estiver usando Python versão 0.4.0 ou inferior, use Database em vez de ReadWriteDatabase.

Configuração	Valor sugerido	Descrição do campo
nome_do_cluster	mykustocluster	O nome do cluster onde o banco de dados será criado.
nome_da_base_de_dados	mykustodatabase	O nome do seu banco de dados.
nome_do_grupo_de_recursos	testrg	O nome do grupo de recursos onde o cluster será criado.
período de eliminação suave	3650 dias, 0:00:00	A quantidade de tempo que os dados serão mantidos disponíveis para consulta.
período_cache_quente	3650 dias, 0:00:00	A quantidade de tempo que os dados serão mantidos em cache.

Execute o seguinte comando para ver o banco de dados que você criou:

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 pacotes e a inicialização da variável de ambiente são iguais à seção anterior.

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 seu 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 onde o banco de dados será criado.
nome do banco de dados	clidatabase	O nome do seu banco de dados.
grupo de recursos	testrg	O nome do grupo de recursos onde o cluster será criado.
banco de dados de leitura-gravação	P365DP31Dwestus	O tipo de banco de dados. Parâmetros: soft-delete-period - Significa o período de tempo durante o qual os dados estarão disponíveis para consulta. Consulte a política de retenção para obter mais informações. período de cache quente - Significa a quantidade de tempo que os dados serão mantidos em cache. Consulte a política de cache para obter mais informações. local -The local onde o banco de dados será criado.

Execute o seguinte comando para ver o banco de dados que você criou:

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

Crie seu 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
Nome do Cluster	mykustocluster	O nome do cluster onde o banco de dados será criado.
Nome	mykustodatabase	O nome do seu banco de dados.
ResourceGroupName	testrg	O nome do grupo de recursos onde o cluster será criado.
SoftDeletePeriod	3650:00:00:00	A quantidade de tempo que os dados serão mantidos disponíveis para consulta.
Período de Cache Rápido	3650:00:00:00	A quantidade de tempo que os dados serão mantidos em cache.

Execute o seguinte comando para ver o banco de dados que você criou:

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

Próximo passo

Criar uma tabela

Partilhar via

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 ARM

Usar o modelo ARM

Criar um banco de dados do Azure Data Explorer

Próximo passo

Comentários

Recursos adicionais