Pozyskiwanie przykładowych danych JSON w formacie JSON do usługi Azure Data Explorer

W tym artykule przedstawiono sposób pozyskiwania danych sformatowanych w formacie JSON do bazy danych usługi Azure Data Explorer. Zaczniesz od prostych przykładów nieprzetworzonych i zamapowanych danych JSON, przejdź do wielowierszowego kodu JSON, a następnie zajmiesz się bardziej złożonymi schematami JSON zawierającymi tablice i słowniki. Przykłady szczegółowo opisują proces pozyskiwania danych sformatowanych w formacie JSON przy użyciu język zapytań Kusto (KQL), C#lub Python.

Uwaga

Nie zalecamy używania .ingest poleceń zarządzania w scenariuszach produkcyjnych. Zamiast tego należy użyć łącznika danych lub programowego pozyskiwania danych przy użyciu jednej z bibliotek klienta Usługi Kusto.

Wymagania wstępne

• Konto Microsoft lub tożsamość użytkownika Microsoft Entra. Subskrypcja platformy Azure nie jest wymagana.
• Baza danych i klaster usługi Azure Data Explorer. Utwórz klaster i bazę danych.

Format JSON

Usługa Azure Data Explorer obsługuje dwa formaty plików JSON:

• json: Rozdzielony wierszem kod JSON. Każdy wiersz w danych wejściowych ma dokładnie jeden rekord JSON. Ten format obsługuje analizowanie komentarzy i właściwości z pojedynczym cudzysłów. Aby uzyskać więcej informacji, zobacz Wiersze JSON.
• multijson: Wielowierszowy kod JSON. Analizator ignoruje separatory linii i odczytuje rekord z poprzedniej pozycji na końcu prawidłowego kodu JSON.

Uwaga

W przypadku pozyskiwania przy użyciu kreatora pozyskiwania domyślny format to multijson. Format może obsługiwać wielowierszowe rekordy JSON i tablice rekordów JSON. Po napotkaniu błędu analizy cały plik zostanie odrzucony. Aby zignorować nieprawidłowe rekordy JSON, wybierz opcję "Ignoruj błędy formatu danych". Spowoduje to przełączenie formatu na json (linie JSON).

Jeśli używasz formatu wiersza JSON (json), wiersze, które nie reprezentują prawidłowych rekordów JSON, są pomijane podczas analizowania.

Pozyskiwanie i mapowanie sformatowanych danych JSON

Pozyskiwanie danych sformatowanych w formacie JSON wymaga określenia formatu przy użyciu właściwości pozyskiwania. Pozyskiwanie danych JSON wymaga mapowania, które mapuje wpis źródłowy JSON na kolumnę docelową. Podczas pozyskiwania danych użyj IngestionMapping właściwości z właściwością ingestionMappingReference (dla wstępnie zdefiniowanego mapowania) pozyskiwania lub jej IngestionMappings właściwości. W tym artykule użyto ingestionMappingReference właściwości pozyskiwania, która jest wstępnie zdefiniowana w tabeli używanej do pozyskiwania. W poniższych przykładach zaczniemy od pozyskiwania rekordów JSON jako nieprzetworzonych danych do tabeli z jedną kolumną. Następnie użyjemy mapowania, aby pozyskać każdą właściwość do jej zamapowanej kolumny.

Prosty przykład JSON

Poniższy przykład to prosty kod JSON z płaską strukturą. Dane zawierają informacje o temperaturze i wilgotności zebrane przez kilka urządzeń. Każdy rekord jest oznaczony identyfikatorem i znacznikiem czasu.

{
    "timestamp": "2019-05-02 15:23:50.0369439",
    "deviceId": "2945c8aa-f13e-4c48-4473-b81440bb5ca2",
    "messageId": "7f316225-839a-4593-92b5-1812949279b3",
    "temperature": 31.0301639051317,
    "humidity": 62.0791099602725
}

Pozyskiwanie nieprzetworzonych rekordów JSON

W tym przykładzie pozyskasz rekordy JSON jako nieprzetworzone dane do tabeli z jedną kolumną. Manipulowanie danymi przy użyciu zapytań i zasad aktualizacji odbywa się po pozyskiwaniu danych.

