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

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, les Azure CLI, PowerShell, Bicep ou un modèle de 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.

Important

L’extension Kusto pour Azure CLI est obsolète et n’est pas conservée. Nous vous recommandons d’utiliser des modèles PowerShell ou ARM/Bicep pour la création de clusters et de bases de données. Si vous choisissez d’utiliser Azure CLI, veillez à installer l’extension Kusto pour vous assurer que vous disposez des commandes CLI les plus récentes pour Azure Data Explorer.

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.

Modèle ARM

Voici un exemple de modèle ARM qui crée un cluster Azure Data Explorer et une base de données au sein de ce cluster avec une configuration minimale. Pour obtenir des détails complets et des propriétés prises en charge, consultez référence de cluster de modèles ARM et référence de base de données de modèle ARM.

{
    "$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",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "sku": {
                "name": "Standard_E8ads_v5",
                "tier": "Standard",
                "capacity": 2
            }
        },
        {
            "name": "[concat(parameters('clusters_kustocluster_name'), '/', parameters('databases_kustodb_name'))]",
            "type": "Microsoft.Kusto/clusters/databases",
            "apiVersion": "2025-02-14",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[resourceId('Microsoft.Kusto/clusters', parameters('clusters_kustocluster_name'))]"
            ],
            "kind": "ReadWrite",
            "properties": {
                "softDeletePeriod": "P365D",
                "hotCachePeriod": "P31D"
            }
        }
    ]
}

Vous trouverez ci-dessous un exemple de modèle Bicep qui crée un cluster Azure Data Explorer et une base de données au sein de ce cluster avec une configuration minimale. Pour obtenir des détails complets et connaître les propriétés prises en charge, consultez référence du cluster Bicep et référence de la base de données Bicep.

    @description('Name of the cluster to create')
    param clusterName string = 'kusto${uniqueString(resourceGroup().id)}'
    
    @description('Name of the database to create')
    param databaseName string = 'kustodb'
    
    @description('Location for all resources.')
    param location string = resourceGroup().location
    
    resource cluster 'Microsoft.Kusto/clusters@2025-02-14' = {
      name: clusterName
      location: location
      sku: {
        name: 'Standard_E8ads_v5'
        tier: 'Standard'
        capacity: 2
      }
    }
    
    
    resource database 'Microsoft.Kusto/clusters/databases@2025-02-14' = {
      parent: cluster
      name: databaseName
      location: location
      kind: 'ReadWrite'
      properties: {
        softDeletePeriod: 'P365D'
        hotCachePeriod: 'P31D'
      }
    }

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.

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.
niveau	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 du 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.

Définissez les variables d’environnement requises, notamment les informations relatives au principal de service figurant dans les 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)

Important

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
nom	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 du SKU.
groupe-de-ressources	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é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.

Le cluster et la base de données sont créés avec le modèle ARM dans la section précédente.

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

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 du 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.
période_de_suppression_réversible	3650 jours, 0:00:00	Durée pendant laquelle les données restent disponibles pour les requêtes.
hot_cache_period	3650 jours, 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.

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)

Important

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.
groupe-de-ressources	testrg	Nom du groupe de ressources dans lequel sera créé le cluster.
base de données en lecture-écriture	P365DP31Dwestus	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

Étape suivante

Créer une table

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-05-13

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

Prérequis

Créez un cluster Azure Data Explorer.

Modèle ARM

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

Étape suivante

Commentaires

Ressources supplémentaires