Créer un cluster et une base de données Azure Data Explorer

Article
05/17/2023

Azure Data Explorer est un service d’analytique données rapide et complètement managé permettant une analyse en temps réel de gros volumes de données diffusées en continu par des applications, des sites web, des appareils IoT, etc. Pour utiliser Azure Data Explorer, créez tout d’abord un cluster et une ou plusieurs bases de données dans ce cluster. Ensuite, vous pouvez ingérer (charger) des données dans une base de données et exécuter des requêtes dessus.

Dans cet article, vous allez apprendre à créer un cluster et une base de données à l’aide de C#, Python, Go, l’interface Azure CLI, PowerShell ou d’un modèle Azure Resource Manager (ARM). Pour savoir comment créer un cluster et une base de données à l’aide du portail Azure, consultez Démarrage rapide : Créer un cluster et une base de données Azure Data Explorer.

Pour obtenir des exemples de code basés sur les versions précédentes du SDK, consultez l’article archivé.

Prérequis

Prérequis par méthode de création de cluster et de base de données :

Un abonnement Azure. Créez un compte Azure gratuit.
Visual Studio 2022 Community Edition. Activez Développement Azure lors de l’installation de Visual Studio.
Installez le package NuGet Microsoft.Azure.Management.Kusto.
Une application et un principal de service Microsoft Entra pouvant accéder aux ressources. Enregistrez l’ID d’annuaire (locataire), l’ID d’application et la clé secrète client.

Un abonnement Azure. Créez un compte Azure gratuit.
Vous pouvez utiliser Azure Cloud Shell pour exécuter le code dans cet article sans avoir à installer quoi que ce soit sur votre environnement local.
Si vous choisissez d’installer et d’utiliser Azure CLI localement, suivez les étapes décrites dans Configurer les paramètres. Cet article requiert Azure CLI version 2.0.4 ou ultérieure. Exécutez az --version pour vérifier votre version. Si vous devez effectuer une installation ou une mise à niveau, consultez Installer Azure CLI.

Configurer les paramètres CLI

Les étapes suivantes ne sont pas requises si vous exécutez des commandes dans Azure Cloud Shell. Si vous exécutez l’interface CLI localement, procédez de la manière suivante pour configurer l’environnement :

Installez l’extension pour utiliser la dernière version de Kusto CLI :
```
az extension add -n kusto
```
Exécutez la commande ci-après pour vous connecter à Azure :
```
az login
```
Définissez l’abonnement dans lequel vous voulez créer le cluster. Remplacez MyAzureSub par le nom de l’abonnement Azure que vous voulez utiliser :
```
az account set --subscription MyAzureSub
```
Définissez le groupe de ressources où vous voulez créer le cluster. Remplacez testrg par le nom du groupe de ressources que vous souhaitez utiliser :
```
az group create --name testrg --location westus
```

Créez un cluster Azure Data Explorer.

Cette section vous guide tout au long du processus de création d’un cluster Azure Data Explorer. Choisissez l’onglet correspondant à votre méthode préférée pour créer le cluster.

Créez votre cluster en utilisant le code suivant :

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

Paramètre	Valeur suggérée	Description du champ
clusterName	mykustocluster	Nom souhaité de votre cluster.
skuName	Standard_E8ads_v5	Référence SKU utilisée pour votre cluster.
tier	Standard	Niveau de référence SKU.
capacité	numéro	Nombre d’instances du cluster.
resourceGroupName	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.

Remarque

Créer un cluster étant une opération à long terme, il est fortement recommandé d’utiliser CreateOrUpdateAsync à la place de CreateOrUpdate.

Exécutez la commande suivante pour vérifier si votre cluster a bien été créé :
```
clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
```
Confirmez la création réussie du cluster en vérifiant que le résultat contient provisioningState comme Succeeded.

Créez votre cluster avec la commande suivante :

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