KQL

Użyj język zapytań Kusto do pozyskiwania danych w formacie nieprzetworzonym JSON.

1. Zaloguj się do witryny https://dataexplorer.azure.com.

2. Wybierz pozycję Dodaj klaster.

3. W oknie dialogowym Dodawanie klastra wprowadź adres URL klastra w formularzu https://<ClusterName>.<Region>.kusto.windows.net/, a następnie wybierz pozycję Dodaj.

4. Wklej następujące polecenie i wybierz pozycję Uruchom , aby utworzyć tabelę.

   .create table RawEvents (Event: dynamic)
   

   To zapytanie tworzy tabelę z jedną Eventkolumną dynamicznego typu danych.

5. Utwórz mapowanie JSON.

   .create table RawEvents ingestion json mapping 'RawEventMapping' '[{"column":"Event","Properties":{"path":"$"}}]'
   

   To polecenie tworzy mapowanie i mapuje ścieżkę $ JSON główną do kolumny Event .

6. Pozyskiwanie danych do RawEvents tabeli.

   .ingest into table RawEvents ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json') with '{"format":"json", "ingestionMappingReference":"RawEventMapping"}'
   

C#

Użyj języka C# do pozyskiwania danych w formacie nieprzetworzonym JSON.

1. Utwórz tabelę RawEvents .

   var kustoUri = "https://<clusterName>.<region>.kusto.windows.net/";
   var connectionStringBuilder = new KustoConnectionStringBuilder(kustoUri)
   {
       FederatedSecurity = true,
       UserID = userId,
       Password = password,
       Authority = tenantId,
       InitialCatalog = databaseName
   };
   using var kustoClient = KustoClientFactory.CreateCslAdminProvider(connectionStringBuilder);
   var tableName = "RawEvents";
   var command = CslCommandGenerator.GenerateTableCreateCommand(
       tableName,
       new[] { Tuple.Create("Events", "System.Object") }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

2. Utwórz mapowanie JSON.

   var tableMappingName = "RawEventMapping";
   command = CslCommandGenerator.GenerateTableMappingCreateCommand(
       IngestionMappingKind.Json,
       tableName,
       tableMappingName,
       new ColumnMapping[]
       {
           new() { ColumnName = "Events", Properties = new Dictionary<string, string> { { "path", "$" } } }
       }
   );
   
   await kustoClient.ExecuteControlCommandAsync(command);
   

   To polecenie tworzy mapowanie i mapuje ścieżkę $ JSON główną do kolumny Event .

3. Pozyskiwanie danych do RawEvents tabeli.

   var ingestUri = "https://ingest-<clusterName>.<region>.kusto.windows.net/";
   
   var ingestConnectionStringBuilder = new KustoConnectionStringBuilder(ingestUri)
   {
       FederatedSecurity = true,
       UserID = userId,
       Password = password,
       Authority = tenantId,
       InitialCatalog = databaseName
   };
   using var ingestClient = KustoIngestFactory.CreateQueuedIngestClient(ingestConnectionStringBuilder);
   
   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.json,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties);
   

Uwaga

Dane są agregowane zgodnie z zasadami przetwarzania wsadowego, co powoduje opóźnienie kilku minut.

Python

Używanie języka Python do pozyskiwania danych w formacie nieprzetworzonym JSON.

1. Utwórz tabelę RawEvents .

   KUSTO_URI = "https://<ClusterName>.<Region>.kusto.windows.net/"
   KCSB_DATA = KustoConnectionStringBuilder.with_aad_device_authentication(KUSTO_URI, AAD_TENANT_ID)
   KUSTO_CLIENT = KustoClient(KCSB_DATA)
   TABLE = "RawEvents"
   
   CREATE_TABLE_COMMAND = ".create table " + TABLE + " (Events: dynamic)"
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_TABLE_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

