Criar um cluster e uma base de dados do Azure Data Explorer

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.
• Edição da Comunidade do Visual Studio 2022. Ative o desenvolvimento do Azure durante a configuração do Visual Studio.
• Instale o pacote NuGet Microsoft.Azure.Management.Kusto.
• Uma entidade de serviço e aplicativo do Azure AD que pode acessar recursos. Guarde o ID do diretório (locatário), ID do aplicativo e segredo do cliente.

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.
• Python 3.4+.
• Instale azure-common e azure-mgmt-kusto pacotes.
• Uma aplicação e entidade de serviço do Azure AD que pode aceder a recursos. Guarde o ID do Diretório (Locatário), ID da Aplicação e Segredo do Cliente.

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.
• Instale o Git.
• Instale uma versão apropriada do Go. Para versões suportadas, consulte Azure Kusto Module for Go.
• Uma aplicação e um principal de serviço do Azure AD que podem acessar recursos. Salve o ID do diretório (locatário), o ID do aplicativo e o Segredo do cliente.

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.
• 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 artigo requer a CLI do Azure versão 2.0.4 ou posterior. Execute az --version para verificar a sua versão. Se precisar de instalar ou atualizar, veja 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:

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

   az extension add -n kusto
   

2. Execute o seguinte comando para iniciar sessão no Azure:

   az login
   

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

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

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.
• 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 os parâmetros

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:

1. Execute o seguinte comando para iniciar sessão no Azure:

   Connect-AzAccount
   

2. Defina a subscrição onde pretende que o cluster seja criado:

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

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

    Install-Module -Name Az.Kusto
   

• Uma subscrição do Azure. Crie uma conta do Azure gratuita.

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

   Definição	Valor sugerido	Descrição do campo
   clusterName	Mykustocluster	O nome desejado do cluster.
   skuName	Standard_E8ads_v5	O SKU que será utilizado para o seu cluster.
   escalão	Standard	O nível de SKU.
   capacidade	número	O número de instâncias do cluster.
   nomeDoGrupoDeRecursos	Testrg	O nome do grupo de recursos onde o cluster será criado.

   Nota

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

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

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

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

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

   Definição	Valor sugerido	Descrição do campo
   nome do cluster	Mykustocluster	O nome desejado do cluster.
   nome_do_SKU	Standard_E8ads_v5	O SKU que será usado para o 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 onde o cluster será criado.

   Nota

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

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

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

1. Defina as variáveis de ambiente necessárias, incluindo informações do principal do 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)>"
   

   Gorjeta

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

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

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)
   

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

   Definição	Valor sugerido	Descrição do campo
   nome	Azureclitest	Nome que deseja para o cluster
   sku	Standard_E8ads_v5	O SKU que será usado para o seu cluster. Parâmetros: name - O nome da SKU. tier - O nível de 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.

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

1. Crie seu cluster usando o seguinte comando:

    New-AzKustoCluster -ResourceGroupName testrg -Name mykustocluster -Location westus2 -SkuTier Standard -SkuCapacity 2 -SkuName 'Standard_E8ads_v5'
   

   Definição	Valor sugerido	Descrição do campo
   Nome	Mykustocluster	O nome desejado para o cluster.
   Sku	Standard_E8ads_v5	A SKU que será usada para 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.

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

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

Modelo ARM

Pode utilizar este modelo para as suas próprias implementações ou personalizá-lo para satisfazer as 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.

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

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

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

   Nota

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

4. Para verificar a implantação, use o seguinte script do Azure PowerShell. Se o Cloud Shell ainda estiver aberto, você não precisará 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 ..."
   

1. Crie seu banco de dados usando o seguinte código:

   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);
   

   Nota

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

   Definição	Valor sugerido	Descrição do campo
   clusterName	Mykustocluster	O nome do cluster onde o banco de dados será criado.
   databaseName	mykustodatabase	O nome do seu banco de dados.
   nomeDoGrupoDeRecursos	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.

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

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

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

   Nota

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

   Definiçã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.
   hot_cache_period (período de cache quente)	3650 dias, 0:00:00	A quantidade de tempo que os dados serão mantidos em cache.

2. 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 os mesmos da seção anterior. Para clonar o repositório de código, consulte Gerenciar um cluster do Azure Data Explorer usando o SDK do Azure Go.

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)
   

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

   Definiçã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 a quantidade de tempo que os dados serão mantidos disponíveis para consulta. Consulte a política de retenção para obter mais informações. hot-cache-period - Significa a quantidade de tempo que os dados serão mantidos em cache. Consulte a política de cache para obter mais informações. location - O local onde o banco de dados será criado.

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

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

   Definiçã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.
   NomeDoGrupoDeRecursos	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.
   HotCachePeriod	3650:00:00:00	A quantidade de tempo que os dados serão mantidos em cache.

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

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

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