Paramètre	Valeur suggérée	Description du champ
nom_cluster	mykustocluster	Nom souhaité de votre cluster.
sku_name	Standard_E8ads_v5	Référence SKU utilisée pour votre cluster.
tier	Standard	Niveau de référence SKU.
capacité	numéro	Nombre d’instances du cluster.
resource_group_name	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.

Remarque

Créer un cluster est une opération de longue durée. La méthode begin_create_or_update retourne une instance de LROPoller. Consultez Classe LROPoller pour obtenir plus d’informations.

Exécutez la commande suivante pour vérifier si votre cluster a bien été créé :

cluster_operations.get(resource_group_name = resource_group_name, cluster_name= cluster_name, custom_headers=None, raw=False)

Confirmez la création réussie du cluster en vérifiant que le résultat contient provisioningState comme Succeeded.

Le code suivant montre comment créer un cluster. Pour cloner le référentiel de code, consultez Gérer un cluster Azure Data Explorer à l’aide du SDK Azure Go.

Définissez les variables d’environnement requises, y compris les informations du principal de service des prérequis. Entrez votre ID d’abonnement, le groupe de ressources et la région où vous souhaitez créer le 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)>"

Conseil

Utilisez auth.NewAuthorizerFromCLIWithResource si Azure CLI est installé et configuré pour l’authentification. Dans ce cas, vous n’avez pas besoin de créer un principal de service.

Exécutez le code suivant pour créer le 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)

Répertoriez les clusters pour garantir une création réussie :

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)

Créez votre cluster avec la commande suivante :

az kusto cluster create --cluster-name azureclitest --sku name="Standard_E8ads_v5" tier="Standard" --resource-group testrg --location westus

Paramètre	Valeur suggérée	Description du champ
name	azureclitest	Nom souhaité de votre cluster.
sku	Standard_E8ads_v5	Référence SKU utilisée pour votre cluster. Paramètres : name - Nom de la référence SKU. tier - Niveau de la référence SKU.
resource-group	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
location	westus	Emplacement où sera créé le cluster.

Vous pouvez définir d’autres paramètres facultatifs, comme la capacité du cluster.

Exécutez la commande suivante pour vérifier si votre cluster a bien été créé :
```
az kusto cluster show --cluster-name azureclitest --resource-group testrg
```
Confirmez la création réussie du cluster en vérifiant que le résultat contient provisioningState comme Succeeded.

Créez votre cluster avec la commande suivante :

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

Paramètre	Valeur suggérée	Description du champ
Nom	mykustocluster	Nom souhaité de votre cluster.
Sku	Standard_E8ads_v5	Référence SKU utilisée pour votre cluster.
ResourceGroupName	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.

Vous pouvez définir d’autres paramètres facultatifs, comme la capacité du cluster.

Exécutez la commande suivante pour vérifier si votre cluster a bien été créé :
```
Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
```
Confirmez la création réussie du cluster en vérifiant que le résultat contient provisioningState comme Succeeded.

Pour savoir comment déployer le modèle ARM suivant à l’aide de PowerShell, consultez Utiliser le modèle ARM. Vous pouvez également déployer le modèle dans le portail Azure en sélectionnant Déployer sur Azure.

Modèle ARM

Vous pouvez utiliser ce modèle pour vos propres déploiements, ou le personnaliser afin qu’il réponde à vos besoins. Pour connaître la syntaxe et les propriétés JSON à utiliser dans un modèle, consultez Types de ressources 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
            }
        }
    ]
}

Utiliser le modèle ARM

Les étapes suivantes expliquent comment déployer le modèle ARM à l’aide de PowerShell.

Ouvrez Azure Cloud Shell, puis suivez les instructions pour vous connecter.

Sélectionnez Copier pour copier le script 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 ..."

Cliquez avec le bouton droit sur la console d’interpréteur de commandes, puis sélectionnez Coller.

Remarque

La création d’un cluster et d’une base de données Azure Data Explorer prend quelques minutes.

