Tworzenie aplikacji do uruchamiania poleceń zarządzania

Dotyczy: ✅Microsoft Fabric✅Azure Data Explorer

Z tego artykułu dowiesz się, jak wykonywać następujące działania:

Warunki wstępne

Skonfiguruj środowisko deweloperskie do korzystania z biblioteki klienta Kusto.

Uruchamianie polecenia zarządzania i przetwarzanie wyników

W preferowanym środowisku IDE lub edytorze tekstów utwórz projekt lub plik o nazwie polecenia zarządzania przy użyciu konwencji odpowiedniej dla preferowanego języka. Następnie dodaj następujący kod:

1. Utwórz aplikację kliencką łączącą klaster. Zastąp znacznik <your_cluster_uri> nazwą klastra.

   • C#
   • Python
   • TypeScript
   • Java

   Notatka

   W przypadku poleceń zarządzania użyjesz metody CreateCslAdminProvider client factory.

   using Kusto.Data;
   using Kusto.Data.Net.Client;
   
   namespace ManagementCommands {
     class ManagementCommands {
       static void Main(string[] args) {
         var clusterUri = "<your_cluster_uri>";
         var kcsb = new KustoConnectionStringBuilder(clusterUri)
             .WithAadUserPromptAuthentication();
   
         using (var kustoClient = KustoClientFactory.CreateCslAdminProvider(kcsb)) {
         }
       }
     }
   }
   

2. Zdefiniuj funkcję, która wyświetla uruchamiane polecenie i jego wynikowe tabele. Ta funkcja rozpakowuje nazwy kolumn w tabelach wyników i drukuje każdą parę nazwa-wartość w nowym wierszu.

   • C#
   • Python
   • TypeScript
   • Java

   static void PrintResultsAsValueList(string command, IDataReader response) {
     while (response.Read()) {
       Console.WriteLine("\n{0}\n", new String('-', 20));
       Console.WriteLine("Command: {0}", command);
       Console.WriteLine("Result:");
       for (int i = 0; i < response.FieldCount; i++) {
         Console.WriteLine("\t{0} - {1}", response.GetName(i), response.IsDBNull(i) ? "None" : response.GetString(i));
       }
     }
   }
   

3. Zdefiniuj polecenie do uruchomienia. Polecenie tworzy tabelę o nazwie MyStormEvents i definiuje schemat tabeli jako listę nazw kolumn i typów. Zastąp symbol zastępczy <your_database> nazwą bazy danych.

   • C#
   • Python
   • TypeScript
   • Java

   string database = "<your_database>";
   string table = "MyStormEvents";
   
   // Create a table named MyStormEvents
   // The brackets contain a list of column Name:Type pairs that defines the table schema
   string command = @$".create table {table}
                     (StartTime:datetime,
                      EndTime:datetime,
                      State:string,
                      DamageProperty:int,
                      DamageCrops:int,
                      Source:string,
                      StormSummary:dynamic)";
   

4. Uruchom polecenie i wyświetl wynik przy użyciu wcześniej zdefiniowanej funkcji.

   • C#
   • Python
   • TypeScript
   • Java

   Notatka

   Użyjesz metody ExecuteControlCommand, aby uruchomić polecenie .

   using (var response = kustoClient.ExecuteControlCommand(database, command, null)) {
     PrintResultsAsValueList(command, response);
   }
   

Pełny kod powinien wyglądać następująco:

using Kusto.Data;
using Kusto.Data.Net.Client;

namespace ManagementCommands {
  class ManagementCommands {
    static void Main(string[] args) {
      string clusterUri = "https://<your_cluster_uri>";
      var kcsb = new KustoConnectionStringBuilder(clusterUri)
          .WithAadUserPromptAuthentication();

      using (var kustoClient = KustoClientFactory.CreateCslAdminProvider(kcsb)) {
        string database = "<your_database>";
        string table = "MyStormEvents";

        // Create a table named MyStormEvents
        // The brackets contain a list of column Name:Type pairs that defines the table schema
        string command = @$".create table {table} 
                          (StartTime:datetime,
                           EndTime:datetime,
                           State:string,
                           DamageProperty:int,
                           DamageCrops:int,
                           Source:string,
                           StormSummary:dynamic)";

        using (var response = kustoClient.ExecuteControlCommand(database, command, null)) {
          PrintResultsAsValueList(command, response);
        }
      }
    }

    static void PrintResultsAsValueList(string command, IDataReader response) {
      while (response.Read()) {
        Console.WriteLine("\n{0}\n", new String('-', 20));
        Console.WriteLine("Command: {0}", command);
        Console.WriteLine("Result:");
        for (int i = 0; i < response.FieldCount; i++) {
          Console.WriteLine("\t{0} - {1}", response.GetName(i), response.IsDBNull(i) ? "None" : response.GetString(i));
        }
      }
    }
  }
}

from azure.kusto.data import KustoClient, KustoConnectionStringBuilder