2. Utwórz mapowanie JSON.

   MAPPING = "RawEventMapping"
   CREATE_MAPPING_COMMAND = ".create table " + TABLE + " ingestion json mapping '" + MAPPING + """' '[{"column":"Event","path":"$"}]'"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_MAPPING_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do RawEvents tabeli.

   INGEST_URI = "https://ingest-<ClusterName>.<Region>.kusto.windows.net/"
   KCSB_INGEST = KustoConnectionStringBuilder.with_aad_device_authentication(INGEST_URI, AAD_TENANT_ID)
   INGESTION_CLIENT = KustoIngestClient(KCSB_INGEST)
   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json'
   
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.JSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

   Uwaga

   Dane są agregowane zgodnie z zasadami przetwarzania wsadowego, co powoduje opóźnienie kilku minut.

Pozyskiwanie zamapowanych rekordów JSON

W tym przykładzie pozyskasz dane rekordów JSON. Każda właściwość JSON jest mapowana na jedną kolumnę w tabeli.

KQL

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i poleceń pozyskiwania.

   .create table Events (Time: datetime, Device: string, MessageId: string, Temperature: double, Humidity: double)
   

2. Utwórz mapowanie JSON.

   .create table Events ingestion json mapping 'FlatEventMapping' '[{"column":"Time","Properties":{"path":"$.timestamp"}},{"column":"Device","Properties":{"path":"$.deviceId"}},{"column":"MessageId","Properties":{"path":"$.messageId"}},{"column":"Temperature","Properties":{"path":"$.temperature"}},{"column":"Humidity","Properties":{"path":"$.humidity"}}]'
   

   W tym mapowaniu, zgodnie ze schematem tabeli, timestamp wpisy zostaną pozyskane do kolumny Time jako datetime typy danych.

3. Pozyskiwanie danych do Events tabeli.

   .ingest into table Events ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json') with '{"format":"json", "ingestionMappingReference":"FlatEventMapping"}'
   

   Plik "simple.json" ma kilka rozdzielonych wierszami rekordów JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania jest FlatEventMapping utworzone.

C#

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i poleceń pozyskiwania.

   var tableName = "Events";
   var command = CslCommandGenerator.GenerateTableCreateCommand(
      tableName,
      new[]
      {
          Tuple.Create("Time", "System.DateTime"),
          Tuple.Create("Device", "System.String"),
          Tuple.Create("MessageId", "System.String"),
          Tuple.Create("Temperature", "System.Double"),
          Tuple.Create("Humidity", "System.Double")
      }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

2. Utwórz mapowanie JSON.

   var tableMappingName = "FlatEventMapping";
   command = CslCommandGenerator.GenerateTableMappingCreateCommand(
       IngestionMappingKind.Json,
       tableName,
       tableMappingName,
       new ColumnMapping[]
       {
           new() { ColumnName = "Time", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.timestamp" } } },
           new() { ColumnName = "Device", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.deviceId" } } },
           new() { ColumnName = "MessageId", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.messageId" } } },
           new() { ColumnName = "Temperature", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.temperature" } } },
           new() { ColumnName = "Humidity", Properties = new Dictionary<string, string> { { MappingConsts.Path, "$.humidity" } } }
       }
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

   W tym mapowaniu, zgodnie ze schematem tabeli, timestamp wpisy zostaną pozyskane do kolumny Time jako datetime typy danych.

3. Pozyskiwanie danych do Events tabeli.

   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.json,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties).ConfigureAwait(false);
   

   Plik "simple.json" ma kilka rozdzielonych wierszami rekordów JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania jest FlatEventMapping utworzone.

Python

1. Utwórz nową tabelę z podobnym schematem do danych wejściowych JSON. Użyjemy tej tabeli dla wszystkich poniższych przykładów i poleceń pozyskiwania.

   TABLE = "Events"
   CREATE_TABLE_COMMAND = ".create table " + TABLE + " (Time: datetime, Device: string, MessageId: string, Temperature: double, Humidity: double)"
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_TABLE_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

2. Utwórz mapowanie JSON.

   MAPPING = "FlatEventMapping"
   CREATE_MAPPING_COMMAND = ".create table Events ingestion json mapping '" + MAPPING + """' '[{"column":"Time","Properties":{"path":"$.timestamp"}},{"column":"Device","Properties":{"path":"$.deviceId"}},{"column":"MessageId","Properties":{"path":"$.messageId"}},{"column":"Temperature","Properties":{"path":"$.temperature"}},{"column":"Humidity","Properties":{"path":"$.humidity"}}]'"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_MAPPING_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do Events tabeli.

   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/simple.json'
   
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.JSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

   Plik "simple.json" ma kilka wierszy rozdzielonych rekordami JSON. Format to json, a mapowanie używane w poleceniu pozyskiwania jest FlatEventMapping utworzone.