Pour vérifier le déploiement, utilisez le script Azure PowerShell suivant. Si Cloud Shell est toujours ouvert, vous n’avez pas besoin de copier/exécuter la première ligne (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 ..."

Créer une base de données Azure Data Explorer

Dans cette section, vous allez créer une base de données dans le cluster créé dans la section précédente.

Créez votre base de données en utilisant le code suivant :

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

Remarque

Si vous utilisez C# version 2.0.0 ou antérieure, utilisez Database au lieu de ReadWriteDatabase.

Paramètre	Valeur suggérée	Description du champ
clusterName	mykustocluster	Nom du cluster dans lequel la base de données est créée.
databaseName	mykustodatabase	Nom de votre base de données.
resourceGroupName	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
softDeletePeriod	3650:00:00:00	Durée pendant laquelle les données restent disponibles pour les requêtes.
hotCachePeriod	3650:00:00:00	Durée pendant laquelle les données sont conservées dans le cache.

Exécutez la commande suivante pour voir la base de données que vous avez créée :

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

Créez votre base de données avec la commande suivante :

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

Remarque

Si vous utilisez Python version 0.4.0 ou antérieure, utilisez Database au lieu de ReadWriteDatabase.

Paramètre	Valeur suggérée	Description du champ
nom_cluster	mykustocluster	Nom du cluster dans lequel la base de données est créée.
database_name	mykustodatabase	Nom de votre base de données.
resource_group_name	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
soft_delete_period	3650 days, 0:00:00	Durée pendant laquelle les données restent disponibles pour les requêtes.
hot_cache_period	3650 days, 0:00:00	Durée pendant laquelle les données sont conservées dans le cache.

Exécutez la commande suivante pour voir la base de données que vous avez créée :

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

Le code suivant montre comment créer la base de données. Les importations de package et l’initiation des variables d’environnement sont identiques à celles de la section précédente. Pour cloner le référentiel de code, consultez Gérer un cluster Azure Data Explorer à l’aide du SDK Azure Go.

Exécutez le code suivant pour créer la base de données :

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)

Répertoriez les bases de données pour garantir une création réussie :

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)

Créez votre base de données avec la commande suivante :

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

Paramètre	Valeur suggérée	Description du champ
cluster-name	azureclitest	Nom du cluster dans lequel la base de données est créée.
database-name	clidatabase	Nom de votre base de données.
resource-group	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
read-write-database	P365D P31D westus	Type de base de données. Paramètres : soft-delete-period - Représente la durée pendant laquelle les données restent disponibles pour les requêtes. Pour plus d’informations, consultez Stratégie de conservation. hot-cache-period - Représente la durée pendant laquelle les données sont conservées dans le cache. Pour plus d’informations, consultez Stratégie de cache. location - Emplacement où sera créée la base de données.

Exécutez la commande suivante pour voir la base de données que vous avez créée :

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

Créez votre base de données avec la commande suivante :

New-AzKustoDatabase -ResourceGroupName testrg -ClusterName mykustocluster -Name mykustodatabase -SoftDeletePeriod 3650:00:00:00 -HotCachePeriod 3650:00:00:00

Paramètre	Valeur suggérée	Description du champ
Nom du cluster	mykustocluster	Nom du cluster dans lequel la base de données est créée.
Nom	mykustodatabase	Nom de votre base de données.
ResourceGroupName	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
SoftDeletePeriod	3650:00:00:00	Durée pendant laquelle les données restent disponibles pour les requêtes.
HotCachePeriod	3650:00:00:00	Durée pendant laquelle les données sont conservées dans le cache.

Exécutez la commande suivante pour voir la base de données que vous avez créée :

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

Étape suivante

Créer une table

Partager via

Créer un cluster et une base de données Azure Data Explorer

Prérequis

Configurer les paramètres CLI

Configurer les paramètres

Créez un cluster Azure Data Explorer.

Modèle ARM

Utiliser le modèle ARM

Créer une base de données Azure Data Explorer

Étape suivante

Commentaires

Ressources supplémentaires