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

Artigo
04/07/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 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 Azure Resource Manager (ARM). 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:

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:

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

CLI do Azure
```
az extension add -n kusto
```
Execute o comando a seguir para entrar no Azure:

CLI do Azure
```
az login
```
Defina a assinatura em que deseja criar o cluster. Substitua MyAzureSub pelo nome da assinatura do Azure que deseja usar:

CLI do Azure
```
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:

CLI do Azure
```
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.

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 do cluster.
skuName	Standard_E8ads_v5	O SKU que será usado para o cluster.
nível	Standard	A camada da SKU.
capacidade	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:

C#
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Confirme a criação bem-sucedida do cluster verificando se o resultado contém provisioningState como Succeeded.

Crie o cluster usando o seguinte comando:

Python

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.
nível	Standard	A camada da SKU.
capacidade	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:

Python

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 as informações da entidade de serviço em pré-requisitos. Insira a ID da assinatura, o grupo de recursos e a região em que você deseja criar o cluster.

Console

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.

Execute o código a seguir para criar o cluster:

golang

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:

golang

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:

CLI do Azure

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:

CLI do Azure
```
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:

Azure PowerShell

 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:

Azure PowerShell
```
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 seguinte modelo de ARM usando o PowerShell, consulte Use o modelo de 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.

JSON

{
    "$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.

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

Azure PowerShell

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

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

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

Crie o banco de dados usando o seguinte comando:

Python

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:

Python

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 iniciação de variáveis de ambiente são as mesmas da seção anterior.

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

golang

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:

golang

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:

CLI do Azure

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
cluster-name	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:

CLI do Azure

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

Crie o banco de dados usando o seguinte comando:

Azure PowerShell

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:

Azure PowerShell

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

Próxima etapa

Criar uma tabela

Recursos adicionais

Documentação

Início Rápido: Criar um cluster e um banco de dados do Azure Data Explorer - Azure Data Explorer

Neste início rápido, você aprenderá a criar um cluster e um banco de dados do Azure Data Explorer.
Criar uma tabela no Azure Data Explorer - Azure Data Explorer

Saiba como criar facilmente uma tabela e definir manualmente o esquema no Azure Data Explorer com o assistente de criação de tabela.
Documentação do Azure Data Explorer - Azure Data Explorer

O Azure Data Explorer é uma plataforma de nuvem de análise de log otimizada para consultas ad hoc de big data.
Provisionamento automatizado no Azure Data Explorer - Azure Data Explorer

Este artigo fornece uma visão geral dos diferentes mecanismos para automatizar o provisionamento de ambientes do Azure Data Explorer.
Obter dados de um arquivo - Azure Data Explorer

Saiba como obter dados de um arquivo local no Azure Data Explorer.
Usar o LightIngest para ingerir dados no Azure Data Explorer - Azure Data Explorer

Conheça o LightIngest, um utilitário de linha de comando para a ingestão de dados ad hoc no Azure Data Explorer.
Adicionar uma conexão de cluster na interface do usuário da Web do Azure Data Explorer - Azure Data Explorer

Saiba como adicionar conexões de cluster para várias contas de usuário ou diretórios do Microsoft Entra na interface do usuário da Web do Azure Data Explorer.
Visão geral da ingestão de dados do Azure Data Explorer - Azure Data Explorer

Saiba mais sobre as diferentes maneiras de ingerir (carregar) com os dados no Azure Data Explorer

Treinamento

Módulo

Criar um banco de dados Lake no Azure Synapse Analytics - Training

Criar um banco de dados Lake no Azure Synapse Analytics

Certificação

Microsoft Certified: Azure Database Administrator Associate - Certifications

Administrar uma infraestrutura de banco de dados do SQL Server para bancos de dados relacionais de nuvem, locais e híbridos usando as ofertas de banco de dados relacional do Microsoft PaaS.

Eventos

FabCon Vegas

31 de mar., 23 - 2 de abr., 23

O maior evento de aprendizado de Fabric, Power BI e SQL. 31 de março a 2 de abril. Use o código FABINSIDER para economizar $ 400.

Registre-se hoje mesmo

Compartilhar via

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

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óxima etapa

Comentários

Recursos adicionais