Pozyskiwanie wielowierszowych rekordów JSON

W tym przykładzie pozyskasz wielowierszowe rekordy JSON. Każda właściwość JSON jest mapowana na jedną kolumnę w tabeli. Plik "multilined.json" ma kilka wcięć rekordów JSON. Format multijson wskazuje odczytywanie rekordów przez strukturę JSON.

KQL

Pozyskiwanie danych do Events tabeli.

.ingest into table Events ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json') with '{"format":"multijson", "ingestionMappingReference":"FlatEventMapping"}'

C#

Pozyskiwanie danych do Events tabeli.

var tableMappingName = "FlatEventMapping";
var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json";
var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
{
    Format = DataSourceFormat.multijson,
    IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
};
await ingestClient.IngestFromStorageAsync(blobPath, properties).ConfigureAwait(false);

Python

Pozyskiwanie danych do Events tabeli.

MAPPING = "FlatEventMapping"
BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/multilined.json'
INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.MULTIJSON, ingestion_mapping_reference=MAPPING)
BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
INGESTION_CLIENT.ingest_from_blob(
    BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)

Pozyskiwanie rekordów JSON zawierających tablice

Typy danych tablicy to uporządkowana kolekcja wartości. Pozyskiwanie tablicy JSON odbywa się za pomocą zasad aktualizacji. Kod JSON jest pozyskiwany zgodnie z tabelą pośrednią. Zasady aktualizacji uruchamia wstępnie zdefiniowaną funkcję w RawEvents tabeli, co powoduje ponowne pozyskiwanie wyników do tabeli docelowej. Pozyskamy dane z następującą strukturą:

{
    "records":
    [
        {
            "timestamp": "2019-05-02 15:23:50.0000000",
            "deviceId": "ddbc1bf5-096f-42c0-a771-bc3dca77ac71",
            "messageId": "7f316225-839a-4593-92b5-1812949279b3",
            "temperature": 31.0301639051317,
            "humidity": 62.0791099602725
        },
        {
            "timestamp": "2019-05-02 15:23:51.0000000",
            "deviceId": "ddbc1bf5-096f-42c0-a771-bc3dca77ac71",
            "messageId": "57de2821-7581-40e4-861e-ea3bde102364",
            "temperature": 33.7529423105311,
            "humidity": 75.4787976739364
        }
    ]
}

KQL

1. update policy Utwórz funkcję, która rozszerza kolekcjęrecords, tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   .create function EventRecordsExpand() {
       RawEvents
       | mv-expand records = Event.records
       | project
           Time = todatetime(records["timestamp"]),
           Device = tostring(records["deviceId"]),
           MessageId = tostring(records["messageId"]),
           Temperature = todouble(records["temperature"]),
           Humidity = todouble(records["humidity"])
   }
   

2. Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej. Użyj getschema operatora, aby przejrzeć schemat.

   EventRecordsExpand() | getschema
   

3. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady będą automatycznie uruchamiać zapytanie na wszystkich nowo pozyskanych danych w tabeli pośredniej RawEventsEvents i pozyskiwać wyniki do tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   .alter table Events policy update @'[{"Source": "RawEvents", "Query": "EventRecordsExpand()", "IsEnabled": "True"}]'
   

4. Pozyskiwanie danych do RawEvents tabeli.

   .ingest into table RawEvents ('https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json') with '{"format":"multijson", "ingestionMappingReference":"RawEventMapping"}'
   

5. Przejrzyj dane w Events tabeli.

   Events
   

C#