def main():
  cluster_uri = "https://<your_cluster_uri>"
  kcsb = KustoConnectionStringBuilder.with_interactive_login(cluster_uri)

  with KustoClient(kcsb) as kusto_client:

    database = "<your_database>"
    table = "MyStormEvents"

    # Create a table named MyStormEvents
    # The brackets contain a list of column Name:Type pairs that defines the table schema
    command = ".create table " + table + " " \
              "(StartTime:datetime," \
              " EndTime:datetime," \
              " State:string," \
              " DamageProperty:int," \
              " DamageCrops:int," \
              " Source:string," \
              " StormSummary:dynamic)"

    response = kusto_client.execute_mgmt(database, command)
    print_result_as_value_list(command, response)

def print_result_as_value_list(command, response):
  # create a list of columns
  cols = (col.column_name for col in response.primary_results[0].columns)

  print("\n" + "-" * 20 + "\n")
  print("Command: " + command)
  # print the values for each row
  for row in response.primary_results[0]:
    print("Result:")
    for col in cols:
      print("\t", col, "-", row[col])

if __name__ == "__main__":
  main()

import { Client as KustoClient, KustoConnectionStringBuilder, KustoResponseDataSet } from "azure-kusto-data/";
import { InteractiveBrowserCredentialInBrowserOptions } from "@azure/identity";

async function main() {
  const clusterUri = "<your_cluster_uri>";
  const authOptions = {
    clientId: "00001111-aaaa-2222-bbbb-3333cccc4444",
    redirectUri: "http://localhost:5173",
  } as InteractiveBrowserCredentialInBrowserOptions;
  const kcsb = KustoConnectionStringBuilder.withUserPrompt(clusterUri, authOptions);
  const kustoClient = new KustoClient(kcsb);

  const database = "<your_database>";
  const table = "MyStormEvents";

  // Create a table named MyStormEvents
  // The brackets contain a list of column Name:Type pairs that defines the table schema
  const command = `.create table ${table}
                 (StartTime:datetime,
                  EndTime:datetime,
                  State:string,
                  DamageProperty:int,
                  Source:string,
                  StormSummary:dynamic)`;

  const response = await kustoClient.executeMgmt(database, command);
  printResultsAsValueList(command, response)
}

function printResultsAsValueList(command: string, response: KustoResponseDataSet) {
  // create a list of columns
  const cols = response.primaryResults[0].columns;

  console.log("\n" + "-".repeat(20) + "\n")
  console.log("Command: " + command)
  // print the values for each row
  for (const row of response.primaryResults[0].rows()) {
    console.log("Result:")
    for (const col of cols) {
        console.log("\t", col.name, "-", row.getValueAt(col.ordinal) ? row.getValueAt(col.ordinal).toString() : "None")
    }
  }
}

main();

import com.microsoft.azure.kusto.data.Client;
import com.microsoft.azure.kusto.data.ClientFactory;
import com.microsoft.azure.kusto.data.KustoOperationResult;
import com.microsoft.azure.kusto.data.KustoResultSetTable;
import com.microsoft.azure.kusto.data.KustoResultColumn;
import com.microsoft.azure.kusto.data.auth.ConnectionStringBuilder;

public class ManagementCommands {
  public static void main(String[] args) throws Exception {
    try {
      String clusterUri = "https://<your_cluster_uri>";
      ConnectionStringBuilder kcsb = ConnectionStringBuilder.createWithUserPrompt(clusterUri);
      try (Client kustoClient = ClientFactory.createClient(kcsb)) {
        String database = "<your_database>";
        String table = "MyStormEvents";

        // Create a table named MyStormEvents
        // The brackets contain a list of column Name:Type pairs that defines the table schema
        String command = ".create table " + table + " " +
                         "(StartTime:datetime," +
                         " EndTime:datetime," +
                         " State:string," +
                         " DamageProperty:int," +
                         " DamageCrops:int," +
                         " Source:string," +
                         " StormSummary:dynamic)";

        KustoOperationResult response = kustoClient.execute(database, command);
        printResultsAsValueList(command, response.getPrimaryResults());
      }
    }
  }
  public static void printResultsAsValueList(String command, KustoResultSetTable results) {
    while (results.next()) {
      System.out.println("\n" + "-".repeat(20) + "\n");
      System.out.println("Command: " + command);
      System.out.println("Result:");
      KustoResultColumn[] columns = results.getColumns();
      for (int i = 0; i < columns.length; i++) {
        System.out.println("\t" + columns[i].getColumnName() + " - " + (results.getObject(i) == null ? "None" : results.getString(i)));
      }
    }
  }
}

Uruchamianie aplikacji

W wierszu poleceń użyj następującego polecenia, aby uruchomić swoją aplikację:

# Change directory to the folder that contains the management commands project
dotnet run .

python management_commands.py

node management-commands.js

npm run dev

mvn install exec:java -Dexec.mainClass="<groupId>.ManagementCommands"

Powinien zostać wyświetlony wynik podobny do następującego:

--------------------

Command: .create table MyStormEvents 
                 (StartTime:datetime,
                  EndTime:datetime,
                  State:string,
                  DamageProperty:int,
                  Source:string,
                  StormSummary:dynamic)
Result:
   TableName - MyStormEvents
   Schema - {"Name":"MyStormEvents","OrderedColumns":[{"Name":"StartTime","Type":"System.DateTime","CslType":"datetime"},{"Name":"EndTime","Type":"System.DateTime","CslType":"datetime"},{"Name":"State","Type":"System.String","CslType":"string"},{"Name":"DamageProperty","Type":"System.Int32","CslType":"int"},{"Name":"Source","Type":"System.String","CslType":"string"},{"Name":"StormSummary","Type":"System.Object","CslType":"dynamic"}]}
   DatabaseName - MyDatabaseName
   Folder - None
   DocString - None

Zmienianie zasad przyjmowania danych na partie na poziomie tabeli

Zachowanie wsadowego pobierania dla tabel można dostosować, zmieniając odpowiednią politykę tabeli. Aby uzyskać więcej informacji, zobacz politykę IngestionBatching.

Na przykład można zmodyfikować aplikację, aby zmienić zasady pozyskiwania wsadowe wartości limitu czasu na 30 sekund, zmieniając zasady ingestionBatching dla tabeli MyStormEvents przy użyciu następującego polecenia:

// Reduce the default batching timeout to 30 seconds
command = @$".alter-merge table {table} policy ingestionbatching '{{ ""MaximumBatchingTimeSpan"":""00:00:30"" }}'";

using (var response = kustoClient.ExecuteControlCommand(database, command, null))
{
  PrintResultsAsValueList(command, response);
}

# Reduce the default batching timeout to 30 seconds
command = ".alter-merge table " + table + " policy ingestionbatching '{ \"MaximumBatchingTimeSpan\":\"00:00:30\" }'"

response = kusto_client.execute_mgmt(database, command)
print_result_as_value_list(command, response)

// Reduce the default batching timeout to 30 seconds
command = ".alter-merge table " + table + " policy ingestionbatching '{ \"MaximumBatchingTimeSpan\":\"00:00:30\" }'"

response = await kustoClient.executeMgmt(database, command)
printResultsAsValueList(command, response)

// Reduce the default batching timeout to 30 seconds
command = ".alter-merge table " + table + " policy ingestionbatching '{ \"MaximumBatchingTimeSpan\":\"00:00:30\" }'";

response = kusto_client.execute(database, command);
printResultsAsValueList(command, response.getPrimaryResults());

Po dodaniu kodu do aplikacji i uruchomieniu go powinien zostać wyświetlony wynik podobny do następującego:

--------------------

Command: .alter-merge table MyStormEvents policy ingestionbatching '{ "MaximumBatchingTimeSpan":"00:00:30" }'
Result:
   PolicyName - IngestionBatchingPolicy
   EntityName - [YourDatabase].[MyStormEvents]
   Policy - {
  "MaximumBatchingTimeSpan": "00:00:30",
  "MaximumNumberOfItems": 500,
  "MaximumRawDataSizeMB": 1024
}
   ChildEntities - None
   EntityType - Table

Pokaż zasady przechowywania na poziomie bazy danych

Polecenia zarządzania umożliwiają wyświetlanie zasad przechowywania bazy danych.

Możesz na przykład zmodyfikować aplikację, aby wyświetlić zasady przechowywania bazy danych przy użyciu następującego kodu. Wynik jest wyselekcjonowyny, aby odsunąć dwie kolumny od wyniku:

// Show the database retention policy (drop some columns from the result)
command = @$".show database {database} policy retention | project-away ChildEntities, EntityType";

using (var response = kustoClient.ExecuteControlCommand(database, command, null)) {
  PrintResultsAsValueList(command, response);
}

# Show the database retention policy (drop some columns from the result)
command = ".show database " + database + " policy retention | project-away ChildEntities, EntityType"

response = kusto_client.execute_mgmt(database, command)
print_result_as_value_list(command, response)

// Show the database retention policy (drop some columns from the result)
command = ".show database " + database + " policy retention | project-away ChildEntities, EntityType"

response = await kustoClient.executeMgmt(database, command)
printResultsAsValueList(command, response)

// Show the database retention policy (drop some columns from the result)
command = ".show database " + database + " policy retention | project-away ChildEntities, EntityType";

response = kusto_client.execute(database, command);
printResultsAsValueList(command, response.getPrimaryResults());

Po dodaniu kodu do aplikacji i uruchomieniu go powinien zostać wyświetlony wynik podobny do następującego:

--------------------

Command: .show database YourDatabase policy retention | project-away ChildEntities, EntityType
Result:
   PolicyName - RetentionPolicy
   EntityName - [YourDatabase]
   Policy - {
  "SoftDeletePeriod": "365.00:00:00",
  "Recoverability": "Enabled"
}

Następny krok