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

• 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.
• Python 3.4+.
• Installez les packages azure-common et azure-mgmt-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.
• Installez Git.
• Installez une version appropriée de Go. Pour connaître les versions prises en charge, consultez Module Azure Kusto pour Go.
• 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 :

1. Installez l’extension pour utiliser la dernière version de Kusto CLI :

   az extension add -n kusto
   

2. Exécutez la commande ci-après pour vous connecter à Azure :

   az login
   

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

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

• Configurez votre environnement à l’aide des instructions dans Utiliser des applets de commande Kusto dans Azure PowerShell.

Configurer les paramètres

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 :

• Un abonnement Azure. Créez un compte Azure gratuit.

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

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

   clusterData = (await clusters.GetAsync(clusterName)).Value.Data;
   

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

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

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

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

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

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

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

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

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

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

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

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

   Get-AzKustoCluster -Name mykustocluster -ResourceGroupName testrg
   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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