1. Utwórz funkcję aktualizacji, która rozszerza kolekcję records , tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   var command = CslCommandGenerator.GenerateCreateFunctionCommand(
       "EventRecordsExpand",
       "UpdateFunctions",
       string.Empty,
       null,
       @"RawEvents
       | mv-expand records = Event
       | project
           Time = todatetime(records['timestamp']),
           Device = tostring(records['deviceId']),
           MessageId = tostring(records['messageId']),
           Temperature = todouble(records['temperature']),
           Humidity = todouble(records['humidity'])",
       ifNotExists: false
   );
   await kustoClient.ExecuteControlCommandAsync(command);
   

   Uwaga

   Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej.

2. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady będą automatycznie uruchamiać zapytanie na wszystkich nowo pozyskanych danych w tabeli pośredniej RawEventsEvents i pozyskiwać wyniki do tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   command = ".alter table Events policy update @'[{'Source': 'RawEvents', 'Query': 'EventRecordsExpand()', 'IsEnabled': 'True'}]";
   await kustoClient.ExecuteControlCommandAsync(command);
   

3. Pozyskiwanie danych do RawEvents tabeli.

   var blobPath = "https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json";
   var tableName = "RawEvents";
   var tableMappingName = "RawEventMapping";
   var properties = new KustoQueuedIngestionProperties(databaseName, tableName)
   {
       Format = DataSourceFormat.multijson,
       IngestionMapping = new IngestionMapping { IngestionMappingReference = tableMappingName }
   };
   await ingestClient.IngestFromStorageAsync(blobPath, properties);
   

4. Przejrzyj dane w Events tabeli.

Python

1. Utwórz funkcję aktualizacji, która rozszerza kolekcję records , tak aby każda wartość w kolekcji odbierała oddzielny wiersz przy użyciu mv-expand operatora . Użyjemy tabeli RawEvents jako tabeli źródłowej i Events jako tabeli docelowej.

   CREATE_FUNCTION_COMMAND =
       '''.create function EventRecordsExpand() {
           RawEvents
           | mv-expand records = Event
           | project
               Time = todatetime(records["timestamp"]),
               Device = tostring(records["deviceId"]),
               MessageId = tostring(records["messageId"]),
               Temperature = todouble(records["temperature"]),
               Humidity = todouble(records["humidity"])
           }'''
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_FUNCTION_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

   Uwaga

   Schemat odebrany przez funkcję musi być zgodny ze schematem tabeli docelowej.

2. Dodaj zasady aktualizacji do tabeli docelowej. Te zasady będą automatycznie uruchamiać zapytanie na wszystkich nowo pozyskanych danych w tabeli pośredniej RawEventsEvents i pozyskiwać wyniki do tabeli. Zdefiniuj zasady zerowego przechowywania, aby uniknąć utrwalania tabeli pośredniej.

   CREATE_UPDATE_POLICY_COMMAND =
       """.alter table Events policy update @'[{'Source': 'RawEvents', 'Query': 'EventRecordsExpand()', 'IsEnabled': 'True'}]"""
   RESPONSE = KUSTO_CLIENT.execute_mgmt(DATABASE, CREATE_UPDATE_POLICY_COMMAND)
   dataframe_from_result_table(RESPONSE.primary_results[0])
   

3. Pozyskiwanie danych do RawEvents tabeli.

   TABLE = "RawEvents"
   MAPPING = "RawEventMapping"
   BLOB_PATH = 'https://kustosamplefiles.blob.core.windows.net/jsonsamplefiles/array.json'
   INGESTION_PROPERTIES = IngestionProperties(database=DATABASE, table=TABLE, dataFormat=DataFormat.MULTIJSON, ingestion_mapping_reference=MAPPING)
   BLOB_DESCRIPTOR = BlobDescriptor(BLOB_PATH, FILE_SIZE)
   INGESTION_CLIENT.ingest_from_blob(
       BLOB_DESCRIPTOR, ingestion_properties=INGESTION_PROPERTIES)
   

4. Przejrzyj dane w Events tabeli.

Zawartość pokrewna

• Omówienie pozyskiwania danych
• Pisanie zapytań